Skip to content
Extraits de code Groupes Projets
Valider 5f4c81ba rédigé par Adrien Payen's avatar Adrien Payen
Parcourir les fichiers

commit coms

parent db3bf33a
Aucune branche associée trouvée
Aucune étiquette associée trouvée
Aucune requête de fusion associée trouvée
Affichage de avec 37 ajouts et 39 suppressions
Aucun aperçu pour ce type de fichier
...@@ -14,7 +14,7 @@ Pour réaliser au mieux nos analyses, nous avons décidé d’utiliser une base ...@@ -14,7 +14,7 @@ Pour réaliser au mieux nos analyses, nous avons décidé d’utiliser une base
Dans le dossier SAMPLE vous trouverez : Dans le dossier SAMPLE vous trouverez :
Un dossier `all_sets` contenant la séparation de la base de données en différents dataset : Un dossier `all_sets` contenant la séparation de la base de données en différents dataset (ces sets de données sont à utiliser dans orange data mining) :
- `test_set.xlsx` reprend toutes les données utilisées pour le test de l'entrainement des modèles supervisés. - `test_set.xlsx` reprend toutes les données utilisées pour le test de l'entrainement des modèles supervisés.
- `training_set.xlsx` reprend toutes les données utilisées pour entrainer les modèles supervisés et non supervisés. - `training_set.xlsx` reprend toutes les données utilisées pour entrainer les modèles supervisés et non supervisés.
......
Aucun aperçu pour ce type de fichier
Aucun aperçu pour ce type de fichier
SEMMA/ASSESSMENT/training_set_matrice.png

65,1 ko

SEMMA/ASSESSMENT/training_set_matrice_confusion.png

203 ko

