Repository: EpistasisLab/tpot2 (language: python)

Issue:
Dev
[please review the [Contribution Guidelines](http://epistasislab.github.io/tpot/contributing/) prior to submitting your pull request. go ahead and delete this line if you've already reviewed said guidelines.]

## What does this PR do?

Some bug fixes

edited ColumnOneHotEncoder to simulate the behavior of the OneHotEncoder. It will now automatically select columns with fewer than 10 unique values and one hot encode them (same behavior as TPOT1). The original OneHotEncoder is not compatible with pandas dataframes, but this one should be. Replaced the OneHotEncoder with ColumnOneHotEncoder in the tpot2 search space. We could also change this later to make the number of unique values a searchable parameter.


A bug in the initial pipeline generator caused the initial pipeline to all be of size 1 when leaf_config_dict was not set. Added an additional check to make sure that the initial population pipelines will include more nodes from the inner_config_dict when leaf_config_dict is None.

A typo prevented the complexity scorer from recursively searching sklearn Pipeline classes. Fixed the typo to correctly pass in the estimator to the recursive function. Previously it was passing in a tuple from the pipeline.steps, rather than the actual estimator found in the second index of that tuple.



Discussion / hints:

Fix patch:
diff --git a/Tutorial/8_Genetic_Algorithm_Overview.ipynb b/Tutorial/8_Genetic_Algorithm_Overview.ipynb
index 7208db65..3abfd1e6 100644
--- a/Tutorial/8_Genetic_Algorithm_Overview.ipynb
+++ b/Tutorial/8_Genetic_Algorithm_Overview.ipynb
@@ -16,14 +16,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "Generation: 100%|██████████| 100/100 [02:22<00:00,  1.42s/it]\n"
+      "Generation: 100%|██████████| 100/100 [04:05<00:00,  2.46s/it]\n"
      ]
     }
    ],
@@ -59,7 +59,7 @@
     "        self.crossover_list = [self._crossover_swap]\n",
     "        \n",
     "\n",
-    "    def mutate(self,):\n",
+    "    def mutate(self, rng_=None):\n",
     "        mutation_list_copy = self.mutation_list.copy()\n",
     "        random.shuffle(mutation_list_copy)\n",
     "        for func in mutation_list_copy:\n",
@@ -67,7 +67,7 @@
     "                return True\n",
     "        return False\n",
     "\n",
-    "    def crossover(self, ind2):\n",
+    "    def crossover(self, ind2, rng_=None):\n",
     "        crossover_list_copy = self.crossover_list.copy()\n",
     "        random.shuffle(crossover_list_copy)\n",
     "        for func in crossover_list_copy:\n",
@@ -146,15 +146,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "best subset {0, 96, 34, 35, 36, 5, 9, 75, 18, 50, 84, 20, 22, 23, 87, 26, 27, 28}\n",
-      "Best value 2422.0, weight 49.38389605974704\n",
+      "best subset {0, 65, 2, 1, 38, 71, 40, 75, 44, 15, 48, 16, 85, 59, 60, 62}\n",
+      "Best value 2056.0, weight 48.6142482308331\n",
       "\n",
       "All results\n"
      ]
@@ -187,63 +187,75 @@
        "      <th>Variation_Function</th>\n",
        "      <th>Individual</th>\n",
        "      <th>Generation</th>\n",
+       "      <th>Submitted Timestamp</th>\n",
+       "      <th>Completed Timestamp</th>\n",
        "      <th>Pareto_Front</th>\n",
        "    </tr>\n",
        "  </thead>\n",
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>0</th>\n",
-       "      <td>(60,)</td>\n",
-       "      <td>11.0</td>\n",
-       "      <td>5.586633</td>\n",
+       "      <td>(16,)</td>\n",
+       "      <td>75.0</td>\n",
+       "      <td>2.054788</td>\n",
        "      <td>NaN</td>\n",
        "      <td>NaN</td>\n",
-       "      <td>&lt;__main__.SubsetSelector object at 0x7fc0b1d2d...</td>\n",
+       "      <td>&lt;__main__.SubsetSelector object at 0x7faf86cfc...</td>\n",
        "      <td>0.0</td>\n",
+       "      <td>1.708121e+09</td>\n",
+       "      <td>1.708121e+09</td>\n",
        "      <td>NaN</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
-       "      <td>(66,)</td>\n",
-       "      <td>192.0</td>\n",
-       "      <td>5.407096</td>\n",
+       "      <td>(13,)</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>4.466691</td>\n",
        "      <td>NaN</td>\n",
        "      <td>NaN</td>\n",
-       "      <td>&lt;__main__.SubsetSelector object at 0x7fc0b1d61...</td>\n",
+       "      <td>&lt;__main__.SubsetSelector object at 0x7faf86635...</td>\n",
        "      <td>0.0</td>\n",
+       "      <td>1.708121e+09</td>\n",
+       "      <td>1.708121e+09</td>\n",
        "      <td>NaN</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
-       "      <td>(2,)</td>\n",
+       "      <td>(41,)</td>\n",
        "      <td>50.0</td>\n",
-       "      <td>5.002992</td>\n",
+       "      <td>6.249590</td>\n",
        "      <td>NaN</td>\n",
        "      <td>NaN</td>\n",
-       "      <td>&lt;__main__.SubsetSelector object at 0x7fc0b1d2c...</td>\n",
+       "      <td>&lt;__main__.SubsetSelector object at 0x7faf84e87...</td>\n",
        "      <td>0.0</td>\n",
+       "      <td>1.708121e+09</td>\n",
+       "      <td>1.708121e+09</td>\n",
        "      <td>NaN</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
-       "      <td>(53,)</td>\n",
-       "      <td>27.0</td>\n",
-       "      <td>4.088630</td>\n",
+       "      <td>(40,)</td>\n",
+       "      <td>35.0</td>\n",
+       "      <td>0.992726</td>\n",
        "      <td>NaN</td>\n",
        "      <td>NaN</td>\n",
-       "      <td>&lt;__main__.SubsetSelector object at 0x7fc0b1d2c...</td>\n",
+       "      <td>&lt;__main__.SubsetSelector object at 0x7faf83fdf...</td>\n",
        "      <td>0.0</td>\n",
+       "      <td>1.708121e+09</td>\n",
+       "      <td>1.708121e+09</td>\n",
        "      <td>NaN</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>4</th>\n",
