diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index ea1f78ee8..a943e3d13 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -224,7 +224,7 @@ jobs:
           ./spin --help
           ./spin coverage --help
           ./spin test --help
-          ./spin coverage -k "slowtest"
+          ./spin coverage
           cp $PWD/build-install/usr/lib/python${{matrix.python-version}}/site-packages/coverage.xml ./coverage.xml
 
       - name: debug
diff --git a/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb b/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb
index 8b5c34f46..3990764bf 100644
--- a/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb
+++ b/benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb
@@ -38,7 +38,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 11,
    "id": "5e2d1279-fa4f-47ef-aa48-fac6d47159ad",
    "metadata": {},
    "outputs": [],
@@ -55,9 +55,9 @@
     "    beta = 10.0\n",
     "    sigma = 10.0 / sigma_factor\n",
     "    n_samples = 2200\n",
-    "    n_estimators = 125\n",
+    "    n_estimators = 500\n",
     "    test_size = 0.1\n",
-    "    n_repeats = 500\n",
+    "    n_repeats = 1000\n",
     "    metric = \"mse\"\n",
     "\n",
     "    rng = np.random.default_rng(seed)\n",
@@ -134,7 +134,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 17,
    "id": "3db4f740-afd9-413e-8089-a8245f2a0747",
    "metadata": {},
    "outputs": [],
@@ -152,7 +152,7 @@
     "    max_features = \"sqrt\"\n",
     "    test_size = 1.0 / 6\n",
     "    metric = \"mse\"\n",
-    "    n_repeats = 200\n",
+    "    n_repeats = 500\n",
     "    permute_per_tree = True\n",
     "    sample_dataset_per_tree = True\n",
     "\n",
@@ -239,7 +239,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "id": "14806903-933b-4e31-a2db-a3a45e0a6f82",
    "metadata": {
     "scrolled": true
@@ -249,2814 +249,213 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
+      "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
+      "  return fit_method(estimator, *args, **kwargs)\n",
+      "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
+      "  return fit_method(estimator, *args, **kwargs)\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "X2/7:  1.0\n"
+      "X1:  0.9940119760479041\n"
      ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
+      "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
+      "  return fit_method(estimator, *args, **kwargs)\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "X1:  1.0\n"
+      "X6:  0.36726546906187624\n"
      ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
+      "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
+      "  return fit_method(estimator, *args, **kwargs)\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "X6:  1.0\n"
+      "X2/7:  0.23952095808383234\n"
      ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
+      "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
+      "  return fit_method(estimator, *args, **kwargs)\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "X2/7:  1.0\n"
+      "X2/7:  0.49101796407185627\n"
      ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
+      "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
+      "  return fit_method(estimator, *args, **kwargs)\n",
+      "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
+      "  return fit_method(estimator, *args, **kwargs)\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "X2/7:  1.0\n"
+      "X1:  0.00998003992015968\n"
      ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
+      "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
+      "  return fit_method(estimator, *args, **kwargs)\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "X1:  1.0\n"
+      "X6:  0.3532934131736527\n"
      ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  1.0\n"
+      "/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/sklearn/base.py:1151: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
+      "  return fit_method(estimator, *args, **kwargs)\n"
      ]
