From 4ac71b6a8ffb526797570a257a51e2cbe9ae5722 Mon Sep 17 00:00:00 2001 From: perib Date: Mon, 31 Jul 2023 17:02:16 -0700 Subject: [PATCH] correctly get n_splits, tutorial update --- Tutorial/1_Estimators_Overview.ipynb | 319 ++++++++++++------ tpot2/tpot_estimator/estimator.py | 2 +- .../tpot_estimator/steady_state_estimator.py | 2 +- 3 files changed, 211 insertions(+), 112 deletions(-) diff --git a/Tutorial/1_Estimators_Overview.ipynb b/Tutorial/1_Estimators_Overview.ipynb index ee6e4624..6e164775 100644 --- a/Tutorial/1_Estimators_Overview.ipynb +++ b/Tutorial/1_Estimators_Overview.ipynb @@ -5,27 +5,28 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "All TPOT estimators can be created with the TPOTEstimator class. \n", - "The TPOTClassifier and TPOTRegressor are set default parameters for the TPOTEstimator for Classification and Regression." + "TPOT1 and TPOTSteady use a standard evolutionary algorithm that evaluates exactly population_size individuals each generation. The next generation does not start until the previous is completely finished evaluating. This leads to underutilized CPU time as the cores are waiting for the last individuals to finish training. \n", + "\n", + "TPOTEstimatorSteadyState will generate and evaluate the next individual as soon as an individual finishes evaluation. The number of individuals being evaluated is determined by the n_jobs parameter. There is no longer a concept of generations. The population_size parameter now refers to the size of the list of evaluated parents. When an individual is evaluated, the selection method updates the list of parents. Then " ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "Generation: 100%|██████████| 5/5 [00:35<00:00, 7.17s/it]\n" + "Evaluations: : 111it [00:30, 3.64it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "0.9947089947089948\n" + "1.0\n" ] } ], @@ -34,36 +35,39 @@ "import sklearn\n", "import sklearn.datasets\n", "\n", - "est = tpot2.TPOTEstimator( population_size=30,\n", - " generations=5,\n", + "est = tpot2.TPOTEstimatorSteadyState( population_size=30,\n", + " initial_population_size=30,\n", " scorers=['roc_auc_ovr'], #scorers can be a list of strings or a list of scorers. These get evaluated during cross validation. \n", " scorers_weights=[1],\n", + "\n", " classification=True,\n", - " n_jobs=1, \n", - " early_stop=5, #how many generations with no improvement to stop after\n", - " \n", - " #List of other objective functions. All objective functions take in an untrained GraphPipeline and return a score or a list of scores\n", + " n_jobs=1,\n", + " #List of other objective functions. All objective functions take in an untrained GraphPipeline and return a score or a list of scores\n", " other_objective_functions= [ ],\n", " \n", " #List of weights for the other objective functions. Must be the same length as other_objective_functions. By default, bigger is better is set to True. \n", " other_objective_functions_weights=[],\n", + "\n", + " max_eval_time_seconds=15,\n", + " max_time_seconds=30,\n", " verbose=2)\n", "\n", + "\n", "scorer = sklearn.metrics.get_scorer('roc_auc_ovo')\n", "X, y = sklearn.datasets.load_iris(return_X_y=True)\n", "X_train, X_test, y_train, y_test = sklearn.model_selection.train_test_split(X, y, train_size=0.75, test_size=0.25)\n", "est.fit(X_train, y_train)\n", - "print(scorer(est, X_test, y_test))" + "print(scorer(est, X_test, y_test))\n" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -79,7 +83,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -107,7 +111,8 @@ " Parents\n", " Variation_Function\n", " Individual\n", - " Generation\n", + " Submitted Timestamp\n", + " Completed Timestamp\n", " Pareto_Front\n", " Instance\n", " \n", @@ -119,48 +124,53 @@ " NaN\n", " NaN\n", " ['LogisticRegression_1']\n", - " 0.0\n", + " 1.690848e+09\n", + " 1.690848e+09\n", " NaN\n", " ['LogisticRegression_1']\n", " \n", " \n", " 1\n", - " 0.978247\n", + " 0.982956\n", " NaN\n", " NaN\n", " ['DecisionTreeClassifier_1']\n", - " 0.0\n", + " 1.690848e+09\n", + " 1.690848e+09\n", " NaN\n", " ['DecisionTreeClassifier_1']\n", " \n", " \n", " 2\n", - " 0.966548\n", + " 0.953313\n", " NaN\n", " NaN\n", " ['KNeighborsClassifier_1']\n", - " 0.0\n", + " 1.690848e+09\n", + " 1.690848e+09\n", " NaN\n", " ['KNeighborsClassifier_1']\n", " \n", " \n", " 3\n", - " 0.99877\n", + " 0.5\n", " NaN\n", " NaN\n", " ['GradientBoostingClassifier_1']\n", - " 0.0\n", + " 1.690848e+09\n", + " 1.690848e+09\n", " NaN\n", " ['GradientBoostingClassifier_1']\n", " \n", " \n", " 4\n", - " 1.0\n", + " 0.983413\n", " NaN\n", " NaN\n", " ['ExtraTreesClassifier_1']\n", - " 0.0\n", - " 0.0\n", + " 1.690848e+09\n", + " 1.690848e+09\n", + " NaN\n", " ['ExtraTreesClassifier_1']\n", " \n", " \n", @@ -172,106 +182,125 @@ " ...\n", " ...\n", " ...\n", + " ...\n", " \n", " \n", - " 145\n", - " 0.993849\n", - " (42,)\n", + " 106\n", + " 0.989742\n", + " (104,)\n", " mutate\n", - " [('GaussianNB_1', 'SelectPercentile_1')]\n", - " 4.0\n", + " [('MLPClassifier_1', 'SelectPercentile_1')]\n", + " 1.690848e+09\n", + " 1.690848e+09\n", " NaN\n", - " [('GaussianNB_1', 'SelectPercentile_1')]\n", + " [('MLPClassifier_1', 'SelectPercentile_1')]\n", " \n", " \n", - " 146\n", - " 0.99877\n", - " (114,)\n", + " 107\n", + " 0.99631\n", + " (12,)\n", " mutate\n", - " [('MLPClassifier_1', 'PolynomialFeatures_1')]\n", - " 4.0\n", + " ['MLPClassifier_1']\n", + " 1.690848e+09\n", + " 1.690848e+09\n", " NaN\n", - " [('MLPClassifier_1', 'PolynomialFeatures_1')]\n", + " ['MLPClassifier_1']\n", " \n", " \n", - " 147\n", + " 108\n", " 0.99754\n", - " (48,)\n", - " mutate\n", - " [('GaussianNB_1', 'SelectPercentile_1'), ('Sel...\n", - " 4.0\n", + " (97, 93)\n", + " crossover_then_mutate\n", + " [('MLPClassifier_1', 'PolynomialFeatures_1'), ...\n", + " 1.690848e+09\n", + " 1.690848e+09\n", " NaN\n", - " [('GaussianNB_1', 'SelectPercentile_1'), ('Sel...\n", + " [('MLPClassifier_1', 'PolynomialFeatures_1'), ...\n", " \n", " \n", - " 148\n", - " 0.5\n", - " (114,)\n", - " mutate\n", - " ['BernoulliNB_1']\n", - " 4.0\n", + " 109\n", + " 0.989484\n", + " (80, 61)\n", + " crossover\n", + " [('MLPClassifier_1', 'FastICA_1')]\n", + " 1.690848e+09\n", + " 1.690848e+09\n", " NaN\n", - " ['BernoulliNB_1']\n", + " [('MLPClassifier_1', 'FastICA_1')]\n", " \n", " \n", - " 149\n", - " 0.999365\n", - " (4,)\n", + " 110\n", + " 0.994008\n", + " (71,)\n", " mutate\n", - " [('ExtraTreesClassifier_1', 'SelectFwe_1')]\n", - " 4.0\n", + " [('GradientBoostingClassifier_1', 'PolynomialF...\n", + " 1.690848e+09\n", + " 1.690848e+09\n", " NaN\n", - " [('ExtraTreesClassifier_1', 'SelectFwe_1')]\n", + " [('GradientBoostingClassifier_1', 'PolynomialF...\n", " \n", " \n", "\n", - "

150 rows × 7 columns

\n", + "

111 rows × 8 columns

\n", "" ], "text/plain": [ - " roc_auc_score Parents Variation_Function \\\n", - "0 0.99631 NaN NaN \n", - "1 0.978247 NaN NaN \n", - "2 0.966548 NaN NaN \n", - "3 0.99877 NaN NaN \n", - "4 1.0 NaN NaN \n", - ".. ... ... ... \n", - "145 0.993849 (42,) mutate \n", - "146 0.99877 (114,) mutate \n", - "147 0.99754 (48,) mutate \n", - "148 0.5 (114,) mutate \n", - "149 0.999365 (4,) mutate \n", + " roc_auc_score Parents Variation_Function \\\n", + "0 0.99631 NaN NaN \n", + "1 0.982956 NaN NaN \n", + "2 0.953313 NaN NaN \n", + "3 0.5 NaN NaN \n", + "4 0.983413 NaN NaN \n", + ".. ... ... ... \n", + "106 0.989742 (104,) mutate \n", + "107 0.99631 (12,) mutate \n", + "108 0.99754 (97, 93) crossover_then_mutate \n", + "109 0.989484 (80, 61) crossover \n", + "110 0.994008 (71,) mutate \n", "\n", - " Individual Generation \\\n", - "0 ['LogisticRegression_1'] 0.0 \n", - "1 ['DecisionTreeClassifier_1'] 0.0 \n", - "2 ['KNeighborsClassifier_1'] 0.0 \n", - "3 ['GradientBoostingClassifier_1'] 0.0 \n", - "4 ['ExtraTreesClassifier_1'] 0.0 \n", - ".. ... ... \n", - "145 [('GaussianNB_1', 'SelectPercentile_1')] 4.0 \n", - "146 [('MLPClassifier_1', 'PolynomialFeatures_1')] 4.0 \n", - "147 [('GaussianNB_1', 'SelectPercentile_1'), ('Sel... 4.0 \n", - "148 ['BernoulliNB_1'] 4.0 \n", - "149 [('ExtraTreesClassifier_1', 'SelectFwe_1')] 4.0 \n", + " Individual Submitted Timestamp \\\n", + "0 ['LogisticRegression_1'] 1.690848e+09 \n", + "1 ['DecisionTreeClassifier_1'] 1.690848e+09 \n", + "2 ['KNeighborsClassifier_1'] 1.690848e+09 \n", + "3 ['GradientBoostingClassifier_1'] 1.690848e+09 \n", + "4 ['ExtraTreesClassifier_1'] 1.690848e+09 \n", + ".. ... ... \n", + "106 [('MLPClassifier_1', 'SelectPercentile_1')] 1.690848e+09 \n", + "107 ['MLPClassifier_1'] 1.690848e+09 \n", + "108 [('MLPClassifier_1', 'PolynomialFeatures_1'), ... 1.690848e+09 \n", + "109 [('MLPClassifier_1', 'FastICA_1')] 1.690848e+09 \n", + "110 [('GradientBoostingClassifier_1', 'PolynomialF... 1.690848e+09 \n", "\n", - " Pareto_Front Instance \n", - "0 NaN ['LogisticRegression_1'] \n", - "1 NaN ['DecisionTreeClassifier_1'] \n", - "2 NaN ['KNeighborsClassifier_1'] \n", - "3 NaN ['GradientBoostingClassifier_1'] \n", - "4 0.0 ['ExtraTreesClassifier_1'] \n", - ".. ... ... \n", - "145 NaN [('GaussianNB_1', 'SelectPercentile_1')] \n", - "146 NaN [('MLPClassifier_1', 'PolynomialFeatures_1')] \n", - "147 NaN [('GaussianNB_1', 'SelectPercentile_1'), ('Sel... \n", - "148 NaN ['BernoulliNB_1'] \n", - "149 NaN [('ExtraTreesClassifier_1', 'SelectFwe_1')] \n", + " Completed Timestamp Pareto_Front \\\n", + "0 1.690848e+09 NaN \n", + "1 1.690848e+09 NaN \n", + "2 1.690848e+09 NaN \n", + "3 1.690848e+09 NaN \n", + "4 1.690848e+09 NaN \n", + ".. ... ... \n", + "106 1.690848e+09 NaN \n", + "107 1.690848e+09 NaN \n", + "108 1.690848e+09 NaN \n", + "109 1.690848e+09 NaN \n", + "110 1.690848e+09 NaN \n", "\n", - "[150 rows x 7 columns]" + " Instance \n", + "0 ['LogisticRegression_1'] \n", + "1 ['DecisionTreeClassifier_1'] \n", + "2 ['KNeighborsClassifier_1'] \n", + "3 ['GradientBoostingClassifier_1'] \n", + "4 ['ExtraTreesClassifier_1'] \n", + ".. ... \n", + "106 [('MLPClassifier_1', 'SelectPercentile_1')] \n", + "107 ['MLPClassifier_1'] \n", + "108 [('MLPClassifier_1', 'PolynomialFeatures_1'), ... \n", + "109 [('MLPClassifier_1', 'FastICA_1')] \n", + "110 [('GradientBoostingClassifier_1', 'PolynomialF... \n", + "\n", + "[111 rows x 8 columns]" ] }, - "execution_count": 3, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -283,7 +312,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -311,35 +340,43 @@ " Parents\n", " Variation_Function\n", " Individual\n", - " Generation\n", + " Submitted Timestamp\n", + " Completed Timestamp\n", " Pareto_Front\n", " Instance\n", " \n", " \n", " \n", " \n", - " 4\n", + " 69\n", + " 0.99754\n", + " (51,)\n", + " mutate\n", + " [('LogisticRegression_1', 'PolynomialFeatures_...\n", + " 1.690848e+09\n", + " 1.690848e+09\n", " 1.0\n", - " NaN\n", - " NaN\n", - " ['ExtraTreesClassifier_1']\n", - " 0.0\n", - " 0.0\n", - " ['ExtraTreesClassifier_1']\n", + " [('LogisticRegression_1', 'PolynomialFeatures_...\n", " \n", " \n", "\n", "" ], "text/plain": [ - " roc_auc_score Parents Variation_Function Individual \\\n", - "4 1.0 NaN NaN ['ExtraTreesClassifier_1'] \n", + " roc_auc_score Parents Variation_Function \\\n", + "69 0.99754 (51,) mutate \n", "\n", - " Generation Pareto_Front Instance \n", - "4 0.0 0.0 ['ExtraTreesClassifier_1'] " + " Individual Submitted Timestamp \\\n", + "69 [('LogisticRegression_1', 'PolynomialFeatures_... 1.690848e+09 \n", + "\n", + " Completed Timestamp Pareto_Front \\\n", + "69 1.690848e+09 1.0 \n", + "\n", + " Instance \n", + "69 [('LogisticRegression_1', 'PolynomialFeatures_... " ] }, - "execution_count": 4, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -349,6 +386,68 @@ "est.pareto_front" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "TPOTEstimator does a standard evolutionary algorithm. In this version, the next generation doesn't start evaluation until all individuals in the previous generation are finished evaluating." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Generation: 100%|██████████| 5/5 [00:35<00:00, 7.17s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9947089947089948\n" + ] + } + ], + "source": [ + "import tpot2\n", + "import sklearn\n", + "import sklearn.datasets\n", + "\n", + "est = tpot2.TPOTEstimator( population_size=30,\n", + " generations=5,\n", + " scorers=['roc_auc_ovr'], #scorers can be a list of strings or a list of scorers. These get evaluated during cross validation. \n", + " scorers_weights=[1],\n", + " classification=True,\n", + " n_jobs=1, \n", + " early_stop=5, #how many generations with no improvement to stop after\n", + " \n", + " #List of other objective functions. All objective functions take in an untrained GraphPipeline and return a score or a list of scores\n", + " other_objective_functions= [ ],\n", + " \n", + " #List of weights for the other objective functions. Must be the same length as other_objective_functions. By default, bigger is better is set to True. \n", + " other_objective_functions_weights=[],\n", + " verbose=2)\n", + "\n", + "scorer = sklearn.metrics.get_scorer('roc_auc_ovo')\n", + "X, y = sklearn.datasets.load_iris(return_X_y=True)\n", + "X_train, X_test, y_train, y_test = sklearn.model_selection.train_test_split(X, y, train_size=0.75, test_size=0.25)\n", + "est.fit(X_train, y_train)\n", + "print(scorer(est, X_test, y_test))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The TPOTClassifier and TPOTRegressor are set default parameters for the TPOTEstimator for Classification and Regression.\n", + "In the future, a metalearner will be used to predict the best values for a given dataset." + ] + }, { "cell_type": "code", "execution_count": 5, diff --git a/tpot2/tpot_estimator/estimator.py b/tpot2/tpot_estimator/estimator.py index 6d1c43b4..092fedeb 100644 --- a/tpot2/tpot_estimator/estimator.py +++ b/tpot2/tpot_estimator/estimator.py @@ -581,7 +581,7 @@ def fit(self, X, y): if isinstance(self.cv, int) or isinstance(self.cv, float): n_folds = self.cv else: - n_folds = self.cv.n_splits + n_folds = self.cv.get_n_splits(X, y) X, y = remove_underrepresented_classes(X, y, n_folds) diff --git a/tpot2/tpot_estimator/steady_state_estimator.py b/tpot2/tpot_estimator/steady_state_estimator.py index 085d5ffe..7ecf0cd0 100644 --- a/tpot2/tpot_estimator/steady_state_estimator.py +++ b/tpot2/tpot_estimator/steady_state_estimator.py @@ -570,7 +570,7 @@ def fit(self, X, y): if isinstance(self.cv, int) or isinstance(self.cv, float): n_folds = self.cv else: - n_folds = self.cv.n_splits + n_folds = self.cv.get_n_splits(X, y) X, y = remove_underrepresented_classes(X, y, n_folds)