-       "      <td>(18,)</td>\n",
-       "      <td>165.0</td>\n",
-       "      <td>4.886466</td>\n",
+       "      <td>(77,)</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.475988</td>\n",
        "      <td>NaN</td>\n",
        "      <td>NaN</td>\n",
-       "      <td>&lt;__main__.SubsetSelector object at 0x7fc0b1d2d...</td>\n",
+       "      <td>&lt;__main__.SubsetSelector object at 0x7faf83ff1...</td>\n",
        "      <td>0.0</td>\n",
+       "      <td>1.708121e+09</td>\n",
+       "      <td>1.708121e+09</td>\n",
        "      <td>NaN</td>\n",
        "    </tr>\n",
        "    <tr>\n",
@@ -256,124 +268,149 @@
        "      <td>...</td>\n",
        "      <td>...</td>\n",
        "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>9995</th>\n",
-       "      <td>(0, 26, 27, 28, 75, 84, 87, 98)</td>\n",
-       "      <td>1016.0</td>\n",
-       "      <td>18.517959</td>\n",
-       "      <td>((0, 26, 27, 28, 75, 84, 87),)</td>\n",
-       "      <td>mutate</td>\n",
-       "      <td>&lt;__main__.SubsetSelector object at 0x7fc09452a...</td>\n",
+       "      <td>(0, 1, 5, 15, 60, 62, 65, 75, 83, 85)</td>\n",
+       "      <td>1323.0</td>\n",
+       "      <td>17.180098</td>\n",
+       "      <td>((0, 5, 15, 60, 62, 65, 75, 83, 85), (0, 5, 15...</td>\n",
+       "      <td>ind_mutate</td>\n",
+       "      <td>&lt;__main__.SubsetSelector object at 0x7faf695e5...</td>\n",
        "      <td>99.0</td>\n",
-       "      <td>NaN</td>\n",
+       "      <td>1.708121e+09</td>\n",
+       "      <td>1.708121e+09</td>\n",
+       "      <td>1.0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>9996</th>\n",
-       "      <td>(0, 26, 27, 28, 31, 65, 75, 87)</td>\n",
-       "      <td>1058.0</td>\n",
-       "      <td>16.186587</td>\n",
-       "      <td>((0, 26, 27, 28, 31, 75, 84, 87),)</td>\n",
-       "      <td>mutate</td>\n",
-       "      <td>&lt;__main__.SubsetSelector object at 0x7fc09452a...</td>\n",
+       "      <td>(0, 8, 15, 60, 62, 65, 75, 96)</td>\n",
+       "      <td>916.0</td>\n",
+       "      <td>18.695221</td>\n",
+       "      <td>((0, 15, 39, 40, 60, 62, 65, 75, 85), (0, 15, ...</td>\n",
+       "      <td>ind_mutate , ind_mutate , ind_crossover</td>\n",
+       "      <td>&lt;__main__.SubsetSelector object at 0x7faf69fbf...</td>\n",
        "      <td>99.0</td>\n",
+       "      <td>1.708121e+09</td>\n",
+       "      <td>1.708121e+09</td>\n",
        "      <td>NaN</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>9997</th>\n",
-       "      <td>(0, 26, 27, 28, 31, 55, 75, 84, 87, 96)</td>\n",
-       "      <td>1264.0</td>\n",
-       "      <td>20.441256</td>\n",
-       "      <td>((0, 26, 27, 28, 31, 75, 84, 85, 87, 96),)</td>\n",
-       "      <td>mutate</td>\n",
-       "      <td>&lt;__main__.SubsetSelector object at 0x7fc09452a...</td>\n",
+       "      <td>(0, 15, 57, 62, 65, 75, 85, 86, 92)</td>\n",
+       "      <td>967.0</td>\n",
+       "      <td>15.581100</td>\n",
+       "      <td>((0, 15, 60, 62, 65, 75, 85, 86), (0, 15, 60, ...</td>\n",
+       "      <td>ind_mutate</td>\n",
+       "      <td>&lt;__main__.SubsetSelector object at 0x7faf6b05a...</td>\n",
        "      <td>99.0</td>\n",
+       "      <td>1.708121e+09</td>\n",
+       "      <td>1.708121e+09</td>\n",
        "      <td>NaN</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>9998</th>\n",
-       "      <td>(26, 27, 31, 75, 84, 87, 94)</td>\n",
-       "      <td>772.0</td>\n",
-       "      <td>8.488381</td>\n",
-       "      <td>((0, 26, 27, 31, 75, 84, 87),)</td>\n",
-       "      <td>mutate</td>\n",
-       "      <td>&lt;__main__.SubsetSelector object at 0x7fc094529...</td>\n",
+       "      <td>(0, 15, 21, 65, 75, 76)</td>\n",
+       "      <td>878.0</td>\n",
+       "      <td>18.495023</td>\n",
+       "      <td>((0, 15, 60, 65, 75), (0, 15, 60, 65, 75))</td>\n",
+       "      <td>ind_mutate</td>\n",
+       "      <td>&lt;__main__.SubsetSelector object at 0x7faf5eec0...</td>\n",
        "      <td>99.0</td>\n",
+       "      <td>1.708121e+09</td>\n",
+       "      <td>1.708121e+09</td>\n",
        "      <td>NaN</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>9999</th>\n",
-       "      <td>(0, 27, 29, 31, 75, 84, 87, 93)</td>\n",
-       "      <td>1060.0</td>\n",
-       "      <td>21.392753</td>\n",
-       "      <td>((0, 27, 28, 31, 75, 84, 85, 87),)</td>\n",
-       "      <td>mutate</td>\n",
-       "      <td>&lt;__main__.SubsetSelector object at 0x7fc09452b...</td>\n",
+       "      <td>(0, 15, 39, 65, 75, 83, 85, 92)</td>\n",
+       "      <td>1054.0</td>\n",
+       "      <td>14.423653</td>\n",
+       "      <td>((0, 2, 15, 39, 60, 65, 75, 83, 85), (0, 15, 3...</td>\n",
+       "      <td>ind_mutate , ind_mutate , ind_crossover</td>\n",
+       "      <td>&lt;__main__.SubsetSelector object at 0x7faf6b36b...</td>\n",
        "      <td>99.0</td>\n",