-    },
+    }
+   ],
+   "source": [
+    "pvalue_dict = defaultdict(list)\n",
+    "rng = np.random.default_rng(seed)\n",
+    "\n",
+    "j_space = np.linspace(0.005, 2.25, 9)\n",
+    "\n",
+    "for sigma_factor in j_space:\n",
+    "    for idx in range(5):\n",
+    "        new_seed = rng.integers(0, np.iinfo(np.uint32).max, dtype=np.uint32)\n",
+    "\n",
+    "        elements_dict = linear_model_ancova(\n",
+    "            sigma_factor,\n",
+    "            new_seed,\n",
+    "            permute_per_tree=False,\n",
+    "            sample_dataset_per_tree=False,\n",
+    "        )\n",
+    "        for key, value in elements_dict.items():\n",
+    "            pvalue_dict[key].append(value)\n",
+    "        pvalue_dict[\"sigma_factor\"].append(sigma_factor)\n",
+    "\n",
+    "df = pd.DataFrame(pvalue_dict)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "5f4eb53c-c82d-4770-836a-552b910dd736",
+   "metadata": {},
+   "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
+      "[autoreload of sktree.stats.forestht failed: Traceback (most recent call last):\n",
+      "  File \"/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/IPython/extensions/autoreload.py\", line 276, in check\n",
+      "    superreload(m, reload, self.old_objects)\n",
+      "  File \"/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/IPython/extensions/autoreload.py\", line 500, in superreload\n",
+      "    update_generic(old_obj, new_obj)\n",
+      "  File \"/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/IPython/extensions/autoreload.py\", line 397, in update_generic\n",
+      "    update(a, b)\n",
+      "  File \"/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/IPython/extensions/autoreload.py\", line 349, in update_class\n",
+      "    if update_generic(old_obj, new_obj):\n",
+      "  File \"/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/IPython/extensions/autoreload.py\", line 397, in update_generic\n",
+      "    update(a, b)\n",
+      "  File \"/Users/adam2392/miniforge3/envs/sktree/lib/python3.9/site-packages/IPython/extensions/autoreload.py\", line 309, in update_function\n",
+      "    setattr(old, name, getattr(new, name))\n",
+      "ValueError: statistic() requires a code object with 1 free vars, not 0\n",
+      "]\n"
      ]
     },
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axs = plt.subplots(2, 2, figsize=(8, 6), sharey=True, sharex=True)\n",
+    "axs = axs.flatten()\n",
+    "\n",
+    "for ax, name in zip(axs, [\"X1\", \"X2\", \"X6\", \"X7\"]):\n",
+    "    sns.lineplot(data=df, x=\"sigma_factor\", y=name, ax=ax, marker=\"o\")\n",
+    "\n",
+    "    ax.axhline([0.05], ls=\"--\", color=\"red\", label=\"alpha\")\n",
+    "    ax.set(title=name, ylabel=\"pvalue\", xlabel=\"SNR (10 / x)\")\n",
+    "    ax.legend()\n",
+    "fig.suptitle(\n",
+    "    \"Linear ANCOVA model with FeatureImportanceRegressor (Permutation per tree and sample dataset per tree)\"\n",
+    ")\n",
+    "fig.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "b470b569-4391-40e2-b7c4-a8439cc026c0",
+   "metadata": {},
+   "outputs": [
     {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  0.001996007984031936\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  0.001996007984031936\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  0.001996007984031936\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  0.001996007984031936\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  0.001996007984031936\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  0.001996007984031936\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  0.001996007984031936\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  0.001996007984031936\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  0.001996007984031936\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  0.001996007984031936\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  0.001996007984031936\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  0.001996007984031936\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  0.001996007984031936\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  0.001996007984031936\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  0.001996007984031936\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  0.001996007984031936\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  0.001996007984031936\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  0.001996007984031936\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  0.001996007984031936\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  0.001996007984031936\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  0.001996007984031936\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  0.001996007984031936\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  0.001996007984031936\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  0.001996007984031936\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  0.001996007984031936\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  0.001996007984031936\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  0.001996007984031936\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  0.001996007984031936\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  0.001996007984031936\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  0.001996007984031936\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  0.001996007984031936\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  0.001996007984031936\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n",
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X1:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X6:  0.001996007984031936\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/adam2392/Documents/scikit-tree/sktree/stats/forestht.py:560: RuntimeWarning: Mean of empty slice\n",
-      "  y_train = y_train.ravel()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "X2/7:  1.0\n"
-     ]
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
     }
    ],
    "source": [
-    "pvalue_dict = defaultdict(list)\n",
-    "rng = np.random.default_rng(seed)\n",
-    "\n",
-    "j_space = np.linspace(0.005, 2.25, 9)\n",
-    "\n",
-    "for sigma_factor in j_space:\n",
-    "    for idx in range(5):\n",
-    "        new_seed = rng.integers(0, np.iinfo(np.uint32).max, dtype=np.uint32)\n",
+    "fig, axs = plt.subplots(2, 2, figsize=(8, 6), sharey=True, sharex=True)\n",
+    "axs = axs.flatten()\n",
     "\n",
-    "        elements_dict = linear_model_ancova(\n",
-    "            sigma_factor,\n",
-    "            new_seed,\n",
-    "            permute_per_tree=True,\n",
-    "            sample_dataset_per_tree=False,\n",
-    "        )\n",
-    "        for key, value in elements_dict.items():\n",
-    "            pvalue_dict[key].append(value)\n",
-    "        pvalue_dict[\"sigma_factor\"].append(sigma_factor)\n",
+    "for ax, name in zip(axs, [\"X1\", \"X2\", \"X6\", \"X7\"]):\n",
+    "    sns.lineplot(data=df, x=\"sigma_factor\", y=name, ax=ax, marker=\"o\")\n",
     "\n",
-    "df = pd.DataFrame(pvalue_dict)"
+    "    ax.axhline([0.05], ls=\"--\", color=\"red\", label=\"alpha\")\n",
+    "    ax.set(title=name, ylabel=\"pvalue\", xlabel=\"SNR (10 / x)\")\n",
+    "    ax.legend()\n",
+    "fig.suptitle(\n",
+    "    \"Linear ANCOVA model with FeatureImportanceRegressor (Permutation per tree and sample dataset per tree)\"\n",
+    ")\n",
+    "fig.tight_layout()"
    ]
   },
   {
diff --git a/examples/plot_MI_gigantic_hypothesis_testing_forest.py b/examples/plot_MI_gigantic_hypothesis_testing_forest.py
index 8408f4e03..fd4f84765 100644
--- a/examples/plot_MI_gigantic_hypothesis_testing_forest.py
+++ b/examples/plot_MI_gigantic_hypothesis_testing_forest.py
@@ -90,10 +90,10 @@
 # computed as the proportion of samples in the null distribution that are less than the
 # observed test statistic.
 
-n_estimators = 125
+n_estimators = 200
 max_features = "sqrt"
 test_size = 0.2
-n_repeats = 500
+n_repeats = 1000
 n_jobs = -1
 
 est = FeatureImportanceForestClassifier(
@@ -107,8 +107,8 @@
     ),
     random_state=seed,
     test_size=test_size,
-    permute_per_tree=True,
-    sample_dataset_per_tree=True,
+    permute_per_tree=False,
+    sample_dataset_per_tree=False,
 )
 
 # we test for the first feature set, which is important and thus should return a pvalue < 0.05
