{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# **Inner Evaluation 1**" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Evaluation of many feature extraction methods along with Random Forest**" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In this part of the project we are going to search the best combination of feature extraction methods and statistics for classifying the Parkinson disease level.\n", "\n", "We are going to apply a methodology for selecting the best alternative that is a classical approach in Machine Learning and is called inner evaluation.\n", "\n", "The basic idea is to split the data in train an test partitions (outer), and using the training one to select the best alternative from a predictive perspective. \n", "This will be done using KFold Cross Validation, a robust and accurate method for estimating the predictive error of the model when predicting new data (validation data), along with grid search methods to optimize the hyper-parameters of the model. \n", "\n", "Along the project inner evaluation will be applied in a iterative way (in several rounds), in order to find a good enough model for our classification problem.\n", "\n", "This is the first round of the inner evaluation and is oriented to find the features extraction methods that seem to work better for our classification task, testing all of them along with Random Forest.\n", "\n", "We have selected Random Forest to conduct this evaluation since is a model that usually works well with any kind of tabular data, both in regression and classification problems." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## **Requirements**" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import polars as pl\n", "import sys\n", "import pickle\n", "import matplotlib.pyplot as plt\n", "from sklearn.ensemble import RandomForestClassifier\n", "import seaborn as sns\n", "sns.set_style('whitegrid')\n", "from sklearn.model_selection import train_test_split, StratifiedKFold, cross_val_score\n", "from itertools import combinations\n" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "sys.path.insert(0, r'C:\\Users\\fscielzo\\Documents\\Packages\\PyML_Package_Private')\n", "from PyML.evaluation import SimpleEvaluation" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "sys.path.insert(0, r'C:\\Users\\fscielzo\\Documents\\Packages\\PyAudio_Package_Private')\n", "from PyAudio import get_X_audio_features" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## **Response and Predictors definition**" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In this section we define the data to be used. Specifically we define the response variable and a set of predictors matrices to be used as different alternatives, each one associate to a combination of features extraction methods and statistics." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "files_list_name = 'Files_List.txt'\n", "files_df = pl.read_csv(files_list_name, separator='\\t', has_header=False, new_columns=['path', 'level'])" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "shape: (3, 2)
pathlevel
stri64
"PDSpeechData/l…0
"PDSpeechData/l…0
"PDSpeechData/l…0
" ], "text/plain": [ "shape: (3, 2)\n", "┌──────────────────────────────────┬───────┐\n", "│ path ┆ level │\n", "│ --- ┆ --- │\n", "│ str ┆ i64 │\n", "╞══════════════════════════════════╪═══════╡\n", "│ PDSpeechData/loc01/loc01_s01.wav ┆ 0 │\n", "│ PDSpeechData/loc01/loc01_s03.wav ┆ 0 │\n", "│ PDSpeechData/loc01/loc01_s05.wav ┆ 0 │\n", "└──────────────────────────────────┴───────┘" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "files_df.head(3)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(240, 2)" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "files_df.shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We define the parameters to be used by the features extraction methods." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "fs = 16000 # Sampling frequency\n", "wst = 0.032 # Window size (seconds)\n", "fpt = 0.008 # Frame period (seconds)\n", "nfft = int(np.ceil(wst*fs)) # Window size (samples)\n", "fp = int(np.ceil(fpt*fs)) # Frame period (samples)\n", "nbands = 40 # Number of filters in the filterbank\n", "ncomp = 20 # Number of MFCC components" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the next cell we define the response variable (target) and the different predictors matrices mentioned above." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "Y = files_df['level'].to_numpy()\n", "\n", "simple_methods = ['MFCC', 'spectral_centroid', 'chroma', 'spectral_bandwidth', \n", " 'spectral_contrast', 'spectral_rolloff', 'zero_crossing_rate', 'tempogram']\n", "\n", "combined_methods = []\n", "\n", "stats = ['mean-std', 'median-std', 'mean-median-std', 'mean-Q25-median-Q75-std']\n", "\n", "sizes = range(2, len(simple_methods) + 1)\n", "\n", "combined_methods = ['-'.join(sorted(combi)) for size in sizes for combi in combinations(simple_methods, size)]\n", "\n", "X_stats, X_stats_train, X_stats_test = {method: {} for method in simple_methods + combined_methods}, {method: {} for method in simple_methods + combined_methods}, {method: {} for method in simple_methods + combined_methods}\n", "\n", "for method in simple_methods:\n", " for stat in stats:\n", "\n", " X_stats[method][stat] = get_X_audio_features(paths=files_df['path'], method=method, stats=stat, sr=fs, n_fft=nfft, hop_length=fp, n_mels=nbands, n_mfcc=ncomp)\n", "\n", "for method in combined_methods:\n", " for stat in stats:\n", "\n", " X_stats[method][stat] = np.column_stack([X_stats[method.split('-')[i]][stat] for i in range(0, len(method.split('-')))])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Response variable" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 2,\n", " 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1,\n", " 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0,\n", " 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,\n", " 1, 1, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", " 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 2,\n", " 2, 2, 2, 2, 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 2, 2,\n", " 2, 2, 2, 1, 1, 1, 2, 2, 2, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", " 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0,\n", " 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3],\n", " dtype=int64)" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Y" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- `X_stats` is a dictionary with all the predictors matrices that will be considered in this round of the inner evaluation." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- There are 255 predictors matrices, that is, 255 combinations of methods-statistics. And all of them will be evaluated!" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "255" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "len(X_stats.keys())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Example of the predictors matrix obtained with the method `MFCC` and the statistics `mean-std`:" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[-213.15875 , 92.984024 , -64.05465 , ..., 7.095715 ,\n", " 6.177743 , 5.351471 ],\n", " [-198.98454 , 68.04833 , -47.42779 , ..., 6.012935 ,\n", " 5.59839 , 4.8842993],\n", " [-240.02739 , 59.765434 , -2.604349 , ..., 5.646291 ,\n", " 5.4601407, 6.5454264],\n", " ...,\n", " [-291.60522 , 81.844025 , 29.577833 , ..., 13.644189 ,\n", " 11.3029785, 9.850929 ],\n", " [-212.69768 , 78.77707 , 16.943432 , ..., 2.2818298,\n", " 2.13314 , 2.4295764],\n", " [-209.18323 , 72.59186 , 32.422817 , ..., 2.3896735,\n", " 3.0300555, 2.1277957]], dtype=float32)" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "X_stats['MFCC']['mean-std']" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Example of the predictors matrix obtained with the combined methods `MFCC-chroma-spectral_centroid` and the statistics `mean-median-std`:" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[-213.15875244, 92.98402405, -64.05464935, ..., 1222.51022012,\n", " 1208.43764311, 106.02869666],\n", " [-198.98454285, 68.04833221, -47.4277916 , ..., 1352.95675704,\n", " 1299.29234374, 292.90811358],\n", " [-240.02738953, 59.76543427, -2.6043489 , ..., 1573.29651356,\n", " 1600.41486793, 452.12319515],\n", " ...,\n", " [-291.60522461, 81.84402466, 29.57783318, ..., 618.70811719,\n", " 531.75061197, 248.36974082],\n", " [-212.69767761, 78.77706909, 16.94343185, ..., 1282.07792881,\n", " 1286.69344979, 64.07181308],\n", " [-209.18322754, 72.59185791, 32.42281723, ..., 1123.23739168,\n", " 1125.9873083 , 66.49508231]])" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "X_stats['MFCC-chroma-spectral_centroid']['mean-median-std']" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Checking if the classification problem is imbalance:" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0 1 2 3] [0.3 0.3 0.25 0.15]\n" ] } ], "source": [ "values, counts = np.unique(Y, return_counts=True)\n", "rel_freqs = counts / len(Y)\n", "print(values, rel_freqs)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The problem is a bit imbalanced, so we will use the balanced accuracy since simple accuracy is distorted by the imbalanced distributions of the response categories.\n", "\n", "Anyway, since the problem is only a bit imbalanced the different between using simple or balanced accuracy will not be very high.\n", "\n", "It's important to notice that balanced accuracy is equivalent to simple accuracy when the problem is balanced, but when not, the balanced accuracy treat all the classed equally while simple accuracy give more weight to the dominant classes, so, if the model performs well in the dominant classes but very bad in the rest, accuracy will be still good, since is dominated by those dominant classes, and this doesn't happen with balanced accuracy, so that we will use it instead of the simple one." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## **Outer validation method: train-test split**" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We split our data (response and predictors) in two partitions, the training and the testing one. The training partition will be used in the inner evaluation for selecting the best approach to predict the PD level, and the test one will only be used at the very end for making an estimation of the future performance of the best approach, that is, and estimation of how this approach will classify the level of PD of new patients." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "for method in simple_methods + combined_methods:\n", " for stat in stats:\n", " X_stats_train[method][stat], X_stats_test[method][stat], Y_train, Y_test = train_test_split(X_stats[method][stat], Y, test_size=0.25, random_state=123, stratify=Y)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## **Applying Inner Evaluation**" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In this section we are going to apply the round one of the inner evaluation." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### **Inner validation method: KFold Cross Validation**" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We define the validation method to be used in the inner evaluation, that will be Stratified KFold Cross Validation." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "inner = StratifiedKFold(n_splits=5, shuffle=True, random_state=123)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Justification of using Cross Validation instead of Simple Validation:**" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0.62121212, 0.49292929, 0.4469697 , 0.81666667, 0.72525253])" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cross_val_score(estimator=RandomForestClassifier(random_state=123), X=X_stats_train['MFCC']['mean-std'], y=Y_train, scoring='balanced_accuracy', cv=inner)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We define dictionaries to save important results that will be gathered in the inner evaluation." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "inner_score, best_params, inner_results = {method: {stat: {} for stat in stats} for method in simple_methods + combined_methods}, {method: {stat: {} for stat in stats} for method in simple_methods + combined_methods}, {method: {stat: {} for stat in stats} for method in simple_methods + combined_methods}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### **Grids for HPO** " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In this part we define the grids for the models that will be evaluated. In this round the unique model will be Random Forest, as we explained at the beginning." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Grid for Random Forest" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "def param_grid_RF(trial):\n", "\n", " param_grid = ({\n", " 'n_estimators': trial.suggest_categorical('n_estimators', [75, 100, 150, 200, 250, 300, 350]),\n", " 'max_depth': trial.suggest_categorical('max_depth', [None, 4, 7, 10, 25, 35]),\n", " 'min_samples_split': trial.suggest_int('min_samples_split', 2, 35),\n", " 'min_samples_leaf': trial.suggest_int('min_samples_leaf', 2, 35),\n", " 'criterion': trial.suggest_categorical('criterion', ['gini']) })\n", "\n", " return param_grid" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### **HPO**" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In this section we are going to optimize (hyper-parameter optimization) Random Forest for each one of the 255 defined predictors matrices." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Th idea is, for each features extraction method, find an optimal version of the Random Forest. Then, all these alternatives will be ranked according to their inner scores (inner balanced accuracies)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### HPO for Random Forest" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Using simple methods for feature extraction" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "model = 'RF'\n", "\n", "simple_eval = SimpleEvaluation(estimator=RandomForestClassifier(random_state=123), param_grid=param_grid_RF, \n", " inner=inner, search_method='optuna', scoring='balanced_accuracy', direction='maximize', \n", " n_trials=35, random_state=123)\n", "\n", "print('Number of methods tried:', len(simple_methods))\n", "for i, method in enumerate(simple_methods):\n", " print('-------------------------------------------------------------------------------')\n", " print(i, method)\n", " print('-------------------------------------------------------------------------------')\n", " for stat in stats:\n", " print(stat)\n", "\n", " simple_eval.fit(X=X_stats_train[method][stat], Y=Y_train)\n", " inner_score[method][stat][model] = simple_eval.inner_score\n", " best_params[method][stat][model]= simple_eval.inner_best_params\n", " inner_results[method][stat][model] = simple_eval.inner_results\n", "# 35 mins" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Using combined methods for feature extraction" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "model = 'RF'\n", "\n", "simple_eval = SimpleEvaluation(estimator=RandomForestClassifier(random_state=123), param_grid=param_grid_RF, \n", " inner=inner, search_method='optuna', scoring='balanced_accuracy', direction='maximize', \n", " n_trials=5, random_state=123)\n", "\n", "print('Number of methods tried:', len(combined_methods))\n", "for i, method in enumerate(combined_methods):\n", " print('-------------------------------------------------------------------------------')\n", " print(i, method)\n", " print('-------------------------------------------------------------------------------')\n", " for stat in stats:\n", " print(stat)\n", "\n", " simple_eval.fit(X=X_stats_train[method][stat], Y=Y_train)\n", " inner_score[method][stat][model] = simple_eval.inner_score\n", " best_params[method][stat][model]= simple_eval.inner_best_params\n", " inner_results[method][stat][model] = simple_eval.inner_results\n", "# 300 mins" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Saving the results" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "'''\n", "with open('results/best_params_I', 'wb') as file:\n", " pickle.dump(best_params, file)\n", "\n", "with open('results/inner_scores_I', 'wb') as file:\n", " pickle.dump(inner_score, file)\n", "\n", "with open('results/inner_results_I', 'wb') as file:\n", " pickle.dump(inner_results, file)\n", "'''" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Opening the results" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [], "source": [ "with open(f'results/best_params_1', 'rb') as file:\n", " best_params = pickle.load(file)\n", "\n", "with open(f'results/inner_scores_1', 'rb') as file:\n", " inner_score = pickle.load(file)\n", "\n", "with open(f'results/inner_results_1', 'rb') as file:\n", " inner_results = pickle.load(file)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### **Selecting the best pipeline**" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In this section we are going to select the best pipeline, that is, the best combination of preprocessing techniques and model, in this case the feature extraction methods are the preprocessing techniques, and the only model considered is Random Forest. \n", "\n", "All the alternatives evaluated are ranked according to their inner scores (balanced accuracy), and the top 25 are summarized in a plot." ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "inner_score_flatten = {key1 + '__' + key2 + '__' + key3 : inner_score[key1][key2][key3] \n", " for key1 in inner_score.keys() \n", " for key2 in inner_score[key1].keys() \n", " for key3 in inner_score[key1][key2].keys()}\n", "best_params_flatten = {key1 + '__' + key2 + '__' + key3 : best_params[key1][key2][key3] \n", " for key1 in best_params.keys() \n", " for key2 in best_params[key1].keys() \n", " for key3 in best_params[key1][key2].keys()}\n", "inner_results_flatten = {key1 + '__' + key2 + '__' + key3 : inner_results[key1][key2][key3] \n", " for key1 in inner_results.keys() \n", " for key2 in inner_results[key1].keys() \n", " for key3 in inner_results[key1][key2].keys()}\n", "\n", "inner_score_values = np.array(list(inner_score_flatten.values()))\n", "pipelines_names = np.array(list(inner_score_flatten.keys()))\n", "best_pipeline = pipelines_names[np.argmax(inner_score_values)]\n", "score_best_pipeline = np.max(inner_score_values)\n", "\n", "combined_models_score = list(zip(pipelines_names, inner_score_values))\n", "sorted_combined_models_score= sorted(combined_models_score, key=lambda x: x[1], reverse=True) # Sort from greater to lower\n", "sorted_pipelines, sorted_scores = zip(*sorted_combined_models_score)\n", "sorted_pipelines = list(sorted_pipelines)\n", "sorted_scores = list(sorted_scores)" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "The best pipeline according to the inner evaluation is: MFCC-chroma-spectral_bandwidth-spectral_contrast-spectral_rolloff__mean-Q25-median-Q75-std__RF\n", "Balanced accuracy of the best pipeline: 0.673\n", "\n", " Best feature extraction method: MFCC-chroma-spectral_bandwidth-spectral_contrast-spectral_rolloff \n", " Best stats: mean-Q25-median-Q75-std \n", " Best model: RF\n", "\n", "The best model hyper-parameters are: {'n_estimators': 250, 'max_depth': 25, 'min_samples_split': 26, 'min_samples_leaf': 2, 'criterion': 'gini'}\n" ] } ], "source": [ "n_top = 25\n", "\n", "fig, axes = plt.subplots(figsize=(5,8))\n", "\n", "ax = sns.barplot(y=sorted_pipelines[0:n_top], x=sorted_scores[0:n_top], color='blue', width=0.4, alpha=0.9)\n", "ax = sns.barplot(y=[best_pipeline], x=[score_best_pipeline], color='red', width=0.4, alpha=0.9)\n", "\n", "ax.set_ylabel('Models', size=12)\n", "ax.set_xlabel('Balanced Accuracy', size=12)\n", "ax.set_xticks(np.round(np.linspace(0, np.max(inner_score_values), 7),3)) \n", "ax.tick_params(axis='y', labelsize=10) \n", "plt.title(f'Pipeline Selection - Top {n_top} pipelines - 5-Fold CV', size=13)\n", "plt.show()\n", "\n", "print(f'The best pipeline according to the inner evaluation is: {best_pipeline}')\n", "print('Balanced accuracy of the best pipeline: ', np.round(score_best_pipeline, 3))\n", "best_method = best_pipeline.split('__')[0]\n", "best_stats = best_pipeline.split('__')[1]\n", "best_model = best_pipeline.split('__')[2]\n", "print('\\n Best feature extraction method: ', best_method, '\\n', 'Best stats: ', best_stats, '\\n', 'Best model: ', best_model)\n", "\n", "print('\\nThe best model hyper-parameters are: ', best_params_flatten[best_pipeline])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We save the top 10 method-stats combinations, since they will be the considered combinations to be evaluated in the second round of the inner evaluation." ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [], "source": [ "top_methods, top_stats = [], []\n", "n_top = 10\n", "\n", "for pipeline in sorted_pipelines[0:n_top]:\n", " top_methods.append(pipeline.split('__')[0])\n", " top_stats.append(pipeline.split('__')[1])" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"\\nwith open('results/top_methods_1', 'wb') as file:\\n pickle.dump(top_methods, file)\\n\\nwith open('results/top_stats_1', 'wb') as file:\\n pickle.dump(top_stats, file)\\n\"" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Saving results \n", "'''\n", "with open('results/top_methods_1', 'wb') as file:\n", " pickle.dump(top_methods, file)\n", "\n", "with open('results/top_stats_1', 'wb') as file:\n", " pickle.dump(top_stats, file)\n", "'''" ] } ], "metadata": { "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.12.0" } }, "nbformat": 4, "nbformat_minor": 2 }