+       "      <td>1.708121e+09</td>\n",
+       "      <td>1.708121e+09</td>\n",
        "      <td>NaN</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
-       "<p>10000 rows × 8 columns</p>\n",
+       "<p>10000 rows × 10 columns</p>\n",
        "</div>"
       ],
       "text/plain": [
-       "                               Selected Index   Value     Weight  \\\n",
-       "0                                       (60,)    11.0   5.586633   \n",
-       "1                                       (66,)   192.0   5.407096   \n",
-       "2                                        (2,)    50.0   5.002992   \n",
-       "3                                       (53,)    27.0   4.088630   \n",
-       "4                                       (18,)   165.0   4.886466   \n",
-       "...                                       ...     ...        ...   \n",
-       "9995          (0, 26, 27, 28, 75, 84, 87, 98)  1016.0  18.517959   \n",
-       "9996          (0, 26, 27, 28, 31, 65, 75, 87)  1058.0  16.186587   \n",
-       "9997  (0, 26, 27, 28, 31, 55, 75, 84, 87, 96)  1264.0  20.441256   \n",
-       "9998             (26, 27, 31, 75, 84, 87, 94)   772.0   8.488381   \n",
-       "9999          (0, 27, 29, 31, 75, 84, 87, 93)  1060.0  21.392753   \n",
+       "                             Selected Index   Value     Weight  \\\n",
+       "0                                     (16,)    75.0   2.054788   \n",
+       "1                                     (13,)    11.0   4.466691   \n",
+       "2                                     (41,)    50.0   6.249590   \n",
+       "3                                     (40,)    35.0   0.992726   \n",
+       "4                                     (77,)     0.0   1.475988   \n",
+       "...                                     ...     ...        ...   \n",
+       "9995  (0, 1, 5, 15, 60, 62, 65, 75, 83, 85)  1323.0  17.180098   \n",
+       "9996         (0, 8, 15, 60, 62, 65, 75, 96)   916.0  18.695221   \n",
+       "9997    (0, 15, 57, 62, 65, 75, 85, 86, 92)   967.0  15.581100   \n",
+       "9998                (0, 15, 21, 65, 75, 76)   878.0  18.495023   \n",
+       "9999        (0, 15, 39, 65, 75, 83, 85, 92)  1054.0  14.423653   \n",
        "\n",
-       "                                         Parents Variation_Function  \\\n",
-       "0                                            NaN                NaN   \n",
-       "1                                            NaN                NaN   \n",
-       "2                                            NaN                NaN   \n",
-       "3                                            NaN                NaN   \n",
-       "4                                            NaN                NaN   \n",
-       "...                                          ...                ...   \n",
-       "9995              ((0, 26, 27, 28, 75, 84, 87),)             mutate   \n",
-       "9996          ((0, 26, 27, 28, 31, 75, 84, 87),)             mutate   \n",
-       "9997  ((0, 26, 27, 28, 31, 75, 84, 85, 87, 96),)             mutate   \n",
-       "9998              ((0, 26, 27, 31, 75, 84, 87),)             mutate   \n",
-       "9999          ((0, 27, 28, 31, 75, 84, 85, 87),)             mutate   \n",
+       "                                                Parents  \\\n",
+       "0                                                   NaN   \n",
+       "1                                                   NaN   \n",
+       "2                                                   NaN   \n",
+       "3                                                   NaN   \n",
+       "4                                                   NaN   \n",
+       "...                                                 ...   \n",
+       "9995  ((0, 5, 15, 60, 62, 65, 75, 83, 85), (0, 5, 15...   \n",
+       "9996  ((0, 15, 39, 40, 60, 62, 65, 75, 85), (0, 15, ...   \n",
+       "9997  ((0, 15, 60, 62, 65, 75, 85, 86), (0, 15, 60, ...   \n",
+       "9998         ((0, 15, 60, 65, 75), (0, 15, 60, 65, 75))   \n",
+       "9999  ((0, 2, 15, 39, 60, 65, 75, 83, 85), (0, 15, 3...   \n",
+       "\n",
+       "                           Variation_Function  \\\n",
+       "0                                         NaN   \n",
+       "1                                         NaN   \n",
+       "2                                         NaN   \n",
+       "3                                         NaN   \n",
+       "4                                         NaN   \n",
+       "...                                       ...   \n",
+       "9995                               ind_mutate   \n",
+       "9996  ind_mutate , ind_mutate , ind_crossover   \n",
+       "9997                               ind_mutate   \n",
+       "9998                               ind_mutate   \n",
+       "9999  ind_mutate , ind_mutate , ind_crossover   \n",
        "\n",
        "                                             Individual  Generation  \\\n",
-       "0     <__main__.SubsetSelector object at 0x7fc0b1d2d...         0.0   \n",
-       "1     <__main__.SubsetSelector object at 0x7fc0b1d61...         0.0   \n",
-       "2     <__main__.SubsetSelector object at 0x7fc0b1d2c...         0.0   \n",
-       "3     <__main__.SubsetSelector object at 0x7fc0b1d2c...         0.0   \n",
-       "4     <__main__.SubsetSelector object at 0x7fc0b1d2d...         0.0   \n",
+       "0     <__main__.SubsetSelector object at 0x7faf86cfc...         0.0   \n",
+       "1     <__main__.SubsetSelector object at 0x7faf86635...         0.0   \n",
+       "2     <__main__.SubsetSelector object at 0x7faf84e87...         0.0   \n",
+       "3     <__main__.SubsetSelector object at 0x7faf83fdf...         0.0   \n",
+       "4     <__main__.SubsetSelector object at 0x7faf83ff1...         0.0   \n",
        "...                                                 ...         ...   \n",
-       "9995  <__main__.SubsetSelector object at 0x7fc09452a...        99.0   \n",
-       "9996  <__main__.SubsetSelector object at 0x7fc09452a...        99.0   \n",
-       "9997  <__main__.SubsetSelector object at 0x7fc09452a...        99.0   \n",
-       "9998  <__main__.SubsetSelector object at 0x7fc094529...        99.0   \n",
-       "9999  <__main__.SubsetSelector object at 0x7fc09452b...        99.0   \n",
+       "9995  <__main__.SubsetSelector object at 0x7faf695e5...        99.0   \n",
+       "9996  <__main__.SubsetSelector object at 0x7faf69fbf...        99.0   \n",
+       "9997  <__main__.SubsetSelector object at 0x7faf6b05a...        99.0   \n",
+       "9998  <__main__.SubsetSelector object at 0x7faf5eec0...        99.0   \n",
+       "9999  <__main__.SubsetSelector object at 0x7faf6b36b...        99.0   \n",
        "\n",
-       "      Pareto_Front  \n",
-       "0              NaN  \n",
-       "1              NaN  \n",
-       "2              NaN  \n",
-       "3              NaN  \n",
-       "4              NaN  \n",
-       "...            ...  \n",
-       "9995           NaN  \n",
-       "9996           NaN  \n",
-       "9997           NaN  \n",
-       "9998           NaN  \n",
-       "9999           NaN  \n",
+       "      Submitted Timestamp  Completed Timestamp  Pareto_Front  \n",
+       "0            1.708121e+09         1.708121e+09           NaN  \n",
+       "1            1.708121e+09         1.708121e+09           NaN  \n",
+       "2            1.708121e+09         1.708121e+09           NaN  \n",
+       "3            1.708121e+09         1.708121e+09           NaN  \n",
+       "4            1.708121e+09         1.708121e+09           NaN  \n",
+       "...                   ...                  ...           ...  \n",
+       "9995         1.708121e+09         1.708121e+09           1.0  \n",
+       "9996         1.708121e+09         1.708121e+09           NaN  \n",
+       "9997         1.708121e+09         1.708121e+09           NaN  \n",
+       "9998         1.708121e+09         1.708121e+09           NaN  \n",
+       "9999         1.708121e+09         1.708121e+09           NaN  \n",
        "\n",
-       "[10000 rows x 8 columns]"
+       "[10000 rows x 10 columns]"
       ]
      },