diff --git a/sktree/_lib/sklearn_fork b/sktree/_lib/sklearn_fork
index e2fee00aa..d9d1ea68f 160000
--- a/sktree/_lib/sklearn_fork
+++ b/sktree/_lib/sklearn_fork
@@ -1 +1 @@
-Subproject commit e2fee00aa461c21b8cfa59eb907d27972415c99b
+Subproject commit d9d1ea68fde4f0bf90caff21dc26044ace3114ae
diff --git a/sktree/stats/forestht.py b/sktree/stats/forestht.py
index 5ce124174..427de8251 100644
--- a/sktree/stats/forestht.py
+++ b/sktree/stats/forestht.py
@@ -23,6 +23,7 @@
     POSTERIOR_FUNCTIONS,
     REGRESSOR_METRICS,
     _compute_null_distribution_coleman,
+    _non_nan_samples,
     train_tree,
 )
 
@@ -140,7 +141,7 @@ def _check_input(self, X: ArrayLike, y: ArrayLike, covariate_index: ArrayLike =
             if not isinstance(covariate_index, (list, tuple, np.ndarray)):
                 raise RuntimeError("covariate_index must be an iterable of integer indices")
             else:
-                if not all(isinstance(idx, int) for idx in covariate_index):
+                if not all(isinstance(idx, (np.integer, int)) for idx in covariate_index):
                     raise RuntimeError("Not all covariate_index are integer indices")
 
         if self._n_samples_ is not None and X.shape[0] != self._n_samples_:
@@ -362,7 +363,7 @@ def test(
         # the posteriors and computing the test statistic on the resampled posteriors
         if self.sample_dataset_per_tree:
             metric_star, metric_star_pi = _compute_null_distribution_coleman(
-                y_test=y[observe_samples, :],
+                y_test=y,
                 y_pred_proba_normal=observe_posteriors,
                 y_pred_proba_perm=permute_posteriors,
                 metric=metric,
@@ -375,10 +376,13 @@ def test(
             # there is only one train and test split, so we can just use that
             _, indices_test = self.train_test_samples_[0]
             y_test = y[indices_test, :]
+            y_pred_proba_normal = observe_posteriors[:, indices_test, :]
+            y_pred_proba_perm = permute_posteriors[:, indices_test, :]
+
             metric_star, metric_star_pi = _compute_null_distribution_coleman(
                 y_test=y_test,
-                y_pred_proba_normal=observe_posteriors,
-                y_pred_proba_perm=permute_posteriors,
+                y_pred_proba_normal=y_pred_proba_normal,
+                y_pred_proba_perm=y_pred_proba_perm,
                 metric=metric,
                 n_repeats=n_repeats,
                 seed=self.random_state,
@@ -588,19 +592,15 @@ def _statistic(
             samples = indices_test
             y_true_final = y_test
 
-        # determine if there are any nans in the final posterior array
-        temp_posterior_forest = np.nanmean(posterior_arr, axis=0)
-        nonnan_indices = np.where(~np.isnan(temp_posterior_forest).any(axis=1))[0]
-
-        # Find the row indices with NaN values in any column
-        samples = nonnan_indices
+        # determine if there are any nans in the final posterior array, when
+        # averaged over the trees
+        samples = _non_nan_samples(posterior_arr)
 
         # Ignore all NaN values (samples not tested)
-        y_true_final = y[(nonnan_indices), :]
-        posterior_arr = posterior_arr[:, (nonnan_indices), :]
+        y_true_final = y[(samples), :]
 
         # Average all posteriors (n_samples_test, n_outputs) to compute the statistic
-        posterior_forest = np.nanmean(posterior_arr, axis=0)
+        posterior_forest = np.nanmean(posterior_arr[:, (samples), :], axis=0)
         stat = metric_func(y_true_final, posterior_forest, **metric_kwargs)
         if covariate_index is None:
             # Ignore all NaN values (samples not tested) -> (n_samples_final, n_outputs)
@@ -750,6 +750,7 @@ def _statistic(
 
         if predict_posteriors:
             # now initialize posterior array as (n_trees, n_samples_test, n_classes)
+            # XXX: currently assumes n_outputs_ == 1
             posterior_arr = np.full(
                 (self.n_estimators, self._n_samples_, estimator.n_classes_), np.nan
             )
@@ -818,19 +819,15 @@ def _statistic(
                     f"AUC metric is not supported for {self._type_of_target_} targets."
                 )
 
-        # determine if there are any nans in the final posterior array
-        temp_posterior_forest = np.nanmean(posterior_arr, axis=0)
-        nonnan_indices = np.where(~np.isnan(temp_posterior_forest).any(axis=1))[0]
-
-        # Find the row indices with NaN values in any column
-        samples = nonnan_indices
+        # determine if there are any nans in the final posterior array, when
+        # averaged over the trees
+        samples = _non_nan_samples(posterior_arr)
 
         # Ignore all NaN values (samples not tested)
-        y_true_final = y[(nonnan_indices), :]
-        posterior_arr = posterior_arr[:, (nonnan_indices), :]
+        y_true_final = y[(samples), :]
 
         # Average all posteriors (n_samples_test, n_outputs) to compute the statistic
-        posterior_forest = np.nanmean(posterior_arr, axis=0)
+        posterior_forest = np.nanmean(posterior_arr[:, (samples), :], axis=0)
         stat = metric_func(y_true_final, posterior_forest, **metric_kwargs)
 
         if covariate_index is None:
@@ -846,51 +843,3 @@ def _statistic(
             return stat, posterior_arr, samples
 
         return stat
-
-    def statistic(
-        self,
-        X: ArrayLike,
-        y: ArrayLike,
-        covariate_index: ArrayLike = None,
-        metric="mi",
-        return_posteriors: bool = False,
-        check_input: bool = True,
-        **metric_kwargs,
-    ):
-        """Compute the test statistic.
-
-        Parameters
-        ----------
-        X : ArrayLike of shape (n_samples, n_features)
-            The data matrix.
-        y : ArrayLike of shape (n_samples, n_outputs)
-            The target matrix.
-        covariate_index : ArrayLike, optional of shape (n_covariates,)
-            The index array of covariates to shuffle, by default None.
-        metric : str, optional
-            The metric to compute, by default "mi", which computes Mutual Information.
-        return_posteriors : bool, optional
-            Whether or not to return the posteriors, by default False.
-        check_input : bool, optional
-            Whether or not to check the input, by default True.
-        **metric_kwargs : dict, optional
-            Additional keyword arguments to pass to the metric function.
-
-        Returns
-        -------
-        stat : float
-            The test statistic.
-        posterior_final : ArrayLike of shape (n_estimators, n_samples_final, n_outputs) or
-            (n_estimators, n_samples_final), optional
-            If ``return_posteriors`` is True, then the posterior probabilities of the
-            samples used in the final test. ``n_samples_final`` is equal to ``n_samples``
-            if all samples are encountered in the test set of at least one tree in the
-            posterior computation.
-        samples : ArrayLike of shape (n_samples_final,), optional
-            The indices of the samples used in the final test. ``n_samples_final`` is
-            equal to ``n_samples`` if all samples are encountered in the test set of at
-            least one tree in the posterior computation.
-        """
-        return super().statistic(
-            X, y, covariate_index, metric, return_posteriors, check_input, **metric_kwargs
-        )
diff --git a/sktree/stats/tests/test_forestht.py b/sktree/stats/tests/test_forestht.py
index 9b849ed22..20fc68e52 100644
--- a/sktree/stats/tests/test_forestht.py
+++ b/sktree/stats/tests/test_forestht.py
@@ -1,7 +1,11 @@
+import pickle
+from pathlib import Path
+
 import numpy as np
 import pytest
 from flaky import flaky
 from joblib import Parallel, delayed
+from numpy.testing import assert_array_equal
 from scipy.special import expit
 from sklearn import datasets
 
@@ -124,8 +128,8 @@ def test_featureimportance_forest_errors():
                 "sample_dataset_per_tree": True,
             },
             300,  # n_samples
-            500,  # n_repeats
-            0.1,  # test_size
+            1000,  # n_repeats
+            0.2,  # test_size
         ],
     ],
 )
@@ -205,12 +209,12 @@ def test_linear_model(hypotester, model_kwargs, n_samples, n_repeats, test_size)
                     n_jobs=-1,
                 ),
                 "random_state": seed,
-                "permute_per_tree": True,
-                "sample_dataset_per_tree": True,
+                "permute_per_tree": False,
+                "sample_dataset_per_tree": False,
             },
-            600,
-            200,
-            1.0 / 6,
+            600,  # n_samples
+            1000,  # n_repeats
+            1.0 / 6,  # test_size
         ],
     ],
 )
