diff --git a/Tutorial/8_SH_and_cv_early_pruning.ipynb b/Tutorial/8_SH_and_cv_early_pruning.ipynb index 160db0be..50ad9585 100644 --- a/Tutorial/8_SH_and_cv_early_pruning.ipynb +++ b/Tutorial/8_SH_and_cv_early_pruning.ipynb @@ -60,7 +60,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -107,348 +107,9 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/perib/Projects/common/Projects/TPOT_Dev/tpot2/tpot2/tpot_estimator/estimator.py:423: UserWarning: Both generations and max_time_mins are set. TPOT will terminate when the first condition is met.\n", - " warnings.warn(\"Both generations and max_time_mins are set. TPOT will terminate when the first condition is met.\")\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Generation: 2%|▏ | 1/50 [00:25<20:56, 25.64s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Generation: 1\n", - "Best roc_auc_score score: 0.9909340659340659\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Generation: 4%|▍ | 2/50 [00:47<18:41, 23.37s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Generation: 2\n", - "Best roc_auc_score score: 0.9918914418914418\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Generation: 6%|▌ | 3/50 [01:25<23:39, 30.21s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Generation: 3\n", - "Best roc_auc_score score: 0.9925990675990676\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Generation: 8%|▊ | 4/50 [02:19<30:20, 39.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Generation: 4\n", - "Best roc_auc_score score: 0.9925990675990676\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Generation: 10%|█ | 5/50 [02:56<28:55, 38.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Generation: 5\n", - "Best roc_auc_score score: 0.9933816183816184\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Generation: 12%|█▏ | 6/50 [03:46<31:15, 42.63s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Generation: 6\n", - "Best roc_auc_score score: 0.9933816183816184\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Generation: 14%|█▍ | 7/50 [04:41<33:15, 46.42s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Generation: 7\n", - "Best roc_auc_score score: 0.9934065934065934\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Generation: 16%|█▌ | 8/50 [05:19<30:39, 43.79s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Generation: 8\n", - "Best roc_auc_score score: 0.9948468198468199\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Generation: 18%|█▊ | 9/50 [05:49<27:01, 39.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Generation: 9\n", - "Best roc_auc_score score: 0.9948468198468199\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Generation: 20%|██ | 10/50 [07:01<33:03, 49.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Generation: 10\n", - "Best roc_auc_score score: 0.9948468198468199\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Generation: 22%|██▏ | 11/50 [07:43<30:38, 47.14s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Generation: 11\n", - "Best roc_auc_score score: 0.9972905525846703\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Generation: 24%|██▍ | 12/50 [08:35<30:52, 48.75s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Generation: 12\n", - "Best roc_auc_score score: 0.9976114081996436\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Generation: 26%|██▌ | 13/50 [09:10<27:31, 44.64s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Generation: 13\n", - "Best roc_auc_score score: 0.9976114081996436\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Generation: 28%|██▊ | 14/50 [10:06<28:49, 48.04s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Generation: 14\n", - "Best roc_auc_score score: 0.9976114081996436\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Generation: 30%|███ | 15/50 [11:08<30:21, 52.05s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Generation: 15\n", - "Best roc_auc_score score: 0.9979411764705883\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Generation: 32%|███▏ | 16/50 [12:28<34:16, 60.49s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Generation: 16\n", - "Best roc_auc_score score: 0.9985249554367203\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Generation: 34%|███▍ | 17/50 [14:09<40:01, 72.78s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Generation: 17\n", - "Best roc_auc_score score: 0.999108734402852\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Generation: 36%|███▌ | 18/50 [14:49<33:37, 63.03s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Generation: 18\n", - "Best roc_auc_score score: 0.999108734402852\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Generation: 38%|███▊ | 19/50 [15:12<26:14, 50.78s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Generation: 19\n", - "Best roc_auc_score score: 0.999108734402852\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Generation: 40%|████ | 20/50 [15:55<24:16, 48.53s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Generation: 20\n", - "Best roc_auc_score score: 0.999108734402852\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Generation: 40%|████ | 20/50 [16:15<24:23, 48.79s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "KeyboardInterrupt\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "/home/perib/miniconda3/envs/myenv/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:349: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", - " warnings.warn(\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "total time: 983.1856114864349\n" - ] - } - ], + "outputs": [], "source": [ "# A Graph pipeline starting with at least one selector as a leaf, potentially followed by a series\n", "# of stacking classifiers or transformers, and ending with a classifier. The graph will have at most 15 nodes and a max depth of 6.\n", @@ -529,12 +190,14 @@ "\n", "In practice, the values of these parameters will depend on the specific problem and the available computational resources. \n", "\n", - "In the following sections, we will show you how to set and manipulate these parameters using Python code in a Jupyter Notebook. We will also provide examples of how these parameters can affect the performance of the algorithm." + "In the following sections, we will show you how to set and manipulate these parameters using Python code in a Jupyter Notebook. We will also provide examples of how these parameters can affect the performance of the algorithm.\n", + "\n", + "(Note that in these small test cases, you may not notice much or any performance improvements, these are more likely to be more beneficial in real world scenarios with larger datasets and slower evaluating pipelines.)" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -574,23 +237,7 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/perib/Projects/common/Projects/TPOT_Dev/tpot2/tpot2/tpot_estimator/estimator.py:423: UserWarning: Both generations and max_time_mins are set. TPOT will terminate when the first condition is met.\n", - " warnings.warn(\"Both generations and max_time_mins are set. TPOT will terminate when the first condition is met.\")\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Generation: 20%|██ | 1/5 [00:32<02:11, 32.94s/it]" - ] - } - ], + "outputs": [], "source": [ "X, y = sklearn.datasets.load_breast_cancer(return_X_y=True)\n", "\n", @@ -601,16 +248,15 @@ " scorers=['roc_auc_ovr'],\n", " scorers_weights=[1],\n", " classification=True,\n", - " search_space = 'linear-light',\n", + " search_space = 'linear',\n", " n_jobs=32,\n", " cv=cv,\n", - " \n", - " # budget_range = [.3,1],\n", - " # generations_until_end_budget=4,\n", + " early_stop=5,\n", + " verbose=3,\n", "\n", " threshold_evaluation_pruning = threshold_evaluation_pruning,\n", " threshold_evaluation_scaling = threshold_evaluation_scaling,\n", - " verbose=2)\n", + " )\n", "\n", "\n", "start = time.time()\n", @@ -620,12 +266,12 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAGwCAYAAABVdURTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAApbUlEQVR4nO3dfXDU5b3//9eSZHNjSRBCwl0MAYMSKSDJQRJBBSQMOIxoHbG2gAq2tGggKAiitmY4JyKVA6KEUkDKGYoMN3qcOZQkB7nHGxKTE+6ObYESqsnJJBQSE0xg8/n+wY+dX0yA/SybbPbi+ZjZmeyV69p9X1zKvrg+n/18HJZlWQIAADBEB38XAAAA4EuEGwAAYBTCDQAAMArhBgAAGIVwAwAAjEK4AQAARiHcAAAAowT7u4C21tjYqG+//VYdO3aUw+HwdzkAAMADlmWppqZGPXr0UIcO19+bueXCzbfffqu4uDh/lwEAALxw9uxZ9erV67p9brlw07FjR0lX/nAiIyP9XA0AAPBEdXW14uLi3J/j13PLhZurh6IiIyMJNwAABBhPTinhhGIAAGAUwg0AADAK4QYAABiFcAMAAIxCuAEAAEYh3AAAAKMQbgAAgFEINwAAwCiEGwAAYBTCDQAAMIpfw82+ffs0YcIE9ejRQw6HQx9//PENx+zdu1fJyckKCwtTnz59tGrVqtYvFAAABAy/hpva2loNGjRI7733nkf9T58+rfHjx2vEiBEqKirSq6++qoyMDG3btq2VKwUAAIHCrzfOHDdunMaNG+dx/1WrVumOO+7QsmXLJEn9+/dXQUGBfve73+knP/lJK1UJAGgrlmXp4iWXv8uAD4SHBHl0k8vWEFB3Bf/ss8+Unp7epG3s2LFau3atLl26pJCQkGZj6uvrVV9f735eXV3d6nUCAOyzLEtPrPpMhWf+6e9S4APHs8YqwumfmBFQJxSXl5crNja2SVtsbKwuX76sysrKFsdkZ2crKirK/YiLi2uLUgEANl285CLYwCcCaudGUrMtLsuyWmy/asGCBZozZ477eXV1NQEHANq5gtceVoQzyN9l4CaEh/hv/QIq3HTr1k3l5eVN2ioqKhQcHKwuXbq0OCY0NFShoaFtUR4AwEcinEF+O6SBwBdQh6VSU1OVn5/fpC0vL08pKSktnm8DAABuPX4NN999952Ki4tVXFws6cpXvYuLi1VaWirpyiGlKVOmuPvPmDFDZ86c0Zw5c3TixAmtW7dOa9eu1csvv+yP8gEAQDvk1z2/goICjRw50v386rkxU6dO1fr161VWVuYOOpKUkJCgHTt2KDMzU++//7569Oihd999l6+BAwAAN7+Gm4ceesh9QnBL1q9f36ztwQcf1FdffdWKVQEAgEAWUOfcAAAA3AjhBgAAGIVwAwAAjEK4AQAARiHcAAAAoxBuAACAUQg3AADAKIQbAABgFMINAAAwCuEGAAAYhXADAACMQrgBAABGIdwAAACjEG4AAIBRCDcAAMAohBsAAGAUwg0AADAK4QYAABiFcAMAAIxCuAEAAEYh3AAAAKMQbgAAgFEINwAAwCiEGwAAYBTCDQAAMArhBgAAGIVwAwAAjEK4AQAARiHcAAAAoxBuAACAUQg3AADAKIQbAABgFMINAAAwCuEGAAAYhXADAACMQrgBAABGIdwAAACjEG4AAIBRCDcAAMAohBsAAGAUwg0AADAK4QYAABiFcAMAAIxCuAEAAEYh3AAAAKMQbgAAgFEINwAAwCiEGwAAYBTCDQAAMArhBgAAGIVwAwAAjEK4AQAARiHcAAAAoxBuAACAUQg3AADAKIQbAABgFMINAAAwSrC/CwAAX7EsSxcvufxdBrxU18DawTcINwCMYFmWnlj1mQrP/NPfpQDwMw5LATDCxUsugo0hUuJvV3hIkL/LQABj5waAcQpee1gRTj4cA1V4SJAcDoe/y0AAI9wAME6EM0gRTv56A25VHJYCAABGIdwAAACj+D3crFy5UgkJCQoLC1NycrL2799/3f4bN27UoEGDFBERoe7du+vZZ59VVVVVG1ULAADaO7+Gm82bN2v27NlauHChioqKNGLECI0bN06lpaUt9j9w4ICmTJmiadOm6dixY9qyZYsOHz6s6dOnt3HlAACgvfJruFm6dKmmTZum6dOnq3///lq2bJni4uKUk5PTYv/PP/9cvXv3VkZGhhISEjR8+HD98pe/VEFBQRtXDgAA2iu/hZuGhgYVFhYqPT29SXt6eroOHTrU4pi0tDT94x//0I4dO2RZlv7v//5PW7du1SOPPHLN96mvr1d1dXWTBwAAMJffwk1lZaVcLpdiY2ObtMfGxqq8vLzFMWlpadq4caMmTZokp9Opbt26qVOnTlqxYsU13yc7O1tRUVHuR1xcnE/nAQAA2he/n1D8wws1WZZ1zYs3HT9+XBkZGXrjjTdUWFionTt36vTp05oxY8Y1X3/BggW6cOGC+3H27Fmf1g8AANoXv13lKjo6WkFBQc12aSoqKprt5lyVnZ2t+++/X3PnzpUkDRw4ULfddptGjBihRYsWqXv37s3GhIaGKjQ01PcTAAAA7ZLfdm6cTqeSk5OVn5/fpD0/P19paWktjqmrq1OHDk1LDgq6col1y7Jap1AAABBQ/HpYas6cOVqzZo3WrVunEydOKDMzU6Wlpe7DTAsWLNCUKVPc/SdMmKDt27crJydHp06d0sGDB5WRkaGhQ4eqR48e/poGAABoR/x685VJkyapqqpKWVlZKisr04ABA7Rjxw7Fx8dLksrKyppc8+aZZ55RTU2N3nvvPb300kvq1KmTRo0apcWLF/trCgAAoJ1xWLfY8Zzq6mpFRUXpwoULioyM9Hc5AHykruGykt7IlSQdzxrLjTMBw9j5/Pb7t6UAAAB8iXADAACMQrgBAABGIdwAAACjEG4AAIBRCDcAAMAohBsAAGAUwg0AADAK4QYAABiFcAMAAIxCuAEAAEYh3AAAAKMQbgAAgFEINwAAwCiEGwAAYBTCDQAAMArhBgAAGIVwAwAAjEK4AQAARiHcAAAAoxBuAACAUQg3AADAKIQbAABgFMINAAAwCuEGAAAYhXADAACMQrgBAABGIdwAAACjEG4AAIBRbIebUaNG6fz5883aq6urNWrUKF/UBAAA4DXb4WbPnj1qaGho1v79999r//79PikKAADAW8GediwpKXH/fPz4cZWXl7ufu1wu7dy5Uz179vRtdQAAADZ5HG4GDx4sh8Mhh8PR4uGn8PBwrVixwqfFAQAA2OVxuDl9+rQsy1KfPn305ZdfqmvXru7fOZ1OxcTEKCgoqFWKBAAA8JTH4SY+Pl6S1NjY2GrFAAAA3CzbJxRnZ2dr3bp1zdrXrVunxYsX+6QoAAAAb9kON7///e919913N2u/5557tGrVKp8UBQAA4C3b4aa8vFzdu3dv1t61a1eVlZX5pCgAAABv2Q43cXFxOnjwYLP2gwcPqkePHj4pCgAAwFsen1B81fTp0zV79mxdunTJ/ZXwXbt2ad68eXrppZd8XiAAAIAdtsPNvHnzdO7cOf361792X6k4LCxMr7zyihYsWODzAgEAAOywHW4cDocWL16s119/XSdOnFB4eLgSExMVGhraGvUBAADY4vVdwcvLy3Xu3Dn17dtXoaGhsizLl3UBAAB4xXa4qaqq0ujRo9WvXz+NHz/e/Q2p6dOnc84NAADwO9vhJjMzUyEhISotLVVERIS7fdKkSdq5c6dPiwMAALDL9jk3eXl5ys3NVa9evZq0JyYm6syZMz4rDAAAwBu2d25qa2ub7NhcVVlZyUnFAADA72yHmwceeEAbNmxwP3c4HGpsbNSSJUs0cuRInxYHAABgl+3DUkuWLNFDDz2kgoICNTQ0aN68eTp27JjOnTvX4pWLAQAA2pLtnZukpCSVlJRo6NChGjNmjGpra/X444+rqKhIffv2bY0aAQAAPGZ750aSunXrpjfffNPXtQAAANw0j8JNSUmJxy84cOBAr4sBAAC4WR6Fm8GDB8vhcNzwKsQOh0Mul8snhQEAAHjDo3Bz+vTp1q4DAADAJzwKN/Hx8a1dBwAAgE94dePM//iP/9D999+vHj16uK9KvGzZMv3nf/6nT4sDAACwy3a4ycnJ0Zw5czR+/HidP3/efY5Np06dtGzZMl/XBwAAYIvtcLNixQr94Q9/0MKFCxUUFORuT0lJ0ZEjR3xaHAAAgF22w83p06d17733NmsPDQ1VbW2tT4oCAADwlu1wk5CQoOLi4mbtf/7zn5WUlOSLmgAAALxm+wrFc+fO1cyZM/X999/Lsix9+eWX2rRpk7Kzs7VmzZrWqBEAAMBjtsPNs88+q8uXL2vevHmqq6vT008/rZ49e2r58uV66qmnWqNGAAAAj3l1b6nnn39ezz//vCorK9XY2KiYmBhf1wUAAOAV2+fcXLx4UXV1dZKk6OhoXbx4UcuWLVNeXp7PiwMAALDLdrh59NFHtWHDBknS+fPnNXToUL3zzjt69NFHlZOTY7uAlStXKiEhQWFhYUpOTtb+/fuv27++vl4LFy5UfHy8QkND1bdvX61bt872+wIAADPZDjdfffWVRowYIUnaunWrunXrpjNnzmjDhg169913bb3W5s2bNXv2bC1cuFBFRUUaMWKExo0bp9LS0muOefLJJ7Vr1y6tXbtWX3/9tTZt2qS7777b7jQAAIChbJ9zU1dXp44dO0qS8vLy9Pjjj6tDhw4aNmyY+1YMnlq6dKmmTZum6dOnS7pyC4fc3Fzl5OQoOzu7Wf+dO3dq7969OnXqlDp37ixJ6t2793Xfo76+XvX19e7n1dXVtmoEAACBxfbOzZ133qmPP/5YZ8+eVW5urtLT0yVJFRUVioyM9Ph1GhoaVFhY6B5/VXp6ug4dOtTimE8++UQpKSl6++231bNnT/Xr108vv/yyLl68eM33yc7OVlRUlPsRFxfncY0AACDw2A43b7zxhl5++WX17t1b9913n1JTUyVd2cVp6crF11JZWSmXy6XY2Ngm7bGxsSovL29xzKlTp3TgwAEdPXpUH330kZYtW6atW7dq5syZ13yfBQsW6MKFC+7H2bNnPa4RAAAEHtuHpZ544gkNHz5cZWVlGjRokLt99OjReuyxx2wX4HA4mjy3LKtZ21WNjY1yOBzauHGjoqKiJF05tPXEE0/o/fffV3h4eLMxoaGhCg0NtV0XAAAITF5d56Zbt27q1q1bk7ahQ4faeo3o6GgFBQU126WpqKhotptzVffu3dWzZ093sJGk/v37y7Is/eMf/1BiYqKtGgAAgHlsH5byFafTqeTkZOXn5zdpz8/PV1paWotj7r//fn377bf67rvv3G1/+ctf1KFDB/Xq1atV6wUAAIHBb+FGkubMmaM1a9Zo3bp1OnHihDIzM1VaWqoZM2ZIunK+zJQpU9z9n376aXXp0kXPPvusjh8/rn379mnu3Ll67rnnWjwkBQAAbj1eHZbylUmTJqmqqkpZWVkqKyvTgAEDtGPHDsXHx0uSysrKmlzz5kc/+pHy8/P14osvKiUlRV26dNGTTz6pRYsW+WsKAACgnXFYlmX5u4i2VF1draioKF24cMHWV9cBtG91DZeV9EauJOl41lhFOP36bzcAPmbn89ur//tPnjypZcuW6cSJE3I4HOrfv79mzZqlvn37elUwAACAr9g+5yY3N1dJSUn68ssvNXDgQA0YMEBffPGF7rnnnmYnBwMAALQ12zs38+fPV2Zmpt56661m7a+88orGjBnjs+IAAADssr1zc+LECU2bNq1Z+3PPPafjx4/7pCgAAABv2Q43Xbt2VXFxcbP24uJixcTE+KImAAAAr9k+LPX888/rF7/4hU6dOqW0tDQ5HA4dOHBAixcv1ksvvdQaNQIAAHjMdrh5/fXX1bFjR73zzjtasGCBJKlHjx767W9/q4yMDJ8XCAAAYIftcONwOJSZmanMzEzV1NRIkjp27OjzwgAAALxh+5ybUaNG6fz585KuhJqrwaa6ulqjRo3yaXEAAAB22d652bNnjxoaGpq1f//999q/f79PigL8xbIsXbzk8ncZ8EJdA+sG4AqPw01JSYn75+PHj6u8vNz93OVyaefOnerZs6dvqwPakGVZemLVZyo8809/lwIAuAkeh5vBgwfL4XDI4XC0ePgpPDxcK1as8GlxQFu6eMlFsDFASvztCg8J8ncZAPzI43Bz+vRpWZalPn366Msvv1TXrl3dv3M6nYqJiVFQEH+hwAwFrz2sCCf/PQei8JAgORwOf5cBwI88Djfx8fGSpMbGxlYrBmgvIpxB3FUaAAKU7W9LAQAAtGeEGwAAYBTCDQAAMArhBgAAGMV2uOnTp4+qqqqatZ8/f159+vTxSVEAAADesh1u/v73v8vlan4l0Pr6en3zzTc+KQoAAMBbHn/X9ZNPPnH/nJubq6ioKPdzl8ulXbt2qXfv3j4tDgAAwC6Pw83EiRMlXbkr+NSpU5v8LiQkRL1799Y777zj0+IAAADs8jjcXL14X0JCgg4fPqzo6OhWKwoAAMBbti/Bevr06daoAwAAwCe8ur78rl27tGvXLlVUVDS7HcO6det8UhgAAIA3bIebN998U1lZWUpJSVH37t25QR0AAGhXbIebVatWaf369Zo8eXJr1AMAAHBTbF/npqGhQWlpaa1RCwAAwE2zHW6mT5+uP/3pT61RCwAAwE2zfVjq+++/1+rVq/Xf//3fGjhwoEJCQpr8funSpT4rDgAAwC7b4aakpESDBw+WJB09erTJ7zi5GAAA+JvtcLN79+7WqAMAAMAnbJ9zc9Xf/vY35ebm6uLFi5Iky7J8VhQAAIC3bIebqqoqjR49Wv369dP48eNVVlYm6cqJxi+99JLPCwQAALDDdrjJzMxUSEiISktLFRER4W6fNGmSdu7c6dPiAAAA7LJ9zk1eXp5yc3PVq1evJu2JiYk6c+aMzwoDAADwhu2dm9ra2iY7NldVVlYqNDTUJ0UBAAB4y3a4eeCBB7Rhwwb3c4fDocbGRi1ZskQjR470aXEAAAB22T4stWTJEj300EMqKChQQ0OD5s2bp2PHjuncuXM6ePBga9QIAADgMds7N0lJSSopKdHQoUM1ZswY1dbW6vHHH1dRUZH69u3bGjUCAAB4zPbOjSR169ZNb775pq9rAQAAuGm2d24++OADbdmypVn7li1b9Mc//tEnRQEAAHjLdrh56623FB0d3aw9JiZG//Zv/+aTogAAALxlO9ycOXNGCQkJzdrj4+NVWlrqk6IAAAC8ZTvcxMTEqKSkpFn7//zP/6hLly4+KQoAAMBbtsPNU089pYyMDO3evVsul0sul0uffvqpZs2apaeeeqo1agQAAPCY7W9LLVq0SGfOnNHo0aMVHHxleGNjo6ZMmcI5NwAAwO9shRvLslRWVqYPPvhAixYtUnFxscLDw/XjH/9Y8fHxrVUjAACAx2yHm8TERB07dkyJiYlKTExsrboAAAC8Yuucmw4dOigxMVFVVVWtVQ8AAMBNsX1C8dtvv625c+fq6NGjrVEPAADATbF9QvHPf/5z1dXVadCgQXI6nQoPD2/y+3PnzvmsOAAAALtsh5tly5a1QhkAAAC+YTvcTJ06tTXqAAAA8Anb59xI0smTJ/Xaa6/ppz/9qSoqKiRJO3fu1LFjx3xaHAAAgF22w83evXv14x//WF988YW2b9+u7777TpJUUlKi3/zmNz4vEAAAwA7b4Wb+/PlatGiR8vPz5XQ63e0jR47UZ5995tPiAAAA7LIdbo4cOaLHHnusWXvXrl25/g0AAPA72+GmU6dOKisra9ZeVFSknj17+qQoAAAAb9kON08//bReeeUVlZeXy+FwqLGxUQcPHtTLL7+sKVOmtEaNAAAAHrMdbv71X/9Vd9xxh3r27KnvvvtOSUlJeuCBB5SWlqbXXnutNWoEAADwmO3r3ISEhGjjxo3KyspSUVGRGhsbde+993ITTQAA0C7YDjdX9e3bV3369JEkORwOnxUEAABwM7y6iN/atWs1YMAAhYWFKSwsTAMGDNCaNWu8KmDlypVKSEhQWFiYkpOTtX//fo/GHTx4UMHBwRo8eLBX7wsAAMxkO9y8/vrrmjVrliZMmKAtW7Zoy5YtmjBhgjIzM22fc7N582bNnj1bCxcuVFFRkUaMGKFx48aptLT0uuMuXLigKVOmaPTo0XbLBwAAhnNYlmXZGRAdHa0VK1bopz/9aZP2TZs26cUXX1RlZaXHr3XfffdpyJAhysnJcbf1799fEydOVHZ29jXHPfXUU0pMTFRQUJA+/vhjFRcXe/ye1dXVioqK0oULFxQZGenxOJivruGykt7IlSQdzxqrCKfXR20BAD5m5/Pb9s6Ny+VSSkpKs/bk5GRdvnzZ49dpaGhQYWGh0tPTm7Snp6fr0KFD1xz3wQcf6OTJkx7f6qG+vl7V1dVNHgAAwFy2w83Pf/7zJjstV61evVo/+9nPPH6dyspKuVwuxcbGNmmPjY1VeXl5i2P++te/av78+dq4caOCgz37V3V2draioqLcj7i4OI9rBAAAgcerffe1a9cqLy9Pw4YNkyR9/vnnOnv2rKZMmaI5c+a4+y1duvSGr/XDb1pZltXit69cLpeefvppvfnmm+rXr5/HtS5YsKBJTdXV1QQcAAAMZjvcHD16VEOGDJEknTx5UtKV+0p17dpVR48edfe70dfDo6OjFRQU1GyXpqKiotlujiTV1NSooKBARUVFeuGFFyRJjY2NsixLwcHBysvL06hRo5qNCw0NVWhoqL1JAgCAgGU73Ozevdsnb+x0OpWcnKz8/PwmN+LMz8/Xo48+2qx/ZGSkjhw50qRt5cqV+vTTT7V161YlJCT4pC4AABDY/Pp1kDlz5mjy5MlKSUlRamqqVq9erdLSUs2YMUPSlUNK33zzjTZs2KAOHTpowIABTcbHxMS4r7MDAAAg+TncTJo0SVVVVcrKylJZWZkGDBigHTt2KD4+XpJUVlZ2w2veAAAA/P/Zvs5NoOM6N7gWrnMDAO1Xq17nBgAAoD0j3AAAAKMQbgAAgFEINwAAwCiEGwAAYBTCDQAAMArhBgAAGIVwAwAAjEK4AQAARiHcAAAAoxBuAACAUQg3AADAKIQbAABgFMINAAAwCuEGAAAYhXADAACMQrgBAABGIdwAAACjEG4AAIBRCDcAAMAohBsAAGAUwg0AADAK4QYAABiFcAMAAIxCuAEAAEYh3AAAAKMQbgAAgFEINwAAwCiEGwAAYBTCDQAAMArhBgAAGIVwAwAAjEK4AQAARiHcAAAAoxBuAACAUQg3AADAKIQbAABglGB/F2ASy7J08ZLL32XAS3UNrB0AmIBw4yOWZemJVZ+p8Mw//V0KAAC3NA5L+cjFSy6CjSFS4m9XeEiQv8sAAHiJnZtWUPDaw4pw8uEYqMJDguRwOPxdBgDAS4SbVhDhDFKEkz9aAAD8gcNSAADAKIQbAABgFMINAAAwCuEGAAAYhXADAACMQrgBAABGIdwAAACjEG4AAIBRCDcAAMAohBsAAGAUwg0AADAK4QYAABiFcAMAAIxCuAEAAEYh3AAAAKMQbgAAgFEINwAAwCiEGwAAYBTCDQAAMArhBgAAGIVwAwAAjEK4AQAARvF7uFm5cqUSEhIUFham5ORk7d+//5p9t2/frjFjxqhr166KjIxUamqqcnNz27BaAADQ3vk13GzevFmzZ8/WwoULVVRUpBEjRmjcuHEqLS1tsf++ffs0ZswY7dixQ4WFhRo5cqQmTJigoqKiNq4cAAC0Vw7Lsix/vfl9992nIUOGKCcnx93Wv39/TZw4UdnZ2R69xj333KNJkybpjTfe8Kh/dXW1oqKidOHCBUVGRnpVd0vqGi4r6Y0ru0jHs8Yqwhnss9cGAOBWZ+fz2287Nw0NDSosLFR6enqT9vT0dB06dMij12hsbFRNTY06d+58zT719fWqrq5u8gAAAObyW7iprKyUy+VSbGxsk/bY2FiVl5d79BrvvPOOamtr9eSTT16zT3Z2tqKiotyPuLi4m6obAAC0b34/odjhcDR5bllWs7aWbNq0Sb/97W+1efNmxcTEXLPfggULdOHCBffj7NmzN10zAABov/x2Ykh0dLSCgoKa7dJUVFQ02835oc2bN2vatGnasmWLHn744ev2DQ0NVWho6E3XCwAAAoPfdm6cTqeSk5OVn5/fpD0/P19paWnXHLdp0yY988wz+tOf/qRHHnmktcsEAAABxq9f6ZkzZ44mT56slJQUpaamavXq1SotLdWMGTMkXTmk9M0332jDhg2SrgSbKVOmaPny5Ro2bJh71yc8PFxRUVF+mwcAAGg//BpuJk2apKqqKmVlZamsrEwDBgzQjh07FB8fL0kqKytrcs2b3//+97p8+bJmzpypmTNnutunTp2q9evXt3X5AACgHfLrdW78gevcAAAQeALiOjcAAACtgXADAACMQrgBAABGIdwAAACjEG4AAIBRCDcAAMAohBsAAGAUwg0AADAK4QYAABiFcAMAAIxCuAEAAEYh3AAAAKMQbgAAgFEINwAAwCiEGwAAYBTCDQAAMArhBgAAGIVwAwAAjEK4AQAARiHcAAAAoxBuAACAUQg3AADAKIQbAABgFMINAAAwCuEGAAAYhXADAACMQrgBAABGIdwAAACjEG4AAIBRCDcAAMAohBsAAGCUYH8XYIrwkCAdzxrr/hkAAPgH4cZHHA6HIpz8cQIA4G8clgIAAEYh3AAAAKMQbgAAgFEINwAAwCiEGwAAYBTCDQAAMArhBgAAGIVwAwAAjEK4AQAARiHcAAAAoxBuAACAUQg3AADAKIQbAABglFvuNtaWZUmSqqur/VwJAADw1NXP7auf49dzy4WbmpoaSVJcXJyfKwEAAHbV1NQoKirqun0clicRyCCNjY369ttv1bFjRzkcDp++dnV1teLi4nT27FlFRkb69LXbA9PnJ5k/R+YX+EyfI/MLfK01R8uyVFNTox49eqhDh+ufVXPL7dx06NBBvXr1atX3iIyMNPY/Wsn8+Unmz5H5BT7T58j8Al9rzPFGOzZXcUIxAAAwCuEGAAAYhXDjQ6GhofrNb36j0NBQf5fSKkyfn2T+HJlf4DN9jswv8LWHOd5yJxQDAACzsXMDAACMQrgBAABGIdwAAACjEG4AAIBRCDc2rVy5UgkJCQoLC1NycrL2799/3f579+5VcnKywsLC1KdPH61ataqNKvWOnfnt2bNHDoej2eN///d/27Biz+3bt08TJkxQjx495HA49PHHH99wTKCtn905BtIaZmdn61/+5V/UsWNHxcTEaOLEifr6669vOC6Q1tCbOQbSGubk5GjgwIHui7ulpqbqz3/+83XHBNL62Z1fIK1dS7Kzs+VwODR79uzr9vPHGhJubNi8ebNmz56thQsXqqioSCNGjNC4ceNUWlraYv/Tp09r/PjxGjFihIqKivTqq68qIyND27Zta+PKPWN3fld9/fXXKisrcz8SExPbqGJ7amtrNWjQIL333nse9Q+09ZPsz/GqQFjDvXv3aubMmfr888+Vn5+vy5cvKz09XbW1tdccE2hr6M0crwqENezVq5feeustFRQUqKCgQKNGjdKjjz6qY8eOtdg/0NbP7vyuCoS1+6HDhw9r9erVGjhw4HX7+W0NLXhs6NCh1owZM5q03X333db8+fNb7D9v3jzr7rvvbtL2y1/+0ho2bFir1Xgz7M5v9+7dliTrn//8ZxtU51uSrI8++ui6fQJt/X7IkzkG8hpWVFRYkqy9e/des0+gr6EncwzkNbQsy7r99tutNWvWtPi7QF8/y7r+/AJ17WpqaqzExEQrPz/fevDBB61Zs2Zds6+/1pCdGw81NDSosLBQ6enpTdrT09N16NChFsd89tlnzfqPHTtWBQUFunTpUqvV6g1v5nfVvffeq+7du2v06NHavXt3a5bZpgJp/W5WIK7hhQsXJEmdO3e+Zp9AX0NP5nhVoK2hy+XShx9+qNraWqWmprbYJ5DXz5P5XRVoazdz5kw98sgjevjhh2/Y119rSLjxUGVlpVwul2JjY5u0x8bGqry8vMUx5eXlLfa/fPmyKisrW61Wb3gzv+7du2v16tXatm2btm/frrvuukujR4/Wvn372qLkVhdI6+etQF1Dy7I0Z84cDR8+XAMGDLhmv0BeQ0/nGGhreOTIEf3oRz9SaGioZsyYoY8++khJSUkt9g3E9bMzv0BbO0n68MMP9dVXXyk7O9uj/v5aw1vuruA3y+FwNHluWVazthv1b6m9vbAzv7vuukt33XWX+3lqaqrOnj2r3/3ud3rggQdatc62EmjrZ1egruELL7ygkpISHThw4IZ9A3UNPZ1joK3hXXfdpeLiYp0/f17btm3T1KlTtXfv3msGgEBbPzvzC7S1O3v2rGbNmqW8vDyFhYV5PM4fa8jOjYeio6MVFBTUbBejoqKiWSq9qlu3bi32Dw4OVpcuXVqtVm94M7+WDBs2TH/96199XZ5fBNL6+VJ7X8MXX3xRn3zyiXbv3q1evXpdt2+grqGdObakPa+h0+nUnXfeqZSUFGVnZ2vQoEFavnx5i30Dcf3szK8l7XntCgsLVVFRoeTkZAUHBys4OFh79+7Vu+++q+DgYLlcrmZj/LWGhBsPOZ1OJScnKz8/v0l7fn6+0tLSWhyTmprarH9eXp5SUlIUEhLSarV6w5v5taSoqEjdu3f3dXl+EUjr50vtdQ0ty9ILL7yg7du369NPP1VCQsINxwTaGnozx5a01zVsiWVZqq+vb/F3gbZ+Lbne/FrSntdu9OjROnLkiIqLi92PlJQU/exnP1NxcbGCgoKajfHbGrbq6cqG+fDDD62QkBBr7dq11vHjx63Zs2dbt912m/X3v//dsizLmj9/vjV58mR3/1OnTlkRERFWZmamdfz4cWvt2rVWSEiItXXrVn9N4brszu/f//3frY8++sj6y1/+Yh09etSaP3++Jcnatm2bv6ZwXTU1NVZRUZFVVFRkSbKWLl1qFRUVWWfOnLEsK/DXz7LszzGQ1vBXv/qVFRUVZe3Zs8cqKytzP+rq6tx9An0NvZljIK3hggULrH379lmnT5+2SkpKrFdffdXq0KGDlZeXZ1lW4K+f3fkF0tpdyw+/LdVe1pBwY9P7779vxcfHW06n0xoyZEiTr2hOnTrVevDBB5v037Nnj3XvvfdaTqfT6t27t5WTk9PGFdtjZ36LFy+2+vbta4WFhVm33367NXz4cOu//uu//FC1Z65+7fKHj6lTp1qWZcb62Z1jIK1hS/OSZH3wwQfuPoG+ht7MMZDW8LnnnnP//dK1a1dr9OjR7g9+ywr89bM7v0Bau2v5YbhpL2vosKz/78weAAAAA3DODQAAMArhBgAAGIVwAwAAjEK4AQAARiHcAAAAoxBuAACAUQg3AADAKIQbAABgFMINgHbPsiz94he/UOfOneVwOFRcXHzd/nv27JHD4dD58+ev2Wf9+vXq1KmTT+sE0D4E+7sAALiRnTt3av369dqzZ4/69Omj6Ohof5cEoB0j3ABo906ePKnu3bvbukM9gFsXh6UAtGvPPPOMXnzxRZWWlsrhcKh3796qr69XRkaGYmJiFBYWpuHDh+vw4cPXfZ3169frjjvuUEREhB577DFVVVW10QwAtDXCDYB2bfny5crKylKvXr1UVlamw4cPa968edq2bZv++Mc/6quvvtKdd96psWPH6ty5cy2+xhdffKHnnntOv/71r1VcXKyRI0dq0aJFbTwTAG2FcAOgXYuKilLHjh0VFBSkbt26KSIiQjk5OVqyZInGjRunpKQk/eEPf1B4eLjWrl3b4mssX75cY8eO1fz589WvXz9lZGRo7NixbTwTAG2FcAMgoJw8eVKXLl3S/fff724LCQnR0KFDdeLEiRbHnDhxQqmpqU3afvgcgDkINwACimVZkiSHw9Gs/YdtPxwD4NZAuAEQUO688045nU4dOHDA3Xbp0iUVFBSof//+LY5JSkrS559/3qTth88BmIOvggMIKLfddpt+9atfae7cuercubPuuOMOvf3226qrq9O0adNaHJORkaG0tDS9/fbbmjhxovLy8rRz5842rhxAW2HnBkDAeeutt/STn/xEkydP1pAhQ/S3v/1Nubm5uv3221vsP2zYMK1Zs0YrVqzQ4MGDlZeXp9dee62NqwbQVhwWB6MBAIBB2LkBAABGIdwAAACjEG4AAIBRCDcAAMAohBsAAGAUwg0AADAK4QYAABiFcAMAAIxCuAEAAEYh3AAAAKMQbgAAgFH+H3KUcggwX2S4AAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -640,7 +286,6 @@ "\n", "selection_evaluation_pruning = [.1, 1]\n", "selection_evaluation_scaling = .5\n", - "cv = 5\n", "\n", "#Population and budget use stepwise\n", "fig, ax1 = plt.subplots()\n", @@ -655,21 +300,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'time' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[4], line 16\u001b[0m\n\u001b[1;32m 1\u001b[0m est \u001b[38;5;241m=\u001b[39m tpot2\u001b[38;5;241m.\u001b[39mTPOTEstimator( \n\u001b[1;32m 2\u001b[0m generations\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m5\u001b[39m,\n\u001b[1;32m 3\u001b[0m scorers\u001b[38;5;241m=\u001b[39m[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mroc_auc_ovr\u001b[39m\u001b[38;5;124m'\u001b[39m],\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 12\u001b[0m \n\u001b[1;32m 13\u001b[0m verbose\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m)\n\u001b[0;32m---> 16\u001b[0m start \u001b[38;5;241m=\u001b[39m \u001b[43mtime\u001b[49m\u001b[38;5;241m.\u001b[39mtime()\n\u001b[1;32m 17\u001b[0m est\u001b[38;5;241m.\u001b[39mfit(X, y)\n\u001b[1;32m 18\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtotal time: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mtime\u001b[38;5;241m.\u001b[39mtime()\u001b[38;5;241m-\u001b[39mstart\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n", - "\u001b[0;31mNameError\u001b[0m: name 'time' is not defined" - ] - } - ], + "outputs": [], "source": [ "\n", "\n", @@ -677,16 +310,18 @@ "est = tpot2.TPOTEstimator( \n", " generations=50,\n", " max_time_mins=None,\n", + " scorers=['roc_auc_ovr'],\n", " scorers_weights=[1],\n", " classification=True,\n", - " search_space = \"linear-light\",\n", + " search_space = 'linear',\n", " n_jobs=32,\n", " cv=cv,\n", + " early_stop=5,\n", + " verbose=3,\n", "\n", " selection_evaluation_pruning = selection_evaluation_pruning,\n", " selection_evaluation_scaling = selection_evaluation_scaling,\n", - "\n", - " verbose=0)\n", + " )\n", "\n", "\n", "start = time.time()\n", @@ -695,59 +330,44 @@ ] }, { - "attachments": {}, - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - "All of the above methods can be used independently or simultaneously as done below:" + "# no pruning\n", + "est = tpot2.TPOTEstimator( \n", + " generations=50,\n", + " max_time_mins=None,\n", + " scorers=['roc_auc_ovr'],\n", + " scorers_weights=[1],\n", + " classification=True,\n", + " search_space = 'linear',\n", + " n_jobs=32,\n", + " cv=cv,\n", + " early_stop=5,\n", + " verbose=3,\n", + " )\n", + "\n", + "\n", + "start = time.time()\n", + "est.fit(X, y)\n", + "print(f\"total time: {time.time()-start}\")" ] }, { - "cell_type": "code", - "execution_count": 9, + "attachments": {}, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([1.2, 3.4, 1. ])" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ - "import math\n", - "np.array([1.2,3.4,1])" + "All of the above methods can be used independently or simultaneously as done below:" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/perib/Projects/common/Projects/TPOT_Dev/tpot2/tpot2/tpot_estimator/estimator.py:423: UserWarning: Both generations and max_time_mins are set. TPOT will terminate when the first condition is met.\n", - " warnings.warn(\"Both generations and max_time_mins are set. TPOT will terminate when the first condition is met.\")\n", - "/home/perib/miniconda3/envs/myenv/lib/python3.10/site-packages/sklearn/preprocessing/_data.py:2785: UserWarning: n_quantiles (802) is greater than the total number of samples (150). n_quantiles is set to n_samples.\n", - " warnings.warn(\n", - "/home/perib/miniconda3/envs/myenv/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:349: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", - " warnings.warn(\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "total time: 98.23117566108704\n" - ] - } - ], + "outputs": [], "source": [ "est = tpot2.TPOTEstimator( \n", " generations=50,\n", @@ -755,9 +375,11 @@ " scorers=['roc_auc_ovr'],\n", " scorers_weights=[1],\n", " classification=True,\n", - " search_space = 'linear-light',\n", + " search_space = 'linear',\n", " n_jobs=32,\n", " cv=cv,\n", + " early_stop=5,\n", + " verbose=3,\n", "\n", " population_size=population_size,\n", " initial_population_size=initial_population_size,\n", @@ -772,8 +394,7 @@ "\n", " selection_evaluation_pruning = selection_evaluation_pruning,\n", " selection_evaluation_scaling = selection_evaluation_scaling,\n", - "\n", - " verbose=0)\n", + " )\n", "\n", "\n", "start = time.time()\n",