-     "execution_count": 4,
+     "execution_count": 2,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -395,12 +432,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1200x400 with 2 Axes>"
       ]
@@ -450,7 +487,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.11"
+   "version": "3.11.7"
   },
   "orig_nbformat": 4,
   "vscode": {
diff --git a/setup.py b/setup.py
index 19f0f322..545055c9 100644
--- a/setup.py
+++ b/setup.py
@@ -33,7 +33,7 @@ def calculate_version():
                       'update_checker>=0.16',
                       'tqdm>=4.36.1',
                       'stopit>=1.1.1',
-                      'pandas>=1.5.3,<2.0.0',
+                      'pandas>=2.2.0',
                       'joblib>=1.1.1',
                       'xgboost>=1.7.0',
                       'matplotlib>=3.6.2',
diff --git a/tpot2/_version.py b/tpot2/_version.py
index 2676adfd..cbf47f72 100644
--- a/tpot2/_version.py
+++ b/tpot2/_version.py
@@ -1,1 +1,1 @@
-__version__ = '0.1.5-alpha'
+__version__ = '0.1.6-alpha'
diff --git a/tpot2/builtin_modules/column_one_hot_encoder.py b/tpot2/builtin_modules/column_one_hot_encoder.py
index e5c8b6ba..4f3843bf 100644
--- a/tpot2/builtin_modules/column_one_hot_encoder.py
+++ b/tpot2/builtin_modules/column_one_hot_encoder.py
@@ -11,16 +11,13 @@
 
 
 
-def auto_select_categorical_features(X):
+def auto_select_categorical_features(X, min_unique=10,):
 
-    if not isinstance(X, pd.DataFrame):
-        return []
-    
-    feature_mask = []
-    for column in X.columns:
-        feature_mask.append(not is_numeric_dtype(X[column]))
+    if isinstance(X, pd.DataFrame):
+        return [col for col in X.columns if len(X[col].unique()) < min_unique]
+    else:
+        return [i for i in range(X.shape[1]) if len(np.unique(X[:, i])) < min_unique]
 
-    return feature_mask
 
 
 def _X_selected(X, selected):
@@ -41,6 +38,21 @@ class ColumnOneHotEncoder(BaseEstimator, TransformerMixin):
 
 
     def __init__(self, columns='auto', drop=None, handle_unknown='error', sparse_output=False, min_frequency=None,max_categories=None):
+        '''
+        
+        Parameters
+        ----------
+
+        columns : str, list, default='auto'
+            - 'auto' : Automatically select categorical features based on columns with less than 10 unique values
+            - 'categorical' : Automatically select categorical features
+            - 'numeric' : Automatically select numeric features
+            - 'all' : Select all features
+            - list : A list of columns to select
+        
+        drop, handle_unknown, sparse_output, min_frequency, max_categories : see sklearn.preprocessing.OneHotEncoder
+
+        '''
 
         self.columns = columns
         self.drop = drop
@@ -73,6 +85,8 @@ def fit(self, X, y=None):
             self.columns_ = list(X.select_dtypes(exclude='number').columns)
         elif self.columns == "numeric":
             self.columns_ =  [col for col in X.columns if is_numeric_dtype(X[col])]
+        elif self.columns == "auto":
+            self.columns_ = auto_select_categorical_features(X)
         elif self.columns == "all":
             if isinstance(X, pd.DataFrame):
                 self.columns_ = X.columns
diff --git a/tpot2/config/transformers.py b/tpot2/config/transformers.py
index ab17b3c8..fe869411 100644
--- a/tpot2/config/transformers.py
+++ b/tpot2/config/transformers.py
@@ -1,7 +1,7 @@
 from functools import partial
 import numpy as np
 
-from tpot2.builtin_modules import ZeroCount, OneHotEncoder
+from tpot2.builtin_modules import ZeroCount, OneHotEncoder, ColumnOneHotEncoder
 from sklearn.preprocessing import Binarizer
 from sklearn.decomposition import FastICA
 from sklearn.cluster import FeatureAgglomeration
@@ -99,5 +99,5 @@ def make_transformer_config_dictionary(random_state=None, n_features=10):
                 RobustScaler: {},
                 StandardScaler: {},
                 ZeroCount: params_tpot_builtins_ZeroCount,
-                OneHotEncoder: params_tpot_builtins_OneHotEncoder,
+                ColumnOneHotEncoder: params_tpot_builtins_OneHotEncoder,
             }