@@ -266,7 +270,6 @@ def test_correlated_logit_model(hypotester, model_kwargs, n_samples, n_repeats,
 
 
 @flaky(max_runs=2)
-@pytest.mark.slowtest
 @pytest.mark.parametrize("criterion", ["gini", "entropy"])
 @pytest.mark.parametrize("honest_prior", ["empirical", "uniform"])
 @pytest.mark.parametrize(
@@ -408,7 +411,54 @@ def run_forest(covariate_index=None):
         pvalue = clf.test(X, y, covariate_index=[covariate_index], metric="mi")
         return pvalue
 
-    out = Parallel(n_jobs=1, backend=backend)(
+    out = Parallel(n_jobs=-1, backend=backend)(
         delayed(run_forest)(covariate_index) for covariate_index in range(n_features)
     )
     assert len(out) == n_features
+
+
+def test_pickle(tmpdir):
+    """Test that pickling works and preserves fitted attributes."""
+    n_samples = 100
+    n_features = 5
+    X = rng.uniform(size=(n_samples, n_features))
+    y = rng.integers(0, 2, size=n_samples)  # Binary classification
+    n_repeats = 1000
+
+    clf = FeatureImportanceForestClassifier(
+        estimator=HonestForestClassifier(
+            n_estimators=10, random_state=seed, n_jobs=1, honest_fraction=0.2
+        ),
+        test_size=0.5,
+    )
+    stat, pvalue = clf.test(X, y, covariate_index=[1], metric="mi", n_repeats=n_repeats)
+
+    with open(Path(tmpdir) / "clf.pkl", "wb") as fpath:
+        pickle.dump(clf, fpath)
+
+    with open(Path(tmpdir) / "clf.pkl", "rb") as fpath:
+        clf_pickle = pickle.load(fpath)
+
+    # recompute pvalue manually and compare
+    pickle_pvalue = (
+        1.0 + (clf_pickle.null_dist_ <= (clf_pickle.permute_stat_ - clf_pickle.observe_stat_)).sum()
+    ) / (1.0 + n_repeats)
+    assert pvalue == pickle_pvalue
+    assert clf_pickle.permute_stat_ - clf_pickle.observe_stat_ == stat
+
+    attr_list = [
+        "test_size",
+        "observe_samples_",
+        "y_true_final_",
+        "observe_posteriors_",
+        "observe_stat_",
+        "_is_fitted",
+        "permute_samples_",
+        "permute_posteriors_",
+        "permute_stat_",
+        "n_samples_test_",
+        "_n_samples_",
+        "_metric",
+    ]
+    for attr in attr_list:
+        assert_array_equal(getattr(clf, attr), getattr(clf_pickle, attr))
diff --git a/sktree/stats/utils.py b/sktree/stats/utils.py
index 30ce83ff8..d2f36c1e4 100644
--- a/sktree/stats/utils.py
+++ b/sktree/stats/utils.py
@@ -16,12 +16,12 @@
 
 
 def _mutual_information(y_true: ArrayLike, y_pred_proba: ArrayLike) -> float:
-    """Compute estimate of mutual information.
+    """Compute estimate of mutual information for supervised classification setting.
 
     Parameters
     ----------
     y_true : ArrayLike of shape (n_samples,)
-        _description_
+        The true labels.
     y_pred_proba : ArrayLike of shape (n_samples, n_outputs)
         Posterior probabilities.
 
@@ -41,21 +41,69 @@ def _mutual_information(y_true: ArrayLike, y_pred_proba: ArrayLike) -> float:
     return H_Y - H_YX
 
 
+def _cond_entropy(y_true: ArrayLike, y_pred_proba: ArrayLike) -> float:
+    """Compute estimate of entropy for supervised classification setting.
+
+    H(Y | X)
+
+    Parameters
+    ----------
+    y_true : ArrayLike of shape (n_samples,)
+        The true labels. Not used in computation of the entropy.
+    y_pred_proba : ArrayLike of shape (n_samples, n_outputs)
+        Posterior probabilities.
+
+    Returns
+    -------
+    float :
+        The estimated MI.
+    """
+    if y_true.squeeze().ndim != 1:
+        raise ValueError(f"y_true must be 1d, not {y_true.shape}")
+
+    # entropy averaged over n_samples
+    H_YX = np.mean(entropy(y_pred_proba, base=np.exp(1), axis=1))
+    return H_YX
+
+
 METRIC_FUNCTIONS = {
     "mse": mean_squared_error,
     "mae": mean_absolute_error,
     "balanced_accuracy": balanced_accuracy_score,
     "auc": roc_auc_score,
     "mi": _mutual_information,
+    "cond_entropy": _cond_entropy,
 }
 
-POSTERIOR_FUNCTIONS = ("mi", "auc")
+POSTERIOR_FUNCTIONS = ("mi", "auc", "cond_entropy")
 
 POSITIVE_METRICS = ("mi", "auc", "balanced_accuracy")
 
 REGRESSOR_METRICS = ("mse", "mae")
 
 
+def _non_nan_samples(posterior_arr: ArrayLike) -> ArrayLike:
+    """Determine which samples are not nan in the posterior tree array.
+
+    Parameters
+    ----------
+    posterior_arr : ArrayLike of shape (n_trees, n_samples, n_outputs)
+        The 3D posterior array from the forest.
+
+    Returns
+    -------
+    nonnan_indices : ArrayLike of shape (n_nonnan_samples,)
+        The indices of the samples that are not nan in the posterior array
+        along axis=1.
+    """
+    # Find the row indices with NaN values along the specified axis
+    nan_indices = np.isnan(posterior_arr).any(axis=2).all(axis=0)
+
+    # Invert the boolean mask to get indices without NaN values
+    nonnan_indices = np.where(~nan_indices)[0]
+    return nonnan_indices
+
+
 def train_tree(
     tree: DecisionTreeClassifier,
     X: ArrayLike,
@@ -218,16 +266,30 @@ def _compute_null_distribution_coleman(
         rng.shuffle(y_pred_ind_arr)
 
         # get random half of the posteriors from two sets of trees
-        first_forest_inds = y_pred_ind_arr[:n_samples_test]
-        second_forest_inds = y_pred_ind_arr[:n_samples_test]
+        first_forest_inds = y_pred_ind_arr[: n_estimators // 2]
+        second_forest_inds = y_pred_ind_arr[n_estimators // 2 :]
+
+        # get random half of the posteriors as one forest
+        first_forest_pred = all_y_pred[first_forest_inds, ...]
+        second_forest_pred = all_y_pred[second_forest_inds, ...]
+
+        # determine if there are any nans in the final posterior array, when
+        # averaged over the trees
+        first_forest_samples = _non_nan_samples(first_forest_pred)
+        second_forest_samples = _non_nan_samples(second_forest_pred)
+
+        # todo: is this step necessary?
+        non_nan_samples = np.intersect1d(
+            first_forest_samples, second_forest_samples, assume_unique=True
+        )
 
-        # get random half of the posteriors
-        y_pred_first_half = np.nanmean(all_y_pred[first_forest_inds], axis=0)
-        y_pred_second_half = np.nanmean(all_y_pred[second_forest_inds], axis=0)
+        # now average the posteriors over the trees for the non-nan samples
+        y_pred_first_half = np.nanmean(first_forest_pred[:, non_nan_samples, :], axis=0)
+        y_pred_second_half = np.nanmean(second_forest_pred[:, non_nan_samples, :], axis=0)
 
         # compute two instances of the metric from the sampled trees
-        first_half_metric = metric_func(y_test, y_pred_first_half)
-        second_half_metric = metric_func(y_test, y_pred_second_half)
+        first_half_metric = metric_func(y_test[non_nan_samples, :], y_pred_first_half)
+        second_half_metric = metric_func(y_test[non_nan_samples, :], y_pred_second_half)
 
         metric_star[idx] = first_half_metric
         metric_star_pi[idx] = second_half_metric