Upload 15 files

models/h5/arbre_descision_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2aa37c8d7e4ec847326abe2996d57dcd720c0a163b9d8707facffcda35b9d488
+size 2255705

models/h5/knn_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fbf26f8d570afb310ea40014ef8692261ce31627565ee5d71f3df4a65c21a7ca
+size 114602

models/h5/random_forest_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e6cac3b4c8aa449be4d8635200414c0473f7e352f88b580dc756b3811307ba1b
+size 1328345

models/h5/svc_linear_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a45e038fcd338cb6320b0f6448125bb33bbb2c3436861cb1394fde64591444bf
+size 81921

models/h5/svc_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a45e038fcd338cb6320b0f6448125bb33bbb2c3436861cb1394fde64591444bf
+size 81921

models/h5/xgb_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6d129877a228a35b97f6d750e3744eb05e8c20f43f90e19ba8761820e9b7ecfa
+size 180954

models/model.py

@@ -0,0 +1,70 @@
+from joblib import load
+from sklearn.preprocessing import PowerTransformer
+import os
+
+#ENCODED CLASS IN ORDER
+JOB_CLASSE = ['admin.','blue-collar','entrepreneur','housemaid','management','retired','self-employed','services','student','technician','unemployed','unknown']
+EDUCATION_CLASSE = ['primary','secondary','tertiary','unknown']
+MARITAL_CLASSE = ['divorced','married','single']
+CONTACT_CLASSE = ['cellular','telephone','unknown']
+MONTH_CLASSE = ['apr','aug','dec','feb','jan','jul','jun','mar','may','nov','oct','sep']
+POUTCOME_CLASSE = ['failure','other','success','unknown']
+BINARY_CLASSE = ['no','yes']
+
+def transform_data(data):
+    # Initialisez PowerTransformer avec la méthode 'yeo-johnson'
+    transformer = PowerTransformer(method='yeo-johnson')
+    # Ajustez le transformer aux données et transformez les données en les normalisant
+    pdays_normalized = transformer.fit_transform(data[['pdays']])
+    day_normalized = transformer.fit_transform(data[['day']])
+    age_normalized = transformer.fit_transform(data[['age']])
+    balance_normalized = transformer.fit_transform(data[['balance']])
+    duration_normalized = transformer.fit_transform(data[['duration']])
+    campaign_normalized = transformer.fit_transform(data[['campaign']])
+    previous_normalized = transformer.fit_transform(data[['previous']])
+    # Remplacez les valeurs dans le DataFrame original par les valeurs normalisées
+    data['pdays'] = pdays_normalized
+    data['age'] = age_normalized
+    data['balance'] = balance_normalized
+    data['duration'] = duration_normalized
+    data['campaign'] = campaign_normalized
+    data['day'] = day_normalized
+    data['previous'] = previous_normalized
+    
+    #categorical variable
+    data['job'] = [JOB_CLASSE.index(data['job'][0])]
+    data['marital'] = [MARITAL_CLASSE.index(data['marital'][0])]
+    data['education'] = [EDUCATION_CLASSE.index(data['education'][0])]
+    data['default'] = [BINARY_CLASSE.index(data['default'][0])]
+    data['housing'] = [BINARY_CLASSE.index(data['housing'][0])]
+    data['loan'] = [BINARY_CLASSE.index(data['loan'][0])]
+    data['contact'] = [CONTACT_CLASSE.index(data['contact'][0])]
+    data['month'] = [MONTH_CLASSE.index(data['month'][0])]
+    data['poutcome'] = [POUTCOME_CLASSE.index(data['poutcome'][0])]
+
+    return data
+
+def xg_boost_model(data):
+    path = os.path.abspath('models/h5/xgb_model.h5')
+    model = load(path)
+    return model.predict(data)
+
+def svc_model(data):
+    path = os.path.abspath('models/h5/svc_model.h5')
+    model = load(path)
+    return model.predict(data)
+
+def knn_model(data):
+    path = os.path.abspath('models/h5/knn_model.h5')
+    model = load(path)
+    return model.predict(data)
+
+def ramdom_forest_model(data):
+    path = os.path.abspath('models/h5/random_forest_model.h5')
+    model = load(path)
+    return model.predict(data)
+
+def svc_linear_model(data):
+    path = os.path.abspath('models/h5/svc_linear_model.h5')
+    model = load(path)
+    return model.predict(data)