diff --git a/tpot2/evolvers/base_evolver.py b/tpot2/evolvers/base_evolver.py
index 9959f9ab..83623754 100644
--- a/tpot2/evolvers/base_evolver.py
+++ b/tpot2/evolvers/base_evolver.py
@@ -483,9 +483,10 @@ def optimize(self, generations=None):
         except KeyboardInterrupt:
             if self.verbose >= 3:
                 print("KeyboardInterrupt")
-
             self.population.remove_invalid_from_population(column_names=self.objective_names, invalid_value="INVALID")
             self.population.remove_invalid_from_population(column_names=self.objective_names, invalid_value="TIMEOUT")
+            self.population.remove_invalid_from_population(column_names="Eval Error", invalid_value="INVALID")
+            self.population.remove_invalid_from_population(column_names="Eval Error", invalid_value="TIMEOUT")
 
 
 
@@ -623,8 +624,7 @@ def evaluate_population_full(self, budget=None):
             parallel_timeout = 10
 
         #scores = tpot2.utils.eval_utils.parallel_eval_objective_list(individuals_to_evaluate, self.objective_functions, self.n_jobs, verbose=self.verbose, timeout=self.max_eval_time_seconds, budget=budget, n_expected_columns=len(self.objective_names), client=self._client, parallel_timeout=parallel_timeout, **self.objective_kwargs)
-        scores, start_times, end_times = tpot2.utils.eval_utils.parallel_eval_objective_list2(individuals_to_evaluate, self.objective_functions, verbose=self.verbose, max_eval_time_seconds=self.max_eval_time_seconds, budget=budget, n_expected_columns=len(self.objective_names), client=self._client, **self.objective_kwargs)
-
+        scores, start_times, end_times, eval_errors = tpot2.utils.eval_utils.parallel_eval_objective_list2(individuals_to_evaluate, self.objective_functions, verbose=self.verbose, max_eval_time_seconds=self.max_eval_time_seconds, budget=budget, n_expected_columns=len(self.objective_names), client=self._client, **self.objective_kwargs)
 
         self.population.update_column(individuals_to_evaluate, column_names=self.objective_names, data=scores)
         if budget is not None:
@@ -632,8 +632,9 @@ def evaluate_population_full(self, budget=None):
 
         self.population.update_column(individuals_to_evaluate, column_names="Submitted Timestamp", data=start_times)
         self.population.update_column(individuals_to_evaluate, column_names="Completed Timestamp", data=end_times)
-        self.population.remove_invalid_from_population(column_names=self.objective_names)
-        self.population.remove_invalid_from_population(column_names=self.objective_names, invalid_value="TIMEOUT")
+        self.population.update_column(individuals_to_evaluate, column_names="Eval Error", data=eval_errors)
+        self.population.remove_invalid_from_population(column_names="Eval Error")
+        self.population.remove_invalid_from_population(column_names="Eval Error", invalid_value="TIMEOUT")
 
     def get_unevaluated_individuals(self, column_names, budget=None, individual_list=None):
         if individual_list is not None:
