pages/Models.py

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%**
    """
    )