pages/Analyse.py

@@ -0,0 +1,17 @@
+import streamlit as st
+import pandas as pd
+from ydata_profiling import ProfileReport
+from streamlit_ydata_profiling import st_profile_report 
+from menu import get_menu
+
+st.set_page_config(
+    layout="wide"
+)
+
+get_menu()
+
+df = pd.read_csv('bank_data.csv').drop(columns=['Unnamed: 0'])
+
+report = ProfileReport(df, title="Analyse des données")
+
+st_profile_report(report, navbar=True)

pages/Models.py

@@ -0,0 +1,487 @@
+import streamlit as st
+from menu import get_menu
+
+st.set_page_config(
+    layout="wide"
+)
+
+get_menu()
+
+
+st.image('images/model2.jpg', use_column_width='always')
+st.markdown(
+    """
+    <style>
+    img {
+        object-fit: cover;
+        max-height: 500px;
+        border-radius: 5px;
+        position: relative;
+        z-index: 0;
+    }
+    </style>
+    """,
+    unsafe_allow_html=True,
+)
+st.title("Résultats statistique")
+st.markdown(
+    """
+    Apres une etude de notre jeux de donnés nous avons tirré quelques conclusions : 
+    - les données sont desequilibré car nous avons **500 client qui disent oui et 4000 non**.
+    Au vue de cela nous avons decider de **reduire le jeux de données (ramené les nom à 500)** pour que nos model puissent bien s'entrainer.
+    - les distribution des variables **[age, balance, duration, campaign, pdays]** ne sont pas bonne 
+    donc nous avons fais une transformation de ses variables avec **PowerTransformer de sklearn.preprocessing** en utlisant la méthode **yeo-johnson**.
+    """
+)
+
+col1, col2 = st.columns([2, .5])
+selected_model = col2.selectbox(label="", options=["XGBOOST", "KNN", "SVC LINEAIRE","SVC", "RAMDOM FOREST"])
+message = f"Description du model {selected_model}"
+col1.title(message)
+
+if selected_model == "KNN":
+    st.markdown(
+    """ 
+    ### #Méthode des k plus proches voisins(KNN)
+    C'est un algorithme d'apprentissage automatique supervisé qui attribue une catégorie à un élément 
+    en fonction de la classe majoritaire des ses plus proches voisins dans l'échantillon d'entraînement.
+    #### #Code
+    ```python
+    from sklearn.neighbors import KNeighborsClassifier
+    from sklearn.model_selection import GridSearchCV
+    from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix
+    import seaborn as sns
+    import matplotlib.pyplot as plt
+
+    # Définissez la grille des hyperparamètres à explorer
+    param_grid = {
+        'n_neighbors': [3, 5, 7, 8, 9],  # Nombre de voisins à considérer
+        'weights': ['uniform', 'distance'],  # Méthode de pondération des voisins
+        'p': [1, 2]  # Paramètre de distance (1 pour la distance de Manhattan, 2 pour la distance euclidienne)
+    }
+
+    # Initialisez le modèle KNeighborsClassifier
+    knn_model = KNeighborsClassifier()
+
+    # Initialisez GridSearchCV avec le modèle, la grille de paramètres et la méthode de validation croisée
+    grid_search = GridSearchCV(estimator=knn_model, param_grid=param_grid, cv=5)
+
+    # Ajustez GridSearchCV aux données d'entraînement
+    grid_search.fit(X_train, y_train)
+
+    # Affichez les meilleurs paramètres et la meilleure précision
+    print("Meilleurs paramètres:", grid_search.best_params_)
+    print("Meilleure précision:", grid_search.best_score_)
+
+    # Créez un nouveau modèle KNeighborsClassifier avec les meilleurs paramètres identifiés
+    best_knn_model = KNeighborsClassifier(**grid_search.best_params_)
+
+    # Entraînez le modèle sur l'ensemble des données d'entraînement
+    best_knn_model.fit(X_train, y_train)
+
+    # Prédictions sur l'ensemble de test
+    y_pred_knn = best_knn_model.predict(X_test)
+
+    # Calcul de la précision
+    accuracy_knn = accuracy_score(y_test, y_pred_knn)
+    print("Précision sur l'ensemble de test:", accuracy_knn)
+
+    # Calcul de la précision
+    precision_knn = precision_score(y_test, y_pred_knn)
+    print("Précision sur l'ensemble de test:", precision_knn)
+
+    # Calcul du rappel
+    recall_knn = recall_score(y_test, y_pred_knn)
+    print("Rappel sur l'ensemble de test:", recall_knn)
+
+    # Calcul du score F1
+    f1_knn = f1_score(y_test, y_pred_knn)
+    print("Score F1 sur l'ensemble de test:", f1_knn)
+
+    # Calculer la matrice de confusion
+    conf_matrix_knn = confusion_matrix(y_test, y_pred_knn)
+
+    # Afficher la matrice de confusion avec seaborn
+    plt.figure(figsize=(8, 6))
+    sns.heatmap(conf_matrix_knn, annot=True, cmap='Blues', fmt='d', cbar=False)
+    plt.xlabel('Prédictions')
+    plt.ylabel('Vraies étiquettes')
+    plt.title('Matrice de Confusion - KNeighborsClassifier')
+    plt.show()
+    ```
+    #### #Résultats
+    - Meilleurs paramètres:
+        ```json
+        {
+            k_voisins : 5, 
+            p : 1, 
+            weights : 'distance'
+        }
+        ```
+    - Meilleure précision: **70%**
+    - Précision sur l'ensemble de test: **69%**
+    - Précision sur l'ensemble de test: **73%**
+    - Rappel sur l'ensemble de test: **64%**
+    - Score F1 sur l'ensemble de test: **68%**
+    """
+    )
+
+if selected_model == "SVC LINEAIRE":
+    st.markdown(
+    """ 
+    ### #Méthode SVC LINEAIRE
+    Les machines à vecteurs de support (SVM) sont un ensemble de techniques d'apprentissage supervisé destinées à résoudre des problèmes de discrimination et de régression.
+    Le SVM et le SVC implémentent le même algorithme mais de maniere différente. 
+    Le module SVM (SVC, NuSVC, etc.) est une enveloppe autour de la bibliothèque libsvm et prend en charge différents noyaux, 
+    tandis que LinearSVC est basé sur liblinear et ne prend en charge qu'un noyau linéaire.
+    #### #Code
+    ```python
+    # Définissez la grille des hyperparamètres à explorer
+    param_grid = {
+        'C': [0.01, 0.1, 0.9, 1, 1.1, 1.2, 1.5, ],  # Paramètre de régularisation
+        'loss': ['hinge', 'squared_hinge'],  # Fonction de perte
+        'max_iter': [900,1000, 1500, 2000]  # Nombre maximum d'itérations
+    }
+
+    # Initialisez le modèle LinearSVC
+    svc_model = LinearSVC()
+
+    # Initialisez GridSearchCV avec le modèle, la grille de paramètres et la méthode de validation croisée
+    grid_search = GridSearchCV(estimator=svc_model, param_grid=param_grid, cv=5)
+
+    # Ajustez GridSearchCV aux données d'entraînement
+    grid_search.fit(X_train, y_train)
+    from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
+
+    # Prédiction sur l'ensemble de test
+    y_pred = best_svc_model.predict(X_test)
+
+    # Calcul de la précision
+    accuracy = accuracy_score(y_test, y_pred)
+    print("Précision sur l'ensemble de test:", accuracy)
+
+    # Calcul de la précision
+    precision = precision_score(y_test, y_pred)
+    print("Précision sur l'ensemble de test:", precision)
+
+    # Calcul du rappel
+    recall = recall_score(y_test, y_pred)
+    print("Rappel sur l'ensemble de test:", recall)
+
+    # Calcul du score F1
+    f1 = f1_score(y_test, y_pred)
+    print("Score F1 sur l'ensemble de test:", f1)from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
+
+    # Prédiction sur l'ensemble de test
+    y_pred = best_svc_model.predict(X_test)
+
+    # Calcul de la précision
+    accuracy = accuracy_score(y_test, y_pred)
+    print("Précision sur l'ensemble de test:", accuracy)
+
+    # Calcul de la précision
+    precision = precision_score(y_test, y_pred)
+    print("Précision sur l'ensemble de test:", precision)
+
+    # Calcul du rappel
+    recall = recall_score(y_test, y_pred)
+    print("Rappel sur l'ensemble de test:", recall)
+
+    # Calcul du score F1
+    f1 = f1_score(y_test, y_pred)
+    print("Score F1 sur l'ensemble de test:", f1)
+    
+    from sklearn.metrics import confusion_matrix
+    import seaborn as sns
+    import matplotlib.pyplot as plt
+
+    # Calculer la matrice de confusion
+    conf_matrix = confusion_matrix(y_test, y_pred)
+
+    # Afficher la matrice de confusion avec seaborn
+    plt.figure(figsize=(8, 6))
+    sns.heatmap(conf_matrix, annot=True, cmap='Blues', fmt='d', cbar=False)
+    plt.xlabel('Prédictions')
+    plt.ylabel('Vraies étiquettes')
+    plt.title('Matrice de Confusion')
+    plt.show()
+    ```
+    #### #Résultats
+    - Meilleurs paramètres:
+        ```json
+        {
+            C : 0.01, 
+            loss : 'hinge', 
+            max_iter : 900,
+        }
+        ```
+    - Meilleure précision: **79%**
+    - Précision sur l'ensemble de test: **78%**
+    - Précision sur l'ensemble de test: **77%**
+    - Rappel sur l'ensemble de test: **80%**
+    - Score F1 sur l'ensemble de test: **79%**
+    """
+    )
+
+if selected_model == "SVC":
+    st.markdown(
+    """ 
+    ### #Méthode SVC
+    Les machines à vecteurs de support (SVM) sont un ensemble de techniques d'apprentissage supervisé destinées à résoudre des problèmes de discrimination et de régression.
+    Le SVM et le SVC implémentent le même algorithme mais de maniere différente. 
+    Le module SVM (SVC, NuSVC, etc.) est une enveloppe autour de la bibliothèque libsvm et prend en charge différents noyaux, 
+    tandis que LinearSVC est basé sur liblinear et ne prend en charge qu'un noyau linéaire.
+    #### #Code
+    ```python
+    from sklearn.svm import SVC
+    from sklearn.model_selection import GridSearchCV
+    from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix
+    import seaborn as sns
+    import matplotlib.pyplot as plt
+
+    # Définissez la grille des hyperparamètres à explorer
+    param_grid = {
+        'C': [1e-5, 1e-4, 1e-3, 1e-2, 1e-1],  # Paramètre de régularisation
+        'kernel': ['linear', 'rbf', 'poly'],  # Type de noyau
+        'gamma': ['scale', 'auto'],  # Coefficient gamma pour le noyau RBF
+    }
+
+    # Initialisez le modèle SVC
+    svc_model = SVC()
+
+    # Initialisez GridSearchCV avec le modèle, la grille de paramètres et la méthode de validation croisée
+    grid_search = GridSearchCV(estimator=svc_model, param_grid=param_grid, cv=5, n_jobs=-1)
+
+    # Ajustez GridSearchCV aux données d'entraînement
+    grid_search.fit(X_train, y_train)
+
+    # Affichez les meilleurs paramètres et la meilleure précision
+    print("Meilleurs paramètres:", grid_search.best_params_)
+    print("Meilleure précision:", grid_search.best_score_)
+
+    # Créez un nouveau modèle SVC avec les meilleurs paramètres identifiés
+    best_svc_model = SVC(**grid_search.best_params_)
+
+    # Entraînez le modèle sur l'ensemble des données d'entraînement
+    best_svc_model.fit(X_train, y_train)
+
+    # Prédictions sur l'ensemble de test
+    y_pred_svc = best_svc_model.predict(X_test)
+
+    # Calcul de la précision
+    accuracy_svc = accuracy_score(y_test, y_pred_svc)
+    print("Précision sur l'ensemble de test:", accuracy_svc)
+
+    # Calcul de la précision
+    precision_svc = precision_score(y_test, y_pred_svc)
+    print("Précision sur l'ensemble de test:", precision_svc)
+
+    # Calcul du rappel
+    recall_svc = recall_score(y_test, y_pred_svc)
+    print("Rappel sur l'ensemble de test:", recall_svc)
+
+    # Calcul du score F1
+    f1_svc = f1_score(y_test, y_pred_svc)
+    print("Score F1 sur l'ensemble de test:", f1_svc)
+
+    # Calculer la matrice de confusion
+    conf_matrix_svc = confusion_matrix(y_test, y_pred_svc)
+
+    # Afficher la matrice de confusion avec seaborn
+    plt.figure(figsize=(8, 6))
+    sns.heatmap(conf_matrix_svc, annot=True, cmap='Blues', fmt='d', cbar=False)
+    plt.xlabel('Prédictions')
+    plt.ylabel('Vraies étiquettes')
+    plt.title('Matrice de Confusion - SVC')
+    plt.show()
+    ```
+    #### #Résultats
+    - Meilleurs paramètres:
+        ```json
+        {
+            C : 0.01, 
+            gamma : 'scale', 
+            kernel : 'linear'
+        }
+        ```
+    - Meilleure précision: **79%**
+    - Précision sur l'ensemble de test: **78%**
+    - Précision sur l'ensemble de test: **77%**
+    - Rappel sur l'ensemble de test: **80%**
+    - Score F1 sur l'ensemble de test: **79%**
+    """
+    )
+
+if selected_model == "RAMDOM FOREST":
+        st.markdown(
+    """ 
+    ### #Méthode de la forêt aléatoire (RAMDOM FOREST)
+    La forêt aléatoire est un algorithme d'apprentissage automatique couramment utilisé, qui permet d'assembler les sorties de plusieurs arbres de décision pour atteindre un résultat unique. 
+    Sa souplesse d'utilisation et sa flexibilité ont favorisé son adoption, car il gère à la fois les problèmes de classification et de régression.
+    #### #Code
+    ```python
+    from sklearn.ensemble import RandomForestClassifier
+    from sklearn.model_selection import GridSearchCV
+    from sklearn.metrics import confusion_matrix, accuracy_score, roc_curve
+    import matplotlib.pyplot as plt
+    import seaborn as sns
+    from sklearn.metrics import confusion_matrix, accuracy_score, roc_curve, precision_score, recall_score, f1_score
+    # Définir la grille des hyperparamètres à explorer
+    param_grid = {
+        'n_estimators': [25,50, 100, 150],
+        'max_depth': [None, 10, 20,25],
+        'min_samples_split': [2, 5, 10,15],
+        'min_samples_leaf': [1, 2, 4,6]
+    }
+
+    # Initialiser le modèle Random Forest
+    rf_model = RandomForestClassifier()
+
+    # Initialiser GridSearchCV avec le modèle, la grille des hyperparamètres et la méthode de validation croisée
+    grid_search = GridSearchCV(estimator=rf_model, param_grid=param_grid, cv=5, n_jobs=-1)
+
+    # Ajuster GridSearchCV aux données d'entraînement
+    grid_search.fit(X_train, y_train)
+
+    # Afficher les meilleurs paramètres et la meilleure précision
+    print("Meilleurs paramètres:", grid_search.best_params_)
+    #print("Meilleure précision:", grid_search.best_score_)
+
+    # Créer un nouveau modèle Random Forest avec les meilleurs paramètres identifiés
+    best_rf_model = RandomForestClassifier(**grid_search.best_params_)
+
+    # Entraîner le modèle sur l'ensemble des données d'entraînement
+    best_rf_model.fit(X_train, y_train)
+
+    # Faire des prédictions sur l'ensemble de test
+    y_pred = best_rf_model.predict(X_test)
+
+    # Calculer la matrice de confusion
+    conf_matrix = confusion_matrix(y_test, y_pred)
+
+    # Afficher la matrice de confusion avec seaborn
+    plt.figure(figsize=(8, 6))
+    sns.heatmap(conf_matrix, annot=True, cmap='Blues', fmt='d', cbar=False)
+    plt.xlabel('Prédictions')
+    plt.ylabel('Vraies étiquettes')
+    plt.title('Matrice de Confusion - Random Forest')
+    plt.show()
+
+    # Calculer les probabilités prédites pour la classe positive (utilisé pour tracer la courbe ROC)
+    y_probs = best_rf_model.predict_proba(X_test)[:, 1]
+
+    # Calculer la courbe ROC
+    fpr, tpr, thresholds = roc_curve(y_test, y_probs)
+
+    # Afficher la courbe ROC
+    plt.figure(figsize=(8, 6))
+    plt.plot(fpr, tpr, label='Random Forest')
+    plt.plot([0, 1], [0, 1], 'k--', label='Random')
+    plt.xlabel('Taux de Faux Positifs')
+    plt.ylabel('Taux de Vrais Positifs')
+    plt.title('Courbe ROC - Random Forest')
+    plt.legend()
+    plt.show()
+
+    # Calculer et afficher l'accuracy
+    accuracy = accuracy_score(y_test, y_pred)
+    # Calculer la précision
+    precision = precision_score(y_test, y_pred)
+
+    # Calculer le rappel
+    recall = recall_score(y_test, y_pred)
+
+    # Calculer le F1-score
+    f1 = f1_score(y_test, y_pred)
+
+    ```
+    #### #Résultats
+    - Meilleurs paramètres:
+        ```json
+        {
+            max_depth : 10, 
+            min_samples_leaf : 2, 
+            min_samples_split : 5, 
+            n_estimators : 100, 
+        }
+        ```
+    - Accuracy: 82%
+    - Précision: 80%
+    - Rappel: 88%
+    - F1-score: 84%
+    """
+    )
+
+
+if selected_model == "XGBOOST":
+    st.markdown(
+    """ 
+    ### #Méthode XGBOOST
+    **XGBOOST** ( eXtreme Gradient Boosting ) est une bibliothèque permettant d’entraîner des algorithmes de Gradient Boosting.
+    Le **Gradient Boosting** consiste à entraîner une série de modèles. Chaque modèle est entraîné dans le but de corriger les erreurs du modèle précédent. La prédiction finale est faite en combinant les prédictions de tous les modèles de la série.
+    #### #Code
+    ```python
+    from xgboost import XGBClassifier
+    from sklearn.model_selection import GridSearchCV
+    from sklearn.metrics import confusion_matrix, accuracy_score, precision_score, recall_score, f1_score
+    import matplotlib.pyplot as plt
+    import seaborn as sns
+
+    # Définir la grille des hyperparamètres à explorer
+    param_grid = {
+        'n_estimators': [100, 200, 300],
+        'max_depth': [3, 4, 5],
+        'learning_rate': [0.01, 0.05, 0.1],
+    }
+
+    # Initialiser le modèle XGBClassifier
+    xgb_model = XGBClassifier()
+
+    # Initialiser GridSearchCV avec le modèle, la grille des hyperparamètres et la méthode de validation croisée
+    grid_search = GridSearchCV(estimator=xgb_model, param_grid=param_grid, cv=5, n_jobs=-1)
+
+    # Ajuster GridSearchCV aux données d'entraînement
+    grid_search.fit(X_train, y_train)
+
+    # Afficher les meilleurs paramètres et la meilleure précision
+    print("Meilleurs paramètres:", grid_search.best_params_)
+
+    # Créer un nouveau modèle XGBClassifier avec les meilleurs paramètres identifiés
+    best_xgb_model = XGBClassifier(**grid_search.best_params_)
+
+    # Entraîner le modèle sur l'ensemble des données d'entraînement
+    best_xgb_model.fit(X_train, y_train)
+
+    # Faire des prédictions sur l'ensemble de test
+    y_pred = best_xgb_model.predict(X_test)
+
+    # Afficher la matrice de confusion
+    conf_matrix = confusion_matrix(y_test, y_pred)
+    plt.figure(figsize=(8, 6))
+    sns.heatmap(conf_matrix, annot=True, cmap='Blues', fmt='d', cbar=False)
+    plt.xlabel('Prédictions')
+    plt.ylabel('Vraies étiquettes')
+    plt.title('Matrice de Confusion - XGBClassifier')
+    plt.show()
+
+    # Afficher les métriques
+    accuracy = accuracy_score(y_test, y_pred)
+    precision = precision_score(y_test, y_pred)
+    recall = recall_score(y_test, y_pred)
+    f1 = f1_score(y_test, y_pred)
+    ```
+    #### #Résultats
+    - Meilleurs paramètres:
+        ```json
+        {
+            learning_rate : 0.1, 
+            max_depth : 5, 
+            n_estimators : 100
+        }
+        ```
+    - Accuracy: **83%**
+    - Précision: **81%**
+    - Rappel: **87%**
+    - F1-score: **84%**
+    """
+    )

