hybrid_3d.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.23.5\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "print(np.__version__)\n",
    "\n",
    "import pickle\n",
    "\n",
    "import os\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.ticker import MaxNLocator\n",
    "\n",
    "from sklearn.datasets import make_classification\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.datasets import make_classification\n",
    "\n",
    "# 2D ploting imports\n",
    "import plotly\n",
    "\n",
    "# 3-D plot using surface graph\n",
    "import plotly.graph_objs as go\n",
    "import numpy as np\n",
    "import plotly.io as pio\n",
    "from scipy.interpolate import griddata\n",
    "\n",
    "\n",
    "from tqdm import tqdm\n",
    "\n",
    "# ignore warnings\n",
    "import warnings\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "from sklearn.metrics import confusion_matrix, f1_score, precision_score, recall_score\n",
    "\n",
    "from tqdm import tqdm\n",
    "\n",
    "# ignore warnings\n",
    "import warnings\n",
    "\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Helper functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Retreive value of given index\n",
    "def get_value(y, index):\n",
    "    x = y[index]\n",
    "    return x\n",
    "\n",
    "\n",
    "def add_uniform_noise(probas, noise_level=0.1):\n",
    "    \"\"\"\n",
    "    Adds random uniform noise to a list of probabilities.\n",
    "\n",
    "    Parameters:\n",
    "    probas (list of float): List of probabilities to add noise to.\n",
    "    noise_level (float): Maximum amount of noise to add. Noise will be in the range [-noise_level, noise_level].\n",
    "\n",
    "    Returns:\n",
    "    list of float: Probabilities with added noise.\n",
    "    \"\"\"\n",
    "    noise = np.random.uniform(-noise_level, noise_level, len(probas))\n",
    "    probas += noise\n",
    "    probas = (probas - min(probas)) / (max(probas) - min(probas))\n",
    "\n",
    "    return probas\n",
    "\n",
    "\n",
    "# Harmonic mean\n",
    "def harmonic_mean(a, b):\n",
    "    return 2 * a * b / (a + b) if (a + b) != 0 else 0.0\n",
    "\n",
    "\n",
    "def weighted_bce_loss(y, y_hat):\n",
    "    # Calculate the lambda value\n",
    "    N_bad = np.sum(y)\n",
    "    N = len(y)\n",
    "    N_good = N - N_bad\n",
    "    lam = N_good / N\n",
    "\n",
    "    # Ensure y_hat values are in (0, 1)\n",
    "    epsilon = 1e-8\n",
    "    y_hat = np.clip(y_hat, epsilon, 1 - epsilon)\n",
    "\n",
    "    # Calculate the weighted BCE loss\n",
    "    wBCE_loss = (-2 / N) * np.sum(\n",
    "        lam * y * np.log(y_hat) + (1 - lam) * (1 - y) * np.log(1 - y_hat)\n",
    "    )\n",
    "\n",
    "    return wBCE_loss\n",
    "\n",
    "\n",
    "# Scoring function\n",
    "def scoring(*, y_true, y_pred, y_pred_proba=None, metric=\"harmonic_tnr_recall\"):\n",
    "    \"\"\"\n",
    "    input: true_labels, predicted_labels, predicted_probabilities, metric\n",
    "    output: score\n",
    "    metric: 'harmonic_tnr_recall', 'harmonic_tnr_precision', 'f1', 'precision', 'recall', 'tnr', 'weighted_binary_cross_entropy'\n",
    "    \"\"\"\n",
    "\n",
    "    cm = confusion_matrix(y_true, y_pred)\n",
    "    tn, fp, fn, tp = cm.ravel()\n",
    "\n",
    "    # Define available metrics\n",
    "    metrics = {\n",
    "        \"harmonic_tnr_recall\": lambda tn, fp, fn, tp: harmonic_mean(\n",
    "            tn / (tn + fp) if (tn + fp) != 0 else 0,\n",
    "            tp / (tp + fn) if (tp + fn) != 0 else 0,\n",
    "        ),\n",
    "        \"harmonic_tnr_precision\": lambda tn, fp, fn, tp: harmonic_mean(\n",
    "            tn / (tn + fp) if (tn + fp) != 0 else 0,\n",
    "            tp / (tp + fp) if (tp + fp) != 0 else 0,\n",
    "        ),\n",
    "        \"f1\": lambda tn, fp, fn, tp: f1_score(y_true, y_pred),\n",
    "        \"precision\": lambda tn, fp, fn, tp: precision_score(y_true, y_pred),\n",
    "        \"recall\": lambda tn, fp, fn, tp: recall_score(y_true, y_pred),\n",
    "        \"tnr\": lambda tn, fp, fn, tp: tn / (tn + fp) if (tn + fp) != 0 else 0.0,\n",
    "        \"weighted_binary_cross_entropy\": lambda y_true, y_pred_proba: weighted_bce_loss(\n",
    "            y_true, y_pred_proba\n",
    "        ),\n",
    "    }\n",
    "\n",
    "    # Calculate the chosen metric\n",
    "    if metric in metrics:\n",
    "        if metric == \"weighted_binary_cross_entropy\":\n",
    "            if y_pred_proba is None:\n",
    "                raise ValueError(\n",
    "                    \"y_pred_proba must be provided when using 'weighted_binary_cross_entropy' as the metric\"\n",
    "                )\n",
    "            score = metrics[metric](y_true, y_pred_proba)\n",
    "        else:\n",
    "            score = metrics[metric](tn, fp, fn, tp)\n",
    "        return score\n",
    "    else:\n",
    "        raise ValueError(\n",
    "            f\"Metric '{metric}' not recognized. Available metrics: {list(metrics.keys())}\"\n",
    "        )\n",
    "\n",
    "\n",
    "# Find mean gap between 1's in the data\n",
    "def find_mean_gap(y):\n",
    "    # Find the indices of 1's in the data\n",
    "    ones_indices = np.where(y == 1)[0]\n",
    "    # Calculate the differences between consecutive 1's\n",
    "    gaps = np.diff(ones_indices)\n",
    "    # Calculate the mean gap\n",
    "    mean_gap = int(np.mean(gaps))\n",
    "    return mean_gap\n",
    "\n",
    "\n",
    "def transform_data(y, trained_probas, predictions, mean_gap_ref):\n",
    "    y_transformed, probas_list, predictions_list = [], [], []\n",
    "    y_transform = y.copy()  # Copy of the original data\n",
    "    probas = trained_probas.copy()\n",
    "\n",
    "    i, start = (\n",
    "        0,\n",
    "        0,\n",
    "    )  # i : index of the current element, start : index of the first element in the current chunk\n",
    "\n",
    "    while i < len(y_transform):\n",
    "        mean_gap = np.random.randint(256, mean_gap_ref + 950)\n",
    "        if (\n",
    "            len(y_transform[i:]) < mean_gap\n",
    "        ):  # if the remaining data is less than the mean gap break\n",
    "            break\n",
    "\n",
    "        elif (\n",
    "            y_transform[start] == 1\n",
    "        ):  # if the first element in the chunk is 1, move to the next element\n",
    "            start += 1\n",
    "            i += 1\n",
    "            continue\n",
    "\n",
    "        elif y_transform[i] == 1:\n",
    "            # if the current element is 1, fill the chunk with 1's by the mean gap\n",
    "            probas_chunk, predictions_chunk, y_chunk = (\n",
    "                probas[start : i + mean_gap],\n",
    "                predictions[start : i + mean_gap],\n",
    "                y[start : i + mean_gap],\n",
    "            )\n",
    "\n",
    "            ones_places = np.where(y_chunk == 1)[0]\n",
    "\n",
    "            for one_place in ones_places:\n",
    "\n",
    "                y_chunk = np.zeros(len(y_chunk))\n",
    "                y_chunk[one_place] = 1\n",
    "                y_transform_chunk = y_chunk.copy()\n",
    "\n",
    "                y_transform_chunk[np.where(y_chunk == 1)[0][0] + 1 :] = 1\n",
    "\n",
    "                # append the chunk to the transformed data\n",
    "                y_transformed.append([y_chunk, y_transform_chunk])\n",
    "                # append the chunk of probabilities to the list\n",
    "                probas_list.append(probas_chunk)\n",
    "                # append the chunk of predictions to the list\n",
    "                predictions_list.append(predictions_chunk)\n",
    "\n",
    "            # move the index to the next element after the chunk\n",
    "            # set the start index to the current index\n",
    "            i += mean_gap\n",
    "            start = i\n",
    "            continue\n",
    "\n",
    "        else:\n",
    "            i += 1\n",
    "\n",
    "    return y_transformed, probas_list, predictions_list\n",
    "\n",
    "\n",
    "# Check transformation validity\n",
    "def check_transformation(data_transformed):\n",
    "    for chunk_pair in data_transformed:\n",
    "        if len(np.where(chunk_pair[0] == 1)[0]) > 1:\n",
    "            raise ValueError(\"more than one 1 found in the original data\")\n",
    "        if len(chunk_pair[0]) != len(\n",
    "            chunk_pair[1]\n",
    "        ):  # checking if the length of the original and transformed data are equal\n",
    "            raise ValueError(\"lenght mismatch found\")\n",
    "\n",
    "        for i in range(\n",
    "            len(chunk_pair[0])\n",
    "        ):  # looping over each intity in each chunk pair\n",
    "            sum_chunk = sum(chunk_pair[0][i + 1 :])\n",
    "\n",
    "            if chunk_pair[0][i] == 0 and chunk_pair[1][i] == 0:\n",
    "                continue\n",
    "\n",
    "            # if the su of the remaining chunk is equal to the sum from index to the end of the list, then the transformation is valid\n",
    "            # example --> trans = [0,0,0,0,1,1,1,1], len:8, index:4, sum(trans)[index:] == 4 == len(trans) - 4\n",
    "            elif (len(chunk_pair[0]) - i == sum(chunk_pair[1][i:])) and sum_chunk == 0:\n",
    "                return True\n",
    "            else:\n",
    "                print(\n",
    "                    f\"false transformation found at index {i}, {chunk_pair[0]} and {chunk_pair[1]}\"\n",
    "                )\n",
    "                return False\n",
    "\n",
    "\n",
    "# Plot the data\n",
    "def plot(\n",
    "    algorithm,\n",
    "    metric=None,\n",
    "    *,\n",
    "    samples=15000,\n",
    "    scores=None,\n",
    "    saved_runs=None,\n",
    "    save_fig=False,\n",
    "    transparent=False,\n",
    "    **kwargs,\n",
    "):\n",
    "\n",
    "    plt.figure(figsize=(18, 9))\n",
    "\n",
    "    saved_runs_means = [np.mean(saved_run) for saved_run in saved_runs]\n",
    "    scores_means = [np.mean(score) for score in scores]\n",
    "    # Find the vertical line where saved runs become negative\n",
    "    negative_indices = [\n",
    "        i for i, saved_run in enumerate(saved_runs_means) if saved_run < 0\n",
    "    ]\n",
    "\n",
    "    if negative_indices:\n",
    "        negative_index = negative_indices[\n",
    "            -1\n",
    "        ]  # Find the last index where saved runs are negative\n",
    "        # Perform linear interpolation\n",
    "        x1 = scores_means[negative_index]\n",
    "        y1 = saved_runs_means[negative_index]\n",
    "        x2 = scores_means[negative_index + 1]\n",
    "        y2 = saved_runs_means[negative_index + 1]\n",
    "\n",
    "        x_zero_cross = x1 + (0 - y1) / (y2 - y1) * (x2 - x1)\n",
    "\n",
    "        plt.axvline(\n",
    "            x=x_zero_cross,\n",
    "            color=\"#EC6602\",\n",
    "            linestyle=\"--\",\n",
    "            linewidth=1.5,\n",
    "            label=\"_nolegend_\",\n",
    "        )\n",
    "        plt.axhline(\n",
    "            y=0,\n",
    "            color=\"#EC6602\",\n",
    "            linestyle=\"--\",\n",
    "            linewidth=1.5,\n",
    "            label=\"_nolegend_\",\n",
    "        )\n",
    "        x_zero_cross = f\"{x_zero_cross:.2f}%\"\n",
    "        # plt.axhline(y=0, color=\"#EC6602\", linestyle=\"--\", linewidth=1.5)\n",
    "\n",
    "    else:\n",
    "        x_zero_cross = None\n",
    "    # Plot with labels for the legend\n",
    "    plt.boxplot(saved_runs, positions=scores_means, widths=2)\n",
    "\n",
    "    plt.plot(\n",
    "        scores_means,\n",
    "        saved_runs_means,\n",
    "        marker=\"o\",\n",
    "        linestyle=\"--\",\n",
    "        color=\"#009999\",\n",
    "        label=\"_nolegend_\",\n",
    "        **kwargs,\n",
    "    )\n",
    "\n",
    "    plt.legend(\n",
    "        [f\"Samples: {samples}\\nThreshold: {x_zero_cross}\"],\n",
    "        loc=\"upper right\",\n",
    "        fontsize=10,\n",
    "        frameon=True,\n",
    "        shadow=False,\n",
    "        title=\"Info\",\n",
    "        title_fontsize=\"20\",\n",
    "    )\n",
    "    # plt.title('Saved Runs Vs Model Scores using Hit Or Miss Algorithm', fontsize=20)\n",
    "    if metric == \"Weighted Binary Crossentropy Loss\":\n",
    "        plt.xlabel(f\"Loss Values ({metric})\", fontsize=25)\n",
    "    else:\n",
    "        plt.xlabel(f\"Score Values ({metric})\", fontsize=25)\n",
    "    plt.ylabel(\"Saved Runs\", fontsize=25)\n",
    "\n",
    "    # remoce borders\n",
    "    plt.gca().spines[\"top\"].set_visible(False)\n",
    "    plt.gca().spines[\"right\"].set_visible(False)\n",
    "\n",
    "    # min = int(np.min(saved_runs_means))\n",
    "    # max = int(np.max(saved_runs_means))\n",
    "\n",
    "    plt.xticks(ticks=range(0, 101, 10), labels=range(0, 101, 10), fontsize=20)\n",
    "    plt.yticks(fontsize=20)\n",
    "    ax = plt.gca()\n",
    "\n",
    "    plt.grid(True)\n",
    "\n",
    "    # ax.yaxis.set_major_locator(MaxNLocator(nbins=20))\n",
    "    # ax.xaxis.set_major_locator(MaxNLocator(nbins=15))\n",
    "\n",
    "    plt.xlim(-1, np.max(scores_means) + 10)\n",
    "    plt.ylim(np.min(saved_runs_means) - 10, np.max(saved_runs_means) + 10)\n",
    "\n",
    "    plt.grid(True)\n",
    "    if save_fig:\n",
    "        if transparent:\n",
    "            transparency = \"transparent\"\n",
    "        else:\n",
    "            transparency = \"non-transparent\"\n",
    "\n",
    "        directory = \"Graphs/\"\n",
    "\n",
    "        if not os.path.exists(directory):\n",
    "            os.makedirs(directory)\n",
    "\n",
    "        plt.savefig(\n",
    "            os.path.join(directory, f\"{algorithm}_{transparency}_{metric}.png\"),\n",
    "            transparent=transparent,\n",
    "            dpi=350,\n",
    "        )\n",
    "\n",
    "    plt.show\n",
    "\n",
    "\n",
    "# 3D ploting\n",
    "# 3D plot\n",
    "def plot_3d(\n",
    "    x,\n",
    "    y,\n",
    "    z,\n",
    "    title=\"3D Plot\",\n",
    "    x_label=\"X\",\n",
    "    y_label=\"Y\",\n",
    "    z_label=\"Z\",\n",
    "    save_fig=False,\n",
    "    transparent=False,\n",
    "    width=800,\n",
    "    height=800,\n",
    "    algorithm=\"algorithm\",\n",
    "    contour=False,\n",
    "):\n",
    "    \"\"\"This function plots the 3D graph of the data using plotly\n",
    "    in contour plot the z axis is represented by colors\"\"\"\n",
    "\n",
    "    # Convert input lists to numpy arrays and flatten them\n",
    "    X = np.array(x)\n",
    "    Y = np.array(y)\n",
    "    Z = np.array(z)\n",
    "\n",
    "    if contour:\n",
    "\n",
    "        # Create grid values first\n",
    "        grid_x, grid_y = np.mgrid[min(X) : max(X) : 80j, min(Y) : max(Y) : 80j]\n",
    "        # grid_x, grid_y = np.meshgrid(np.linspace(np.min(X), np.max(X), 50), np.linspace(np.min(Y), np.max(Y), 50))\n",
    "        # Interpolate using cubic interpolation\n",
    "\n",
    "        grid_z = griddata((X, Y), Z, (grid_x, grid_y), method=\"nearest\")\n",
    "\n",
    "        # contour plot using matplotlib not plotly\n",
    "\n",
    "        plt.contourf(grid_x, grid_y, grid_z, levels=29, cmap=\"viridis\")\n",
    "        plt.colorbar()\n",
    "        # hide the title of the graph\n",
    "        # plt.title('Contour Plot with Cubic Interpolation')\n",
    "\n",
    "        # naming axis\n",
    "        plt.xlabel(x_label)\n",
    "        plt.ylabel(y_label)\n",
    "        plt.show()\n",
    "        # save the contour plot\n",
    "        plt.savefig(f\"{algorithm}_contourV1.png\")\n",
    "\n",
    "        if save_fig:\n",
    "            if transparent:\n",
    "                transparency = \"transparent\"\n",
    "\n",
    "                # save the figure in png extension with name of the algorithm and transparency\n",
    "                plt.savefig(\n",
    "                    f\"{algorithm}_transContourV1_{transparency}.png\", transparent=True\n",
    "                )\n",
    "\n",
    "            else:\n",
    "                transparency = \"non-transparent\"\n",
    "\n",
    "                # save the figure in png extension with name of the algorithm and transparency\n",
    "                plt.savefig(f\"{algorithm}nontransContourV1.png\")\n",
    "        return\n",
    "\n",
    "    # Create grid values first\n",
    "    grid_x, grid_y = np.meshgrid(\n",
    "        np.linspace(np.min(X), np.max(X), 50), np.linspace(np.min(Y), np.max(Y), 50)\n",
    "    )\n",
    "\n",
    "    # Interpolate the z values on the grid using 'nearest' method\n",
    "    grid_z = griddata((X, Y), Z, (grid_x, grid_y), method=\"linear\")\n",
    "\n",
    "    # Create the 3D surface plot\n",
    "    surface = go.Surface(x=grid_x, y=grid_y, z=grid_z, colorscale=\"Viridis\")\n",
    "\n",
    "    layout = go.Layout(\n",
    "        title=title,\n",
    "        scene=dict(xaxis_title=x_label, yaxis_title=y_label, zaxis_title=z_label),\n",
    "        width=width,\n",
    "        height=height,\n",
    "    )\n",
    "    fig = go.Figure(data=[surface], layout=layout)\n",
    "    fig.show()\n",
    "\n",
    "    if save_fig:\n",
    "        if transparent:\n",
    "            transparency = \"transparent\"\n",
    "            layout_trans = go.Layout(\n",
    "                title=title,\n",
    "                scene=dict(\n",
    "                    xaxis_title=x_label, yaxis_title=y_label, zaxis_title=z_label\n",
    "                ),\n",
    "                paper_bgcolor=\"rgba(0,0,0,0)\",  # Transparent background for the plot\n",
    "                plot_bgcolor=\"rgba(0,0,0,0)\",  # Transparent background for the plot\n",
    "                width=width,\n",
    "                height=height,\n",
    "            )\n",
    "            fig = go.Figure(data=[surface], layout=layout_trans)\n",
    "            # save the figure in png extension with name of the algorithm and transparency\n",
    "            pio.write_image(fig, f\"{algorithm}_trans3d.png\")\n",
    "\n",
    "        else:\n",
    "            transparency = \"non-transparent\"\n",
    "\n",
    "            # save the figure in png extension with name of the algorithm and transparency\n",
    "            pio.write_image(fig, f\"{algorithm}nontrans_3d.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Algorithms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Binary search\n",
    "def find_bad_cl(y):\n",
    "    num_of_runs = 0\n",
    "    low, high = 0, len(y) - 1\n",
    "\n",
    "    state_of_first = get_value(y, 0)\n",
    "    state_of_last = get_value(y, len(y) - 1)\n",
    "\n",
    "    if state_of_first == 0 and state_of_last == 0:\n",
    "        return -1, num_of_runs\n",
    "\n",
    "    while low < high:\n",
    "        mid = (low + high) // 2\n",
    "\n",
    "        state_of_current = get_value(y, mid)\n",
    "        num_of_runs += 1\n",
    "\n",
    "        if state_of_current == 0:\n",
    "            low = mid + 1\n",
    "        elif state_of_current == 1:\n",
    "            high = mid\n",
    "\n",
    "    result = high\n",
    "    binary_runs = []\n",
    "    binary_runs.append(num_of_runs)\n",
    "    return num_of_runs, result\n",
    "\n",
    "\n",
    "# Helper function for equilibrium\n",
    "def diffs(probas, low):\n",
    "    diffs = [\n",
    "        abs(sum1 - sum2)\n",
    "        for sum1, sum2 in [\n",
    "            (sum(probas[: i + 1]), sum(probas[i:])) for i in range(1, len(probas))\n",
    "        ]\n",
    "    ]\n",
    "    index = np.argmin(diffs)\n",
    "    index += low\n",
    "    return index, diffs\n",
    "\n",
    "\n",
    "# Equilibruim algorithm\n",
    "def equilibrium(*, data_transformed, probas):\n",
    "    num_of_runs = 0\n",
    "\n",
    "    data_transformed_len = len(data_transformed[1])\n",
    "    low, high = 0, data_transformed_len - 1\n",
    "\n",
    "    state_of_first = get_value(data_transformed[1], 0)\n",
    "    state_of_last = get_value(data_transformed[1], data_transformed_len - 1)\n",
    "\n",
    "    if state_of_first == 0 and state_of_last == 0:\n",
    "        return -1, num_of_runs\n",
    "\n",
    "    heuristic_runs = []\n",
    "\n",
    "    previous_mid = -1\n",
    "    while len(probas[low:high]) >= 1:\n",
    "        mid, _ = diffs(probas[low : high + 1], low)\n",
    "        state_of_current = get_value(data_transformed[1], mid)\n",
    "        num_of_runs += 1\n",
    "\n",
    "        if state_of_current == 0 and previous_mid != mid:\n",
    "            low = mid + 1\n",
    "\n",
    "        elif state_of_current == 1 and previous_mid != mid:\n",
    "            high = mid\n",
    "\n",
    "        else:\n",
    "            return num_of_runs, high\n",
    "\n",
    "        previous_mid = mid\n",
    "\n",
    "    heuristic_runs.append(num_of_runs)\n",
    "    return num_of_runs, high\n",
    "\n",
    "\n",
    "# Hit or Miss algorithm\n",
    "def hit_or_miss(data_transformed, probas_and_idxs):\n",
    "    heuristic_runs = 0\n",
    "    dynamic = [-1 for _ in range(len(data_transformed[1]))]\n",
    "\n",
    "    highest_probas = sorted(probas_and_idxs, key=lambda t: t[0], reverse=True)\n",
    "\n",
    "    for _, idx in highest_probas:\n",
    "        if dynamic[idx] != -1:\n",
    "            continue\n",
    "\n",
    "        test_outcome = get_value(data_transformed[1], idx)\n",
    "        heuristic_runs += 1\n",
    "\n",
    "        dynamic[idx] = test_outcome\n",
    "\n",
    "        if test_outcome == 1:\n",
    "            prev_outcome = get_value(data_transformed[1], idx - 1)\n",
    "            heuristic_runs += 1\n",
    "            dynamic[idx - 1] = prev_outcome\n",
    "\n",
    "            if prev_outcome == 0:\n",
    "                return heuristic_runs, idx\n",
    "\n",
    "        for i, val in enumerate(dynamic):\n",
    "            if val == 1 and dynamic[i - 1] == 0:\n",
    "                return heuristic_runs, i\n",
    "\n",
    "    return heuristic_runs, len(data_transformed[1]) - 1\n",
    "\n",
    "\n",
    "# Helper function to caluclate the score for Balanced Intelligent Reduction\n",
    "def get_score(i, low, mid, high, alpha, beta, proba):\n",
    "    proba_factor = alpha * proba\n",
    "    position_factor = 1 - beta * (np.abs(i - mid) / (high - low))\n",
    "    score = proba_factor + position_factor\n",
    "    return score\n",
    "\n",
    "\n",
    "# Balanced Intelligent Reduction algorithm\n",
    "def balanced_intelligent_reduction(transformed, probas, weight, harmonic):\n",
    "    alpha = weight * harmonic\n",
    "    beta = 1 - alpha\n",
    "\n",
    "    dynamic_list = [-1 for _ in range(len(transformed[1]))]\n",
    "    heuristic_runs = 0\n",
    "\n",
    "    high = len(transformed[1]) - 1\n",
    "    low = 0\n",
    "\n",
    "    previous_idx = -1\n",
    "\n",
    "    while len(dynamic_list[low:high]) >= 1:\n",
    "        mid = (high + low) // 2\n",
    "\n",
    "        initial_scores = [\n",
    "            (get_score(i, low, mid, high, alpha, beta, probas[i]), i)\n",
    "            for i in range(low, high + 1)\n",
    "        ]\n",
    "        scores = sorted(initial_scores, key=lambda x: x[0], reverse=True)\n",
    "        idx = scores[0][1]\n",
    "\n",
    "        test_outcome = get_value(transformed[1], idx)\n",
    "        heuristic_runs += 1\n",
    "\n",
    "        dynamic_list[idx] = test_outcome\n",
    "\n",
    "        for i, num in enumerate(dynamic_list):\n",
    "            if num == 1 and dynamic_list[i - 1] == 0:\n",
    "                return heuristic_runs, i\n",
    "\n",
    "        if test_outcome == 1:\n",
    "            high = idx\n",
    "            if previous_idx == idx:\n",
    "                return heuristic_runs, idx\n",
    "            previous_idx = idx\n",
    "\n",
    "        elif test_outcome == 0:\n",
    "            low = idx + 1\n",
    "\n",
    "    return heuristic_runs, idx\n",
    "\n",
    "\n",
    "# Hybrid search algorithm\n",
    "def hybrid_search(commits, probabilities, alpha):\n",
    "    num_of_runs = 0\n",
    "    len_commits = len(commits)\n",
    "    low, high = 0, len_commits - 1\n",
    "\n",
    "    state_of_first = get_value(commits, 0)\n",
    "    state_of_last = get_value(commits, len_commits - 1)\n",
    "\n",
    "    if state_of_first == 0 and state_of_last == 0:\n",
    "        return -1, num_of_runs\n",
    "\n",
    "    while low < high:\n",
    "        binary_mid = (low + high) // 2\n",
    "\n",
    "        # alpha is the weight of the probabilities and adjustable parameter\n",
    "        prob_mid, diffs_ = diffs(probabilities[low : high + 1], low)\n",
    "        new_mid = int(((alpha * prob_mid) + ((1 - alpha) * binary_mid)))\n",
    "\n",
    "        num_of_runs += 1\n",
    "        if commits[new_mid] == 1:\n",
    "            high = new_mid\n",
    "\n",
    "        elif commits[new_mid] == 0:\n",
    "            low = new_mid + 1\n",
    "\n",
    "    return num_of_runs, high"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Run"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Run(\n",
    "    *,\n",
    "    X,\n",
    "    y,\n",
    "    mean_gap_ref,\n",
    "    model,\n",
    "    metric,\n",
    "    comparison=False,\n",
    "    algorithm=\"equilibrium\",\n",
    "    noise_level,\n",
    "    **kwargs,\n",
    "):\n",
    "    \"\"\"\n",
    "    input: model, metric, stats, comparison, algorithm, WBCE_weights, BIR_weight\n",
    "    output: saved_runs, average_score\n",
    "    WBCE_weights: Weights for the weighted binary crossentropy\n",
    "    BIR_weight: Weight for the Balanced Intelligent Reduction\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    algorithms = [\n",
    "        \"equilibrium\",\n",
    "        \"hit_or_miss\",\n",
    "        \"balanced_intelligent_reduction\",\n",
    "        \"hybrid_search\",\n",
    "    ]\n",
    "\n",
    "    scores = []\n",
    "\n",
    "    trained_probas = model.predict_proba(X)[:, 1]\n",
    "    predictions = model.predict(X)\n",
    "\n",
    "    y_transformed, probas, predictions = transform_data(\n",
    "        y, trained_probas, predictions, mean_gap_ref\n",
    "    )\n",
    "    transformation_valid = check_transformation(y_transformed)\n",
    "\n",
    "    binary_runs_list = []\n",
    "    heuristic_runs_list = []\n",
    "    probas = [add_uniform_noise(proba, noise_level=noise_level) for proba in probas]\n",
    "    if not transformation_valid:\n",
    "        raise ValueError(\"Transformation is not valid\")\n",
    "\n",
    "    # add noise to the probabilities\n",
    "\n",
    "    for transformed, (proba, prediction) in zip(\n",
    "        y_transformed, zip(probas, predictions)\n",
    "    ):\n",
    "        # transformed[0] for original data\n",
    "        # transformed[1] for transformed data\n",
    "\n",
    "        binary_runs, binary_result = find_bad_cl(transformed[1])\n",
    "        score = scoring(\n",
    "            y_true=transformed[0], y_pred=prediction, y_pred_proba=proba, metric=metric\n",
    "        )\n",
    "        scores.append(score)\n",
    "\n",
    "        if algorithm in algorithms:\n",
    "            if algorithm == \"equilibrium\":\n",
    "                heuristic_runs, heuristic_result = equilibrium(\n",
    "                    data_transformed=transformed, probas=proba\n",
    "                )\n",
    "\n",
    "            elif algorithm == \"hit_or_miss\":\n",
    "                probas_and_idxs = [(proba[i], i) for i in range(len(proba))]\n",
    "                heuristic_runs, heuristic_result = hit_or_miss(\n",
    "                    data_transformed=transformed, probas_and_idxs=probas_and_idxs\n",
    "                )\n",
    "\n",
    "            elif algorithm == \"balanced_intelligent_reduction\":\n",
    "                heuristic_runs, heuristic_result = balanced_intelligent_reduction(\n",
    "                    transformed=transformed,\n",
    "                    probas=proba,\n",
    "                    weight=kwargs.get(\"BIR_weight\", 0.5),\n",
    "                    harmonic=score,\n",
    "                )\n",
    "            elif algorithm == \"hybrid_search\":\n",
    "                alpha = kwargs.get(\"alpha\", 0.5)\n",
    "                heuristic_runs, heuristic_result = hybrid_search(\n",
    "                    commits=transformed[1], probabilities=proba, alpha=alpha\n",
    "                )\n",
    "        else:\n",
    "            raise ValueError(\n",
    "                f\"Algorithm not found. Choose one of the following: {algorithms}\"\n",
    "            )\n",
    "\n",
    "        try:\n",
    "            if binary_result == heuristic_result:\n",
    "                pass\n",
    "            else:\n",
    "                raise ValueError(\"Results do not match\")\n",
    "        except:\n",
    "            print(\"Error\")\n",
    "            print(\n",
    "                f\"binary_result: {binary_result}, heuristic_result: {heuristic_result}\"\n",
    "            )\n",
    "            print(\n",
    "                f\"binary_runs: {binary_runs}, heuristic_runs: {heuristic_runs}, score: {score}\"\n",
    "            )\n",
    "        binary_runs_list.append(binary_runs)\n",
    "        heuristic_runs_list.append(heuristic_runs)\n",
    "\n",
    "        # 1 by 1 comparison of the results\n",
    "        if comparison:\n",
    "            print(\"-\" * 70)\n",
    "            print(\n",
    "                f\"binary_runs: {binary_runs}, heuristic_runs: {heuristic_runs}, score: {score}\"\n",
    "            )\n",
    "\n",
    "    average_score = np.mean(scores)\n",
    "    saved_runs = (sum(binary_runs_list) - sum(heuristic_runs_list)) / sum(\n",
    "        binary_runs_list\n",
    "    )\n",
    "\n",
    "    return saved_runs, average_score, binary_runs_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main(\n",
    "    *,\n",
    "    n_iterations=18,\n",
    "    stats=True,\n",
    "    metric=\"weighted_binary_cross_entropy\",\n",
    "    algorithm=\"hit_or_miss\",\n",
    "    save_results=True,\n",
    "    **parameters,\n",
    "):\n",
    "\n",
    "    samples = parameters.get(\"samples\", 50000)\n",
    "    features = parameters.get(\"features\", 100)\n",
    "    X, y = make_classification(\n",
    "        n_samples=samples,\n",
    "        n_features=features,\n",
    "        n_redundant=10,\n",
    "        n_informative=parameters.get(\"n_informative\", 50),\n",
    "        n_classes=2,\n",
    "        weights=[0.965, 0.035],\n",
    "        flip_y=0.01,\n",
    "        random_state=42,\n",
    "    )\n",
    "\n",
    "    mean_gap_ref = find_mean_gap(y)\n",
    "\n",
    "    saved_runs_data = []  # list to store the saved_runs for each n iteration\n",
    "    scores_data = []  # list to store the scores for each n iteration\n",
    "    for max_depth in tqdm(\n",
    "        range(1, parameters.get(\"max_depth\", 13)),\n",
    "        desc=\"Max Depth Progress\",\n",
    "        colour=\"green\",\n",
    "    ):\n",
    "\n",
    "        model = RandomForestClassifier(\n",
    "            n_estimators=100,\n",
    "            criterion=\"entropy\",\n",
    "            max_depth=max_depth,\n",
    "            min_samples_split=2,\n",
    "            min_samples_leaf=1,\n",
    "            random_state=42,\n",
    "            n_jobs=8,\n",
    "        )\n",
    "\n",
    "        model.fit(X, y)\n",
    "        avg_saved_runs = []  # Reset the average saved runs for each n iterations\n",
    "        avg_scores = []  # Reset the average scores for each n iterations\n",
    "\n",
    "        noise_level = (25 * np.exp(-0.4 * max_depth)) / 10\n",
    "\n",
    "        for _ in range(n_iterations):\n",
    "            saved_runs, avg_score, binary_runs = Run(\n",
    "                X=X,\n",
    "                y=y,\n",
    "                mean_gap_ref=mean_gap_ref,\n",
    "                model=model,\n",
    "                metric=metric,\n",
    "                comparison=False,\n",
    "                algorithm=algorithm,\n",
    "                noise_level=noise_level,\n",
    "                **parameters,\n",
    "            )\n",
    "\n",
    "            avg_saved_runs.append(saved_runs * 100)\n",
    "            avg_scores.append(avg_score * 100)\n",
    "\n",
    "        saved_runs_data.append(avg_saved_runs)\n",
    "        scores_data.append(avg_scores)\n",
    "        if stats:\n",
    "            print(f\"max_depth: {max_depth}\")\n",
    "            print(f\"score: {(sum(avg_scores) / len(avg_scores)):.2f}%\")\n",
    "            print(f\"saved_runs: {sum(avg_saved_runs) / len(avg_saved_runs):.2f}%\")\n",
    "            print(\"-\" * 70)\n",
    "    if save_results:\n",
    "        # save results using pickle\n",
    "        directory = f\"Paper results/\"\n",
    "        if not os.path.exists(directory):\n",
    "            os.makedirs(directory)\n",
    "\n",
    "        with open(\n",
    "            os.path.join(directory, f\"{algorithm} using {metric}.pkl\"), \"wb\"\n",
    "        ) as f:\n",
    "            pickle.dump({\"scores\": scores_data, \"saved_runs\": saved_runs_data}, f)\n",
    "\n",
    "    return saved_runs_data, scores_data, binary_runs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Max Depth Progress: 100%|\u001b[32m██████████\u001b[0m| 1/1 [00:22<00:00, 22.62s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max_depth: 1\n",
      "score: 0.75%\n",
      "saved_runs: -4497.68%\n",
      "----------------------------------------------------------------------\n",
      "         4146753 function calls (4134073 primitive calls) in 22.859 seconds\n",
      "\n",
      "   Ordered by: standard name\n",
      "\n",
      "   ncalls  tottime  percall  cumtime  percall filename:lineno(function)\n",
      "       18    0.030    0.002   21.548    1.197 1806065167.py:1(Run)\n",
      "       18    0.000    0.000    0.079    0.004 1806065167.py:40(<listcomp>)\n",
      "     1381    0.074    0.000    0.074    0.000 1806065167.py:63(<listcomp>)\n",
      "     1381    0.006    0.000    0.009    0.000 3060019757.py:2(find_bad_cl)\n",
      "     1381   18.923    0.014   19.222    0.014 3060019757.py:79(hit_or_miss)\n",
      "     1381    0.019    0.000    0.019    0.000 3060019757.py:81(<listcomp>)\n",
      "   855934    0.046    0.000    0.046    0.000 3060019757.py:83(<lambda>)\n",
      "        1    0.002    0.002   22.859   22.859 3943478207.py:1(main)\n",
      "       18    0.029    0.002    0.098    0.005 4016118467.py:105(transform_data)\n",
      "       18    0.000    0.000    0.007    0.000 4016118467.py:167(check_transformation)\n",
      "   604385    0.068    0.000    0.068    0.000 4016118467.py:2(get_value)\n",
      "     1381    0.024    0.000    0.058    0.000 4016118467.py:30(weighted_bce_loss)\n",
      "     1381    0.005    0.000    0.880    0.001 4016118467.py:48(scoring)\n",
      "     1381    0.004    0.000    0.079    0.000 4016118467.py:7(add_uniform_noise)\n",
      "     1381    0.001    0.000    0.058    0.000 4016118467.py:72(<lambda>)\n",
      "        1    0.000    0.000    0.000    0.000 4016118467.py:95(find_mean_gap)\n",
      "     2762    0.001    0.000    0.013    0.000 <__array_function__ internals>:177(all)\n",
      "       18    0.000    0.000    0.003    0.000 <__array_function__ internals>:177(argmax)\n",
      "       38    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(atleast_1d)\n",
      "     5524    0.002    0.000    0.006    0.000 <__array_function__ internals>:177(can_cast)\n",
      "     1381    0.001    0.000    0.020    0.000 <__array_function__ internals>:177(clip)\n",
      "     1384    0.001    0.000    0.004    0.000 <__array_function__ internals>:177(concatenate)\n",
      "        1    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(copy)\n",
      "     5560    0.003    0.000    0.007    0.000 <__array_function__ internals>:177(copyto)\n",
      "       37    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(cumsum)\n",
      "     4143    0.001    0.000    0.022    0.000 <__array_function__ internals>:177(delete)\n",
      "        1    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(diff)\n",
      "        5    0.000    0.000    0.029    0.006 <__array_function__ internals>:177(dot)\n",
      "        1    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(hstack)\n",
      "       19    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(mean)\n",
      "     1381    0.001    0.000    0.004    0.000 <__array_function__ internals>:177(nan_to_num)\n",
      "     4143    0.002    0.000    0.006    0.000 <__array_function__ internals>:177(ndim)\n",
      "        2    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(prod)\n",
      "     2763    0.001    0.000    0.007    0.000 <__array_function__ internals>:177(reshape)\n",
      "     2799    0.001    0.000    0.049    0.000 <__array_function__ internals>:177(sum)\n",
      "     1381    0.001    0.000    0.022    0.000 <__array_function__ internals>:177(union1d)\n",
      "    12433    0.006    0.000    0.109    0.000 <__array_function__ internals>:177(unique)\n",
      "        1    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(unpackbits)\n",
      "     2781    0.001    0.000    0.003    0.000 <__array_function__ internals>:177(where)\n",
      "    16850    0.003    0.000    0.010    0.000 <frozen abc>:117(__instancecheck__)\n",
      "     6990    0.001    0.000    0.003    0.000 <frozen abc>:121(__subclasscheck__)\n",
      "        1    0.000    0.000    0.000    0.000 <frozen genericpath>:16(exists)\n",
      "      296    0.000    0.000    0.000    0.000 <frozen importlib._bootstrap>:1207(_handle_fromlist)\n",
      "     4700    0.002    0.000    0.003    0.000 <frozen importlib._bootstrap>:405(parent)\n",
      "        1    0.000    0.000    0.000    0.000 <frozen os>:674(__getitem__)\n",
      "        1    0.000    0.000    0.000    0.000 <frozen os>:756(encode)\n",
      "        1    0.000    0.000    0.000    0.000 <frozen posixpath>:41(_get_sep)\n",
      "        1    0.000    0.000    0.000    0.000 <frozen posixpath>:71(join)\n",
      "        1    0.001    0.001   22.860   22.860 <string>:1(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 __init__.py:144(_DType_reduce)\n",
      "      296    0.000    0.000    0.003    0.000 __init__.py:36(__init__)\n",
      "      296    0.000    0.000    0.012    0.000 __init__.py:43(start)\n",
      "       74    0.000    0.000    0.001    0.000 __init__.py:7(_make_name)\n",
      "    18030    0.009    0.000    0.016    0.000 _array_api.py:177(_is_numpy_namespace)\n",
      "     1381    0.001    0.000    0.025    0.000 _array_api.py:182(_union1d)\n",
      "     5599    0.003    0.000    0.027    0.000 _array_api.py:189(isdtype)\n",
      "       75    0.000    0.000    0.000    0.000 _array_api.py:196(<genexpr>)\n",
      "5674/5600    0.004    0.000    0.024    0.000 _array_api.py:201(_isdtype_single)\n",
      "      111    0.000    0.000    0.000    0.000 _array_api.py:210(<genexpr>)\n",
      "     5562    0.007    0.000    0.019    0.000 _array_api.py:235(supported_float_dtypes)\n",
      "    22173    0.002    0.000    0.002    0.000 _array_api.py:306(_check_device_cpu)\n",
      "    40650    0.014    0.000    0.018    0.000 _array_api.py:372(__getattr__)\n",
      "    22173    0.009    0.000    0.014    0.000 _array_api.py:392(asarray)\n",
      "     8287    0.003    0.000    0.070    0.000 _array_api.py:406(unique_values)\n",
      "     2762    0.002    0.000    0.009    0.000 _array_api.py:412(reshape)\n",
      "     5599    0.002    0.000    0.029    0.000 _array_api.py:427(isdtype)\n",
      "    51220    0.016    0.000    0.049    0.000 _array_api.py:473(get_namespace)\n",
      "    16612    0.016    0.000    0.136    0.000 _array_api.py:730(_asarray_with_order)\n",
      "     1383    0.000    0.000    0.000    0.000 _array_api.py:84(_check_array_api_dispatch)\n",
      "     1381    0.001    0.000    0.001    0.000 _base.py:107(__init__)\n",
      "        1    0.000    0.000    0.000    0.000 _base.py:112(__init__)\n",
      "     1381    0.001    0.000    0.002    0.000 _base.py:1276(_process_toarray_args)\n",
      "     2762    0.005    0.000    0.046    0.000 _base.py:1289(_get_index_dtype)\n",
      "        1    0.000    0.000    0.000    0.000 _base.py:129(_validate_estimator)\n",
      "      100    0.000    0.000    0.052    0.001 _base.py:139(_make_estimator)\n",
      "      100    0.000    0.000    0.000    0.000 _base.py:146(<dictcomp>)\n",
      "    47080    0.008    0.000    0.011    0.000 _base.py:1483(issparse)\n",
      "       36    0.000    0.000    0.002    0.000 _base.py:169(_partition_estimators)\n",
      "     2762    0.001    0.000    0.004    0.000 _base.py:285(nnz)\n",
      "      100    0.001    0.000    0.020    0.000 _base.py:44(_set_random_states)\n",
      "       37    0.000    0.000    0.000    0.000 _classes.py:1082(_more_tags)\n",
      "      102    0.000    0.000    0.000    0.000 _classes.py:127(__init__)\n",
      "       37    0.000    0.000    0.001    0.000 _classes.py:184(_support_missing_values)\n",
      "        1    0.000    0.000    0.003    0.003 _classes.py:191(_compute_missing_values_in_feature_mask)\n",
      "      102    0.000    0.000    0.000    0.000 _classes.py:945(__init__)\n",
      "     1381    0.017    0.000    0.678    0.000 _classification.py:247(confusion_matrix)\n",
      "     1381    0.007    0.000    0.301    0.000 _classification.py:75(_check_targets)\n",
      "     2766    0.002    0.000    0.009    0.000 _config.py:211(config_context)\n",
      "    56827    0.010    0.000    0.016    0.000 _config.py:24(_get_threadlocal_config)\n",
      "    54061    0.017    0.000    0.037    0.000 _config.py:32(get_config)\n",
      "     2766    0.004    0.000    0.006    0.000 _config.py:57(set_config)\n",
      "     2762    0.002    0.000    0.003    0.000 _coo.py:144(_getnnz)\n",
      "     1381    0.010    0.000    0.033    0.000 _coo.py:170(_check)\n",
      "     1381    0.003    0.000    0.011    0.000 _coo.py:224(toarray)\n",
      "     1381    0.007    0.000    0.088    0.000 _coo.py:25(__init__)\n",
      "     1381    0.001    0.000    0.001    0.000 _data.py:20(__init__)\n",
      "     1381    0.000    0.000    0.000    0.000 _data.py:23(dtype)\n",
      "        1    0.000    0.000    0.000    0.000 _forest.py:1494(__init__)\n",
      "        1    0.000    0.000    0.000    0.000 _forest.py:234(__init__)\n",
      "        1    0.000    0.000    1.067    1.067 _forest.py:331(fit)\n",
      "        1    0.000    0.000    0.052    0.052 _forest.py:478(<listcomp>)\n",
      "       16    0.000    0.000    0.000    0.000 _forest.py:493(<genexpr>)\n",
      "       36    0.000    0.000    0.113    0.003 _forest.py:632(_validate_X_predict)\n",
      "        1    0.000    0.000    0.000    0.000 _forest.py:748(__init__)\n",
      "        1    0.000    0.000    0.003    0.003 _forest.py:830(_validate_y_class_weight)\n",
      "       18    0.005    0.000    0.575    0.032 _forest.py:883(predict)\n",
      "       36    0.002    0.000    1.138    0.032 _forest.py:922(predict_proba)\n",
      "        1    0.000    0.000    0.000    0.000 _forest.py:95(_get_n_samples_bootstrap)\n",
      "       36    0.000    0.000    0.001    0.000 _forest.py:952(<listcomp>)\n",
      "      576    0.000    0.000    0.004    0.000 _forest.py:957(<genexpr>)\n",
      "        2    0.000    0.000    0.025    0.012 _indexing.py:176(_safe_indexing)\n",
      "        2    0.025    0.012    0.025    0.012 _indexing.py:24(_array_indexing)\n",
      "        1    0.000    0.000    0.025    0.025 _indexing.py:408(resample)\n",
      "        1    0.000    0.000    0.000    0.000 _indexing.py:558(<listcomp>)\n",
      "        1    0.000    0.000    0.025    0.025 _indexing.py:559(<listcomp>)\n",
      "        1    0.000    0.000    0.025    0.025 _indexing.py:567(shuffle)\n",
      "        2    0.000    0.000    0.000    0.000 _indexing.py:92(_determine_key_type)\n",
      "     8286    0.001    0.000    0.001    0.000 _matrix.py:64(get_shape)\n",
      "     2762    0.001    0.000    0.001    0.000 _methods.py:102(_clip_dep_is_byte_swapped)\n",
      "     1381    0.003    0.000    0.003    0.000 _methods.py:107(_clip_dep_invoke_with_casting)\n",
      "     1381    0.002    0.000    0.016    0.000 _methods.py:126(_clip)\n",
      "       19    0.000    0.000    0.000    0.000 _methods.py:163(_mean)\n",
      "     5524    0.001    0.000    0.007    0.000 _methods.py:38(_amax)\n",
      "     8286    0.002    0.000    0.009    0.000 _methods.py:42(_amin)\n",
      "        1    0.000    0.000    0.000    0.000 _methods.py:46(_sum)\n",
      "        1    0.000    0.000    0.000    0.000 _methods.py:50(_prod)\n",
      "       19    0.000    0.000    0.000    0.000 _methods.py:66(_count_reduce_items)\n",
      "     2762    0.005    0.000    0.009    0.000 _methods.py:92(_clip_dep_is_scalar_nan)\n",
      "        1    0.000    0.000    0.000    0.000 _monitor.py:94(report)\n",
      "      592    0.000    0.000    0.001    0.000 _parallel_backends.py:124(get_nested_backend)\n",
      "       74    0.000    0.000    0.000    0.000 _parallel_backends.py:137(retrieval_context)\n",
      "       36    0.000    0.000    0.000    0.000 _parallel_backends.py:185(in_main_thread)\n",
      "       37    0.000    0.000    0.000    0.000 _parallel_backends.py:227(effective_n_jobs)\n",
      "       37    0.001    0.000    0.015    0.000 _parallel_backends.py:239(terminate)\n",
      "      592    0.000    0.000    0.031    0.000 _parallel_backends.py:250(apply_async)\n",
      "       73    0.000    0.000    0.000    0.000 _parallel_backends.py:280(__init__)\n",
      "      702    0.000    0.000    0.000    0.000 _parallel_backends.py:34(__init__)\n",
      "       37    0.000    0.000    0.000    0.000 _parallel_backends.py:389(configure)\n",
      "      592    0.000    0.000    0.027    0.000 _parallel_backends.py:400(_get_pool)\n",
      "       36    0.000    0.000    0.000    0.000 _parallel_backends.py:513(effective_n_jobs)\n",
      "      592    0.000    0.000    0.000    0.000 _parallel_backends.py:615(__init__)\n",
      "       37    0.000    0.000    0.000    0.000 _parallel_backends.py:80(start_call)\n",
      "       37    0.000    0.000    0.000    0.000 _parallel_backends.py:83(stop_call)\n",
      "      629    0.000    0.000    0.000    0.000 _parallel_backends.py:89(compute_batch_size)\n",
      "11104/11103    0.007    0.000    0.010    0.000 _param_validation.py:101(make_constraint)\n",
      "1383/1382    0.010    0.000    1.055    0.001 _param_validation.py:182(wrapper)\n",
      "     1382    0.002    0.000    0.002    0.000 _param_validation.py:195(<listcomp>)\n",
      "     1382    0.001    0.000    0.001    0.000 _param_validation.py:201(<dictcomp>)\n",
      "     1383    0.007    0.000    0.035    0.000 _param_validation.py:25(validate_parameter_constraints)\n",
      "     9713    0.001    0.000    0.001    0.000 _param_validation.py:259(__init__)\n",
      "       18    0.000    0.000    0.000    0.000 _param_validation.py:291(__init__)\n",
      "        8    0.000    0.000    0.000    0.000 _param_validation.py:295(is_satisfied_by)\n",
      "     4147    0.000    0.000    0.000    0.000 _param_validation.py:305(is_satisfied_by)\n",
      "     1384    0.000    0.000    0.000    0.000 _param_validation.py:363(is_satisfied_by)\n",
      "        3    0.000    0.000    0.000    0.000 _param_validation.py:433(__init__)\n",
      "        3    0.000    0.000    0.000    0.000 _param_validation.py:442(_check_params)\n",
      "       21    0.000    0.000    0.000    0.000 _param_validation.py:481(__contains__)\n",
      "       24    0.000    0.000    0.000    0.000 _param_validation.py:497(is_satisfied_by)\n",
      "     5526    0.001    0.000    0.014    0.000 _param_validation.py:525(is_satisfied_by)\n",
      "        2    0.000    0.000    0.000    0.000 _param_validation.py:559(__init__)\n",
      "        2    0.000    0.000    0.000    0.000 _param_validation.py:567(is_satisfied_by)\n",
      "        4    0.000    0.000    0.000    0.000 _param_validation.py:568(<genexpr>)\n",
      "        5    0.000    0.000    0.000    0.000 _param_validation.py:584(__init__)\n",
      "        5    0.000    0.000    0.000    0.000 _param_validation.py:591(is_satisfied_by)\n",
      "       10    0.000    0.000    0.000    0.000 _param_validation.py:592(<genexpr>)\n",
      "        1    0.000    0.000    0.000    0.000 _param_validation.py:608(__init__)\n",
      "        1    0.000    0.000    0.000    0.000 _param_validation.py:616(is_satisfied_by)\n",
      "        2    0.000    0.000    0.000    0.000 _param_validation.py:617(<genexpr>)\n",
      "     6939    0.003    0.000    0.013    0.000 _param_validation.py:72(<listcomp>)\n",
      "        1    0.000    0.000    0.000    0.000 _samples_generator.py:245(<listcomp>)\n",
      "      2/1    0.000    0.000    0.000    0.000 _samples_generator.py:26(_generate_hypercube)\n",
      "        1    0.058    0.058    0.237    0.237 _samples_generator.py:42(make_classification)\n",
      "     1381    0.001    0.000    0.001    0.000 _sputils.py:110(getdtype)\n",
      "     1381    0.001    0.000    0.002    0.000 _sputils.py:136(getdata)\n",
      "     2762    0.014    0.000    0.039    0.000 _sputils.py:148(get_index_dtype)\n",
      "     1381    0.001    0.000    0.002    0.000 _sputils.py:217(isintlike)\n",
      "     1381    0.001    0.000    0.003    0.000 _sputils.py:239(isshape)\n",
      "     1381    0.003    0.000    0.005    0.000 _sputils.py:295(check_shape)\n",
      "     4143    0.001    0.000    0.001    0.000 _sputils.py:308(<genexpr>)\n",
      "     4143    0.001    0.000    0.001    0.000 _sputils.py:313(<genexpr>)\n",
      "     1381    0.000    0.000    0.000    0.000 _sputils.py:94(to_native)\n",
      "     2840    0.003    0.000    0.003    0.000 _ufunc_config.py:131(geterr)\n",
      "     2840    0.004    0.000    0.008    0.000 _ufunc_config.py:32(seterr)\n",
      "     1418    0.000    0.000    0.000    0.000 _ufunc_config.py:425(__init__)\n",
      "     1420    0.001    0.000    0.006    0.000 _ufunc_config.py:429(__enter__)\n",
      "     1420    0.001    0.000    0.004    0.000 _ufunc_config.py:434(__exit__)\n",
      "       37    0.000    0.000    0.001    0.000 _utils.py:19(eval_expr)\n",
      "   111/37    0.000    0.000    0.000    0.000 _utils.py:36(eval_)\n",
      "        1    0.000    0.000    0.000    0.000 _weakrefset.py:110(remove)\n",
      "        2    0.000    0.000    0.000    0.000 _weakrefset.py:17(__init__)\n",
      "        2    0.000    0.000    0.000    0.000 _weakrefset.py:21(__enter__)\n",
      "        2    0.000    0.000    0.000    0.000 _weakrefset.py:27(__exit__)\n",
      "      271    0.000    0.000    0.000    0.000 _weakrefset.py:39(_remove)\n",
      "        2    0.000    0.000    0.000    0.000 _weakrefset.py:53(_commit_removals)\n",
      "        3    0.000    0.000    0.000    0.000 _weakrefset.py:63(__iter__)\n",
      "      408    0.000    0.000    0.000    0.000 _weakrefset.py:85(add)\n",
      "    12433    0.003    0.000    0.004    0.000 arraysetops.py:125(_unpack_tuple)\n",
      "    12433    0.001    0.000    0.001    0.000 arraysetops.py:133(_unique_dispatcher)\n",
      "    12433    0.010    0.000    0.096    0.000 arraysetops.py:138(unique)\n",
      "    12433    0.042    0.000    0.079    0.000 arraysetops.py:323(_unique1d)\n",
      "     1381    0.000    0.000    0.000    0.000 arraysetops.py:743(_union1d_dispatcher)\n",
      "     1381    0.001    0.000    0.021    0.000 arraysetops.py:747(union1d)\n",
      "       37    0.000    0.000    0.001    0.000 ast.py:33(parse)\n",
      "       74    0.000    0.000    0.000    0.000 ast.py:516(_getter)\n",
      "      111    0.000    0.000    0.000    0.000 ast.py:531(__instancecheck__)\n",
      "       74    0.000    0.000    0.000    0.000 base.py:1347(_more_tags)\n",
      "        1    0.000    0.000    1.068    1.068 base.py:1456(wrapper)\n",
      "      501    0.003    0.000    0.040    0.000 base.py:196(_get_param_names)\n",
      "      501    0.003    0.000    0.004    0.000 base.py:210(<listcomp>)\n",
      "      501    0.001    0.000    0.002    0.000 base.py:225(<listcomp>)\n",
      "      501    0.002    0.000    0.044    0.000 base.py:227(get_params)\n",
      "      200    0.001    0.000    0.018    0.000 base.py:251(set_params)\n",
      "      100    0.000    0.000    0.022    0.000 base.py:295(__sklearn_clone__)\n",
      "       37    0.000    0.000    0.000    0.000 base.py:388(_more_tags)\n",
      "       37    0.000    0.000    0.000    0.000 base.py:391(_get_tags)\n",
      " 1400/100    0.001    0.000    0.022    0.000 base.py:40(clone)\n",
      "       37    0.000    0.000    0.000    0.000 base.py:402(_check_n_features)\n",
      "       37    0.000    0.000    0.000    0.000 base.py:448(_check_feature_names)\n",
      "       37    0.000    0.000    0.116    0.003 base.py:537(_validate_data)\n",
      "        1    0.000    0.000    0.001    0.001 base.py:658(_validate_params)\n",
      "       37    0.000    0.000    0.000    0.000 base.py:766(_more_tags)\n",
      " 1400/100    0.002    0.000    0.022    0.000 base.py:94(_clone_parametrized)\n",
      "       74    0.000    0.000    0.000    0.000 connection.py:117(__init__)\n",
      "       74    0.000    0.000    0.000    0.000 connection.py:130(__del__)\n",
      "      111    0.000    0.000    0.000    0.000 connection.py:134(_check_closed)\n",
      "      111    0.000    0.000    0.000    0.000 connection.py:142(_check_writable)\n",
      "      111    0.000    0.000    0.001    0.000 connection.py:181(send_bytes)\n",
      "       74    0.000    0.000    0.000    0.000 connection.py:359(_close)\n",
      "      111    0.000    0.000    0.000    0.000 connection.py:364(_send)\n",
      "      111    0.000    0.000    0.001    0.000 connection.py:389(_send_bytes)\n",
      "       37    0.000    0.000    0.001    0.000 connection.py:515(Pipe)\n",
      "       37    0.000    0.000    0.004    0.000 context.py:110(SimpleQueue)\n",
      "      111    0.000    0.000    0.000    0.000 context.py:187(get_context)\n",
      "       74    0.000    0.000    0.000    0.000 context.py:197(get_start_method)\n",
      "       74    0.000    0.000    0.000    0.000 context.py:237(get_context)\n",
      "       74    0.000    0.000    0.003    0.000 context.py:65(Lock)\n",
      "     1420    0.002    0.000    0.002    0.000 contextlib.py:104(__init__)\n",
      "     1420    0.001    0.000    0.004    0.000 contextlib.py:132(__enter__)\n",
      "     1420    0.001    0.000    0.007    0.000 contextlib.py:141(__exit__)\n",
      "     1420    0.001    0.000    0.003    0.000 contextlib.py:287(helper)\n",
      "        2    0.000    0.000    0.000    0.000 contextlib.py:65(_recreate_cm)\n",
      "        2    0.000    0.000    0.000    0.000 contextlib.py:78(inner)\n",
      "     1300    0.001    0.000    0.002    0.000 copy.py:128(deepcopy)\n",
      "     1300    0.000    0.000    0.000    0.000 copy.py:182(_deepcopy_atomic)\n",
      "       37    0.000    0.000    0.000    0.000 disk.py:42(memstr_to_bytes)\n",
      "    13940    0.002    0.000    0.002    0.000 enum.py:1091(__new__)\n",
      "    13940    0.005    0.000    0.007    0.000 enum.py:685(__call__)\n",
      "       18    0.000    0.000    0.000    0.000 fromnumeric.py:1123(_argmax_dispatcher)\n",
      "       18    0.000    0.000    0.003    0.000 fromnumeric.py:1127(argmax)\n",
      "     2763    0.000    0.000    0.000    0.000 fromnumeric.py:193(_reshape_dispatcher)\n",
      "     2763    0.001    0.000    0.004    0.000 fromnumeric.py:198(reshape)\n",
      "     1381    0.000    0.000    0.000    0.000 fromnumeric.py:2081(_clip_dispatcher)\n",
      "     1381    0.001    0.000    0.019    0.000 fromnumeric.py:2085(clip)\n",
      "     2799    0.000    0.000    0.000    0.000 fromnumeric.py:2157(_sum_dispatcher)\n",
      "     2799    0.002    0.000    0.046    0.000 fromnumeric.py:2162(sum)\n",
      "     2762    0.000    0.000    0.000    0.000 fromnumeric.py:2401(_all_dispatcher)\n",
      "     2762    0.002    0.000    0.010    0.000 fromnumeric.py:2406(all)\n",
      "       37    0.000    0.000    0.000    0.000 fromnumeric.py:2493(_cumsum_dispatcher)\n",
      "       37    0.000    0.000    0.000    0.000 fromnumeric.py:2497(cumsum)\n",
      "        2    0.000    0.000    0.000    0.000 fromnumeric.py:2922(_prod_dispatcher)\n",
      "        2    0.000    0.000    0.000    0.000 fromnumeric.py:2927(prod)\n",
      "     4143    0.000    0.000    0.000    0.000 fromnumeric.py:3117(_ndim_dispatcher)\n",
      "     4143    0.002    0.000    0.003    0.000 fromnumeric.py:3121(ndim)\n",
      "       19    0.000    0.000    0.000    0.000 fromnumeric.py:3308(_mean_dispatcher)\n",
      "       19    0.000    0.000    0.000    0.000 fromnumeric.py:3313(mean)\n",
      "     4199    0.002    0.000    0.024    0.000 fromnumeric.py:51(_wrapfunc)\n",
      "     5563    0.006    0.000    0.052    0.000 fromnumeric.py:69(_wrapreduction)\n",
      "     5563    0.002    0.000    0.002    0.000 fromnumeric.py:70(<dictcomp>)\n",
      "        1    0.000    0.000    0.000    0.000 function_base.py:1315(_diff_dispatcher)\n",
      "        1    0.000    0.000    0.000    0.000 function_base.py:1319(diff)\n",
      "     4143    0.000    0.000    0.000    0.000 function_base.py:4995(_delete_dispatcher)\n",
      "     4143    0.012    0.000    0.019    0.000 function_base.py:4999(delete)\n",
      "        1    0.000    0.000    0.000    0.000 function_base.py:866(_copy_dispatcher)\n",
      "        1    0.000    0.000    0.000    0.000 function_base.py:870(copy)\n",
      "     1184    0.002    0.000    0.003    0.000 functools.py:35(update_wrapper)\n",
      "      592    0.000    0.000    0.000    0.000 functools.py:65(wraps)\n",
      "     5624    0.004    0.000    0.004    0.000 getlimits.py:648(__init__)\n",
      "     2762    0.001    0.000    0.001    0.000 getlimits.py:659(min)\n",
      "     2862    0.001    0.000    0.001    0.000 getlimits.py:672(max)\n",
      "     1883    0.002    0.000    0.003    0.000 inspect.py:167(get_annotations)\n",
      "     1883    0.020    0.000    0.064    0.000 inspect.py:2333(_signature_from_function)\n",
      "     1883    0.009    0.000    0.077    0.000 inspect.py:2428(_signature_from_callable)\n",
      "    13940    0.017    0.000    0.027    0.000 inspect.py:2686(__init__)\n",
      "    38543    0.003    0.000    0.003    0.000 inspect.py:2739(name)\n",
      "    13831    0.001    0.000    0.001    0.000 inspect.py:2743(default)\n",
      "    40720    0.003    0.000    0.003    0.000 inspect.py:2751(kind)\n",
      "     1382    0.000    0.000    0.000    0.000 inspect.py:2831(__init__)\n",
      "     1382    0.005    0.000    0.007    0.000 inspect.py:2892(apply_defaults)\n",
      "      172    0.000    0.000    0.000    0.000 inspect.py:292(isclass)\n",
      "     1883    0.005    0.000    0.010    0.000 inspect.py:2972(__init__)\n",
      "    15823    0.004    0.000    0.005    0.000 inspect.py:3019(<genexpr>)\n",
      "     1883    0.001    0.000    0.079    0.000 inspect.py:3024(from_callable)\n",
      "     4647    0.000    0.000    0.000    0.000 inspect.py:3032(parameters)\n",
      "     1382    0.013    0.000    0.018    0.000 inspect.py:3076(_bind)\n",
      "     1382    0.001    0.000    0.019    0.000 inspect.py:3207(bind)\n",
      "     1883    0.002    0.000    0.080    0.000 inspect.py:3278(signature)\n",
      "     3766    0.001    0.000    0.001    0.000 inspect.py:378(isfunction)\n",
      "       37    0.000    0.000    0.000    0.000 inspect.py:729(getmro)\n",
      "     1883    0.002    0.000    0.003    0.000 inspect.py:735(unwrap)\n",
      "     1883    0.000    0.000    0.001    0.000 inspect.py:755(_is_wrapper)\n",
      "        1    0.000    0.000    0.000    0.000 interactiveshell.py:301(_modified_open)\n",
      "       15    0.000    0.000    0.000    0.000 iostream.py:137(_event_pipe)\n",
      "       15    0.000    0.000    0.000    0.000 iostream.py:258(schedule)\n",
      "        1    0.000    0.000    0.000    0.000 iostream.py:363(fileno)\n",
      "       13    0.000    0.000    0.000    0.000 iostream.py:519(_is_master_process)\n",
      "       13    0.000    0.000    0.000    0.000 iostream.py:546(_schedule_flush)\n",
      "        5    0.000    0.000    0.001    0.000 iostream.py:561(flush)\n",
      "       13    0.000    0.000    0.000    0.000 iostream.py:624(write)\n",
      "       37    0.000    0.000    0.000    0.000 logger.py:23(_squeeze_time)\n",
      "       37    0.000    0.000    0.000    0.000 logger.py:39(short_format_time)\n",
      "     5560    0.000    0.000    0.000    0.000 multiarray.py:1071(copyto)\n",
      "        1    0.000    0.000    0.000    0.000 multiarray.py:1209(unpackbits)\n",
      "     1384    0.000    0.000    0.000    0.000 multiarray.py:148(concatenate)\n",
      "     2781    0.000    0.000    0.000    0.000 multiarray.py:341(where)\n",
      "     5524    0.000    0.000    0.000    0.000 multiarray.py:498(can_cast)\n",
      "        5    0.000    0.000    0.000    0.000 multiarray.py:736(dot)\n",
      "     6905    0.003    0.000    0.003    0.000 multiclass.py:111(<genexpr>)\n",
      "     4143    0.001    0.000    0.001    0.000 multiclass.py:113(<genexpr>)\n",
      "     5525    0.015    0.000    0.114    0.000 multiclass.py:126(is_multilabel)\n",
      "     2762    0.002    0.000    0.027    0.000 multiclass.py:19(_unique_multiclass)\n",
      "        1    0.000    0.000    0.001    0.001 multiclass.py:199(check_classification_targets)\n",
      "     5525    0.032    0.000    0.326    0.000 multiclass.py:226(type_of_target)\n",
      "     1381    0.009    0.000    0.199    0.000 multiclass.py:41(unique_labels)\n",
      "     4143    0.001    0.000    0.154    0.000 multiclass.py:78(<genexpr>)\n",
      "     5524    0.003    0.000    0.011    0.000 numeric.py:149(ones)\n",
      "     2763    0.003    0.000    0.005    0.000 numeric.py:1873(isscalar)\n",
      "       36    0.000    0.000    0.000    0.000 numeric.py:289(full)\n",
      "     5524    0.002    0.000    0.002    0.000 numerictypes.py:282(issubclass_)\n",
      "     2762    0.002    0.000    0.005    0.000 numerictypes.py:356(issubdtype)\n",
      "       37    0.001    0.000    2.023    0.055 parallel.py:1000(__call__)\n",
      "      592    0.000    0.000    0.002    0.000 parallel.py:104(delayed_function)\n",
      "      592    0.000    0.000    0.002    0.000 parallel.py:114(__init__)\n",
      "      592    0.000    0.000    0.000    0.000 parallel.py:118(with_config)\n",
      "      592    0.000    0.000    0.000    0.000 parallel.py:21(_with_config)\n",
      "      592    0.000    0.000    0.000    0.000 parallel.py:271(__init__)\n",
      "     1776    0.000    0.000    0.000    0.000 parallel.py:301(__len__)\n",
      "      592    0.000    0.000    0.000    0.000 parallel.py:371(__init__)\n",
      "       36    0.000    0.000    0.001    0.000 parallel.py:411(effective_n_jobs)\n",
      "       37    0.000    0.000    2.023    0.055 parallel.py:51(__call__)\n",
      "       37    0.000    0.000    0.002    0.000 parallel.py:669(__init__)\n",
      "      592    0.000    0.000    0.005    0.000 parallel.py:70(<genexpr>)\n",
      "       37    0.000    0.000    0.000    0.000 parallel.py:772(_initialize_backend)\n",
      "      592    0.000    0.000    0.002    0.000 parallel.py:78(delayed)\n",
      "       37    0.000    0.000    0.015    0.000 parallel.py:797(_terminate_backend)\n",
      "      592    0.001    0.000    0.032    0.000 parallel.py:801(_dispatch)\n",
      "      629    0.002    0.000    0.044    0.000 parallel.py:838(dispatch_one_batch)\n",
      "       73    0.000    0.000    0.001    0.000 parallel.py:89(get_active_backend)\n",
      "       74    0.000    0.000    0.000    0.000 parallel.py:904(_print)\n",
      "       37    0.025    0.001    1.962    0.053 parallel.py:960(retrieve)\n",
      "       37    0.000    0.000    0.000    0.000 pool.py:157(__init__)\n",
      "       37    0.001    0.000    0.027    0.001 pool.py:183(__init__)\n",
      "       37    0.000    0.000    0.000    0.000 pool.py:266(__del__)\n",
      "       37    0.000    0.000    0.017    0.000 pool.py:305(_repopulate_pool)\n",
      "       37    0.001    0.000    0.017    0.000 pool.py:314(_repopulate_pool_static)\n",
      "      592    0.000    0.000    0.000    0.000 pool.py:351(_check_running)\n",
      "      592    0.001    0.000    0.003    0.000 pool.py:453(apply_async)\n",
      "       37    0.000    0.000    0.001    0.000 pool.py:647(close)\n",
      "       37    0.000    0.000    0.011    0.000 pool.py:654(terminate)\n",
      "       37    0.000    0.000    0.010    0.000 pool.py:680(_terminate_pool)\n",
      "      592    0.001    0.000    0.002    0.000 pool.py:747(__init__)\n",
      "     3700    0.003    0.000    0.004    0.000 pool.py:756(ready)\n",
      "     3700    0.004    0.000    1.920    0.001 pool.py:764(wait)\n",
      "     3700    0.007    0.000    1.931    0.001 pool.py:767(get)\n",
      "      296    0.001    0.000    0.004    0.000 pool.py:924(Process)\n",
      "       37    0.000    0.000    0.027    0.001 pool.py:929(__init__)\n",
      "       37    0.000    0.000    0.000    0.000 pool.py:932(_setup_queues)\n",
      "       37    0.000    0.000    0.000    0.000 pool.py:938(_get_sentinels)\n",
      "       37    0.000    0.000    0.000    0.000 pool.py:945(_help_stuff_finish)\n",
      "       36    0.000    0.000    0.000    0.000 process.py:198(daemon)\n",
      "       36    0.000    0.000    0.000    0.000 process.py:37(current_process)\n",
      "      592    0.001    0.000    0.002    0.000 queue.py:122(put)\n",
      "      703    0.001    0.000    0.002    0.000 queue.py:154(get)\n",
      "       37    0.000    0.000    0.000    0.000 queue.py:206(_init)\n",
      "      703    0.000    0.000    0.000    0.000 queue.py:209(_qsize)\n",
      "      592    0.000    0.000    0.000    0.000 queue.py:213(_put)\n",
      "      592    0.000    0.000    0.000    0.000 queue.py:217(_get)\n",
      "       37    0.000    0.000    0.000    0.000 queue.py:34(__init__)\n",
      "       37    0.000    0.000    0.004    0.000 queues.py:339(__init__)\n",
      "      111    0.000    0.000    0.002    0.000 queues.py:369(put)\n",
      "       74    0.000    0.000    0.000    0.000 random.py:480(choices)\n",
      "       74    0.000    0.000    0.000    0.000 random.py:493(<listcomp>)\n",
      "        2    0.000    0.000    0.000    0.000 random.py:800(getrandbits)\n",
      "      111    0.000    0.000    0.000    0.000 reduction.py:38(__init__)\n",
      "      111    0.000    0.000    0.001    0.000 reduction.py:48(dumps)\n",
      "      148    0.000    0.000    0.001    0.000 resource_tracker.py:142(_check_alive)\n",
      "       74    0.000    0.000    0.001    0.000 resource_tracker.py:153(register)\n",
      "       74    0.000    0.000    0.001    0.000 resource_tracker.py:157(unregister)\n",
      "      148    0.000    0.000    0.001    0.000 resource_tracker.py:161(_send)\n",
      "      148    0.000    0.000    0.001    0.000 resource_tracker.py:78(ensure_running)\n",
      "       38    0.000    0.000    0.000    0.000 shape_base.py:19(_atleast_1d_dispatcher)\n",
      "        1    0.000    0.000    0.000    0.000 shape_base.py:207(_arrays_for_stack_dispatcher)\n",
      "        1    0.000    0.000    0.000    0.000 shape_base.py:218(_vhstack_dispatcher)\n",
      "       38    0.000    0.000    0.000    0.000 shape_base.py:23(atleast_1d)\n",
      "        1    0.000    0.000    0.000    0.000 shape_base.py:285(hstack)\n",
      "       15    0.000    0.000    0.000    0.000 socket.py:621(send)\n",
      "        6    0.000    0.000    0.000    0.000 std.py:101(acquire)\n",
      "        6    0.000    0.000    0.000    0.000 std.py:105(release)\n",
      "        4    0.000    0.000    0.000    0.000 std.py:109(__enter__)\n",
      "        4    0.000    0.000    0.000    0.000 std.py:112(__exit__)\n",
      "        1    0.000    0.000    0.000    0.000 std.py:1144(__del__)\n",
      "        3    0.000    0.000    0.000    0.000 std.py:1147(__str__)\n",
      "        2    0.000    0.000    0.000    0.000 std.py:1150(_comparable)\n",
      "        2    0.000    0.000    0.000    0.000 std.py:1154(__hash__)\n",
      "        2    0.000    0.000    0.001    0.000 std.py:1157(__iter__)\n",
      "        1    0.000    0.000    0.000    0.000 std.py:1195(update)\n",
      "        2    0.000    0.000    0.000    0.000 std.py:1262(close)\n",
      "        2    0.000    0.000    0.000    0.000 std.py:1283(fp_write)\n",
      "        1    0.000    0.000    0.000    0.000 std.py:1298(<lambda>)\n",
      "        2    0.000    0.000    0.001    0.001 std.py:1322(refresh)\n",
      "        3    0.000    0.000    0.000    0.000 std.py:1443(format_dict)\n",
      "        3    0.000    0.000    0.001    0.000 std.py:1461(display)\n",
      "        3    0.000    0.000    0.000    0.000 std.py:152(__init__)\n",
      "        6    0.000    0.000    0.000    0.000 std.py:162(colour)\n",
      "        3    0.000    0.000    0.000    0.000 std.py:166(colour)\n",
      "        3    0.000    0.000    0.000    0.000 std.py:185(__format__)\n",
      "        3    0.000    0.000    0.000    0.000 std.py:225(__init__)\n",
      "        6    0.000    0.000    0.000    0.000 std.py:230(__call__)\n",
      "        5    0.000    0.000    0.000    0.000 std.py:285(format_interval)\n",
      "        1    0.000    0.000    0.001    0.001 std.py:326(status_printer)\n",
      "        3    0.000    0.000    0.001    0.000 std.py:339(fp_write)\n",
      "        3    0.000    0.000    0.001    0.000 std.py:345(print_status)\n",
      "        3    0.000    0.000    0.000    0.000 std.py:352(format_meter)\n",
      "        1    0.000    0.000    0.000    0.000 std.py:551(__new__)\n",
      "        1    0.000    0.000    0.000    0.000 std.py:567(_get_free_pos)\n",
      "        1    0.000    0.000    0.000    0.000 std.py:570(<setcomp>)\n",
      "        1    0.000    0.000    0.000    0.000 std.py:574(_decr_instances)\n",
      "        1    0.000    0.000    0.000    0.000 std.py:648(get_lock)\n",
      "        1    0.000    0.000    0.001    0.001 std.py:837(__init__)\n",
      "       74    0.000    0.000    0.003    0.000 synchronize.py:161(__init__)\n",
      "       74    0.001    0.000    0.003    0.000 synchronize.py:50(__init__)\n",
      "       74    0.000    0.000    0.001    0.000 synchronize.py:84(_cleanup)\n",
      "       74    0.000    0.000    0.000    0.000 synchronize.py:90(_make_methods)\n",
      "      111    0.000    0.000    0.000    0.000 synchronize.py:94(__enter__)\n",
      "      111    0.000    0.000    0.000    0.000 synchronize.py:97(__exit__)\n",
      "       74    0.000    0.000    0.000    0.000 tempfile.py:142(rng)\n",
      "       74    0.000    0.000    0.001    0.000 tempfile.py:153(__next__)\n",
      "      111    0.000    0.000    0.000    0.000 threading.py:1044(_stop)\n",
      "      111    0.000    0.000    0.009    0.000 threading.py:1080(join)\n",
      "      168    0.000    0.000    0.009    0.000 threading.py:1118(_wait_for_tstate_lock)\n",
      "      296    0.000    0.000    0.000    0.000 threading.py:1145(name)\n",
      "      296    0.000    0.000    0.000    0.000 threading.py:1156(name)\n",
      "       10    0.000    0.000    0.000    0.000 threading.py:1161(ident)\n",
      "       57    0.000    0.000    0.000    0.000 threading.py:1185(is_alive)\n",
      "      518    0.000    0.000    0.000    0.000 threading.py:1199(daemon)\n",
      "      407    0.000    0.000    0.000    0.000 threading.py:1214(daemon)\n",
      "      407    0.000    0.000    0.000    0.000 threading.py:1317(_make_invoke_excepthook)\n",
      "     1262    0.000    0.000    0.000    0.000 threading.py:1446(current_thread)\n",
      "     1115    0.002    0.000    0.002    0.000 threading.py:236(__init__)\n",
      "     5407    0.003    0.000    0.004    0.000 threading.py:264(__enter__)\n",
      "     5407    0.003    0.000    0.004    0.000 threading.py:267(__exit__)\n",
      "     2938    0.001    0.000    0.002    0.000 threading.py:273(_release_save)\n",
      "     2938    0.003    0.000    0.004    0.000 threading.py:276(_acquire_restore)\n",
      "     4122    0.002    0.000    0.003    0.000 threading.py:279(_is_owned)\n",
      "     2938    0.015    0.000    1.907    0.001 threading.py:288(wait)\n",
      "     1184    0.000    0.000    0.001    0.000 threading.py:359(notify)\n",
      "     1004    0.001    0.000    0.003    0.000 threading.py:555(__init__)\n",
      "     4683    0.001    0.000    0.001    0.000 threading.py:568(is_set)\n",
      "     4112    0.012    0.000    1.926    0.000 threading.py:604(wait)\n",
      "      407    0.000    0.000    0.000    0.000 threading.py:804(_newname)\n",
      "      407    0.001    0.000    0.003    0.000 threading.py:849(__init__)\n",
      "       37    0.000    0.000    0.000    0.000 threading.py:90(RLock)\n",
      "      407    0.001    0.000    0.015    0.000 threading.py:938(start)\n",
      "     1381    0.000    0.000    0.000    0.000 type_check.py:400(_nan_to_num_dispatcher)\n",
      "     1381    0.001    0.000    0.002    0.000 type_check.py:404(nan_to_num)\n",
      "       74    0.000    0.000    0.000    0.000 util.py:171(register_after_fork)\n",
      "      111    0.000    0.000    0.000    0.000 util.py:186(__init__)\n",
      "      111    0.000    0.000    0.012    0.000 util.py:205(__call__)\n",
      "      111    0.000    0.000    0.000    0.000 util.py:44(sub_debug)\n",
      "      629    0.000    0.000    0.000    0.000 util.py:48(debug)\n",
      "        2    0.000    0.000    0.000    0.000 utils.py:118(disable_on_exception)\n",
      "        8    0.000    0.000    0.001    0.000 utils.py:125(inner)\n",
      "        1    0.000    0.000    0.000    0.000 utils.py:144(__init__)\n",
      "        2    0.000    0.000    0.000    0.000 utils.py:153(__eq__)\n",
      "        1    0.000    0.000    0.000    0.000 utils.py:183(_is_utf)\n",
      "        1    0.000    0.000    0.000    0.000 utils.py:197(_supports_unicode)\n",
      "        6    0.000    0.000    0.000    0.000 utils.py:204(_is_ascii)\n",
      "        1    0.000    0.000    0.000    0.000 utils.py:213(_screen_shape_wrapper)\n",
      "        1    0.000    0.000    0.000    0.000 utils.py:264(_screen_shape_linux)\n",
      "        1    0.000    0.000    0.000    0.000 utils.py:278(<listcomp>)\n",
      "        3    0.000    0.000    0.000    0.000 utils.py:305(_text_width)\n",
      "      190    0.000    0.000    0.000    0.000 utils.py:306(<genexpr>)\n",
      "        3    0.000    0.000    0.000    0.000 utils.py:309(disp_len)\n",
      "        3    0.000    0.000    0.000    0.000 utils.py:39(__init__)\n",
      "        3    0.000    0.000    0.000    0.000 utils.py:43(__format__)\n",
      "        1    0.000    0.000    0.000    0.000 utils.py:56(__eq__)\n",
      "        2    0.000    0.000    0.000    0.000 utils.py:70(__getattr__)\n",
      "        3    0.000    0.000    0.000    0.000 utils.py:83(wrapper_setattr)\n",
      "        1    0.000    0.000    0.000    0.000 utils.py:87(__init__)\n",
      "       37    0.000    0.000    0.000    0.000 uuid.py:139(__init__)\n",
      "       37    0.000    0.000    0.000    0.000 uuid.py:334(hex)\n",
      "       37    0.000    0.000    0.001    0.000 uuid.py:721(uuid4)\n",
      "        1    0.000    0.000    0.004    0.004 validation.py:1154(check_X_y)\n",
      "        1    0.000    0.000    0.000    0.000 validation.py:1325(_check_y)\n",
      "     2762    0.004    0.000    0.060    0.000 validation.py:1348(column_or_1d)\n",
      "      104    0.000    0.000    0.001    0.000 validation.py:1411(check_random_state)\n",
      "       72    0.000    0.000    0.001    0.000 validation.py:1549(_is_fitted)\n",
      "       72    0.000    0.000    0.001    0.000 validation.py:1581(<listcomp>)\n",
      "       72    0.000    0.000    0.001    0.000 validation.py:1587(check_is_fitted)\n",
      "     6984    0.002    0.000    0.003    0.000 validation.py:2205(_is_pandas_df)\n",
      "        2    0.000    0.000    0.000    0.000 validation.py:2214(_is_polars_df_or_series)\n",
      "       37    0.000    0.000    0.000    0.000 validation.py:2232(_get_feature_names)\n",
      "     5526    0.003    0.000    0.005    0.000 validation.py:288(_is_arraylike)\n",
      "     5526    0.002    0.000    0.013    0.000 validation.py:296(_is_arraylike_not_scalar)\n",
      "     6947    0.003    0.000    0.006    0.000 validation.py:301(_use_interchange_protocol)\n",
      "       37    0.000    0.000    0.000    0.000 validation.py:311(_num_features)\n",
      "     6947    0.012    0.000    0.028    0.000 validation.py:364(_num_samples)\n",
      "     2764    0.003    0.000    0.059    0.000 validation.py:436(check_consistent_length)\n",
      "     2764    0.002    0.000    0.030    0.000 validation.py:454(<listcomp>)\n",
      "    13850    0.005    0.000    0.008    0.000 validation.py:655(_ensure_no_complex_data)\n",
      "    13850    0.001    0.000    0.001    0.000 validation.py:665(_check_estimator_name)\n",
      "    13850    0.004    0.000    0.005    0.000 validation.py:713(_is_extension_array_dtype)\n",
      "    13850    0.054    0.000    0.295    0.000 validation.py:718(check_array)\n",
      "       37    0.001    0.000    0.035    0.001 validation.py:93(_assert_all_finite)\n",
      "    24900    0.011    0.000    0.037    0.000 warnings.py:165(simplefilter)\n",
      "    24900    0.014    0.000    0.025    0.000 warnings.py:181(_add_filter)\n",
      "    24900    0.007    0.000    0.007    0.000 warnings.py:440(__init__)\n",
      "    24900    0.016    0.000    0.017    0.000 warnings.py:466(__enter__)\n",
      "    24900    0.011    0.000    0.012    0.000 warnings.py:487(__exit__)\n",
      "       74    0.000    0.000    0.000    0.000 weakref.py:105(remove)\n",
      "       74    0.000    0.000    0.000    0.000 weakref.py:164(__setitem__)\n",
      "       74    0.000    0.000    0.000    0.000 weakref.py:347(__new__)\n",
      "       74    0.000    0.000    0.000    0.000 weakref.py:352(__init__)\n",
      "      296    0.000    0.000    0.000    0.000 weakref.py:367(__init__)\n",
      "      160    0.000    0.000    0.000    0.000 weakref.py:369(remove)\n",
      "      296    0.000    0.000    0.000    0.000 weakref.py:427(__setitem__)\n",
      "       75    0.000    0.000    0.000    0.000 {built-in method __new__ of type object at 0x1053355f0}\n",
      "    16850    0.004    0.000    0.007    0.000 {built-in method _abc._abc_instancecheck}\n",
      "     6990    0.002    0.000    0.002    0.000 {built-in method _abc._abc_subclasscheck}\n",
      "       74    0.000    0.000    0.000    0.000 {built-in method _multiprocessing.sem_unlink}\n",
      "       17    0.000    0.000    0.000    0.000 {built-in method _operator.ge}\n",
      "        4    0.000    0.000    0.000    0.000 {built-in method _operator.gt}\n",
      "     2762    0.000    0.000    0.000    0.000 {built-in method _operator.index}\n",
      "        3    0.000    0.000    0.000    0.000 {built-in method _operator.le}\n",
      "       18    0.000    0.000    0.000    0.000 {built-in method _operator.lt}\n",
      "       37    0.000    0.000    0.000    0.000 {built-in method _operator.mul}\n",
      "        1    0.000    0.000    0.000    0.000 {built-in method _pickle.dump}\n",
      "      111    0.000    0.000    0.000    0.000 {built-in method _struct.pack}\n",
      "     4015    0.002    0.000    0.002    0.000 {built-in method _thread.allocate_lock}\n",
      "     1262    0.000    0.000    0.000    0.000 {built-in method _thread.get_ident}\n",
      "      407    0.006    0.000    0.006    0.000 {built-in method _thread.start_new_thread}\n",
      "    74700    0.004    0.000    0.004    0.000 {built-in method _warnings._filters_mutated}\n",
      "       74    0.000    0.000    0.000    0.000 {built-in method _weakref._remove_dead_weakref}\n",
      "        2    0.000    0.000    0.000    0.000 {built-in method _weakref.proxy}\n",
      "        5    0.000    0.000    0.000    0.000 {built-in method builtins.abs}\n",
      "     1463    0.001    0.000    0.002    0.000 {built-in method builtins.any}\n",
      "     3766    0.000    0.000    0.000    0.000 {built-in method builtins.callable}\n",
      "       37    0.001    0.000    0.001    0.000 {built-in method builtins.compile}\n",
      "       13    0.000    0.000    0.000    0.000 {built-in method builtins.divmod}\n",
      "        1    0.000    0.000   22.860   22.860 {built-in method builtins.exec}\n",
      "    86847    0.008    0.000    0.008    0.000 {built-in method builtins.getattr}\n",
      "   247645    0.023    0.000    0.026    0.000 {built-in method builtins.hasattr}\n",
      "     3259    0.000    0.000    0.000    0.000 {built-in method builtins.id}\n",
      "241625/241366    0.020    0.000    0.030    0.000 {built-in method builtins.isinstance}\n",
      "     9704    0.001    0.000    0.001    0.000 {built-in method builtins.issubclass}\n",
      "     2801    0.000    0.000    0.000    0.000 {built-in method builtins.iter}\n",
      "   133755    0.008    0.000    0.008    0.000 {built-in method builtins.len}\n",
      "     4257    0.023    0.000    0.023    0.000 {built-in method builtins.max}\n",
      "     8324    0.047    0.000    0.047    0.000 {built-in method builtins.min}\n",
      "    11979    0.002    0.000    0.011    0.000 {built-in method builtins.next}\n",
      "       63    0.000    0.000    0.000    0.000 {built-in method builtins.ord}\n",
      "        4    0.000    0.000    0.000    0.000 {built-in method builtins.print}\n",
      "     7120    0.001    0.000    0.001    0.000 {built-in method builtins.setattr}\n",
      "     3363    0.169    0.000    0.215    0.000 {built-in method builtins.sorted}\n",
      "      366    0.007    0.000    0.007    0.000 {built-in method builtins.sum}\n",
      "       72    0.000    0.000    0.000    0.000 {built-in method builtins.vars}\n",
      "        1    0.000    0.000    0.000    0.000 {built-in method fcntl.ioctl}\n",
      "       39    0.000    0.000    0.000    0.000 {built-in method from_bytes}\n",
      "     1381    0.000    0.000    0.000    0.000 {built-in method from_iterable}\n",
      "        1    0.000    0.000    0.000    0.000 {built-in method io.open}\n",
      "      592    0.000    0.000    0.000    0.000 {built-in method math.floor}\n",
      "        2    0.000    0.000    0.000    0.000 {built-in method now}\n",
      "     1383    0.001    0.000    0.001    0.000 {built-in method numpy.arange}\n",
      "     5525    0.003    0.000    0.003    0.000 {built-in method numpy.array}\n",
      "    24925    0.005    0.000    0.005    0.000 {built-in method numpy.asanyarray}\n",
      "    58119    0.084    0.000    0.084    0.000 {built-in method numpy.asarray}\n",
      "        1    0.000    0.000    0.000    0.000 {built-in method numpy.ascontiguousarray}\n",
      "48558/38888    0.053    0.000    0.255    0.000 {built-in method numpy.core._multiarray_umath.implement_array_function}\n",
      "       20    0.000    0.000    0.000    0.000 {built-in method numpy.core._multiarray_umath.normalize_axis_index}\n",
      "    17994    0.004    0.000    0.004    0.000 {built-in method numpy.empty}\n",
      "     5680    0.001    0.000    0.001    0.000 {built-in method numpy.geterrobj}\n",
      "     2840    0.001    0.000    0.001    0.000 {built-in method numpy.seterrobj}\n",
      "     1420    0.009    0.000    0.009    0.000 {built-in method numpy.zeros}\n",
      "       74    0.000    0.000    0.000    0.000 {built-in method posix.close}\n",
      "        1    0.000    0.000    0.000    0.000 {built-in method posix.fspath}\n",
      "      383    0.000    0.000    0.000    0.000 {built-in method posix.getpid}\n",
      "       37    0.000    0.000    0.000    0.000 {built-in method posix.pipe}\n",
      "        1    0.000    0.000    0.000    0.000 {built-in method posix.stat}\n",
      "       39    0.000    0.000    0.000    0.000 {built-in method posix.urandom}\n",
      "      407    0.001    0.000    0.001    0.000 {built-in method posix.write}\n",
      "     1381    0.004    0.000    0.004    0.000 {built-in method scipy.sparse._sparsetools.coo_todense}\n",
      "     1883    0.000    0.000    0.000    0.000 {built-in method sys.getrecursionlimit}\n",
      "      672    0.000    0.000    0.000    0.000 {built-in method time.time}\n",
      "      187    0.000    0.000    0.000    0.000 {built-in method unicodedata.east_asian_width}\n",
      "        1    0.000    0.000    0.000    0.000 {built-in method utcfromtimestamp}\n",
      "        2    0.000    0.000    0.000    0.000 {function SeedSequence.generate_state at 0x10932e8e0}\n",
      "    13940    0.001    0.000    0.001    0.000 {method '__contains__' of 'frozenset' objects}\n",
      "      111    0.000    0.000    0.000    0.000 {method '__enter__' of '_multiprocessing.SemLock' objects}\n",
      "     5407    0.001    0.000    0.001    0.000 {method '__enter__' of '_thread.lock' objects}\n",
      "        1    0.000    0.000    0.000    0.000 {method '__exit__' of '_io._IOBase' objects}\n",
      "      111    0.000    0.000    0.000    0.000 {method '__exit__' of '_multiprocessing.SemLock' objects}\n",
      "     5341    0.001    0.000    0.001    0.000 {method '__exit__' of '_thread.RLock' objects}\n",
      "     5555    0.001    0.000    0.001    0.000 {method '__exit__' of '_thread.lock' objects}\n",
      "        6    0.000    0.000    0.000    0.000 {method 'acquire' of '_multiprocessing.SemLock' objects}\n",
      "        6    0.000    0.000    0.000    0.000 {method 'acquire' of '_thread.RLock' objects}\n",
      "    13104    1.892    0.000    1.892    0.000 {method 'acquire' of '_thread.lock' objects}\n",
      "      412    0.000    0.000    0.000    0.000 {method 'add' of 'set' objects}\n",
      "     3545    0.001    0.000    0.001    0.000 {method 'append' of 'collections.deque' objects}\n",
      "    30903    0.002    0.000    0.002    0.000 {method 'append' of 'list' objects}\n",
      "       18    0.003    0.000    0.003    0.000 {method 'argmax' of 'numpy.ndarray' objects}\n",
      "        1    0.001    0.001    0.001    0.001 {method 'argsort' of 'numpy.ndarray' objects}\n",
      "     1383    0.000    0.000    0.000    0.000 {method 'astype' of 'numpy.ndarray' objects}\n",
      "     1381    0.001    0.000    0.017    0.000 {method 'clip' of 'numpy.ndarray' objects}\n",
      "    54172    0.005    0.000    0.005    0.000 {method 'copy' of 'dict' objects}\n",
      "     1417    0.001    0.000    0.001    0.000 {method 'copy' of 'numpy.ndarray' objects}\n",
      "       37    0.000    0.000    0.000    0.000 {method 'count' of 'list' objects}\n",
      "       37    0.000    0.000    0.000    0.000 {method 'cumsum' of 'numpy.ndarray' objects}\n",
      "        1    0.000    0.000    0.000    0.000 {method 'difference' of 'set' objects}\n",
      "        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}\n",
      "      271    0.000    0.000    0.000    0.000 {method 'discard' of 'set' objects}\n",
      "      111    0.000    0.000    0.000    0.000 {method 'dump' of '_pickle.Pickler' objects}\n",
      "      150    0.000    0.000    0.000    0.000 {method 'encode' of 'str' objects}\n",
      "     3289    0.000    0.000    0.000    0.000 {method 'endswith' of 'str' objects}\n",
      "     3701    0.001    0.000    0.001    0.000 {method 'extend' of 'list' objects}\n",
      "    12433    0.007    0.000    0.007    0.000 {method 'flatten' of 'numpy.ndarray' objects}\n",
      "      166    0.000    0.000    0.000    0.000 {method 'format' of 'str' objects}\n",
      "       37    0.000    0.000    0.000    0.000 {method 'get' of '_queue.SimpleQueue' objects}\n",
      "    30629    0.002    0.000    0.002    0.000 {method 'get' of 'dict' objects}\n",
      "      111    0.000    0.000    0.000    0.000 {method 'getbuffer' of '_io.BytesIO' objects}\n",
      "    25492    0.002    0.000    0.002    0.000 {method 'insert' of 'list' objects}\n",
      "    13940    0.001    0.000    0.001    0.000 {method 'isidentifier' of 'str' objects}\n",
      "     8828    0.001    0.000    0.001    0.000 {method 'items' of 'dict' objects}\n",
      "     1382    0.000    0.000    0.000    0.000 {method 'items' of 'mappingproxy' objects}\n",
      "       74    0.000    0.000    0.000    0.000 {method 'join' of 'str' objects}\n",
      "        2    0.000    0.000    0.000    0.000 {method 'keys' of 'dict' objects}\n",
      "      111    0.000    0.000    0.000    0.000 {method 'locked' of '_thread.lock' objects}\n",
      "     5524    0.001    0.000    0.009    0.000 {method 'max' of 'numpy.ndarray' objects}\n",
      "     8286    0.002    0.000    0.011    0.000 {method 'min' of 'numpy.ndarray' objects}\n",
      "     1200    0.000    0.000    0.000    0.000 {method 'partition' of 'str' objects}\n",
      "     4158    0.000    0.000    0.000    0.000 {method 'pop' of 'dict' objects}\n",
      "     3702    0.001    0.000    0.001    0.000 {method 'pop' of 'list' objects}\n",
      "     2762    0.000    0.000    0.000    0.000 {method 'pop' of 'set' objects}\n",
      "      592    0.000    0.000    0.000    0.000 {method 'popleft' of 'collections.deque' objects}\n",
      "        1    0.000    0.000    0.000    0.000 {method 'prod' of 'numpy.generic' objects}\n",
      "      925    0.000    0.000    0.000    0.000 {method 'put' of '_queue.SimpleQueue' objects}\n",
      "    36030    0.040    0.000    0.040    0.000 {method 'randint' of 'numpy.random.mtrand.RandomState' objects}\n",
      "      592    0.000    0.000    0.000    0.000 {method 'random' of '_random.Random' objects}\n",
      "     2762    0.001    0.000    0.001    0.000 {method 'ravel' of 'numpy.ndarray' objects}\n",
      "    19393    0.057    0.000    0.057    0.000 {method 'reduce' of 'numpy.ufunc' objects}\n",
      "        6    0.000    0.000    0.000    0.000 {method 'release' of '_multiprocessing.SemLock' objects}\n",
      "        6    0.000    0.000    0.000    0.000 {method 'release' of '_thread.RLock' objects}\n",
      "     3049    0.000    0.000    0.000    0.000 {method 'release' of '_thread.lock' objects}\n",
      "    24900    0.007    0.000    0.007    0.000 {method 'remove' of 'list' objects}\n",
      "        3    0.000    0.000    0.000    0.000 {method 'remove' of 'set' objects}\n",
      "      333    0.000    0.000    0.000    0.000 {method 'replace' of 'str' objects}\n",
      "     2800    0.001    0.000    0.001    0.000 {method 'reshape' of 'numpy.ndarray' objects}\n",
      "     4700    0.001    0.000    0.001    0.000 {method 'rpartition' of 'str' objects}\n",
      "        2    0.001    0.000    0.001    0.000 {method 'shuffle' of 'numpy.random.mtrand.RandomState' objects}\n",
      "    12432    0.025    0.000    0.025    0.000 {method 'sort' of 'numpy.ndarray' objects}\n",
      "        2    0.116    0.058    0.116    0.058 {method 'standard_normal' of 'numpy.random.mtrand.RandomState' objects}\n",
      "     1851    0.000    0.000    0.000    0.000 {method 'startswith' of 'str' objects}\n",
      "        3    0.000    0.000    0.000    0.000 {method 'sub' of 're.Pattern' objects}\n",
      "        1    0.000    0.000    0.000    0.000 {method 'sum' of 'numpy.ndarray' objects}\n",
      "       18    0.002    0.000    0.002    0.000 {method 'take' of 'numpy.ndarray' objects}\n",
      "       72    0.000    0.000    0.000    0.000 {method 'tolist' of 'numpy.ndarray' objects}\n",
      "     1387    0.006    0.000    0.006    0.000 {method 'uniform' of 'numpy.random.mtrand.RandomState' objects}\n",
      "     1483    0.000    0.000    0.000    0.000 {method 'update' of 'dict' objects}\n",
      "        6    0.000    0.000    0.000    0.000 {method 'upper' of 'str' objects}\n",
      "     3265    0.001    0.000    0.001    0.000 {method 'values' of 'mappingproxy' objects}\n",
      "        1    0.000    0.000    0.000    0.000 {method 'view' of 'numpy.ndarray' objects}\n",
      "       13    0.000    0.000    0.000    0.000 {method 'write' of '_io.StringIO' objects}\n",
      "\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "import cProfile\n",
    "\n",
    "cProfile.run(\"main()\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Max Depth Progress:   0%|\u001b[32m          \u001b[0m| 0/1 [00:08<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unexpected exception formatting exception. Falling back to standard exception\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "Traceback (most recent call last):\n",
      "  File \"/Users/omarmagdy/anaconda3/lib/python3.11/site-packages/IPython/core/interactiveshell.py\", line 3553, in run_code\n",
      "    exec(code_obj, self.user_global_ns, self.user_ns)\n",
      "  File \"/var/folders/sj/34cxtzy5771dh68fqmq6vzw80000gn/T/ipykernel_47154/1215949073.py\", line 5, in <module>\n",
      "    ) = main(\n",
      "        ^^^^^\n",
      "  File \"/var/folders/sj/34cxtzy5771dh68fqmq6vzw80000gn/T/ipykernel_47154/2846279493.py\", line 49, in main\n",
      "    saved_runs, avg_score, binary_runs = Run(\n",
      "                                         ^^^^\n",
      "  File \"/var/folders/sj/34cxtzy5771dh68fqmq6vzw80000gn/T/ipykernel_47154/1806065167.py\", line 64, in Run\n",
      "    heuristic_runs, heuristic_result = hit_or_miss(\n",
      "                                       ^^^^^^^^^^^^\n",
      "  File \"/var/folders/sj/34cxtzy5771dh68fqmq6vzw80000gn/T/ipykernel_47154/3060019757.py\", line -1, in hit_or_miss\n",
      "KeyboardInterrupt\n",
      "\n",
      "During handling of the above exception, another exception occurred:\n",
      "\n",
      "Traceback (most recent call last):\n",
      "  File \"/Users/omarmagdy/anaconda3/lib/python3.11/site-packages/IPython/core/interactiveshell.py\", line 2144, in showtraceback\n",
      "    stb = self.InteractiveTB.structured_traceback(\n",
      "          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
      "  File \"/Users/omarmagdy/anaconda3/lib/python3.11/site-packages/IPython/core/ultratb.py\", line 1435, in structured_traceback\n",
      "    return FormattedTB.structured_traceback(\n",
      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
      "  File \"/Users/omarmagdy/anaconda3/lib/python3.11/site-packages/IPython/core/ultratb.py\", line 1326, in structured_traceback\n",
      "    return VerboseTB.structured_traceback(\n",
      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
      "  File \"/Users/omarmagdy/anaconda3/lib/python3.11/site-packages/IPython/core/ultratb.py\", line 1173, in structured_traceback\n",
      "    formatted_exception = self.format_exception_as_a_whole(etype, evalue, etb, number_of_lines_of_context,\n",
      "                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
      "  File \"/Users/omarmagdy/anaconda3/lib/python3.11/site-packages/IPython/core/ultratb.py\", line 1088, in format_exception_as_a_whole\n",
      "    frames.append(self.format_record(record))\n",
      "                  ^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
      "  File \"/Users/omarmagdy/anaconda3/lib/python3.11/site-packages/IPython/core/ultratb.py\", line 970, in format_record\n",
      "    frame_info.lines, Colors, self.has_colors, lvals\n",
      "    ^^^^^^^^^^^^^^^^\n",
      "  File \"/Users/omarmagdy/anaconda3/lib/python3.11/site-packages/IPython/core/ultratb.py\", line 792, in lines\n",
      "    return self._sd.lines\n",
      "           ^^^^^^^^^^^^^^\n",
      "  File \"/Users/omarmagdy/anaconda3/lib/python3.11/site-packages/stack_data/utils.py\", line 145, in cached_property_wrapper\n",
      "    value = obj.__dict__[self.func.__name__] = self.func(obj)\n",
      "                                               ^^^^^^^^^^^^^^\n",
      "  File \"/Users/omarmagdy/anaconda3/lib/python3.11/site-packages/stack_data/core.py\", line 698, in lines\n",
      "    pieces = self.included_pieces\n",
      "             ^^^^^^^^^^^^^^^^^^^^\n",
      "  File \"/Users/omarmagdy/anaconda3/lib/python3.11/site-packages/stack_data/utils.py\", line 145, in cached_property_wrapper\n",
      "    value = obj.__dict__[self.func.__name__] = self.func(obj)\n",
      "                                               ^^^^^^^^^^^^^^\n",
      "  File \"/Users/omarmagdy/anaconda3/lib/python3.11/site-packages/stack_data/core.py\", line 649, in included_pieces\n",
      "    pos = scope_pieces.index(self.executing_piece)\n",
      "                             ^^^^^^^^^^^^^^^^^^^^\n",
      "  File \"/Users/omarmagdy/anaconda3/lib/python3.11/site-packages/stack_data/utils.py\", line 145, in cached_property_wrapper\n",
      "    value = obj.__dict__[self.func.__name__] = self.func(obj)\n",
      "                                               ^^^^^^^^^^^^^^\n",
      "  File \"/Users/omarmagdy/anaconda3/lib/python3.11/site-packages/stack_data/core.py\", line 628, in executing_piece\n",
      "    return only(\n",
      "           ^^^^^\n",
      "  File \"/Users/omarmagdy/anaconda3/lib/python3.11/site-packages/executing/executing.py\", line 164, in only\n",
      "    raise NotOneValueFound('Expected one value, found 0')\n",
      "executing.executing.NotOneValueFound: Expected one value, found 0\n"
     ]
    }
   ],
   "source": [
    "(saved_runs, scores, binary_runs) = main(\n",
    "    n_iterations=18,\n",
    "    stats=True,\n",
    "    metric=\"weighted_binary_cross_entropy\",\n",
    "    algorithm=\"hit_or_miss\",\n",
    "    save_results=True,\n",
    "    max_depth=2,\n",
    "    samples=50000,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10, 7))\n",
    "plt.boxplot(binary_runs, medianprops=dict(color=\"#EF9536\"))\n",
    "plt.title(\"Binary Runs\", fontsize=20)\n",
    "# set dpi to 300 for better quality\n",
    "\n",
    "plt.gca().spines[\"top\"].set_visible(False)\n",
    "plt.gca().spines[\"right\"].set_visible(False)\n",
    "plt.yticks(ticks=[8, 9, 10], fontsize=20)\n",
    "\n",
    "plt.xticks([])\n",
    "plt.savefig(\"binary_runs.png\", dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot(\n",
    "    algorithm,\n",
    "    metric=None,\n",
    "    *,\n",
    "    samples=15000,\n",
    "    scores=None,\n",
    "    saved_runs=None,\n",
    "    save_fig=False,\n",
    "    transparent=False,\n",
    "    **kwargs,\n",
    "):\n",
    "\n",
    "    plt.figure(figsize=(18, 9))\n",
    "\n",
    "    saved_runs_means = [np.mean(saved_run) for saved_run in saved_runs]\n",
    "    scores_means = [np.mean(score) / 100 for score in scores]\n",
    "\n",
    "    # Find the vertical line where saved runs become negative\n",
    "    negative_indices = [\n",
    "        i for i, saved_run in enumerate(saved_runs_means) if saved_run < 0\n",
    "    ]\n",
    "\n",
    "    if negative_indices:\n",
    "        negative_index = negative_indices[\n",
    "            -1\n",
    "        ]  # Find the last index where saved runs are negative\n",
    "        # Perform linear interpolation\n",
    "        x1 = scores_means[negative_index]\n",
    "        y1 = saved_runs_means[negative_index]\n",
    "        x2 = scores_means[negative_index + 1]\n",
    "        y2 = saved_runs_means[negative_index + 1]\n",
    "\n",
    "        x_zero_cross = x1 + (0 - y1) / (y2 - y1) * (x2 - x1)\n",
    "\n",
    "        plt.axvline(\n",
    "            x=x_zero_cross,\n",
    "            color=\"#EC6602\",\n",
    "            linestyle=\"--\",\n",
    "            linewidth=1.5,\n",
    "            label=\"_nolegend_\",\n",
    "        )\n",
    "        plt.axhline(\n",
    "            y=0,\n",
    "            color=\"#EC6602\",\n",
    "            linestyle=\"--\",\n",
    "            linewidth=1.5,\n",
    "            label=\"_nolegend_\",\n",
    "        )\n",
    "        x_zero_cross = f\"{x_zero_cross:.4f}\"\n",
    "        # x_zero_cross = f'{x_zero_cross/100:.2f}'\n",
    "        # plt.axhline(y=0, color=\"#EC6602\", linestyle=\"--\", linewidth=1.5)\n",
    "\n",
    "    else:\n",
    "        x_zero_cross = None\n",
    "    # Plot with labels for the legend\n",
    "    plt.boxplot(\n",
    "        saved_runs,\n",
    "        positions=scores_means,\n",
    "        widths=0.0005,\n",
    "        medianprops=dict(color=\"#EF9536\"),\n",
    "    )\n",
    "\n",
    "    plt.plot(\n",
    "        scores_means,\n",
    "        saved_runs_means,\n",
    "        marker=\"o\",\n",
    "        linestyle=\"--\",\n",
    "        color=\"#4EAD90\",\n",
    "        label=\"_nolegend_\",\n",
    "        linewidth=3,\n",
    "        **kwargs,\n",
    "    )\n",
    "\n",
    "    plt.legend(\n",
    "        [f\"Samples: {samples}\\nThreshold: {x_zero_cross}\"],\n",
    "        loc=\"upper right\",\n",
    "        fontsize=10,\n",
    "        frameon=False,\n",
    "        shadow=False,\n",
    "        title=\"Info\",\n",
    "        title_fontsize=\"20\",\n",
    "    )\n",
    "    # plt.title('Saved Runs Vs Model Scores using Hit Or Miss Algorithm', fontsize=20)\n",
    "    if metric == \"Weighted Binary Crossentropy Loss\":\n",
    "        plt.xlabel(f\"Loss Values ({metric})\", fontsize=25)\n",
    "    else:\n",
    "        plt.xlabel(f\"Score Values ({metric})\", fontsize=25)\n",
    "    plt.ylabel(\"Saved Runs\", fontsize=25)\n",
    "\n",
    "    ax = plt.gca()\n",
    "    # ax.minorticks_on()\n",
    "    plt.grid(which=\"both\", axis=\"both\", linestyle=\"-\", linewidth=\"0.3\", color=\"gray\")\n",
    "\n",
    "    # max = int(np.max(scores_means))\n",
    "    max = round(np.max(scores_means), 2)\n",
    "\n",
    "    plt.xticks(\n",
    "        ticks=np.arange(0, max, 0.001), labels=np.arange(0, max, 0.001), fontsize=20\n",
    "    )\n",
    "    plt.yticks(fontsize=20)\n",
    "\n",
    "    plt.xlim(0, 0.008)\n",
    "    plt.ylim(int(np.min(saved_runs)) - 10, int(np.max(saved_runs)) + 500)\n",
    "\n",
    "    # ax.yaxis.set_major_locator(MaxNLocator(nbins=15))\n",
    "    # ax.xaxis.set_major_locator(MaxNLocator(nbins=45))\n",
    "\n",
    "    # For positive only\n",
    "    # plt.ylim(-10, 80)\n",
    "    # plt.xlim(0, 0.01)\n",
    "\n",
    "    # plt.xticks(ticks = np.arange(0, 0.015, 0.001), labels=np.arange(0, 0.015, 0.001), fontsize=20)\n",
    "    # plt.yticks(fontsize=20)\n",
    "\n",
    "    ax.yaxis.set_major_locator(MaxNLocator(nbins=13))\n",
    "    ax.xaxis.set_major_locator(MaxNLocator(nbins=9))\n",
    "\n",
    "    # Remove borders\n",
    "    plt.gca().spines[\"top\"].set_visible(False)\n",
    "    plt.gca().spines[\"right\"].set_visible(False)\n",
    "\n",
    "    if save_fig:\n",
    "        if transparent:\n",
    "            transparency = \"transparent\"\n",
    "        else:\n",
    "            transparency = \"non-transparent\"\n",
    "\n",
    "        directory = \"Graphs/\"\n",
    "\n",
    "        if not os.path.exists(directory):\n",
    "            os.makedirs(directory)\n",
    "\n",
    "        plt.savefig(\n",
    "            os.path.join(directory, f\"{algorithm}_{transparency}_{metric}.png\"),\n",
    "            transparent=transparent,\n",
    "            dpi=350,\n",
    "        )\n",
    "\n",
    "    plt.show"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1800x900 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot(\n",
    "    algorithm=\"Hit Or Miss\",\n",
    "    # metric='Weighted Binary Crossentropy Loss',\n",
    "    metric=\"Weighted Binary Crossentropy Loss\",\n",
    "    samples=15000,\n",
    "    scores=scores,\n",
    "    saved_runs=saved_runs,\n",
    "    save_fig=True,\n",
    "    transparent=False,\n",
    "    markersize=2,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3D ploting "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "saved_runs_plot = []\n",
    "scores_plot = []\n",
    "alphas_plot = []\n",
    "binary_runs_plot = []\n",
    "\n",
    "for alpha in np.arange(0.0, 1.1, 0.1):\n",
    "    saved_runs, scores, binary_runs = main(\n",
    "        n_iterations=14,\n",
    "        stats=False,\n",
    "        metric=\"weighted_binary_cross_entropy\",\n",
    "        algorithm=\"hybrid_search\",\n",
    "        save_results=True,\n",
    "        max_depth=29,\n",
    "        alpha=alpha,\n",
    "    )\n",
    "    print(f\"alpha: {alpha}\")\n",
    "    binary_runs_plot.append(binary_runs)\n",
    "    saved_runs_plot.append(saved_runs)\n",
    "    scores_plot.append(scores)\n",
    "    alphas_plot.append(alpha)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"alpha plot length: {len(alphas_plot)}\")\n",
    "print(f\"saved_runs plot length: {len(saved_runs_plot)}\")\n",
    "print(f\"scores plot length: {len(scores_plot)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# prepare for three dimensional plot\n",
    "len(saved_runs_plot)\n",
    "num_of_alphas = len(alphas_plot)\n",
    "# max_max_depth\n",
    "max_max_depth = 29\n",
    "scores_results_graph = []\n",
    "saved_runs_graph = []\n",
    "alphas_graph = []\n",
    "for saved_run_iter in scores_plot:\n",
    "    for val in saved_run_iter:\n",
    "        scores_results_graph.append(np.mean(val))\n",
    "\n",
    "\n",
    "for saved_run_iter in saved_runs_plot:\n",
    "    for val in saved_run_iter:\n",
    "        saved_runs_graph.append(np.mean(val))\n",
    "\n",
    "# convresion of alpha to be the same length as the saved_runs_graph\n",
    "# same value of alpha for each 30 iterations\n",
    "for i in range(num_of_alphas):\n",
    "    for j in range(max_max_depth - 1):\n",
    "        alphas_graph.append(alphas_plot[i])\n",
    "\n",
    "# Assertion to check the length of the saved_runs_graph and scores_results_graph and alphas_graph\n",
    "assert len(alphas_graph) == len(saved_runs_graph) == len(scores_results_graph)\n",
    "\n",
    "print(f\"length of saved_runs_graph: {len(saved_runs_graph)}\")\n",
    "print(f\"length of scores_results_graph: {len(alphas_graph)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3D plot -- the 3D surface plot\n",
    "plot_3d(\n",
    "    alphas_graph,\n",
    "    scores_results_graph,\n",
    "    saved_runs_graph,\n",
    "    title=None,\n",
    "    x_label=\"alpha\",\n",
    "    y_label=\"wBCE loss\",\n",
    "    z_label=\"Saved Runs\",\n",
    "    save_fig=True,\n",
    "    transparent=True,\n",
    "    width=1000,\n",
    "    height=1000,\n",
    "    algorithm=\"hybrid_search_algo\",\n",
    "    contour=False,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# out contour heatmap plot\n",
    "plot_3d(\n",
    "    alphas_graph,\n",
    "    scores_results_graph,\n",
    "    saved_runs_graph,\n",
    "    title=None,\n",
    "    x_label=\"alpha\",\n",
    "    y_label=\"wBCE loss\",\n",
    "    z_label=\"Saved Runs\",\n",
    "    save_fig=True,\n",
    "    transparent=True,\n",
    "    width=1000,\n",
    "    height=1000,\n",
    "    algorithm=\"hybrid_search_algo\",\n",
    "    contour=True,\n",
    ")  # contour plot"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}