@@ -695,7 +696,7 @@ def evaluate_population_selection_early_stop(self,survival_counts, thresholds=No
             if parallel_timeout < 0:
                 parallel_timeout = 10
 
-            scores, start_times, end_times = tpot2.utils.eval_utils.parallel_eval_objective_list2(individual_list=unevaluated_individuals_this_step,
+            scores, start_times, end_times, eval_errors = tpot2.utils.eval_utils.parallel_eval_objective_list2(individual_list=unevaluated_individuals_this_step,
                                     objective_list=self.objective_functions,
                                     verbose=self.verbose,
                                     max_eval_time_seconds=self.max_eval_time_seconds,
@@ -706,14 +707,14 @@ def evaluate_population_selection_early_stop(self,survival_counts, thresholds=No
                                     client=self._client,
                                     **self.objective_kwargs,
                                     )
-
+            
             self.population.update_column(unevaluated_individuals_this_step, column_names=this_step_names, data=scores)
             self.population.update_column(unevaluated_individuals_this_step, column_names="Submitted Timestamp", data=start_times)
             self.population.update_column(unevaluated_individuals_this_step, column_names="Completed Timestamp", data=end_times)
+            self.population.update_column(unevaluated_individuals_this_step, column_names="Eval Error", data=eval_errors)
 
-
-            self.population.remove_invalid_from_population(column_names=this_step_names)
-            self.population.remove_invalid_from_population(column_names=this_step_names, invalid_value="TIMEOUT")
+            self.population.remove_invalid_from_population(column_names="Eval Error")
+            self.population.remove_invalid_from_population(column_names="Eval Error", invalid_value="TIMEOUT")
 
             #remove invalids:
             invalids = []
diff --git a/tpot2/evolvers/steady_state_evolver.py b/tpot2/evolvers/steady_state_evolver.py
index a45e4059..952efa82 100644
--- a/tpot2/evolvers/steady_state_evolver.py
+++ b/tpot2/evolvers/steady_state_evolver.py
@@ -22,6 +22,15 @@
 import dask
 import warnings
 
+
+def ind_mutate(ind, rng_):
+    rng = np.random.default_rng(rng_)
+    return ind.mutate(rng_=rng)
+
+def ind_crossover(ind1, ind2, rng_):
+    rng = np.random.default_rng(rng_)
+    return ind1.crossover(ind2, rng_=rng)
+
 class SteadyStateEvolver():
     def __init__(   self,
                     individual_generator ,
@@ -241,6 +250,8 @@ def optimize(self):
 
             done = False
             start_time = time.time()
+
+            enough_parents_evaluated=False
             while not done:
 
                 ###############################
@@ -257,20 +268,31 @@ def optimize(self):
 
                 #Loop through all futures, collect completed and timeout futures.
                 for completed_future in list(submitted_futures.keys()):
-
+                    eval_error = None
                     #get scores and update
                     if completed_future.done(): #if future is done
                         #If the future is done but threw and error, record the error
                         if completed_future.exception() or completed_future.status == "error": #if the future is done and threw an error
                             print("Exception in future")
                             print(completed_future.exception())
-                            scores = ["INVALID" for _ in range(len(self.objective_names))]
+                            scores = [np.nan for _ in range(len(self.objective_names))]
+                            eval_error = "INVALID"
                         elif completed_future.cancelled(): #if the future is done and was cancelled
                             print("Cancelled future (likely memory related)")
-                            scores = ["INVALID" for _ in range(len(self.objective_names))]
+                            scores = [np.nan for _ in range(len(self.objective_names))]
+                            eval_error = "INVALID"
                         else: #if the future is done and did not throw an error, get the scores
                             try:
                                 scores = completed_future.result()
+
+                                #check if scores contain "INVALID" or "TIMEOUT"
+                                if "INVALID" in scores:
+                                    eval_error = "INVALID"
+                                    scores = [np.nan]
+                                elif "TIMEOUT" in scores:
+                                    eval_error = "TIMEOUT"
+                                    scores = [np.nan]
+
                             except Exception as e:
                                 print("Exception in future, but not caught by dask")
                                 print(e)
@@ -279,7 +301,8 @@ def optimize(self):
                                 print("status", completed_future.status)
                                 print("done", completed_future.done())
                                 print("cancelld ", completed_future.cancelled())
-                                scores = ["INVALID" for _ in range(len(self.objective_names))]
+                                scores = [np.nan for _ in range(len(self.objective_names))]
+                                eval_error = "INVALID"
                     else: #if future is not done
 
                         #check if the future has been running for too long, cancel the future
@@ -289,7 +312,8 @@ def optimize(self):
                             if self.verbose >= 4:
                                 print(f'WARNING AN INDIVIDUAL TIMED OUT (Fallback): \n {submitted_futures[completed_future]} \n')
 
-                            scores = ["TIMEOUT" for _ in range(len(self.objective_names))]
+                            scores = [np.nan for _ in range(len(self.objective_names))]
+                            eval_error = "TIMEOUT"
                         else:
                             continue #otherwise, continue to next future
 
@@ -304,6 +328,7 @@ def optimize(self):
                         scores = [scores[0] for _ in range(len(self.objective_names))]
                     self.population.update_column(this_individual, column_names=self.objective_names, data=scores)
                     self.population.update_column(this_individual, column_names="Completed Timestamp", data=time.time())
+                    self.population.update_column(this_individual, column_names="Eval Error", data=eval_error)
                     if budget is not None:
                         self.population.update_column(this_individual, column_names="Budget", data=this_budget)
 
@@ -314,9 +339,8 @@ def optimize(self):
 
                 #now we have a list of completed futures
 
-
-                self.population.remove_invalid_from_population(column_names=self.objective_names, invalid_value="INVALID")
-                self.population.remove_invalid_from_population(column_names=self.objective_names, invalid_value="TIMEOUT")
+                self.population.remove_invalid_from_population(column_names="Eval Error", invalid_value="INVALID")
+                self.population.remove_invalid_from_population(column_names="Eval Error", invalid_value="TIMEOUT")
 
 
                 ###############################
@@ -429,33 +453,56 @@ def optimize(self):
                 ###############################
                 n_individuals_to_submit = self.max_queue_size - len(submitted_futures)
                 if n_individuals_to_submit > 0:
-                    parents_df = self.population.get_column(self.population.population, column_names=self.objective_names+ ["Individual"], to_numpy=False)
-                    parents_df = parents_df[~parents_df[self.objective_names].isin(["TIMEOUT","INVALID"]).any(axis=1)]
-                    parents_df = parents_df[~parents_df[self.objective_names].isna().any(axis=1)]
-
-                    cur_evaluated_population = parents_df["Individual"].to_numpy()
-                    if len(cur_evaluated_population) > 0:
-                        scores = parents_df[self.objective_names].to_numpy()
-                        weighted_scores = scores * self.objective_function_weights
-                        #number of crossover pairs and mutation only parent to generate
-
-                        if len(parents_df) < 2:
-                            var_ops = ["mutate" for _ in range(n_individuals_to_submit)]
-                        else:
-                            var_ops = [self.rng.choice(["crossover","mutate_then_crossover","crossover_then_mutate",'mutate'],p=[self.crossover_probability,self.mutate_then_crossover_probability, self.crossover_then_mutate_probability,self.mutate_probability]) for _ in range(n_individuals_to_submit)]
-
-                        parents = []
-                        for op in var_ops:
+                    #count non-nan values in the objective columns
+                    if not enough_parents_evaluated:
+                        parents_df = self.population.get_column(self.population.population, column_names=self.objective_names, to_numpy=False)
+                        scores = parents_df[self.objective_names[0]].to_numpy()
+                        #count non-nan values in the objective columns
+                        n_evaluated = np.count_nonzero(~np.isnan(scores))
+                        if n_evaluated >0 :
+                            enough_parents_evaluated=True
+                    
+                    # parents_df = self.population.get_column(self.population.population, column_names=self.objective_names+ ["Individual"], to_numpy=False)
+                    # parents_df = parents_df[~parents_df[self.objective_names].isin(["TIMEOUT","INVALID"]).any(axis=1)]
+                    # parents_df = parents_df[~parents_df[self.objective_names].isna().any(axis=1)]
+
+                    # cur_evaluated_population = parents_df["Individual"].to_numpy()
+                    # if len(cur_evaluated_population) > 0:
+                    #     scores = parents_df[self.objective_names].to_numpy()
+                    #     weighted_scores = scores * self.objective_function_weights
+                    #     #number of crossover pairs and mutation only parent to generate
+
+                    #     if len(parents_df) < 2:
+                    #         var_ops = ["mutate" for _ in range(n_individuals_to_submit)]
+                    #     else:
+                    #         var_ops = [self.rng.choice(["crossover","mutate_then_crossover","crossover_then_mutate",'mutate'],p=[self.crossover_probability,self.mutate_then_crossover_probability, self.crossover_then_mutate_probability,self.mutate_probability]) for _ in range(n_individuals_to_submit)]
+
+                    #     parents = []
+                    #     for op in var_ops:
+                    #         if op == "mutate":
+                    #             parents.extend(np.array(cur_evaluated_population)[self.parent_selector(weighted_scores, k=1, n_parents=1, rng_=self.rng)])
+                    #         else:
+                    #             parents.extend(np.array(cur_evaluated_population)[self.parent_selector(weighted_scores, k=1, n_parents=2, rng_=self.rng)])
+
+                    #     #_offspring = self.population.create_offspring2(parents, var_ops, rng_=self.rng, add_to_population=True)
+                    #     offspring = self.population.create_offspring2(parents, var_ops, [ind_mutate], None, [ind_crossover], None, add_to_population=True, keep_repeats=False, mutate_until_unique=True, rng_=self.rng)
+
+                    if enough_parents_evaluated:
+
+                        parents = self.population.parent_select(selector=self.parent_selector, weights=self.objective_function_weights, columns_names=self.objective_names, k=n_individuals_to_submit, n_parents=2, rng_=self.rng)
+                        p = np.array([self.crossover_probability, self.mutate_then_crossover_probability, self.crossover_then_mutate_probability, self.mutate_probability])
+                        p = p / p.sum()
+                        var_op_list = self.rng.choice(["crossover", "mutate_then_crossover", "crossover_then_mutate", "mutate"], size=n_individuals_to_submit, p=p)
+
+                        for i, op in enumerate(var_op_list):
                             if op == "mutate":
-                                parents.extend(np.array(cur_evaluated_population)[self.parent_selector(weighted_scores, k=1, n_parents=1, rng_=self.rng)])
-                            else:
-                                parents.extend(np.array(cur_evaluated_population)[self.parent_selector(weighted_scores, k=1, n_parents=2, rng_=self.rng)])
+                                parents[i] = parents[i][0] #mutations take a single individual
 
-                        _offspring = self.population.create_offspring(parents, var_ops, rng_=self.rng, n_jobs=1, add_to_population=True)
+                        offspring = self.population.create_offspring2(parents, var_op_list, [ind_mutate], None, [ind_crossover], None, add_to_population=True, keep_repeats=False, mutate_until_unique=True, rng_=self.rng)
 
                     # If we don't have enough evaluated individuals to use as parents for variation, we create new individuals randomly
                     # This can happen if the individuals in the initial population are invalid
-                    if len(cur_evaluated_population) == 0 and len(submitted_futures) < self.max_queue_size:
+                    elif len(submitted_futures) < self.max_queue_size:
 
                         initial_population = self.population.evaluated_individuals.iloc[:self.initial_population_size*3]
                         invalid_initial_population = initial_population[initial_population[self.objective_names].isin(["TIMEOUT","INVALID"]).any(axis=1)]
diff --git a/tpot2/individual_representations/graph_pipeline_individual/individual.py b/tpot2/individual_representations/graph_pipeline_individual/individual.py
index f890e80f..9ca1a9da 100644
--- a/tpot2/individual_representations/graph_pipeline_individual/individual.py
+++ b/tpot2/individual_representations/graph_pipeline_individual/individual.py
@@ -1137,7 +1137,10 @@ def _cached_transform(cache_nunber=0):
         pass
 
     def __str__(self):
-        return self.export_pipeline().__str__()
+        try:
+            return f"<GraphIdnividual {0}".format(self.export_pipeline().__str__())
+        except:
+            return "<Invalid GraphIdnividual>"
 
     def unique_id(self) -> GraphKey:
         if self.key is None:
diff --git a/tpot2/individual_representations/graph_pipeline_individual/templates.py b/tpot2/individual_representations/graph_pipeline_individual/templates.py
index cd8015cc..9b383141 100644
--- a/tpot2/individual_representations/graph_pipeline_individual/templates.py
+++ b/tpot2/individual_representations/graph_pipeline_individual/templates.py
@@ -54,7 +54,7 @@ def estimator_graph_individual_generator(
             starting_ops = []
             if inner_config_dict is not None:
                 starting_ops.append(ind._mutate_insert_inner_node)
-            if leaf_config_dict is not None:
+            if leaf_config_dict is not None or inner_config_dict is not None:
                 starting_ops.append(ind._mutate_insert_leaf)
                 n_nodes -= 1
 
diff --git a/tpot2/objectives/complexity.py b/tpot2/objectives/complexity.py
index 2ba41cfe..b9167fa5 100644
--- a/tpot2/objectives/complexity.py
+++ b/tpot2/objectives/complexity.py
@@ -142,7 +142,7 @@ def MultinomialNB_Complexity(model):
 
 def calculate_model_complexity(est):
     if isinstance(est, sklearn.pipeline.Pipeline) or isinstance(est, sklearn.pipeline.FeatureUnion):
-        return sum(calculate_model_complexity(estimator) for estimator in est.steps)
+        return sum(calculate_model_complexity(estimator) for _,estimator in est.steps)
     if isinstance(est, GraphPipeline):
         return sum(calculate_model_complexity(est.graph.nodes[node]['instance']) for node in est.graph.nodes)
 
diff --git a/tpot2/population.py b/tpot2/population.py
index a3a0c54c..4e842eb9 100644
--- a/tpot2/population.py
+++ b/tpot2/population.py
@@ -85,6 +85,7 @@ def __init__(   self,
             column_names = ["Parents", "Variation_Function"]
         self.evaluated_individuals = pd.DataFrame(columns=column_names)
         self.evaluated_individuals["Parents"] = self.evaluated_individuals["Parents"].astype('object')
+        
         self.use_unique_id = True #Todo clean this up. perhaps pull unique_id() out of baseestimator and have it be supplied as a function
         self.n_jobs = n_jobs
         self.callback=callback
@@ -125,7 +126,6 @@ def remove_invalid_from_population(self, column_names, invalid_value = "INVALID"
         '''
         if isinstance(column_names, str): #TODO check this
             column_names = [column_names]
-        new_pop = []
         is_valid = lambda ind: ind.unique_id() not in self.evaluated_individuals.index or invalid_value not in self.evaluated_individuals.loc[ind.unique_id(),column_names].to_list()
         self.population = [ind for ind in self.population if is_valid(ind)]
 
@@ -301,13 +301,15 @@ def create_offspring(self, parents_list, var_op_list, rng_=None, add_to_populati
                         parent_keys = [parent.unique_id() for parent in parents]
                         if not pd.api.types.is_object_dtype(self.evaluated_individuals["Parents"]): #TODO Is there a cleaner way of doing this? Not required for some python environments?
                             self.evaluated_individuals["Parents"] = self.evaluated_individuals["Parents"].astype('object')
+                        if not pd.api.types.is_object_dtype(self.evaluated_individuals["Variation_Function"]):#TODO Is there a cleaner way of doing this? Not required for some python environments?
+                            self.evaluated_individuals["Variation_Function"] = self.evaluated_individuals["Variation_Function"].astype('object')
                         self.evaluated_individuals.at[new_child.unique_id(),"Parents"] = tuple(parent_keys)
 
                         #if var_op is a function
                         if hasattr(var_op, '__call__'):
                             self.evaluated_individuals.at[new_child.unique_id(),"Variation_Function"] = var_op.__name__
                         else:
-                            self.evaluated_individuals.at[new_child.unique_id(),"Variation_Function"] = var_op
+                            self.evaluated_individuals.at[new_child.unique_id(),"Variation_Function"] = str(var_op)
 
 
                         new_offspring.append(new_child)
@@ -377,8 +379,16 @@ def create_offspring2(self, parents_list, var_op_list, mutation_functions,mutati
                         if not pd.api.types.is_object_dtype(self.evaluated_individuals["Parents"]): #TODO Is there a cleaner way of doing this? Not required for some python environments?
                             self.evaluated_individuals["Parents"] = self.evaluated_individuals["Parents"].astype('object')
                         self.evaluated_individuals.at[new_child.unique_id(),"Parents"] = tuple(parent_keys)
+                        
+                        #check if Variation_Function variable is an object type
+                        if not pd.api.types.is_object_dtype(self.evaluated_individuals["Variation_Function"]): #TODO Is there a cleaner way of doing this? Not required for some python environments?
+                            self.evaluated_individuals["Variation_Function"] = self.evaluated_individuals["Variation_Function"].astype('object')
 
-                        self.evaluated_individuals.at[new_child.unique_id(),"Variation_Function"] = var_op
+                        #if var_op is a function
+                        if hasattr(var_op, '__call__'):
+                            self.evaluated_individuals.at[new_child.unique_id(),"Variation_Function"] = var_op.__name__
+                        else:
+                            self.evaluated_individuals.at[new_child.unique_id(),"Variation_Function"] = str(var_op)
 
 
                         new_offspring.append(new_child)
diff --git a/tpot2/utils/eval_utils.py b/tpot2/utils/eval_utils.py
index d3fe68bc..ccc847f3 100644
--- a/tpot2/utils/eval_utils.py
+++ b/tpot2/utils/eval_utils.py
@@ -152,7 +152,6 @@ def parallel_eval_objective_list2(individual_list,
     submitted_futures = {}
     scores_dict = {}
     submitted_inds = set()
-
     while len(submitted_futures) < max_queue_size and len(individual_stack)>0:
         individual = individual_stack.pop()
         future = client.submit(eval_objective_list, individual,  objective_list, verbose=verbose, timeout=max_eval_time_seconds,**objective_kwargs)
@@ -181,13 +180,25 @@ def parallel_eval_objective_list2(individual_list,
                 if completed_future.exception() or completed_future.status == "error": #if the future is done and threw an error
                     print("Exception in future")
                     print(completed_future.exception())
-                    scores = ["INVALID"]
+                    scores = [np.nan for _ in range(n_expected_columns)]
+                    eval_error = "INVALID"
                 elif completed_future.cancelled(): #if the future is done and was cancelled
                     print("Cancelled future (likely memory related)")
-                    scores = ["INVALID"]
+                    scores = [np.nan for _ in range(n_expected_columns)]
+                    eval_error = "INVALID"
                 else: #if the future is done and did not throw an error, get the scores
                     try:
                         scores = completed_future.result()
+                        #check if scores contain "INVALID" or "TIMEOUT"
+                        if "INVALID" in scores:
+                            eval_error = "INVALID"
+                            scores = [np.nan for _ in range(n_expected_columns)]
+                        elif "TIMEOUT" in scores:
+                            eval_error = "TIMEOUT"
+                            scores = [np.nan for _ in range(n_expected_columns)]
+                        else:
+                            eval_error = None
+                        
                     except Exception as e:
                         print("Exception in future, but not caught by dask")
                         print(e)
@@ -196,7 +207,8 @@ def parallel_eval_objective_list2(individual_list,
                         print("status", completed_future.status)
                         print("done", completed_future.done())
                         print("cancelld ", completed_future.cancelled())
-                        scores = ["INVALID"]
+                        scores = [np.nan for _ in range(n_expected_columns)]
+                        eval_error = "INVALID"
             else: #if future is not done
                 
                 #check if the future has been running for too long, cancel the future
@@ -206,7 +218,8 @@ def parallel_eval_objective_list2(individual_list,
                     if verbose >= 4:
                         print(f'WARNING AN INDIVIDUAL TIMED OUT (Fallback): \n {submitted_futures[completed_future]} \n')
                     
-                    scores = ["TIMEOUT"]
+                    scores = [np.nan for _ in range(n_expected_columns)]
+                    eval_error = "TIMEOUT"
                 else:
                     continue #otherwise, continue to next future
         
@@ -215,6 +228,7 @@ def parallel_eval_objective_list2(individual_list,
             scores_dict[cur_individual] = {"scores": scores, 
                                         "start_time": submitted_futures[completed_future]["time"],
                                         "end_time": time.time(),
+                                        "eval_error": eval_error,
                                         }
             
 
@@ -235,10 +249,9 @@ def parallel_eval_objective_list2(individual_list,
     final_scores = [scores_dict[individual]["scores"] for individual in individual_list]
     final_start_times = [scores_dict[individual]["start_time"] for individual in individual_list]
     final_end_times = [scores_dict[individual]["end_time"] for individual in individual_list]
-
+    final_eval_errors = [scores_dict[individual]["eval_error"] for individual in individual_list]
     final_scores = process_scores(final_scores, n_expected_columns)
-
-    return final_scores, final_start_times, final_end_times
+    return final_scores, final_start_times, final_end_times, final_eval_errors
 
 
 ###################


Test patch:
diff --git a/tpot2/tests/test_estimators.py b/tpot2/tests/test_estimators.py
index 5c6f47ba..29dfa8f8 100644
--- a/tpot2/tests/test_estimators.py
+++ b/tpot2/tests/test_estimators.py
@@ -41,6 +41,7 @@ def test_tpot_estimator_predict(tpot_estimator_with_pipeline,sample_dataset):
     y_pred = tpot_estimator_with_pipeline.predict(X_test)
     assert len(y_pred) == len(X_test)
 
+@pytest.mark.skip(reason="not an informative test. X_test is a list instead of a numpy array or pandas dataframe.")
 def test_tpot_estimator_score(tpot_estimator_with_pipeline,sample_dataset):
     random.seed(42)
     #random sample 10% of the dataset