pages/Prediction.py

@@ -0,0 +1,112 @@
+import streamlit as st
+import pandas as pd
+import models.model as mod
+from menu import get_menu
+
+st.set_page_config(
+    layout="centered"
+)
+get_menu()
+
+
+
+st.title("Formulaire")
+
+with st.form("prediction_form", border=False):    
+    # info bancaire
+    name = st.text_input('Votre nom')
+    age = st.number_input('Votre age', min_value=16)
+    
+    job,education = st.columns(2)
+    job_val = job.selectbox('Votre metier', ["admin.","unknown","unemployed","management","housemaid","entrepreneur","student","blue-collar","self-employed","retired","technician","services"])
+    education_val = education.selectbox('Votre niveau d\'etude', ["unknown","secondary","primary","tertiary"])
+    marital = st.selectbox('Votre status marital', ["married","divorced","single"])
+    
+    balance = st.number_input('Votre solde annuel moyen (en euro)', min_value=1)
+    
+    default = st.checkbox('Avez vous un crédit en déficite ?')
+    housing = st.checkbox('Avez vous un pret logement ?')
+    loan = st.checkbox('Avez vous un pret ?')
+    
+    #informations contact
+    
+    contact = st.selectbox('Moyen de contact', ["unknown","telephone","cellular"])
+    day,month = st.columns([2,2])
+    
+    day_val = day.number_input('Dernier jours de contact du mois', min_value=0)
+    month_val = month.selectbox('Dernier mois de contact de l\'année', ['jan','fed','mar','apr','may','jun','jul','aug','sep','oct','nov','dec'])
+    duration = st.number_input('Durée de la derniere conversation', min_value=0)
+    
+    #autres infos
+    campaign = st.number_input('Nombre de contact effectuer pour cette campagne', min_value=0)
+    pdays  = st.number_input('Nombre de jours ecoulé depuis le dernier contact', min_value=0)
+    previous  = st.number_input('Nombre de contact effectuer avant cette campagne', min_value=0)
+    poutcome = st.selectbox('Resultat de la derniere campagne', ["unknown","other","failure","success"])
+    
+    
+    selected_model = st.selectbox('Choisir le model', ["XGBOOST", "KNN", "SVC LINEAIRE","SVC", "RAMDOM FOREST"])
+    
+
+    submitted = st.form_submit_button('Predire le choix', use_container_width=True)
+    
+    if submitted:
+        if name  == "":
+          st.error('Le nom est obligatoire !')
+        else:
+            data_vals = [
+                age,
+                job_val,
+                marital,
+                education_val,
+                'yes' if default else 'no',
+                balance,
+                'yes' if housing else 'no',
+                'yes' if loan else 'no',
+                contact,
+                day_val,
+                month_val,
+                duration,
+                campaign,
+                pdays,
+                previous,
+                poutcome
+            ]
+            index = [
+                "age",
+                "job",
+                "marital",
+                "education",
+                "default",
+                "balance",
+                "housing",
+                "loan",
+                "contact",
+                "day",
+                "month",
+                "duration",
+                "campaign",
+                "pdays",
+                "previous",
+                "poutcome"
+            ]
+            data = pd.DataFrame([data_vals], columns=index)
+            data_transform = mod.transform_data(data)
+            
+            if selected_model == "XGBOOST":
+                res = mod.xg_boost_model(data_transform)
+            elif selected_model == "KNN":
+                res = mod.knn_model(data_transform)
+            elif selected_model == "SVC LINEAIRE":
+                res = mod.svc_linear_model(data_transform)
+            elif selected_model == "SVC":
+                res = mod.svc_model(data_transform)
+            else:
+                res = mod.ramdom_forest_model(data_transform)
+            
+            msg = f"D'apres notre model {selected_model} le client {name} " 
+            if res == 0:
+              st.error(f"{msg} ne va pas souscrire à l'offre.")
+            else:
+                st.success(f"{msg} va pas souscrire à l'offre.")
+    
+