...@@ -3,7 +3,7 @@ from scipy.stats import chi2_contingency ...@@ -3,7 +3,7 @@ from scipy.stats import chi2_contingency
# Charger les données depuis le fichier Excel # Charger les données depuis le fichier Excel
nom_fichier_excel = "DATA/xlsx/booking.xlsx" nom_fichier_excel = "DATA/xlsx/booking.xlsx"
nom_feuille = "main_data_2017" # Remplacez par le nom réel de votre feuille nom_feuille = "main_data_2017"
donnees = pd.read_excel(nom_fichier_excel, sheet_name=nom_feuille) donnees = pd.read_excel(nom_fichier_excel, sheet_name=nom_feuille)
# Variables à comparer # Variables à comparer
......
...@@ -5,7 +5,7 @@ import matplotlib.pyplot as plt ...@@ -5,7 +5,7 @@ import matplotlib.pyplot as plt
import pandas as pd import pandas as pd
import os import os
import matplotlib.pyplot as plt import matplotlib.pyplot as plt
def scatter_plot_all_pairs_separate(dataframe, sheet_name, output_folder): def scatter_plot_all_pairs_separate(dataframe, sheet_name, output_folder):
# Récupérer la liste des noms de colonnes (en excluant "Booking_ID" et "date of reservation") # Récupérer la liste des noms de colonnes (en excluant "Booking_ID" et "date of reservation")
column_names = [col for col in dataframe.columns if col not in ["Booking_ID", "date of reservation"]] column_names = [col for col in dataframe.columns if col not in ["Booking_ID", "date of reservation"]]
...@@ -31,7 +31,6 @@ def scatter_plot_all_pairs_separate(dataframe, sheet_name, output_folder): ...@@ -31,7 +31,6 @@ def scatter_plot_all_pairs_separate(dataframe, sheet_name, output_folder):
# Charger les données depuis le fichier Excel avec la feuille spécifiée # Charger les données depuis le fichier Excel avec la feuille spécifiée
df = pd.read_excel("/Users/adrien/vscodeworkspace/data_mining_analyses/SEMMA/SAMPLE/booking.xlsx") df = pd.read_excel("/Users/adrien/vscodeworkspace/data_mining_analyses/SEMMA/SAMPLE/booking.xlsx")
# Spécifier le dossier de sortie
output_folder = "/Users/adrien/vscodeworkspace/data_mining_analyses/SEMMA/EXPLORE/analyses_multivariées/résultats/nuage de points" output_folder = "/Users/adrien/vscodeworkspace/data_mining_analyses/SEMMA/EXPLORE/analyses_multivariées/résultats/nuage de points"
sheet_name = "main_data_2017" sheet_name = "main_data_2017"
......
...@@ -2,7 +2,7 @@ import pandas as pd ...@@ -2,7 +2,7 @@ import pandas as pd
import matplotlib.pyplot as plt import matplotlib.pyplot as plt
# Remplacez 'votre_fichier_excel.xlsx' par le chemin vers votre fichier Excel # Remplacez 'votre_fichier_excel.xlsx' par le chemin vers votre fichier Excel
excel_file_path = 'DATA/xlsx/booking.xlsx' # Remplacez par le nom de votre feuille Excel excel_file_path = 'DATA/xlsx/booking.xlsx'
# Charger le fichier Excel en spécifiant la feuille # Charger le fichier Excel en spécifiant la feuille
df = pd.read_excel(excel_file_path, sheet_name="main_data_2017") df = pd.read_excel(excel_file_path, sheet_name="main_data_2017")
......
...@@ -3,7 +3,7 @@ import matplotlib.pyplot as plt ...@@ -3,7 +3,7 @@ import matplotlib.pyplot as plt
import seaborn as sns import seaborn as sns
import numpy as np import numpy as np
from scipy.stats import norm from scipy.stats import norm
import os # Importer le module os pour la gestion des fichiers import os
# Charger le fichier Excel # Charger le fichier Excel
excel_file_path = 'DATA/xlsx/booking.xlsx' excel_file_path = 'DATA/xlsx/booking.xlsx'
......
...@@ -17,10 +17,10 @@ def preprocess_dataframe(df): ...@@ -17,10 +17,10 @@ def preprocess_dataframe(df):
# Charger les données depuis le fichier Excel # Charger les données depuis le fichier Excel
train_df = pd.read_excel("SEMMA/SAMPLE/all_sets/validation_set.xlsx", sheet_name="Sheet1") train_df = pd.read_excel("SEMMA/SAMPLE/all_sets/validation_set.xlsx", sheet_name="Sheet1")
train_df = preprocess_dataframe(train_df) # Assurez-vous d'avoir cette fonction de prétraitement définie train_df = preprocess_dataframe(train_df)
# Sélectionner les caractéristiques pour le clustering # Sélectionner les caractéristiques pour le clustering
features = ['lead time', 'average price'] # Choisissez en fonction du type de clustering features = ['lead time', 'average price']
# Utilisation de l'algorithme K-Means # Utilisation de l'algorithme K-Means
kmeans = KMeans(n_clusters=4, random_state=42) kmeans = KMeans(n_clusters=4, random_state=42)
......
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
# ALL the imports # ALL the imports
import pandas as pd import pandas as pd
import numpy as np import numpy as np
import matplotlib.pyplot as plt import matplotlib.pyplot as plt
import seaborn as sns import seaborn as sns
import datetime as dt import datetime as dt
from sklearn.model_selection import train_test_split from sklearn.model_selection import train_test_split
from sklearn.model_selection import GridSearchCV from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import RandomForestClassifier from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC from sklearn.svm import SVC
from sklearn.metrics import accuracy_score from sklearn.metrics import accuracy_score
from sklearn.metrics import roc_curve from sklearn.metrics import roc_curve
from sklearn.metrics import roc_auc_score from sklearn.metrics import roc_auc_score
from sklearn.metrics import confusion_matrix, classification_report from sklearn.metrics import confusion_matrix, classification_report
from sklearn.feature_selection import SelectKBest, f_classif from sklearn.feature_selection import SelectKBest, f_classif
import warnings import warnings
warnings.filterwarnings('ignore') warnings.filterwarnings('ignore')
%matplotlib inline %matplotlib inline
scores = {} scores = {}
``` ```
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
df = pd.read_excel("/Users/adrien/vscodeworkspace/data_mining_analyses/SEMMA/SAMPLE/booking.xlsx",sheet_name="main_data_2017") df = pd.read_excel("/Users/adrien/vscodeworkspace/data_mining_analyses/SEMMA/SAMPLE/booking.xlsx",sheet_name="main_data_2017")
df = df.drop(['Booking_ID','date of reservation'], axis=1) df = df.drop(['Booking_ID','date of reservation'], axis=1)
df = pd.get_dummies(df, columns=['type of meal', 'room type', 'market segment type']) df = pd.get_dummies(df, columns=['type of meal', 'room type', 'market segment type'])
df['booking status'] = df['booking status'].replace({'Not_Canceled': 1, 'Canceled': 0}) df['booking status'] = df['booking status'].replace({'Not_Canceled': 1, 'Canceled': 0})
df["average price"] = df["average price"].round().astype(int) df["average price"] = df["average price"].round().astype(int)
#df['booking status'].value_counts() #df['booking status'].value_counts()
object_columns = df.select_dtypes(include=["object"]).columns object_columns = df.select_dtypes(include=["object"]).columns
df = pd.get_dummies(df, columns=object_columns) df = pd.get_dummies(df, columns=object_columns)
df = df.replace({True: 1, False: 0}) df = df.replace({True: 1, False: 0})
#df.info() #df.info()
#df.describe() #df.describe()
``` ```
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
def preprocess_dataframe(df): def preprocess_dataframe(df):
df = df.drop(['Booking_ID', 'date of reservation'], axis=1) df = df.drop(['Booking_ID', 'date of reservation'], axis=1)
df = pd.get_dummies(df, columns=['type of meal', 'room type', 'market segment type']) df = pd.get_dummies(df, columns=['type of meal', 'room type', 'market segment type'])
df['booking status'] = df['booking status'].replace({'Not_Canceled': 1, 'Canceled': 0}) df['booking status'] = df['booking status'].replace({'Not_Canceled': 1, 'Canceled': 0})
df["average price"] = df["average price"].round().astype(int) df["average price"] = df["average price"].round().astype(int)
object_columns = df.select_dtypes(include=["object"]).columns object_columns = df.select_dtypes(include=["object"]).columns
df = pd.get_dummies(df, columns=object_columns) df = pd.get_dummies(df, columns=object_columns)
df = df.replace({True: 1, False: 0}) df = df.replace({True: 1, False: 0})
return df return df
``` ```
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
# GENERATE A NEW DATA FRAME AND SEARCH WHAT ARE THE BEST FEATURES # GENERATE A NEW DATA FRAME AND SEARCH WHAT ARE THE BEST FEATURES
# do a dataframe without booking status # do a dataframe without booking status
features = df.drop(["booking status"], axis=1) features = df.drop(["booking status"], axis=1)
# create a target with the name booking status # create a target with the name booking status
target = df["booking status"] target = df["booking status"]
# Evaluate the features with stats # Evaluate the features with stats
k_best = SelectKBest(score_func=f_classif, k=10) k_best = SelectKBest(score_func=f_classif, k=10)
# ajuste le modèle pour inclure que les targets # ajuste le modèle pour inclure que les targets
X = k_best.fit_transform(features, target) X = k_best.fit_transform(features, target)
y = target y = target
# Get the indices of the selected features # Get the indices of the selected features
selected_features_indices = k_best.get_support(indices=True) selected_features_indices = k_best.get_support(indices=True)
# Get the scores associated with each feature # Get the scores associated with each feature
feature_scores = k_best.scores_ feature_scores = k_best.scores_
# Create a list of tuples containing feature names and scores # Create a list of tuples containing feature names and scores
feature_info = list(zip(features.columns, feature_scores)) feature_info = list(zip(features.columns, feature_scores))
# Sort the feature info in descending order based on scores # Sort the feature info in descending order based on scores
sorted_feature_info = sorted(feature_info, key=lambda x: x[1], reverse=True) sorted_feature_info = sorted(feature_info, key=lambda x: x[1], reverse=True)
for feature_name, feature_score in sorted_feature_info[:10]: for feature_name, feature_score in sorted_feature_info[:10]:
print(f"{feature_name}: {feature_score:.2f}") print(f"{feature_name}: {feature_score:.2f}")
``` ```
%% Output %% Output
lead time: 901.22 lead time: 901.22
type of meal_Meal Plan 2: 321.83 type of meal_Meal Plan 2: 321.83
type of meal_Meal Plan 1: 186.01 type of meal_Meal Plan 1: 186.01
special requests: 107.94 special requests: 107.94
number of adults: 88.87 number of adults: 88.87
room type_Room_Type 4: 70.83 room type_Room_Type 4: 70.83
room type_Room_Type 1: 65.16 room type_Room_Type 1: 65.16
number of weekend nights: 49.35 number of weekend nights: 49.35
repeated: 37.23 repeated: 37.23
type of meal_Not Selected: 26.81 type of meal_Not Selected: 26.81
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
# Charger l'ensemble d'entraînement # Charger l'ensemble d'entraînement
train_df = pd.read_excel("/Users/adrien/vscodeworkspace/data_mining_analyses/SEMMA/SAMPLE/all_sets/training_set.xlsx", sheet_name="Sheet1") train_df = pd.read_excel("/Users/adrien/vscodeworkspace/data_mining_analyses/SEMMA/SAMPLE/all_sets/training_set.xlsx", sheet_name="Sheet1")
train_df = preprocess_dataframe(train_df) train_df = preprocess_dataframe(train_df)
# Charger l'ensemble de validation # Charger l'ensemble de validation
valid_df = pd.read_excel("/Users/adrien/vscodeworkspace/data_mining_analyses/SEMMA/SAMPLE/all_sets/validation_set.xlsx", sheet_name="Sheet1") valid_df = pd.read_excel("/Users/adrien/vscodeworkspace/data_mining_analyses/SEMMA/SAMPLE/all_sets/validation_set.xlsx", sheet_name="Sheet1")
valid_df = preprocess_dataframe(valid_df) valid_df = preprocess_dataframe(valid_df)
# Séparer les données et la cible pour l'ensemble d'entraînement # Séparer les données et la cible pour l'ensemble d'entraînement
X_train = train_df.drop("booking status", axis=1) X_train = train_df.drop("booking status", axis=1)
y_train = train_df["booking status"] y_train = train_df["booking status"]
# Séparer les données et la cible pour l'ensemble de validation # Séparer les données et la cible pour l'ensemble de validation
X_valid = valid_df.drop("booking status", axis=1) X_valid = valid_df.drop("booking status", axis=1)
y_valid = valid_df["booking status"] y_valid = valid_df["booking status"]
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### Meilleurs modèles de prédiction ### Meilleurs modèles de prédiction
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### logistic regression ### logistic regression
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
# Créez et entraînez le modèle de régression logistique # Créer et entraîner le modèle de régression logistique
# Vérifiez la présence des colonnes spécifiées dans l'ensemble de validation # Vérifier la présence des colonnes spécifiées dans l'ensemble de validation
missing_columns = set(['type of meal', 'room type', 'market segment type']) - set(X_valid.columns) missing_columns = set(['type of meal', 'room type', 'market segment type']) - set(X_valid.columns)
# Affichez les colonnes manquantes # Afficher les colonnes manquantes
print("Colonnes manquantes dans l'ensemble de validation:", missing_columns) print("Colonnes manquantes dans l'ensemble de validation:", missing_columns)
# Réappliquez l'encodage one-hot sur l'ensemble de validation
if missing_columns: if missing_columns:
# Si des colonnes sont manquantes, ajoutez-les avec des valeurs nulles # Si des colonnes sont manquantes, ajoute avec des valeurs nulles
for col in missing_columns: for col in missing_columns:
X_valid[col] = 0 X_valid[col] = 0
# Réappliquez l'encodage one-hot sur l'ensemble de validation # Réappliquer l'encodage one-hot sur l'ensemble de validation
X_valid_encoded = pd.get_dummies(X_valid, columns=['type of meal', 'room type', 'market segment type']) X_valid_encoded = pd.get_dummies(X_valid, columns=['type of meal', 'room type', 'market segment type'])
# Assurez-vous que les colonnes dans X_valid_encoded sont dans le même ordre que dans X_train # on s'assure que les colonnes dans X_valid_encoded sont dans le même ordre que dans X_train
X_valid_encoded = X_valid_encoded[X_train.columns] X_valid_encoded = X_valid_encoded[X_train.columns]
log_reg = LogisticRegression() log_reg = LogisticRegression()
params = {"C": [0.01, 0.1, 1, 10, 100], "penalty": ["l1", "l2"]} params = {"C": [0.01, 0.1, 1, 10, 100], "penalty": ["l1", "l2"]}
grid_search = GridSearchCV(log_reg, param_grid=params, cv=5) grid_search = GridSearchCV(log_reg, param_grid=params, cv=5)
grid_search.fit(X_train, y_train) grid_search.fit(X_train, y_train)
# Affichez les meilleurs paramètres et le meilleur score # Afficher les meilleurs paramètres et le meilleur score
print(f"Best Parameters: {grid_search.best_params_}") print(f"Best Parameters: {grid_search.best_params_}")
print(f"Best Score: {grid_search.best_score_}") print(f"Best Score: {grid_search.best_score_}")
# Obtenez le meilleur modèle # Obtener le meilleur modèle
best_log_reg = grid_search.best_estimator_ best_log_reg = grid_search.best_estimator_
# Faites des prédictions sur l'ensemble de validation # Faire des prédictions sur l'ensemble de validation
y_pred = best_log_reg.predict(X_valid_encoded) y_pred = best_log_reg.predict(X_valid_encoded)
# Évaluez les performances du modèle sur l'ensemble de validation # Évaluer les performances du modèle sur l'ensemble de validation
print(f"Accuracy: {accuracy_score(y_valid, y_pred):.2f}") print(f"Accuracy: {accuracy_score(y_valid, y_pred):.2f}")
scores["Logistic Regression"] = accuracy_score(y_valid, y_pred) scores["Logistic Regression"] = accuracy_score(y_valid, y_pred)
print("---------------------------------------------------------") print("---------------------------------------------------------")
print(f"Confusion Matrix: \n{confusion_matrix(y_valid, y_pred)}") print(f"Confusion Matrix: \n{confusion_matrix(y_valid, y_pred)}")
sns.heatmap(confusion_matrix(y_valid, y_pred), annot=True, cmap="Blues", fmt=".0f") sns.heatmap(confusion_matrix(y_valid, y_pred), annot=True, cmap="Blues", fmt=".0f")
print("---------------------------------------------------------") print("---------------------------------------------------------")
print(f"Classification Report: \n{classification_report(y_valid, y_pred)}") print(f"Classification Report: \n{classification_report(y_valid, y_pred)}")
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### Decision Tree Classifier ### Decision Tree Classifier
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
best_dt = grid_search.best_estimator_ best_dt = grid_search.best_estimator_
# Vérifiez la présence des colonnes spécifiées dans l'ensemble de validation # Vérifie la présence des colonnes spécifiées dans l'ensemble de validation
missing_columns_dt = set(X_train.columns) - set(X_valid.columns) missing_columns_dt = set(X_train.columns) - set(X_valid.columns)
# Affichez les colonnes manquantes # Affiche les colonnes manquantes
print("Colonnes manquantes dans l'ensemble de validation pour Decision Tree:", missing_columns_dt) print("Colonnes manquantes dans l'ensemble de validation pour Decision Tree:", missing_columns_dt)
# Ajoutez les colonnes manquantes avec des valeurs nulles à l'ensemble de validation # Ajoute les colonnes manquantes avec des valeurs nulles à l'ensemble de validation
for col in missing_columns_dt: for col in missing_columns_dt:
X_valid[col] = 0 X_valid[col] = 0
# Assurez-vous que les colonnes dans X_valid sont dans le même ordre que dans X_train # Assure que les colonnes dans X_valid sont dans le même ordre que dans X_train
X_valid = X_valid[X_train.columns] X_valid = X_valid[X_train.columns]
# Faites des prédictions sur l'ensemble de validation avec le modèle Decision Tree # Fait des prédictions sur l'ensemble de validation avec le modèle Decision Tree
y_pred_dt = best_dt.predict(X_valid) y_pred_dt = best_dt.predict(X_valid)
# Évaluez les performances du modèle sur l'ensemble de validation # Évaluez les performances du modèle sur l'ensemble de validation
print(f"Accuracy for Decision Tree: {accuracy_score(y_valid, y_pred_dt):.2f}") print(f"Accuracy for Decision Tree: {accuracy_score(y_valid, y_pred_dt):.2f}")
scores["Decision Tree"] = accuracy_score(y_valid, y_pred_dt) scores["Decision Tree"] = accuracy_score(y_valid, y_pred_dt)
print("---------------------------------------------------------") print("---------------------------------------------------------")
print(f"Confusion Matrix for Decision Tree: \n{confusion_matrix(y_valid, y_pred_dt)}") print(f"Confusion Matrix for Decision Tree: \n{confusion_matrix(y_valid, y_pred_dt)}")
sns.heatmap(confusion_matrix(y_valid, y_pred_dt), annot=True, cmap="Blues", fmt=".0f") sns.heatmap(confusion_matrix(y_valid, y_pred_dt), annot=True, cmap="Blues", fmt=".0f")
print("---------------------------------------------------------") print("---------------------------------------------------------")
print(f"Classification Report for Decision Tree: \n{classification_report(y_valid, y_pred_dt)}") print(f"Classification Report for Decision Tree: \n{classification_report(y_valid, y_pred_dt)}")
# Probabilités prédites pour la classe positive # Probabilités prédites pour la classe positive
y_prob_dt = best_dt.predict_proba(X_valid)[:, 1] y_prob_dt = best_dt.predict_proba(X_valid)[:, 1]
# Calcul des taux de faux positifs et vrais positifs ainsi que l'aire sous la courbe ROC (AUC) # Calcul des taux de faux positifs et vrais positifs ainsi que l'aire sous la courbe ROC (AUC)
fpr_dt, tpr_dt, thresholds_dt = roc_curve(y_valid, y_prob_dt) fpr_dt, tpr_dt, thresholds_dt = roc_curve(y_valid, y_prob_dt)
roc_auc_dt = auc(fpr_dt, tpr_dt) roc_auc_dt = auc(fpr_dt, tpr_dt)
# Tracer la courbe ROC pour Decision Tree Classifier # Tracer la courbe ROC pour Decision Tree Classifier
plt.figure(figsize=(8, 8)) plt.figure(figsize=(8, 8))
plt.plot(fpr_dt, tpr_dt, color='darkorange', lw=2, label='ROC curve (AUC = {:.2f})'.format(roc_auc_dt)) plt.plot(fpr_dt, tpr_dt, color='darkorange', lw=2, label='ROC curve (AUC = {:.2f})'.format(roc_auc_dt))
plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--') plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
plt.xlabel('False Positive Rate') plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate') plt.ylabel('True Positive Rate')
plt.title('Receiver Operating Characteristic (ROC) Curve for Decision Tree Classifier') plt.title('Receiver Operating Characteristic (ROC) Curve for Decision Tree Classifier')
plt.legend(loc='lower right') plt.legend(loc='lower right')
plt.show() plt.show()
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### Random Forest ### Random Forest
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
from sklearn.ensemble import RandomForestClassifier from sklearn.ensemble import RandomForestClassifier
# Créez et entraînez le modèle Random Forest # Crée et entraîne le modèle Random Forest
rf = RandomForestClassifier(max_depth=20, n_estimators=20) rf = RandomForestClassifier(max_depth=20, n_estimators=20)
rf.fit(X_train, y_train) rf.fit(X_train, y_train)
# Vérifiez la présence des colonnes spécifiées dans l'ensemble de test # Vérifie la présence des colonnes spécifiées dans l'ensemble de test
missing_columns_rf = set(X_train.columns) - set(X_valid.columns) missing_columns_rf = set(X_train.columns) - set(X_valid.columns)
# Affichez les colonnes manquantes # Affiche les colonnes manquantes
print("Colonnes manquantes dans l'ensemble de test pour Random Forest:", missing_columns_rf) print("Colonnes manquantes dans l'ensemble de test pour Random Forest:", missing_columns_rf)
# Ajoutez les colonnes manquantes avec des valeurs nulles à l'ensemble de test # Ajoute les colonnes manquantes avec des valeurs nulles à l'ensemble de test
for col in missing_columns_rf: for col in missing_columns_rf:
X_valid[col] = 0 X_valid[col] = 0
# Assurez-vous que les colonnes dans X_test sont dans le même ordre que dans X_train # Assure que les colonnes dans X_test sont dans le même ordre que dans X_train
X_valid = X_valid[X_train.columns] X_valid = X_valid[X_train.columns]
# Faites des prédictions sur l'ensemble de test avec le modèle Random Forest # Fait des prédictions sur l'ensemble de test avec le modèle Random Forest
y_pred_rf = rf.predict(X_valid) y_pred_rf = rf.predict(X_valid)
# Évaluez les performances du modèle sur l'ensemble de test # Évalue les performances du modèle sur l'ensemble de test
print(f"Accuracy for Random Forest: {accuracy_score(y_valid, y_pred_rf):.2f}") print(f"Accuracy for Random Forest: {accuracy_score(y_valid, y_pred_rf):.2f}")
scores["Random Forest"] = accuracy_score(y_valid, y_pred_rf) scores["Random Forest"] = accuracy_score(y_valid, y_pred_rf)
print("---------------------------------------------------------") print("---------------------------------------------------------")
print(f"Confusion Matrix for Random Forest: \n{confusion_matrix(y_valid, y_pred_rf)}") print(f"Confusion Matrix for Random Forest: \n{confusion_matrix(y_valid, y_pred_rf)}")
sns.heatmap(confusion_matrix(y_valid, y_pred_rf), annot=True, cmap="Blues", fmt=".0f") sns.heatmap(confusion_matrix(y_valid, y_pred_rf), annot=True, cmap="Blues", fmt=".0f")
print("---------------------------------------------------------") print("---------------------------------------------------------")
print(f"Classification Report for Random Forest: \n{classification_report(y_valid, y_pred_rf)}") print(f"Classification Report for Random Forest: \n{classification_report(y_valid, y_pred_rf)}")
# Probabilités prédites pour la classe positive # Probabilités prédites pour la classe positive
y_prob_rf = rf.predict_proba(X_valid)[:, 1] y_prob_rf = rf.predict_proba(X_valid)[:, 1]
# Calcul des taux de faux positifs et vrais positifs ainsi que l'aire sous la courbe ROC (AUC) # Calcul des taux de faux positifs et vrais positifs ainsi que l'aire sous la courbe ROC (AUC)
fpr_rf, tpr_rf, thresholds_rf = roc_curve(y_valid, y_prob_rf) fpr_rf, tpr_rf, thresholds_rf = roc_curve(y_valid, y_prob_rf)
roc_auc_rf = auc(fpr_rf, tpr_rf) roc_auc_rf = auc(fpr_rf, tpr_rf)
# Tracer la courbe ROC pour Random Forest # Trace la courbe ROC pour Random Forest
plt.figure(figsize=(8, 8)) plt.figure(figsize=(8, 8))
plt.plot(fpr_rf, tpr_rf, color='darkorange', lw=2, label='ROC curve (AUC = {:.2f})'.format(roc_auc_rf)) plt.plot(fpr_rf, tpr_rf, color='darkorange', lw=2, label='ROC curve (AUC = {:.2f})'.format(roc_auc_rf))
plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--') plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
plt.xlabel('False Positive Rate') plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate') plt.ylabel('True Positive Rate')
plt.title('Receiver Operating Characteristic (ROC) Curve for Random Forest') plt.title('Receiver Operating Characteristic (ROC) Curve for Random Forest')
plt.legend(loc='lower right') plt.legend(loc='lower right')
plt.show() plt.show()
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### Neural Network ### Neural Network
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
from tensorflow import keras from tensorflow import keras
from tensorflow.keras.models import Sequential from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense from tensorflow.keras.layers import Dense
# Créez le modèle # Crée le modèle
model = Sequential() model = Sequential()
# Ajoutez une couche cachée avec 64 neurones et une fonction d'activation ReLU # Ajoute une couche cachée avec 64 neurones et une fonction d'activation ReLU
model.add(Dense(64, input_dim=X_train.shape[1], activation='relu')) model.add(Dense(64, input_dim=X_train.shape[1], activation='relu'))
# Ajoutez une couche de sortie avec une fonction d'activation sigmoid pour la classification binaire # Ajoute une couche de sortie avec une fonction d'activation sigmoid pour la classification binaire
model.add(Dense(1, activation='sigmoid')) model.add(Dense(1, activation='sigmoid'))
# Compilez le modèle avec une fonction de perte (loss) binaire_crossentropy et un optimiseur comme Adam # Compile le modèle avec une fonction de perte (loss) binaire_crossentropy et un optimiseur comme Adam
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
# Entraînez le modèle sur l'ensemble d'entraînement # Entraîne le modèle sur l'ensemble d'entraînement
model.fit(X_train, y_train, epochs=10, batch_size=32, validation_data=(X_valid, y_valid)) model.fit(X_train, y_train, epochs=10, batch_size=32, validation_data=(X_valid, y_valid))
# Faites des prédictions sur l'ensemble de validation # Fait des prédictions sur l'ensemble de validation
y_pred_nn = model.predict(X_valid) y_pred_nn = model.predict(X_valid)
y_pred_nn = (y_pred_nn > 0.5).astype(int) y_pred_nn = (y_pred_nn > 0.5).astype(int)
# Évaluez les performances du modèle sur l'ensemble de validation # Évalue les performances du modèle sur l'ensemble de validation
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
print(f"Accuracy for Neural Network: {accuracy_score(y_valid, y_pred_nn):.2f}") print(f"Accuracy for Neural Network: {accuracy_score(y_valid, y_pred_nn):.2f}")
scores["Neural Network"] = accuracy_score(y_valid, y_pred_nn) scores["Neural Network"] = accuracy_score(y_valid, y_pred_nn)
print("---------------------------------------------------------") print("---------------------------------------------------------")
print(f"Confusion Matrix for Neural Network: \n{confusion_matrix(y_valid, y_pred_nn)}") print(f"Confusion Matrix for Neural Network: \n{confusion_matrix(y_valid, y_pred_nn)}")
sns.heatmap(confusion_matrix(y_valid, y_pred_nn), annot=True, cmap="Blues", fmt=".0f") sns.heatmap(confusion_matrix(y_valid, y_pred_nn), annot=True, cmap="Blues", fmt=".0f")
print("---------------------------------------------------------") print("---------------------------------------------------------")
print(f"Classification Report for Neural Network: \n{classification_report(y_valid, y_pred_nn)}") print(f"Classification Report for Neural Network: \n{classification_report(y_valid, y_pred_nn)}")
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### Models Comparison ### Models Comparison
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
for model, score in scores.items(): for model, score in scores.items():
print(f"{model}: {score:.4f}") print(f"{model}: {score:.4f}")
``` ```
......
Aucun aperçu pour ce type de fichier
0% Chargement en cours ou .
You are about to add 0 people to the discussion. Proceed with caution.
Terminez d'abord l'édition de ce message.
Veuillez vous inscrire ou vous pour commenter