2 lines (1 with data), 366.6 kB

{"cells":[{"cell_type":"code","execution_count":2,"metadata":{"execution":{"iopub.execute_input":"2024-06-14T17:14:02.183007Z","iopub.status.busy":"2024-06-14T17:14:02.182568Z","iopub.status.idle":"2024-06-14T17:14:06.187080Z","shell.execute_reply":"2024-06-14T17:14:06.185673Z","shell.execute_reply.started":"2024-06-14T17:14:02.182972Z"},"trusted":true},"outputs":[],"source":["# Configuration du chemin d'accès\n","import sys\n","import os\n","sys.path.append(os.path.abspath(os.path.join('..', 'src')))\n","\n","# Configuration du chemin d'accès\n","import sys\n","import os\n","sys.path.append(os.path.abspath(os.path.join('..', 'src')))\n","\n","# PANDAS\n","import pandas as pd \n","pd.set_option(\"display.max_rows\", None, \"display.max_columns\", None) \n","\n","# WARNINGS\n","import warnings\n","warnings.filterwarnings('ignore')\n","\n","# NUMPY\n","import numpy as np\n","\n","# STATS\n","import scipy.stats as stats\n","from scipy.stats import norm, skew\n","import scipy as sp\n","from scipy.stats import chi2_contingency\n","\n","# MATPLOTLIB\n","import matplotlib as mlp\n","import matplotlib.pyplot as plt\n","plt.style.use('fivethirtyeight') \n","%matplotlib inline\n","\n","# PANDAS\n","import pandas as pd \n","pd.set_option(\"display.max_rows\", None, \"display.max_columns\", None) \n","\n","# SEABORN\n","import seaborn as sns\n","\n","# SCIKIT-LEARN: MODELES\n","from sklearn.linear_model import LogisticRegression # Régression logistique\n","from sklearn.svm import SVC # Support Vector Classifier\n","from sklearn.ensemble import RandomForestClassifier # Random Forest\n","from sklearn.ensemble import GradientBoostingClassifier # Gradient Boosting\n","from sklearn.ensemble import AdaBoostClassifier # AdaBoost\n","from sklearn.ensemble import BaggingClassifier # Bagging\n","\n","\n","# SCIKIT-LEARN: VALIDATION CROISEE + OPTIMISATION\n","from sklearn.model_selection import train_test_split # Séparer en données train et test\n","from sklearn.model_selection import cross_val_score # Validation croisée pour comparison entre modèles\n","from sklearn.model_selection import validation_curve # Courbe de validation : visulaisr des scores lors du choix d'un hyper-paramètre\n","from sklearn.model_selection import GridSearchCV # Tester plusieurs hyper-paramètres\n","from sklearn.model_selection import learning_curve # Courbe d'apprentissage : visualisation des scores du train et du validation sets en fonction des quanitiés des données\n","from sklearn.impute import SimpleImputer\n","from sklearn.preprocessing import OrdinalEncoder\n","\n"," ## YellowBrick\n","from yellowbrick.model_selection import LearningCurve\n","from yellowbrick.model_selection import ValidationCurve\n","\n","## EVALUATION\n","from sklearn.metrics import accuracy_score\n","from sklearn.metrics import f1_score\n","from sklearn.metrics import confusion_matrix\n","from sklearn.metrics import ConfusionMatrixDisplay\n","from sklearn.metrics import classification_report\n","\n","# SCHIKIT-LEARN: PIPELINE AND TRANSFORMATEURll\n","from sklearn.pipeline import make_pipeline\n","from sklearn.compose import make_column_transformer"]},{"cell_type":"code","execution_count":3,"metadata":{"execution":{"iopub.execute_input":"2024-06-14T17:14:06.189932Z","iopub.status.busy":"2024-06-14T17:14:06.189341Z","iopub.status.idle":"2024-06-14T17:14:06.836996Z","shell.execute_reply":"2024-06-14T17:14:06.835598Z","shell.execute_reply.started":"2024-06-14T17:14:06.189891Z"},"trusted":true},"outputs":[],"source":["data = pd.read_csv('/kaggle/input/smoking-drinking-dataset/smoking_driking_dataset_Ver01.csv'\n","                   , nrows=100000\n","                )\n","df_smoking_drinking = data.copy()"]},{"cell_type":"code","execution_count":4,"metadata":{"execution":{"iopub.execute_input":"2024-06-14T17:14:08.670551Z","iopub.status.busy":"2024-06-14T17:14:08.670120Z","iopub.status.idle":"2024-06-14T17:14:08.678701Z","shell.execute_reply":"2024-06-14T17:14:08.677478Z","shell.execute_reply.started":"2024-06-14T17:14:08.670511Z"},"trusted":true},"outputs":[],"source":["def preprocess_data(data, target):\n","    X = data.drop(columns=[target])\n","    y = data[target]\n","    return X, y\n","\n","def split_data(data, target, test_size=0.2, val_size=0.1):\n","    X, y = preprocess_data(data, target)\n","    X_train, X_temp, y_train, y_temp = train_test_split(X, y, test_size=test_size + val_size, stratify=y)\n","    X_val, X_test, y_val, y_test = train_test_split(X_temp, y_temp, test_size=test_size / (test_size + val_size), stratify=y_temp)\n","    return X_train, X_val, X_test, y_train, y_val, y_test"]},{"cell_type":"code","execution_count":5,"metadata":{"execution":{"iopub.execute_input":"2024-06-14T17:14:11.727056Z","iopub.status.busy":"2024-06-14T17:14:11.726604Z","iopub.status.idle":"2024-06-14T17:14:11.859708Z","shell.execute_reply":"2024-06-14T17:14:11.858423Z","shell.execute_reply.started":"2024-06-14T17:14:11.727026Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["X_train shape: (69999, 23)\n","X_val shape: (10000, 23)\n","X_test shape: (20001, 23)\n"]}],"source":["X_train, X_val, X_test, y_train, y_val, y_test = split_data(df_smoking_drinking, 'SMK_stat_type_cd')\n","\n","print('X_train shape:', X_train.shape)\n","print('X_val shape:', X_val.shape)\n","print('X_test shape:', X_test.shape)"]},{"attachments":{},"cell_type":"markdown","metadata":{},"source":["# Séparation variables continue/catégorielles"]},{"cell_type":"code","execution_count":6,"metadata":{"execution":{"iopub.execute_input":"2024-06-14T17:14:14.433968Z","iopub.status.busy":"2024-06-14T17:14:14.433497Z","iopub.status.idle":"2024-06-14T17:14:14.454777Z","shell.execute_reply":"2024-06-14T17:14:14.453533Z","shell.execute_reply.started":"2024-06-14T17:14:14.433932Z"},"trusted":true},"outputs":[],"source":["# Normalisation des variables continues\n","from sklearn.preprocessing import StandardScaler\n","\n","cont_features = df_smoking_drinking.select_dtypes('float64').columns\n","cont_features = cont_features.drop('SMK_stat_type_cd')\n","\n","cat_features = df_smoking_drinking.select_dtypes(include = ['int64', 'object']).columns\n","cat_features = cat_features.drop(['DRK_YN'])"]},{"cell_type":"code","execution_count":7,"metadata":{"execution":{"iopub.execute_input":"2024-06-14T17:14:16.513598Z","iopub.status.busy":"2024-06-14T17:14:16.513171Z","iopub.status.idle":"2024-06-14T17:14:16.522450Z","shell.execute_reply":"2024-06-14T17:14:16.521146Z","shell.execute_reply.started":"2024-06-14T17:14:16.513564Z"},"trusted":true},"outputs":[],"source":["def create_model_pipeline(cat_features, cont_features, model_class, **model_params):\n","    # Créer les pipelines pour les caractéristiques catégorielles et numériques\n","    categorical_pipeline = make_pipeline(\n","        SimpleImputer(strategy='most_frequent'),\n","        OrdinalEncoder(handle_unknown='use_encoded_value', unknown_value=-1)  # Gérer les catégories inconnues\n","    )\n","\n","    numeric_pipeline = make_pipeline(\n","        SimpleImputer(),\n","        StandardScaler()\n","    )\n","\n","    # Créer le préprocesseur\n","    preprocessor_robust = make_column_transformer(\n","        (categorical_pipeline, cat_features),\n","        (numeric_pipeline, cont_features)\n","    )\n","\n","    # Créer le pipeline avec le modèle spécifié et ses paramètres\n","    model_pipeline = make_pipeline(preprocessor_robust, model_class(**model_params))\n","    return model_pipeline\n"]},{"cell_type":"code","execution_count":8,"metadata":{"execution":{"iopub.execute_input":"2024-06-14T17:14:20.653547Z","iopub.status.busy":"2024-06-14T17:14:20.653080Z","iopub.status.idle":"2024-06-14T17:14:20.665796Z","shell.execute_reply":"2024-06-14T17:14:20.664301Z","shell.execute_reply.started":"2024-06-14T17:14:20.653507Z"},"trusted":true},"outputs":[],"source":["def train_and_evaluate_model(model, X_train, y_train, X_test, y_test, model_name):\n","    print('\\n\\n')\n","    print(f\"--- Evaluation du modèle : {model_name} ---\")\n","\n","    # Entraînement du modèle\n","    model.fit(X_train, y_train)\n","\n","    # Prédiction sur le jeu de test\n","    y_test_pred = model.predict(X_test)\n","\n","    # Évaluation du modèle\n","    accuracy = accuracy_score(y_test, y_test_pred)\n","    f1 = f1_score(y_test, y_test_pred, average='weighted')\n","    print('Accuracy:', accuracy)\n","    print('F1:', f1)\n","\n","    # Matrice de confusion\n","    cm = confusion_matrix(y_test, y_test_pred)\n","    disp = ConfusionMatrixDisplay(confusion_matrix=cm)\n","    fig, ax = plt.subplots(figsize=(10, 10))\n","    plt.title(f\"Confusion Matrix for {model_name}\")  # Add model name to the title\n","    disp.plot(ax=ax, values_format='d')  # Utiliser le format 'd' pour afficher les nombres entiers\n","\n","\n","    # Rapport de classification\n","    print(classification_report(y_test, y_test_pred))\n","\n","    # Score du modèle\n","    score = model.score(X_test, y_test)\n","    print('Score :', score)\n","    \n","    return accuracy, f1, score"]},{"cell_type":"code","execution_count":9,"metadata":{"execution":{"iopub.execute_input":"2024-06-14T17:14:32.251994Z","iopub.status.busy":"2024-06-14T17:14:32.251539Z","iopub.status.idle":"2024-06-14T17:14:32.261867Z","shell.execute_reply":"2024-06-14T17:14:32.260385Z","shell.execute_reply.started":"2024-06-14T17:14:32.251961Z"},"trusted":true},"outputs":[],"source":["import numpy as np\n","import matplotlib.pyplot as plt\n","from yellowbrick.model_selection import LearningCurve\n","\n","def plot_learning_curve(pipeline, X_train, y_train, model_name=\"Model\", cv=3, scoring='accuracy'):\n","    # Extract the last estimator from the pipeline\n","    model_step_name = list(pipeline.named_steps.keys())[-1]\n","    model = pipeline.named_steps[model_step_name]\n","    \n","    plt.figure()\n","    visualizer = LearningCurve(\n","        model,\n","        cv=cv,\n","        scoring=scoring,\n","        train_sizes=np.linspace(0.1, 1.0, 10),\n","        n_jobs=-1\n","    )\n","    visualizer.fit(pipeline[:-1].fit_transform(X_train, y_train), y_train)\n","    visualizer.finalize()\n","    visualizer.show(title=f\"Learning Curve for {model_name}\")\n","    plt.show()\n"]},{"cell_type":"code","execution_count":10,"metadata":{"execution":{"iopub.execute_input":"2024-06-14T17:14:34.607948Z","iopub.status.busy":"2024-06-14T17:14:34.607487Z","iopub.status.idle":"2024-06-14T17:14:34.617990Z","shell.execute_reply":"2024-06-14T17:14:34.616292Z","shell.execute_reply.started":"2024-06-14T17:14:34.607911Z"},"trusted":true},"outputs":[],"source":["import numpy as np\n","import matplotlib.pyplot as plt\n","from yellowbrick.model_selection import ValidationCurve\n","\n","def plot_validation_curve(pipeline, X_train, y_train, param_name, param_range, model_name=\"Model\", cv=3, scoring='accuracy'):\n","    # Extract the last estimator from the pipeline\n","    model_step_name = list(pipeline.named_steps.keys())[-1]\n","    model = pipeline.named_steps[model_step_name]\n","    \n","    plt.figure()\n","    visualizer = ValidationCurve(\n","        model, param_name=param_name, param_range=param_range,\n","        cv=cv, scoring=scoring, n_jobs=-1\n","    )\n","    visualizer.fit(pipeline[:-1].fit_transform(X_train, y_train), y_train)\n","    visualizer.finalize()\n","    visualizer.show(title=f\"Validation Curve for {model_name} with parameter {param_name}\")\n","    plt.show()\n"]},{"attachments":{},"cell_type":"markdown","metadata":{},"source":["## Apprentissage par ensemble - Pipeline"]},{"cell_type":"code","execution_count":27,"metadata":{"execution":{"iopub.execute_input":"2024-06-14T18:08:00.045955Z","iopub.status.busy":"2024-06-14T18:08:00.045512Z","iopub.status.idle":"2024-06-14T18:08:00.053062Z","shell.execute_reply":"2024-06-14T18:08:00.051706Z","shell.execute_reply.started":"2024-06-14T18:08:00.045921Z"},"trusted":true},"outputs":[],"source":["# Création du pipeline RandomForest\n","rf_pipeline = create_model_pipeline(\n","    cat_features, cont_features, RandomForestClassifier, random_state=42, class_weight='balanced')\n","\n","# Création du pipeline GradientBoosting\n","gb_pipeline = create_model_pipeline(\n","    cat_features, cont_features, GradientBoostingClassifier, n_estimators=300, learning_rate=0.1, max_depth=3,random_state=42)\n"]},{"cell_type":"code","execution_count":13,"metadata":{"execution":{"iopub.execute_input":"2024-06-14T09:41:58.379841Z","iopub.status.busy":"2024-06-14T09:41:58.379519Z","iopub.status.idle":"2024-06-14T09:45:22.175731Z","shell.execute_reply":"2024-06-14T09:45:22.174757Z","shell.execute_reply.started":"2024-06-14T09:41:58.379816Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["\n","\n","\n","--- Evaluation du modèle : RandomForest ---\n","Accuracy: 0.6785660716964151\n","F1: 0.6997764771537723\n","              precision    recall  f1-score   support\n","\n","         1.0       0.94      0.73      0.82     12112\n","         2.0       0.42      0.58      0.49      3551\n","         3.0       0.48      0.62      0.54      4338\n","\n","    accuracy                           0.68     20001\n","   macro avg       0.61      0.64      0.61     20001\n","weighted avg       0.75      0.68      0.70     20001\n","\n","Score : 0.6785660716964151\n","\n","\n","\n","--- Evaluation du modèle : GradientBoosting ---\n","Accuracy: 0.7000649967501625\n","F1: 0.7012485169618449\n","              precision    recall  f1-score   support\n","\n","         1.0       0.84      0.83      0.83     12112\n","         2.0       0.45      0.42      0.43      3551\n","         3.0       0.52      0.58      0.55      4338\n","\n","    accuracy                           0.70     20001\n","   macro avg       0.60      0.61      0.61     20001\n","weighted avg       0.70      0.70      0.70     20001\n","\n","Score : 0.7000649967501625\n","CPU times: user 3min 22s, sys: 65.8 ms, total: 3min 23s\n","Wall time: 3min 23s\n"]},{"data":{"text/plain":["(0.7000649967501625, 0.7012485169618449, 0.7000649967501625)"]},"execution_count":13,"metadata":{},"output_type":"execute_result"},{"data":{"image/png":"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","text/plain":["<Figure size 1000x1000 with 2 Axes>"]},"metadata":{},"output_type":"display_data"},{"data":{"image/png":"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","text/plain":["<Figure size 1000x1000 with 2 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["%%time\n","train_and_evaluate_model(rf_pipeline, X_train, y_train, X_test, y_test, model_name='RandomForest')\n","train_and_evaluate_model(gb_pipeline, X_train, y_train, X_test, y_test, model_name='GradientBoosting')"]},{"cell_type":"code","execution_count":17,"metadata":{"execution":{"iopub.execute_input":"2024-06-14T09:46:54.996725Z","iopub.status.busy":"2024-06-14T09:46:54.995604Z","iopub.status.idle":"2024-06-14T10:06:05.459503Z","shell.execute_reply":"2024-06-14T10:06:05.458405Z","shell.execute_reply.started":"2024-06-14T09:46:54.996690Z"},"trusted":true},"outputs":[{"data":{"image/png":"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","text/plain":["<Figure size 800x550 with 1 Axes>"]},"metadata":{},"output_type":"display_data"},{"data":{"image/png":"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","text/plain":["<Figure size 800x550 with 1 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["# Affichage de la courbe d'apprentissage\n","plot_learning_curve(rf_pipeline, X_train, y_train, model_name=\"RandomForest\")\n","plot_learning_curve(gb_pipeline, X_train, y_train, model_name=\"GradientBoosting\")\n"]},{"cell_type":"code","execution_count":null,"metadata":{"execution":{"iopub.execute_input":"2024-06-14T10:06:05.462494Z","iopub.status.busy":"2024-06-14T10:06:05.462050Z"},"trusted":true},"outputs":[{"data":{"image/png":"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","text/plain":["<Figure size 800x550 with 1 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["# Affichage de la courbe de validation pour le paramètre 'n_estimators'\n","param_range_n_estimators = np.arange(50, 1501, 50)  # Valeurs pour n_estimators\n","plot_validation_curve(rf_pipeline, X_train, y_train, param_name='n_estimators', param_range=param_range_n_estimators, model_name=\"RandomForest\")"]},{"cell_type":"code","execution_count":null,"metadata":{"execution":{"iopub.execute_input":"2024-06-14T12:46:11.686495Z","iopub.status.busy":"2024-06-14T12:46:11.685755Z"},"trusted":true},"outputs":[],"source":["# Affichage de la courbe de validation pour le paramètre 'n_estimators'\n","param_range_n_estimators = np.arange(50, 1501, 50)  # Valeurs pour n_estimators\n","plot_validation_curve(gb_pipeline, X_train, y_train, param_name='n_estimators', param_range=param_range_n_estimators, model_name=\"GradientBoosting\")\n"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["import optuna\n","from sklearn.ensemble import GradientBoostingClassifier\n","from sklearn.model_selection import cross_val_score\n","from sklearn.metrics import accuracy_score, f1_score, confusion_matrix, ConfusionMatrixDisplay, classification_report\n","import matplotlib.pyplot as plt\n","\n","def hyperoptimize_gb_model(pipeline, X_train, y_train, X_test, y_test, n_trials=5, timeout=600):\n","    # Définissez la fonction objective pour Optuna\n","    def objective(trial):\n","        n_estimators = trial.suggest_int('gradientboostingclassifier__n_estimators',5, 2000)\n","        learning_rate = trial.suggest_loguniform('gradientboostingclassifier__learning_rate', 0.01, 0.3)\n","        max_depth = trial.suggest_int('gradientboostingclassifier__max_depth', 2, 32)\n","        min_samples_split = trial.suggest_int('gradientboostingclassifier__min_samples_split', 2, 10)\n","        min_samples_leaf = trial.suggest_int('gradientboostingclassifier__min_samples_leaf', 2, 10)\n","        \n","        pipeline.set_params(\n","            gradientboostingclassifier__n_estimators=n_estimators,\n","            gradientboostingclassifier__learning_rate=learning_rate,\n","            gradientboostingclassifier__max_depth=max_depth,\n","            gradientboostingclassifier__min_samples_split=min_samples_split,\n","            gradientboostingclassifier__min_samples_leaf=min_samples_leaf\n","        )\n","\n","        # Apply the preprocessing steps except the last step\n","        X_train_transformed = pipeline[:-1].fit_transform(X_train, y_train)\n","        score = cross_val_score(pipeline.named_steps['gradientboostingclassifier'], X_train_transformed, y_train, cv=3, scoring='accuracy').mean()\n","        return score\n","\n","    # Créez un objet study et optimisez la fonction objective\n","    study = optuna.create_study(direction='maximize')\n","    study.optimize(objective, n_trials=n_trials, timeout=timeout)\n","\n","    # Affichez les meilleurs hyperparamètres\n","    print('Best parameters:', study.best_params)\n","\n","    # Entraînez le modèle avec les meilleurs hyperparamètres\n","    pipeline.set_params(**study.best_params)\n","    pipeline.fit(X_train, y_train)\n","\n","    # Prédiction sur le jeu de test\n","    y_test_pred = pipeline.predict(X_test)\n","\n","    # Évaluation du modèle\n","    accuracy = accuracy_score(y_test, y_test_pred)\n","    f1 = f1_score(y_test, y_test_pred, average='weighted')\n","    print('Accuracy on test set:', accuracy)\n","    print('F1 score on test set:', f1)\n","\n","    # Matrice de confusion\n","    cm = confusion_matrix(y_test, y_test_pred)\n","    disp = ConfusionMatrixDisplay(confusion_matrix=cm)\n","    fig, ax = plt.subplots(figsize=(10, 10))\n","    disp.plot(ax=ax, values_format='d')  # Utiliser le format 'd' pour afficher les nombres entiers\n","    plt.title(\"Confusion Matrix for GradientBoostingClassifier\")\n","    plt.show()\n","\n","\n","    # Rapport de classification\n","    print(classification_report(y_test, y_test_pred))\n","\n","    return study.best_params, accuracy, f1\n"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["%%time\n","# Hyper-optimisation pour GradientBoosting\n","best_params_gb, accuracy_gb, f1_gb = hyperoptimize_gb_model(\n","    gb_pipeline, X_train, y_train, X_test, y_test, n_trials=5, timeout=600)"]},{"cell_type":"code","execution_count":24,"metadata":{"execution":{"iopub.execute_input":"2024-06-14T18:07:19.743354Z","iopub.status.busy":"2024-06-14T18:07:19.742210Z","iopub.status.idle":"2024-06-14T18:07:20.147821Z","shell.execute_reply":"2024-06-14T18:07:20.146580Z","shell.execute_reply.started":"2024-06-14T18:07:19.743312Z"},"trusted":true},"outputs":[],"source":["import optuna\n","from sklearn.ensemble import RandomForestClassifier\n","from sklearn.model_selection import cross_val_score\n","from sklearn.metrics import accuracy_score, f1_score, confusion_matrix, ConfusionMatrixDisplay, classification_report\n","import matplotlib.pyplot as plt\n","\n","def hyperoptimize_rf_model(pipeline, X_train, y_train, X_test, y_test, n_trials=5, timeout=600):\n","    # Définissez la fonction objective pour Optuna\n","    def objective(trial):\n","        n_estimators = trial.suggest_int('randomforestclassifier__n_estimators', 50, 2000)\n","        max_depth = trial.suggest_int('randomforestclassifier__max_depth', 2, 32)\n","        min_samples_split = trial.suggest_int('randomforestclassifier__min_samples_split', 2, 15)\n","        min_samples_leaf = trial.suggest_int('randomforestclassifier__min_samples_leaf', 3, 10)\n","        \n","        pipeline.set_params(\n","            randomforestclassifier__n_estimators=n_estimators,\n","            randomforestclassifier__max_depth=max_depth,\n","            randomforestclassifier__min_samples_split=min_samples_split,\n","            randomforestclassifier__min_samples_leaf=min_samples_leaf\n","        )\n","\n","        # Apply the preprocessing steps except the last step\n","        X_train_transformed = pipeline[:-1].fit_transform(X_train, y_train)\n","        score = cross_val_score(pipeline.named_steps['randomforestclassifier'], X_train_transformed, y_train, cv=3, scoring='accuracy').mean()\n","        return score\n","\n","    # Créez un objet study et optimisez la fonction objective\n","    study = optuna.create_study(direction='maximize')\n","    study.optimize(objective, n_trials=n_trials, timeout=timeout)\n","\n","    # Affichez les meilleurs hyperparamètres\n","    print('Best parameters:', study.best_params)\n","\n","    # Entraînez le modèle avec les meilleurs hyperparamètres\n","    pipeline.set_params(**study.best_params)\n","    pipeline.fit(X_train, y_train)\n","\n","    # Prédiction sur le jeu de test\n","    y_test_pred = pipeline.predict(X_test)\n","\n","    # Évaluation du modèle\n","    accuracy = accuracy_score(y_test, y_test_pred)\n","    f1 = f1_score(y_test, y_test_pred, average='weighted')\n","    print('Accuracy on test set:', accuracy)\n","    print('F1 score on test set:', f1)\n","\n","    # Matrice de confusion\n","    cm = confusion_matrix(y_test, y_test_pred)\n","    disp = ConfusionMatrixDisplay(confusion_matrix=cm)\n","    fig, ax = plt.subplots(figsize=(10, 10))\n","    disp.plot(ax=ax, values_format='d')  # Utiliser le format 'd' pour afficher les nombres entiers\n","    plt.title(\"Confusion Matrix for RandomForestClassifier\")\n","    plt.show()\n","\n","    # Rapport de classification\n","    print(classification_report(y_test, y_test_pred))\n","\n","    return study.best_params, accuracy, f1\n"]},{"cell_type":"code","execution_count":28,"metadata":{"collapsed":true,"execution":{"iopub.execute_input":"2024-06-14T18:08:13.657862Z","iopub.status.busy":"2024-06-14T18:08:13.657426Z","iopub.status.idle":"2024-06-14T18:14:14.141088Z","shell.execute_reply":"2024-06-14T18:14:14.139640Z","shell.execute_reply.started":"2024-06-14T18:08:13.657828Z"},"jupyter":{"outputs_hidden":true},"trusted":true},"outputs":[{"name":"stderr","output_type":"stream","text":["[I 2024-06-14 18:08:13,660] A new study created in memory with name: no-name-3ebd0091-70f3-4ad3-bfe2-ca7559ea5b30\n","[W 2024-06-14 18:14:13,339] Trial 0 failed with parameters: {'randomforestclassifier__n_estimators': 1171, 'randomforestclassifier__max_depth': 31, 'randomforestclassifier__min_samples_split': 11, 'randomforestclassifier__min_samples_leaf': 7} because of the following error: KeyboardInterrupt().\n","Traceback (most recent call last):\n","  File \"/opt/conda/lib/python3.10/site-packages/optuna/study/_optimize.py\", line 196, in _run_trial\n","    value_or_values = func(trial)\n","  File \"/tmp/ipykernel_33/1879812907.py\", line 24, in objective\n","    score = cross_val_score(pipeline.named_steps['randomforestclassifier'], X_train_transformed, y_train, cv=3, scoring='accuracy').mean()\n","  File \"/opt/conda/lib/python3.10/site-packages/sklearn/model_selection/_validation.py\", line 515, in cross_val_score\n","    cv_results = cross_validate(\n","  File \"/opt/conda/lib/python3.10/site-packages/sklearn/model_selection/_validation.py\", line 266, in cross_validate\n","    results = parallel(\n","  File \"/opt/conda/lib/python3.10/site-packages/sklearn/utils/parallel.py\", line 63, in __call__\n","    return super().__call__(iterable_with_config)\n","  File \"/opt/conda/lib/python3.10/site-packages/joblib/parallel.py\", line 1918, in __call__\n","    return output if self.return_generator else list(output)\n","  File \"/opt/conda/lib/python3.10/site-packages/joblib/parallel.py\", line 1847, in _get_sequential_output\n","    res = func(*args, **kwargs)\n","  File \"/opt/conda/lib/python3.10/site-packages/sklearn/utils/parallel.py\", line 123, in __call__\n","    return self.function(*args, **kwargs)\n","  File \"/opt/conda/lib/python3.10/site-packages/sklearn/model_selection/_validation.py\", line 686, in _fit_and_score\n","    estimator.fit(X_train, y_train, **fit_params)\n","  File \"/opt/conda/lib/python3.10/site-packages/sklearn/ensemble/_forest.py\", line 473, in fit\n","    trees = Parallel(\n","  File \"/opt/conda/lib/python3.10/site-packages/sklearn/utils/parallel.py\", line 63, in __call__\n","    return super().__call__(iterable_with_config)\n","  File \"/opt/conda/lib/python3.10/site-packages/joblib/parallel.py\", line 1918, in __call__\n","    return output if self.return_generator else list(output)\n","  File \"/opt/conda/lib/python3.10/site-packages/joblib/parallel.py\", line 1847, in _get_sequential_output\n","    res = func(*args, **kwargs)\n","  File \"/opt/conda/lib/python3.10/site-packages/sklearn/utils/parallel.py\", line 123, in __call__\n","    return self.function(*args, **kwargs)\n","  File \"/opt/conda/lib/python3.10/site-packages/sklearn/ensemble/_forest.py\", line 184, in _parallel_build_trees\n","    tree.fit(X, y, sample_weight=curr_sample_weight, check_input=False)\n","  File \"/opt/conda/lib/python3.10/site-packages/sklearn/tree/_classes.py\", line 889, in fit\n","    super().fit(\n","  File \"/opt/conda/lib/python3.10/site-packages/sklearn/tree/_classes.py\", line 379, in fit\n","    builder.build(self.tree_, X, y, sample_weight)\n","KeyboardInterrupt\n","[W 2024-06-14 18:14:13,344] Trial 0 failed with value None.\n"]},{"ename":"KeyboardInterrupt","evalue":"","output_type":"error","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)","File \u001b[0;32m<timed exec>:2\u001b[0m\n","Cell \u001b[0;32mIn[24], line 29\u001b[0m, in \u001b[0;36mhyperoptimize_rf_model\u001b[0;34m(pipeline, X_train, y_train, X_test, y_test, n_trials, timeout)\u001b[0m\n\u001b[1;32m     27\u001b[0m \u001b[38;5;66;03m# Créez un objet study et optimisez la fonction objective\u001b[39;00m\n\u001b[1;32m     28\u001b[0m study \u001b[38;5;241m=\u001b[39m optuna\u001b[38;5;241m.\u001b[39mcreate_study(direction\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mmaximize\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m---> 29\u001b[0m \u001b[43mstudy\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptimize\u001b[49m\u001b[43m(\u001b[49m\u001b[43mobjective\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mn_trials\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_trials\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtimeout\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     31\u001b[0m \u001b[38;5;66;03m# Affichez les meilleurs hyperparamètres\u001b[39;00m\n\u001b[1;32m     32\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mBest parameters:\u001b[39m\u001b[38;5;124m'\u001b[39m, study\u001b[38;5;241m.\u001b[39mbest_params)\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/optuna/study/study.py:451\u001b[0m, in \u001b[0;36mStudy.optimize\u001b[0;34m(self, func, n_trials, timeout, n_jobs, catch, callbacks, gc_after_trial, show_progress_bar)\u001b[0m\n\u001b[1;32m    348\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21moptimize\u001b[39m(\n\u001b[1;32m    349\u001b[0m     \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m    350\u001b[0m     func: ObjectiveFuncType,\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    357\u001b[0m     show_progress_bar: \u001b[38;5;28mbool\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m,\n\u001b[1;32m    358\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m    359\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"Optimize an objective function.\u001b[39;00m\n\u001b[1;32m    360\u001b[0m \n\u001b[1;32m    361\u001b[0m \u001b[38;5;124;03m    Optimization is done by choosing a suitable set of hyperparameter values from a given\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    449\u001b[0m \u001b[38;5;124;03m            If nested invocation of this method occurs.\u001b[39;00m\n\u001b[1;32m    450\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[0;32m--> 451\u001b[0m     \u001b[43m_optimize\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    452\u001b[0m \u001b[43m        \u001b[49m\u001b[43mstudy\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m    453\u001b[0m \u001b[43m        \u001b[49m\u001b[43mfunc\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    454\u001b[0m \u001b[43m        \u001b[49m\u001b[43mn_trials\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_trials\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    455\u001b[0m \u001b[43m        \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtimeout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    456\u001b[0m \u001b[43m        \u001b[49m\u001b[43mn_jobs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_jobs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    457\u001b[0m \u001b[43m        \u001b[49m\u001b[43mcatch\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mtuple\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mcatch\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43misinstance\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mcatch\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mIterable\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[43mcatch\u001b[49m\u001b[43m,\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    458\u001b[0m \u001b[43m        \u001b[49m\u001b[43mcallbacks\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcallbacks\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    459\u001b[0m \u001b[43m        \u001b[49m\u001b[43mgc_after_trial\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgc_after_trial\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    460\u001b[0m \u001b[43m        \u001b[49m\u001b[43mshow_progress_bar\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mshow_progress_bar\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    461\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/optuna/study/_optimize.py:62\u001b[0m, in \u001b[0;36m_optimize\u001b[0;34m(study, func, n_trials, timeout, n_jobs, catch, callbacks, gc_after_trial, show_progress_bar)\u001b[0m\n\u001b[1;32m     60\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m     61\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m n_jobs \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[0;32m---> 62\u001b[0m         \u001b[43m_optimize_sequential\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m     63\u001b[0m \u001b[43m            \u001b[49m\u001b[43mstudy\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     64\u001b[0m \u001b[43m            \u001b[49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     65\u001b[0m \u001b[43m            \u001b[49m\u001b[43mn_trials\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     66\u001b[0m \u001b[43m            \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     67\u001b[0m \u001b[43m            \u001b[49m\u001b[43mcatch\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     68\u001b[0m \u001b[43m            \u001b[49m\u001b[43mcallbacks\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     69\u001b[0m \u001b[43m            \u001b[49m\u001b[43mgc_after_trial\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     70\u001b[0m \u001b[43m            \u001b[49m\u001b[43mreseed_sampler_rng\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m     71\u001b[0m \u001b[43m            \u001b[49m\u001b[43mtime_start\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m     72\u001b[0m \u001b[43m            \u001b[49m\u001b[43mprogress_bar\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mprogress_bar\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     73\u001b[0m \u001b[43m        \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     74\u001b[0m     \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m     75\u001b[0m         \u001b[38;5;28;01mif\u001b[39;00m n_jobs \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m:\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/optuna/study/_optimize.py:159\u001b[0m, in \u001b[0;36m_optimize_sequential\u001b[0;34m(study, func, n_trials, timeout, catch, callbacks, gc_after_trial, reseed_sampler_rng, time_start, progress_bar)\u001b[0m\n\u001b[1;32m    156\u001b[0m         \u001b[38;5;28;01mbreak\u001b[39;00m\n\u001b[1;32m    158\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 159\u001b[0m     frozen_trial \u001b[38;5;241m=\u001b[39m \u001b[43m_run_trial\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstudy\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcatch\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    160\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m    161\u001b[0m     \u001b[38;5;66;03m# The following line mitigates memory problems that can be occurred in some\u001b[39;00m\n\u001b[1;32m    162\u001b[0m     \u001b[38;5;66;03m# environments (e.g., services that use computing containers such as GitHub Actions).\u001b[39;00m\n\u001b[1;32m    163\u001b[0m     \u001b[38;5;66;03m# Please refer to the following PR for further details:\u001b[39;00m\n\u001b[1;32m    164\u001b[0m     \u001b[38;5;66;03m# https://github.com/optuna/optuna/pull/325.\u001b[39;00m\n\u001b[1;32m    165\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m gc_after_trial:\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/optuna/study/_optimize.py:247\u001b[0m, in \u001b[0;36m_run_trial\u001b[0;34m(study, func, catch)\u001b[0m\n\u001b[1;32m    240\u001b[0m         \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28;01mFalse\u001b[39;00m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mShould not reach.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    242\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (\n\u001b[1;32m    243\u001b[0m     frozen_trial\u001b[38;5;241m.\u001b[39mstate \u001b[38;5;241m==\u001b[39m TrialState\u001b[38;5;241m.\u001b[39mFAIL\n\u001b[1;32m    244\u001b[0m     \u001b[38;5;129;01mand\u001b[39;00m func_err \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m    245\u001b[0m     \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(func_err, catch)\n\u001b[1;32m    246\u001b[0m ):\n\u001b[0;32m--> 247\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m func_err\n\u001b[1;32m    248\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m frozen_trial\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/optuna/study/_optimize.py:196\u001b[0m, in \u001b[0;36m_run_trial\u001b[0;34m(study, func, catch)\u001b[0m\n\u001b[1;32m    194\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m get_heartbeat_thread(trial\u001b[38;5;241m.\u001b[39m_trial_id, study\u001b[38;5;241m.\u001b[39m_storage):\n\u001b[1;32m    195\u001b[0m     \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 196\u001b[0m         value_or_values \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtrial\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    197\u001b[0m     \u001b[38;5;28;01mexcept\u001b[39;00m exceptions\u001b[38;5;241m.\u001b[39mTrialPruned \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m    198\u001b[0m         \u001b[38;5;66;03m# TODO(mamu): Handle multi-objective cases.\u001b[39;00m\n\u001b[1;32m    199\u001b[0m         state \u001b[38;5;241m=\u001b[39m TrialState\u001b[38;5;241m.\u001b[39mPRUNED\n","Cell \u001b[0;32mIn[24], line 24\u001b[0m, in \u001b[0;36mhyperoptimize_rf_model.<locals>.objective\u001b[0;34m(trial)\u001b[0m\n\u001b[1;32m     22\u001b[0m \u001b[38;5;66;03m# Apply the preprocessing steps except the last step\u001b[39;00m\n\u001b[1;32m     23\u001b[0m X_train_transformed \u001b[38;5;241m=\u001b[39m pipeline[:\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m.\u001b[39mfit_transform(X_train, y_train)\n\u001b[0;32m---> 24\u001b[0m score \u001b[38;5;241m=\u001b[39m \u001b[43mcross_val_score\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpipeline\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnamed_steps\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mrandomforestclassifier\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mX_train_transformed\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my_train\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcv\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscoring\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43maccuracy\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mmean()\n\u001b[1;32m     25\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m score\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/sklearn/model_selection/_validation.py:515\u001b[0m, in \u001b[0;36mcross_val_score\u001b[0;34m(estimator, X, y, groups, scoring, cv, n_jobs, verbose, fit_params, pre_dispatch, error_score)\u001b[0m\n\u001b[1;32m    512\u001b[0m \u001b[38;5;66;03m# To ensure multimetric format is not supported\u001b[39;00m\n\u001b[1;32m    513\u001b[0m scorer \u001b[38;5;241m=\u001b[39m check_scoring(estimator, scoring\u001b[38;5;241m=\u001b[39mscoring)\n\u001b[0;32m--> 515\u001b[0m cv_results \u001b[38;5;241m=\u001b[39m \u001b[43mcross_validate\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    516\u001b[0m \u001b[43m    \u001b[49m\u001b[43mestimator\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mestimator\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    517\u001b[0m \u001b[43m    \u001b[49m\u001b[43mX\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    518\u001b[0m \u001b[43m    \u001b[49m\u001b[43my\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    519\u001b[0m \u001b[43m    \u001b[49m\u001b[43mgroups\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgroups\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    520\u001b[0m \u001b[43m    \u001b[49m\u001b[43mscoring\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m{\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mscore\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mscorer\u001b[49m\u001b[43m}\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    521\u001b[0m \u001b[43m    \u001b[49m\u001b[43mcv\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcv\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    522\u001b[0m \u001b[43m    \u001b[49m\u001b[43mn_jobs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_jobs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    523\u001b[0m \u001b[43m    \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mverbose\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    524\u001b[0m \u001b[43m    \u001b[49m\u001b[43mfit_params\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfit_params\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    525\u001b[0m \u001b[43m    \u001b[49m\u001b[43mpre_dispatch\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpre_dispatch\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    526\u001b[0m \u001b[43m    \u001b[49m\u001b[43merror_score\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43merror_score\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    527\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    528\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m cv_results[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtest_score\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/sklearn/model_selection/_validation.py:266\u001b[0m, in \u001b[0;36mcross_validate\u001b[0;34m(estimator, X, y, groups, scoring, cv, n_jobs, verbose, fit_params, pre_dispatch, return_train_score, return_estimator, error_score)\u001b[0m\n\u001b[1;32m    263\u001b[0m \u001b[38;5;66;03m# We clone the estimator to make sure that all the folds are\u001b[39;00m\n\u001b[1;32m    264\u001b[0m \u001b[38;5;66;03m# independent, and that it is pickle-able.\u001b[39;00m\n\u001b[1;32m    265\u001b[0m parallel \u001b[38;5;241m=\u001b[39m Parallel(n_jobs\u001b[38;5;241m=\u001b[39mn_jobs, verbose\u001b[38;5;241m=\u001b[39mverbose, pre_dispatch\u001b[38;5;241m=\u001b[39mpre_dispatch)\n\u001b[0;32m--> 266\u001b[0m results \u001b[38;5;241m=\u001b[39m \u001b[43mparallel\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    267\u001b[0m \u001b[43m    \u001b[49m\u001b[43mdelayed\u001b[49m\u001b[43m(\u001b[49m\u001b[43m_fit_and_score\u001b[49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    268\u001b[0m \u001b[43m        \u001b[49m\u001b[43mclone\u001b[49m\u001b[43m(\u001b[49m\u001b[43mestimator\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    269\u001b[0m \u001b[43m        \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    270\u001b[0m \u001b[43m        \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    271\u001b[0m \u001b[43m        \u001b[49m\u001b[43mscorers\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    272\u001b[0m \u001b[43m        \u001b[49m\u001b[43mtrain\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    273\u001b[0m \u001b[43m        \u001b[49m\u001b[43mtest\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    274\u001b[0m \u001b[43m        \u001b[49m\u001b[43mverbose\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    275\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m    276\u001b[0m \u001b[43m        \u001b[49m\u001b[43mfit_params\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    277\u001b[0m \u001b[43m        \u001b[49m\u001b[43mreturn_train_score\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mreturn_train_score\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    278\u001b[0m \u001b[43m        \u001b[49m\u001b[43mreturn_times\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m    279\u001b[0m \u001b[43m        \u001b[49m\u001b[43mreturn_estimator\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mreturn_estimator\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    280\u001b[0m \u001b[43m        \u001b[49m\u001b[43merror_score\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43merror_score\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    281\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    282\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mtrain\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtest\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mcv\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msplit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgroups\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    283\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    285\u001b[0m _warn_or_raise_about_fit_failures(results, error_score)\n\u001b[1;32m    287\u001b[0m \u001b[38;5;66;03m# For callabe scoring, the return type is only know after calling. If the\u001b[39;00m\n\u001b[1;32m    288\u001b[0m \u001b[38;5;66;03m# return type is a dictionary, the error scores can now be inserted with\u001b[39;00m\n\u001b[1;32m    289\u001b[0m \u001b[38;5;66;03m# the correct key.\u001b[39;00m\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/sklearn/utils/parallel.py:63\u001b[0m, in \u001b[0;36mParallel.__call__\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m     58\u001b[0m config \u001b[38;5;241m=\u001b[39m get_config()\n\u001b[1;32m     59\u001b[0m iterable_with_config \u001b[38;5;241m=\u001b[39m (\n\u001b[1;32m     60\u001b[0m     (_with_config(delayed_func, config), args, kwargs)\n\u001b[1;32m     61\u001b[0m     \u001b[38;5;28;01mfor\u001b[39;00m delayed_func, args, kwargs \u001b[38;5;129;01min\u001b[39;00m iterable\n\u001b[1;32m     62\u001b[0m )\n\u001b[0;32m---> 63\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__call__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43miterable_with_config\u001b[49m\u001b[43m)\u001b[49m\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/joblib/parallel.py:1918\u001b[0m, in \u001b[0;36mParallel.__call__\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m   1916\u001b[0m     output \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_get_sequential_output(iterable)\n\u001b[1;32m   1917\u001b[0m     \u001b[38;5;28mnext\u001b[39m(output)\n\u001b[0;32m-> 1918\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m output \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mreturn_generator \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;43mlist\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43moutput\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1920\u001b[0m \u001b[38;5;66;03m# Let's create an ID that uniquely identifies the current call. If the\u001b[39;00m\n\u001b[1;32m   1921\u001b[0m \u001b[38;5;66;03m# call is interrupted early and that the same instance is immediately\u001b[39;00m\n\u001b[1;32m   1922\u001b[0m \u001b[38;5;66;03m# re-used, this id will be used to prevent workers that were\u001b[39;00m\n\u001b[1;32m   1923\u001b[0m \u001b[38;5;66;03m# concurrently finalizing a task from the previous call to run the\u001b[39;00m\n\u001b[1;32m   1924\u001b[0m \u001b[38;5;66;03m# callback.\u001b[39;00m\n\u001b[1;32m   1925\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_lock:\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/joblib/parallel.py:1847\u001b[0m, in \u001b[0;36mParallel._get_sequential_output\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m   1845\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mn_dispatched_batches \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[1;32m   1846\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mn_dispatched_tasks \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[0;32m-> 1847\u001b[0m res \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1848\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mn_completed_tasks \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[1;32m   1849\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mprint_progress()\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/sklearn/utils/parallel.py:123\u001b[0m, in \u001b[0;36m_FuncWrapper.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    121\u001b[0m     config \u001b[38;5;241m=\u001b[39m {}\n\u001b[1;32m    122\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m config_context(\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mconfig):\n\u001b[0;32m--> 123\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfunction\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/sklearn/model_selection/_validation.py:686\u001b[0m, in \u001b[0;36m_fit_and_score\u001b[0;34m(estimator, X, y, scorer, train, test, verbose, parameters, fit_params, return_train_score, return_parameters, return_n_test_samples, return_times, return_estimator, split_progress, candidate_progress, error_score)\u001b[0m\n\u001b[1;32m    684\u001b[0m         estimator\u001b[38;5;241m.\u001b[39mfit(X_train, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mfit_params)\n\u001b[1;32m    685\u001b[0m     \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 686\u001b[0m         \u001b[43mestimator\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX_train\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my_train\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mfit_params\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    688\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n\u001b[1;32m    689\u001b[0m     \u001b[38;5;66;03m# Note fit time as time until error\u001b[39;00m\n\u001b[1;32m    690\u001b[0m     fit_time \u001b[38;5;241m=\u001b[39m time\u001b[38;5;241m.\u001b[39mtime() \u001b[38;5;241m-\u001b[39m start_time\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/sklearn/ensemble/_forest.py:473\u001b[0m, in \u001b[0;36mBaseForest.fit\u001b[0;34m(self, X, y, sample_weight)\u001b[0m\n\u001b[1;32m    462\u001b[0m trees \u001b[38;5;241m=\u001b[39m [\n\u001b[1;32m    463\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_make_estimator(append\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m, random_state\u001b[38;5;241m=\u001b[39mrandom_state)\n\u001b[1;32m    464\u001b[0m     \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(n_more_estimators)\n\u001b[1;32m    465\u001b[0m ]\n\u001b[1;32m    467\u001b[0m \u001b[38;5;66;03m# Parallel loop: we prefer the threading backend as the Cython code\u001b[39;00m\n\u001b[1;32m    468\u001b[0m \u001b[38;5;66;03m# for fitting the trees is internally releasing the Python GIL\u001b[39;00m\n\u001b[1;32m    469\u001b[0m \u001b[38;5;66;03m# making threading more efficient than multiprocessing in\u001b[39;00m\n\u001b[1;32m    470\u001b[0m \u001b[38;5;66;03m# that case. However, for joblib 0.12+ we respect any\u001b[39;00m\n\u001b[1;32m    471\u001b[0m \u001b[38;5;66;03m# parallel_backend contexts set at a higher level,\u001b[39;00m\n\u001b[1;32m    472\u001b[0m \u001b[38;5;66;03m# since correctness does not rely on using threads.\u001b[39;00m\n\u001b[0;32m--> 473\u001b[0m trees \u001b[38;5;241m=\u001b[39m \u001b[43mParallel\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    474\u001b[0m \u001b[43m    \u001b[49m\u001b[43mn_jobs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mn_jobs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    475\u001b[0m \u001b[43m    \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mverbose\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    476\u001b[0m \u001b[43m    \u001b[49m\u001b[43mprefer\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mthreads\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m    477\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    478\u001b[0m \u001b[43m    \u001b[49m\u001b[43mdelayed\u001b[49m\u001b[43m(\u001b[49m\u001b[43m_parallel_build_trees\u001b[49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    479\u001b[0m \u001b[43m        \u001b[49m\u001b[43mt\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    480\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbootstrap\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    481\u001b[0m \u001b[43m        \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    482\u001b[0m \u001b[43m        \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    483\u001b[0m \u001b[43m        \u001b[49m\u001b[43msample_weight\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    484\u001b[0m \u001b[43m        \u001b[49m\u001b[43mi\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    485\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mtrees\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    486\u001b[0m \u001b[43m        \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mverbose\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    487\u001b[0m \u001b[43m        \u001b[49m\u001b[43mclass_weight\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mclass_weight\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    488\u001b[0m \u001b[43m        \u001b[49m\u001b[43mn_samples_bootstrap\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_samples_bootstrap\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    489\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    490\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mt\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43menumerate\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mtrees\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    491\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    493\u001b[0m \u001b[38;5;66;03m# Collect newly grown trees\u001b[39;00m\n\u001b[1;32m    494\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mestimators_\u001b[38;5;241m.\u001b[39mextend(trees)\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/sklearn/utils/parallel.py:63\u001b[0m, in \u001b[0;36mParallel.__call__\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m     58\u001b[0m config \u001b[38;5;241m=\u001b[39m get_config()\n\u001b[1;32m     59\u001b[0m iterable_with_config \u001b[38;5;241m=\u001b[39m (\n\u001b[1;32m     60\u001b[0m     (_with_config(delayed_func, config), args, kwargs)\n\u001b[1;32m     61\u001b[0m     \u001b[38;5;28;01mfor\u001b[39;00m delayed_func, args, kwargs \u001b[38;5;129;01min\u001b[39;00m iterable\n\u001b[1;32m     62\u001b[0m )\n\u001b[0;32m---> 63\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__call__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43miterable_with_config\u001b[49m\u001b[43m)\u001b[49m\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/joblib/parallel.py:1918\u001b[0m, in \u001b[0;36mParallel.__call__\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m   1916\u001b[0m     output \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_get_sequential_output(iterable)\n\u001b[1;32m   1917\u001b[0m     \u001b[38;5;28mnext\u001b[39m(output)\n\u001b[0;32m-> 1918\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m output \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mreturn_generator \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;43mlist\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43moutput\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1920\u001b[0m \u001b[38;5;66;03m# Let's create an ID that uniquely identifies the current call. If the\u001b[39;00m\n\u001b[1;32m   1921\u001b[0m \u001b[38;5;66;03m# call is interrupted early and that the same instance is immediately\u001b[39;00m\n\u001b[1;32m   1922\u001b[0m \u001b[38;5;66;03m# re-used, this id will be used to prevent workers that were\u001b[39;00m\n\u001b[1;32m   1923\u001b[0m \u001b[38;5;66;03m# concurrently finalizing a task from the previous call to run the\u001b[39;00m\n\u001b[1;32m   1924\u001b[0m \u001b[38;5;66;03m# callback.\u001b[39;00m\n\u001b[1;32m   1925\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_lock:\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/joblib/parallel.py:1847\u001b[0m, in \u001b[0;36mParallel._get_sequential_output\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m   1845\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mn_dispatched_batches \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[1;32m   1846\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mn_dispatched_tasks \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[0;32m-> 1847\u001b[0m res \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1848\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mn_completed_tasks \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[1;32m   1849\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mprint_progress()\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/sklearn/utils/parallel.py:123\u001b[0m, in \u001b[0;36m_FuncWrapper.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    121\u001b[0m     config \u001b[38;5;241m=\u001b[39m {}\n\u001b[1;32m    122\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m config_context(\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mconfig):\n\u001b[0;32m--> 123\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfunction\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/sklearn/ensemble/_forest.py:184\u001b[0m, in \u001b[0;36m_parallel_build_trees\u001b[0;34m(tree, bootstrap, X, y, sample_weight, tree_idx, n_trees, verbose, class_weight, n_samples_bootstrap)\u001b[0m\n\u001b[1;32m    181\u001b[0m     \u001b[38;5;28;01melif\u001b[39;00m class_weight \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mbalanced_subsample\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m    182\u001b[0m         curr_sample_weight \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m=\u001b[39m compute_sample_weight(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mbalanced\u001b[39m\u001b[38;5;124m\"\u001b[39m, y, indices\u001b[38;5;241m=\u001b[39mindices)\n\u001b[0;32m--> 184\u001b[0m     \u001b[43mtree\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msample_weight\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcurr_sample_weight\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcheck_input\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m    185\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    186\u001b[0m     tree\u001b[38;5;241m.\u001b[39mfit(X, y, sample_weight\u001b[38;5;241m=\u001b[39msample_weight, check_input\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m)\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/sklearn/tree/_classes.py:889\u001b[0m, in \u001b[0;36mDecisionTreeClassifier.fit\u001b[0;34m(self, X, y, sample_weight, check_input)\u001b[0m\n\u001b[1;32m    859\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mfit\u001b[39m(\u001b[38;5;28mself\u001b[39m, X, y, sample_weight\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, check_input\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m):\n\u001b[1;32m    860\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"Build a decision tree classifier from the training set (X, y).\u001b[39;00m\n\u001b[1;32m    861\u001b[0m \n\u001b[1;32m    862\u001b[0m \u001b[38;5;124;03m    Parameters\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    886\u001b[0m \u001b[38;5;124;03m        Fitted estimator.\u001b[39;00m\n\u001b[1;32m    887\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[0;32m--> 889\u001b[0m     \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    890\u001b[0m \u001b[43m        \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    891\u001b[0m \u001b[43m        \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    892\u001b[0m \u001b[43m        \u001b[49m\u001b[43msample_weight\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msample_weight\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    893\u001b[0m \u001b[43m        \u001b[49m\u001b[43mcheck_input\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcheck_input\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    894\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    895\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/sklearn/tree/_classes.py:379\u001b[0m, in \u001b[0;36mBaseDecisionTree.fit\u001b[0;34m(self, X, y, sample_weight, check_input)\u001b[0m\n\u001b[1;32m    368\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    369\u001b[0m     builder \u001b[38;5;241m=\u001b[39m BestFirstTreeBuilder(\n\u001b[1;32m    370\u001b[0m         splitter,\n\u001b[1;32m    371\u001b[0m         min_samples_split,\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    376\u001b[0m         \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmin_impurity_decrease,\n\u001b[1;32m    377\u001b[0m     )\n\u001b[0;32m--> 379\u001b[0m \u001b[43mbuilder\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbuild\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtree_\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msample_weight\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    381\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mn_outputs_ \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m is_classifier(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m    382\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mn_classes_ \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mn_classes_[\u001b[38;5;241m0\u001b[39m]\n","\u001b[0;31mKeyboardInterrupt\u001b[0m: "]}],"source":["%%time\n","# Hyper-optimisation pour RandomForest\n","best_params_rf, accuracy_rf, f1_rf = hyperoptimize_rf_model(\n","    rf_pipeline, X_train, y_train, X_test, y_test, n_trials=5, timeout=600)"]},{"cell_type":"code","execution_count":33,"metadata":{"execution":{"iopub.execute_input":"2024-06-14T18:16:56.075934Z","iopub.status.busy":"2024-06-14T18:16:56.075396Z","iopub.status.idle":"2024-06-14T18:16:56.082830Z","shell.execute_reply":"2024-06-14T18:16:56.081142Z","shell.execute_reply.started":"2024-06-14T18:16:56.075896Z"},"trusted":true},"outputs":[],"source":["gb_pipeline_2ND = create_model_pipeline(\n","    cat_features, cont_features, GradientBoostingClassifier, n_estimators=3000, learning_rate=0.1, max_depth=5, min_samples_leaf=4,random_state=42)"]},{"cell_type":"code","execution_count":null,"metadata":{"execution":{"iopub.execute_input":"2024-06-14T18:16:57.527130Z","iopub.status.busy":"2024-06-14T18:16:57.526655Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["\n","\n","\n","--- Evaluation du modèle : GradientBoostingClassifier 2nd ---\n"]}],"source":["train_and_evaluate_model(gb_pipeline_2ND, X_train, y_train, X_test, y_test, model_name='GradientBoostingClassifier 2nd')"]}],"metadata":{"kaggle":{"accelerator":"none","dataSources":[{"datasetId":3679617,"sourceId":6386941,"sourceType":"datasetVersion"}],"dockerImageVersionId":30732,"isGpuEnabled":false,"isInternetEnabled":false,"language":"python","sourceType":"notebook"},"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.10.13"}},"nbformat":4,"nbformat_minor":4}