{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "tp4-000",
   "metadata": {},
   "source": [
    "# Practical 4 — Logistic regression\n",
    "\n",
    "In this practical, we analyse and implement a logistic regression for classification (yes the name is not perfect, but you should understand after the lesson)\n",
    "\n",
    "**Objectives**\n",
    "- connect a linear score, a sigmoid probability and a class decision;\n",
    "- compute binary logistic loss for a few observations;\n",
    "- fit a regularized logistic model in a scaling pipeline;\n",
    "- choose `C` and a decision threshold using development data only;\n",
    "- interpret a ROC curve and report one untouched test evaluation.\n",
    "\n",
    "Some exercises are inspired by *Machine Learning with PyTorch and Scikit-Learn*, Chapter 3, \"Modeling class probabilities via logistic regression\" of Raschka S."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "tp4-001",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "from sklearn.datasets import load_breast_cancer\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import (\n",
    "    accuracy_score,\n",
    "    confusion_matrix,\n",
    "    f1_score,\n",
    "    precision_score,\n",
    "    recall_score,\n",
    "    roc_auc_score,\n",
    "    roc_curve,\n",
    ")\n",
    "from sklearn.model_selection import StratifiedKFold, cross_val_score, train_test_split\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "RANDOM_STATE = 42\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "tp4-002",
   "metadata": {},
   "source": [
    "## 1. Data and protocol\n",
    "\n",
    "We use the [Wisconsin breast cancer dataset](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_breast_cancer.html). Each row contains 30 measurements computed from an image of a cell nucleus. In the original encoding, `0` means malignant and `1` means benign. **Here we recode malignant as class 1**, so recall means the fraction of malignant cases detected.\n",
    "\n",
    "This is a teaching dataset and a predictive exercise, not a clinical decision system. Split the data before fitting any preprocessing. Keep the test set untouched until Section 6. \n",
    "\n",
    "Documentation: [`train_test_split`](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "tp4-003",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train: n=341, malignant prevalence=37.2%\n",
      "valid: n=114, malignant prevalence=37.7%\n",
      " test: n=114, malignant prevalence=36.8%\n",
      "X shape: (569, 30)\n"
     ]
    }
   ],
   "source": [
    "dataset = load_breast_cancer()\n",
    "X = dataset.data\n",
    "y = (dataset.target == 0).astype(int)  # 1 = malignant\n",
    "feature_names = np.asarray(dataset.feature_names)\n",
    "\n",
    "X_dev, X_test, y_dev, y_test = train_test_split(\n",
    "    X, y, test_size=0.20, stratify=y, random_state=RANDOM_STATE\n",
    ")\n",
    "X_train, X_valid, y_train, y_valid = train_test_split(\n",
    "    X_dev, y_dev, test_size=0.25, stratify=y_dev, random_state=RANDOM_STATE\n",
    ")\n",
    "\n",
    "for name, target in ((\"train\", y_train), (\"valid\", y_valid), (\"test\", y_test)):\n",
    "    print(f\"{name:>5}: n={len(target):3d}, malignant prevalence={target.mean():.1%}\")\n",
    "print(\"X shape:\", X.shape)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "tp4-004",
   "metadata": {
    "tags": [
     "exercise"
    ]
   },
   "outputs": [],
   "source": [
    "# TODO: inspect the range of at least three features on X_train.\n",
    "# Are their scales similar? What does y_train.mean() represent?\n",
    "# Why use stratify in both splits?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "tp4-005",
   "metadata": {
    "tags": [
     "correction"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           mean radius: min=    6.98, max=   27.42, std=    3.59\n",
      "          mean texture: min=    9.71, max=   39.28, std=    4.35\n",
      "        mean perimeter: min=   43.79, max=  186.90, std=   24.82\n",
      "Malignant prevalence in training: 37.2%\n",
      "Stratification preserves approximately the same class proportions in each split.\n"
     ]
    }
   ],
   "source": [
    "for index in (0, 1, 2):\n",
    "    values = X_train[:, index]\n",
    "    print(\n",
    "        f\"{feature_names[index]:>22}: \"\n",
    "        f\"min={values.min():8.2f}, max={values.max():8.2f}, \"\n",
    "        f\"std={values.std():8.2f}\"\n",
    "    )\n",
    "print(f\"Malignant prevalence in training: {y_train.mean():.1%}\")\n",
    "print(\"Stratification preserves approximately the same class proportions in each split.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "tp4-006",
   "metadata": {},
   "source": [
    "## 2. Score, sigmoid and loss\n",
    "\n",
    "For a linear score $z=\\mathbf w^\\top\\mathbf x+b$, logistic regression assumes\n",
    "\n",
    "$$\n",
    "\\operatorname{logit}(p)=\\log\\frac{p}{1-p}=z,\n",
    "\\qquad\n",
    "p=\\sigma(z)=\\frac{1}{1+e^{-z}}.\n",
    "$$\n",
    "\n",
    "The logit maps probabilities to real scores; the sigmoid maps scores back to probabilities. For the three scores below, compute $p$, then verify that $\\operatorname{logit}(p)$ recovers $z$. What happens at $z=0$?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "tp4-007",
   "metadata": {
    "tags": [
     "exercise"
    ]
   },
   "outputs": [],
   "source": [
    "scores = np.array([-2.0, 0.0, 2.0])\n",
    "\n",
    "# TODO: write sigmoid(z) using np.exp.\n",
    "# TODO: compute probabilities = sigmoid(scores).\n",
    "# TODO: recover scores with np.log(probabilities / (1 - probabilities)).\n",
    "# Compare both score arrays with np.allclose.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "tp4-008",
   "metadata": {
    "tags": [
     "correction"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "scores:        [-2.  0.  2.]\n",
      "probabilities: [0.119 0.5   0.881]\n",
      "recovered:     [-2.  0.  2.]\n",
      "inverse relation: True\n"
     ]
    }
   ],
   "source": [
    "def sigmoid(z):\n",
    "    return 1.0 / (1.0 + np.exp(-z))\n",
    "\n",
    "probabilities = sigmoid(scores)\n",
    "recovered_scores = np.log(probabilities / (1.0 - probabilities))\n",
    "print(\"scores:       \", scores)\n",
    "print(\"probabilities:\", np.round(probabilities, 3)) # probability of 0.5 att z  = 0\n",
    "print(\"recovered:    \", np.round(recovered_scores, 3))\n",
    "print(\"inverse relation:\", np.allclose(scores, recovered_scores))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "tp4-009",
   "metadata": {},
   "source": [
    "For a binary label $y\\in\\{0,1\\}$, the loss for a predicted probability $p=P(Y=1\\mid\\mathbf x)$ is\n",
    "\n",
    "$$\n",
    "\\ell(y,p)=-y\\log p-(1-y)\\log(1-p).\n",
    "$$\n",
    "\n",
    "Evaluate it for `(y, p) = (1, 0.9), (1, 0.1), (0, 0.9), (0, 0.1)`. Which predictions receive the largest penalty? This is the negative log-likelihood of the Bernoulli model discussed in CM03.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "tp4-010",
   "metadata": {
    "tags": [
     "exercise"
    ]
   },
   "outputs": [],
   "source": [
    "labels_small = np.array([1, 1, 0, 0])\n",
    "probs_small = np.array([0.9, 0.1, 0.9, 0.1])\n",
    "\n",
    "# TODO: implement binary_log_loss(y_true, p) and compute all four losses.\n",
    "# For these values, no clipping is required. Keep the function vectorized.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "tp4-011",
   "metadata": {
    "tags": [
     "correction"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y=1, p=0.9, loss=0.105\n",
      "y=1, p=0.1, loss=2.303\n",
      "y=0, p=0.9, loss=2.303\n",
      "y=0, p=0.1, loss=0.105\n",
      "Confident wrong predictions receive the largest loss.\n"
     ]
    }
   ],
   "source": [
    "def binary_log_loss(y_true, p):\n",
    "    return -y_true * np.log(p) - (1 - y_true) * np.log1p(-p)\n",
    "\n",
    "small_losses = binary_log_loss(labels_small, probs_small)\n",
    "for label, probability, loss in zip(labels_small, probs_small, small_losses):\n",
    "    print(f\"y={label}, p={probability:.1f}, loss={loss:.3f}\")\n",
    "print(\"Confident wrong predictions receive the largest loss.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "tp4-012",
   "metadata": {},
   "source": [
    "## 3. A complete logistic pipeline\n",
    "The 30 features have different scales. Keep [`StandardScaler`](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.StandardScaler.html) inside a [`Pipeline`](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.Pipeline.html), followed by [`LogisticRegression`](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html). In cross-validation, each fold must fit its scaler using only that fold's training observations.\n",
    "\n",
    "The classifier's `decision_function` returns the linear score $z$; `predict_proba` returns the corresponding probability. Check this relationship numerically. We use the default $L_2$ regularization and `C=1.0` for the initial model. Identify the role of $C$ according to $\\lambda$ in the lesson.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "tp4-013",
   "metadata": {
    "tags": [
     "exercise"
    ]
   },
   "outputs": [],
   "source": [
    "# TODO: build a Pipeline with steps named \"scale\" and \"classifier\".\n",
    "# Use StandardScaler() and LogisticRegression(C=1.0, max_iter=2000).\n",
    "# Fit on X_train, y_train only.\n",
    "# Compute z_valid and p_valid for X_valid.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "tp4-014",
   "metadata": {
    "tags": [
     "correction"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First five scores:        [ -3.908  37.308 -13.945  -4.359  -4.475]\n",
      "First five probabilities: [0.02  1.    0.    0.013 0.011]\n",
      "sigmoid(z) agrees: True\n",
      "Scaler trained on training subset: True\n"
     ]
    }
   ],
   "source": [
    "model = Pipeline([\n",
    "    (\"scale\", StandardScaler()),\n",
    "    (\"classifier\", LogisticRegression(C=1.0, max_iter=2000)),\n",
    "])\n",
    "model.fit(X_train, y_train)\n",
    "z_valid = model.decision_function(X_valid)\n",
    "p_valid = model.predict_proba(X_valid)[:, 1]\n",
    "\n",
    "print(\"First five scores:       \", np.round(z_valid[:5], 3))\n",
    "print(\"First five probabilities:\", np.round(p_valid[:5], 3))\n",
    "print(\"sigmoid(z) agrees:\", np.allclose(sigmoid(z_valid), p_valid))\n",
    "print(\"Scaler trained on training subset:\",\n",
    "      np.allclose(model.named_steps[\"scale\"].mean_, X_train.mean(axis=0)))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "tp4-015",
   "metadata": {
    "tags": [
     "exercise"
    ]
   },
   "outputs": [],
   "source": [
    "# TODO: compare model.predict(X_valid) with (p_valid >= 0.5).astype(int).\n",
    "# Print accuracy, precision, recall, F1 and ROC-AUC on validation data.\n",
    "# Which metric uses probabilities instead of thresholded labels?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "tp4-016",
   "metadata": {
    "tags": [
     "correction"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Comparison between default predictions and thresholded probabilities: True\n",
      "Accuracy: 0.974\n",
      "Precision: 0.955\n",
      "Recall: 0.977\n",
      "F1: 0.966\n",
      "ROC-AUC: 0.996\n",
      "ROC-AUC uses the probability scores, not one set of class labels.\n"
     ]
    }
   ],
   "source": [
    "y_valid_default = model.predict(X_valid)\n",
    "print(f\"Comparison between default predictions and thresholded probabilities: {np.array_equal(y_valid_default, (p_valid >= 0.5).astype(int))}\")\n",
    "print(f\"Accuracy: {accuracy_score(y_valid, y_valid_default):.3f}\")\n",
    "print(f\"Precision: {precision_score(y_valid, y_valid_default):.3f}\")\n",
    "print(f\"Recall: {recall_score(y_valid, y_valid_default):.3f}\")\n",
    "print(f\"F1: {f1_score(y_valid, y_valid_default):.3f}\")\n",
    "print(f\"ROC-AUC: {roc_auc_score(y_valid, p_valid):.3f}\")\n",
    "print(\"ROC-AUC uses the probability scores, not one set of class labels.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "tp4-017",
   "metadata": {},
   "source": [
    "## 4. Choose the regularization strength\n",
    "\n",
    "`C` is the inverse of regularization strength: a smaller value shrinks coefficients more. Compare a short logarithmic list of `C` values with five-fold [`StratifiedKFold`](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.StratifiedKFold.html) on **training data only**. Use [`cross_val_score`](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.cross_val_score.html) with `scoring=\"roc_auc\"`. We will use the validation set to derive a possibly better threshold.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "tp4-018",
   "metadata": {
    "tags": [
     "exercise"
    ]
   },
   "outputs": [],
   "source": [
    "C_values = np.logspace(-3, 2, 8)\n",
    "cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=RANDOM_STATE)\n",
    "\n",
    "# TODO: for each C, create a fresh pipeline, compute five CV ROC-AUC scores,\n",
    "# and store their mean and standard deviation. Select the best C.\n",
    "# Keep the validation and test sets out of this loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "tp4-019",
   "metadata": {
    "tags": [
     "correction"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C=   0.001: CV ROC-AUC=0.984 +/- 0.014\n",
      "C=0.005179: CV ROC-AUC=0.989 +/- 0.010\n",
      "C= 0.02683: CV ROC-AUC=0.992 +/- 0.008\n",
      "C=  0.1389: CV ROC-AUC=0.994 +/- 0.008\n",
      "C=  0.7197: CV ROC-AUC=0.994 +/- 0.009\n",
      "C=   3.728: CV ROC-AUC=0.994 +/- 0.008\n",
      "C=   19.31: CV ROC-AUC=0.992 +/- 0.008\n",
      "C=     100: CV ROC-AUC=0.988 +/- 0.010\n",
      "Selected C: 3.728\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# We can also use a GridSearchCV to find the best hyperparameter C, but here we do it manually to illustrate the process.\n",
    "\n",
    "cv_means = []\n",
    "cv_stds = []\n",
    "for C in C_values:\n",
    "    candidate = Pipeline([\n",
    "        (\"scale\", StandardScaler()),\n",
    "        (\"classifier\", LogisticRegression(C=C, max_iter=2000)),\n",
    "    ])\n",
    "    scores_cv = cross_val_score(\n",
    "        candidate, X_train, y_train, cv=cv, scoring=\"roc_auc\"\n",
    "    )\n",
    "    cv_means.append(scores_cv.mean())\n",
    "    cv_stds.append(scores_cv.std())\n",
    "\n",
    "cv_means = np.asarray(cv_means)\n",
    "cv_stds = np.asarray(cv_stds)\n",
    "best_C = C_values[np.argmax(cv_means)]\n",
    "for C, mean, std in zip(C_values, cv_means, cv_stds):\n",
    "    print(f\"C={C:8.4g}: CV ROC-AUC={mean:.3f} +/- {std:.3f}\")\n",
    "print(f\"Selected C: {best_C:.4g}\")\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(6, 4))\n",
    "ax.errorbar(C_values, cv_means, yerr=cv_stds, marker=\"o\", capsize=3)\n",
    "ax.set_xscale(\"log\")\n",
    "ax.set_xlabel(\"C (smaller = stronger regularization)\")\n",
    "ax.set_ylabel(\"Cross-validated ROC-AUC\")\n",
    "ax.grid(alpha=0.25)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "tp4-020",
   "metadata": {},
   "source": [
    "Fit a new pipeline on the whole training subset with `best_C`. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "tp4-021",
   "metadata": {
    "tags": [
     "exercise"
    ]
   },
   "outputs": [],
   "source": [
    "# TODO: fit selected_model using best_C on X_train, y_train."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "tp4-022",
   "metadata": {
    "tags": [
     "correction"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>#sk-container-id-1 {\n",
       "  /* Definition of color scheme common for light and dark mode */\n",
       "  --sklearn-color-text: #000;\n",
       "  --sklearn-color-text-muted: #666;\n",
       "  --sklearn-color-line: gray;\n",
       "  /* Definition of color scheme for unfitted estimators */\n",
       "  --sklearn-color-unfitted-level-0: #fff5e6;\n",
       "  --sklearn-color-unfitted-level-1: #f6e4d2;\n",
       "  --sklearn-color-unfitted-level-2: #ffe0b3;\n",
       "  --sklearn-color-unfitted-level-3: chocolate;\n",
       "  /* Definition of color scheme for fitted estimators */\n",
       "  --sklearn-color-fitted-level-0: #f0f8ff;\n",
       "  --sklearn-color-fitted-level-1: #d4ebff;\n",
       "  --sklearn-color-fitted-level-2: #b3dbfd;\n",
       "  --sklearn-color-fitted-level-3: cornflowerblue;\n",
       "\n",
       "  /* Specific color for light theme */\n",
       "  --sklearn-color-text-on-default-background: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, black)));\n",
       "  --sklearn-color-background: var(--sg-background-color, var(--theme-background, var(--jp-layout-color0, white)));\n",
       "  --sklearn-color-border-box: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, black)));\n",
       "  --sklearn-color-icon: #696969;\n",
       "\n",
       "  @media (prefers-color-scheme: dark) {\n",
       "    /* Redefinition of color scheme for dark theme */\n",
       "    --sklearn-color-text-on-default-background: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, white)));\n",
       "    --sklearn-color-background: var(--sg-background-color, var(--theme-background, var(--jp-layout-color0, #111)));\n",
       "    --sklearn-color-border-box: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, white)));\n",
       "    --sklearn-color-icon: #878787;\n",
       "  }\n",
       "}\n",
       "\n",
       "#sk-container-id-1 {\n",
       "  color: var(--sklearn-color-text);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 pre {\n",
       "  padding: 0;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 input.sk-hidden--visually {\n",
       "  border: 0;\n",
       "  clip: rect(1px 1px 1px 1px);\n",
       "  clip: rect(1px, 1px, 1px, 1px);\n",
       "  height: 1px;\n",
       "  margin: -1px;\n",
       "  overflow: hidden;\n",
       "  padding: 0;\n",
       "  position: absolute;\n",
       "  width: 1px;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-dashed-wrapped {\n",
       "  border: 1px dashed var(--sklearn-color-line);\n",
       "  margin: 0 0.4em 0.5em 0.4em;\n",
       "  box-sizing: border-box;\n",
       "  padding-bottom: 0.4em;\n",
       "  background-color: var(--sklearn-color-background);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-container {\n",
       "  /* jupyter's `normalize.less` sets `[hidden] { display: none; }`\n",
       "     but bootstrap.min.css set `[hidden] { display: none !important; }`\n",
       "     so we also need the `!important` here to be able to override the\n",
       "     default hidden behavior on the sphinx rendered scikit-learn.org.\n",
       "     See: https://github.com/scikit-learn/scikit-learn/issues/21755 */\n",
       "  display: inline-block !important;\n",
       "  position: relative;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-text-repr-fallback {\n",
       "  display: none;\n",
       "}\n",
       "\n",
       "div.sk-parallel-item,\n",
       "div.sk-serial,\n",
       "div.sk-item {\n",
       "  /* draw centered vertical line to link estimators */\n",
       "  background-image: linear-gradient(var(--sklearn-color-text-on-default-background), var(--sklearn-color-text-on-default-background));\n",
       "  background-size: 2px 100%;\n",
       "  background-repeat: no-repeat;\n",
       "  background-position: center center;\n",
       "}\n",
       "\n",
       "/* Parallel-specific style estimator block */\n",
       "\n",
       "#sk-container-id-1 div.sk-parallel-item::after {\n",
       "  content: \"\";\n",
       "  width: 100%;\n",
       "  border-bottom: 2px solid var(--sklearn-color-text-on-default-background);\n",
       "  flex-grow: 1;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-parallel {\n",
       "  display: flex;\n",
       "  align-items: stretch;\n",
       "  justify-content: center;\n",
       "  background-color: var(--sklearn-color-background);\n",
       "  position: relative;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-parallel-item {\n",
       "  display: flex;\n",
       "  flex-direction: column;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-parallel-item:first-child::after {\n",
       "  align-self: flex-end;\n",
       "  width: 50%;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-parallel-item:last-child::after {\n",
       "  align-self: flex-start;\n",
       "  width: 50%;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-parallel-item:only-child::after {\n",
       "  width: 0;\n",
       "}\n",
       "\n",
       "/* Serial-specific style estimator block */\n",
       "\n",
       "#sk-container-id-1 div.sk-serial {\n",
       "  display: flex;\n",
       "  flex-direction: column;\n",
       "  align-items: center;\n",
       "  background-color: var(--sklearn-color-background);\n",
       "  padding-right: 1em;\n",
       "  padding-left: 1em;\n",
       "}\n",
       "\n",
       "\n",
       "/* Toggleable style: style used for estimator/Pipeline/ColumnTransformer box that is\n",
       "clickable and can be expanded/collapsed.\n",
       "- Pipeline and ColumnTransformer use this feature and define the default style\n",
       "- Estimators will overwrite some part of the style using the `sk-estimator` class\n",
       "*/\n",
       "\n",
       "/* Pipeline and ColumnTransformer style (default) */\n",
       "\n",
       "#sk-container-id-1 div.sk-toggleable {\n",
       "  /* Default theme specific background. It is overwritten whether we have a\n",
       "  specific estimator or a Pipeline/ColumnTransformer */\n",
       "  background-color: var(--sklearn-color-background);\n",
       "}\n",
       "\n",
       "/* Toggleable label */\n",
       "#sk-container-id-1 label.sk-toggleable__label {\n",
       "  cursor: pointer;\n",
       "  display: flex;\n",
       "  width: 100%;\n",
       "  margin-bottom: 0;\n",
       "  padding: 0.5em;\n",
       "  box-sizing: border-box;\n",
       "  text-align: center;\n",
       "  align-items: start;\n",
       "  justify-content: space-between;\n",
       "  gap: 0.5em;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 label.sk-toggleable__label .caption {\n",
       "  font-size: 0.6rem;\n",
       "  font-weight: lighter;\n",
       "  color: var(--sklearn-color-text-muted);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 label.sk-toggleable__label-arrow:before {\n",
       "  /* Arrow on the left of the label */\n",
       "  content: \"▸\";\n",
       "  float: left;\n",
       "  margin-right: 0.25em;\n",
       "  color: var(--sklearn-color-icon);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {\n",
       "  color: var(--sklearn-color-text);\n",
       "}\n",
       "\n",
       "/* Toggleable content - dropdown */\n",
       "\n",
       "#sk-container-id-1 div.sk-toggleable__content {\n",
       "  display: none;\n",
       "  text-align: left;\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-toggleable__content.fitted {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-0);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-toggleable__content pre {\n",
       "  margin: 0.2em;\n",
       "  border-radius: 0.25em;\n",
       "  color: var(--sklearn-color-text);\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-toggleable__content.fitted pre {\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-0);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {\n",
       "  /* Expand drop-down */\n",
       "  display: block;\n",
       "  width: 100%;\n",
       "  overflow: visible;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {\n",
       "  content: \"▾\";\n",
       "}\n",
       "\n",
       "/* Pipeline/ColumnTransformer-specific style */\n",
       "\n",
       "#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
       "  color: var(--sklearn-color-text);\n",
       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-label.fitted input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
       "  background-color: var(--sklearn-color-fitted-level-2);\n",
       "}\n",
       "\n",
       "/* Estimator-specific style */\n",
       "\n",
       "/* Colorize estimator box */\n",
       "#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-estimator.fitted input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-2);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-label label.sk-toggleable__label,\n",
       "#sk-container-id-1 div.sk-label label {\n",
       "  /* The background is the default theme color */\n",
       "  color: var(--sklearn-color-text-on-default-background);\n",
       "}\n",
       "\n",
       "/* On hover, darken the color of the background */\n",
       "#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {\n",
       "  color: var(--sklearn-color-text);\n",
       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
       "}\n",
       "\n",
       "/* Label box, darken color on hover, fitted */\n",
       "#sk-container-id-1 div.sk-label.fitted:hover label.sk-toggleable__label.fitted {\n",
       "  color: var(--sklearn-color-text);\n",
       "  background-color: var(--sklearn-color-fitted-level-2);\n",
       "}\n",
       "\n",
       "/* Estimator label */\n",
       "\n",
       "#sk-container-id-1 div.sk-label label {\n",
       "  font-family: monospace;\n",
       "  font-weight: bold;\n",
       "  display: inline-block;\n",
       "  line-height: 1.2em;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-label-container {\n",
       "  text-align: center;\n",
       "}\n",
       "\n",
       "/* Estimator-specific */\n",
       "#sk-container-id-1 div.sk-estimator {\n",
       "  font-family: monospace;\n",
       "  border: 1px dotted var(--sklearn-color-border-box);\n",
       "  border-radius: 0.25em;\n",
       "  box-sizing: border-box;\n",
       "  margin-bottom: 0.5em;\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-estimator.fitted {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-0);\n",
       "}\n",
       "\n",
       "/* on hover */\n",
       "#sk-container-id-1 div.sk-estimator:hover {\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-estimator.fitted:hover {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-2);\n",
       "}\n",
       "\n",
       "/* Specification for estimator info (e.g. \"i\" and \"?\") */\n",
       "\n",
       "/* Common style for \"i\" and \"?\" */\n",
       "\n",
       ".sk-estimator-doc-link,\n",
       "a:link.sk-estimator-doc-link,\n",
       "a:visited.sk-estimator-doc-link {\n",
       "  float: right;\n",
       "  font-size: smaller;\n",
       "  line-height: 1em;\n",
       "  font-family: monospace;\n",
       "  background-color: var(--sklearn-color-background);\n",
       "  border-radius: 1em;\n",
       "  height: 1em;\n",
       "  width: 1em;\n",
       "  text-decoration: none !important;\n",
       "  margin-left: 0.5em;\n",
       "  text-align: center;\n",
       "  /* unfitted */\n",
       "  border: var(--sklearn-color-unfitted-level-1) 1pt solid;\n",
       "  color: var(--sklearn-color-unfitted-level-1);\n",
       "}\n",
       "\n",
       ".sk-estimator-doc-link.fitted,\n",
       "a:link.sk-estimator-doc-link.fitted,\n",
       "a:visited.sk-estimator-doc-link.fitted {\n",
       "  /* fitted */\n",
       "  border: var(--sklearn-color-fitted-level-1) 1pt solid;\n",
       "  color: var(--sklearn-color-fitted-level-1);\n",
       "}\n",
       "\n",
       "/* On hover */\n",
       "div.sk-estimator:hover .sk-estimator-doc-link:hover,\n",
       ".sk-estimator-doc-link:hover,\n",
       "div.sk-label-container:hover .sk-estimator-doc-link:hover,\n",
       ".sk-estimator-doc-link:hover {\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-3);\n",
       "  color: var(--sklearn-color-background);\n",
       "  text-decoration: none;\n",
       "}\n",
       "\n",
       "div.sk-estimator.fitted:hover .sk-estimator-doc-link.fitted:hover,\n",
       ".sk-estimator-doc-link.fitted:hover,\n",
       "div.sk-label-container:hover .sk-estimator-doc-link.fitted:hover,\n",
       ".sk-estimator-doc-link.fitted:hover {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-3);\n",
       "  color: var(--sklearn-color-background);\n",
       "  text-decoration: none;\n",
       "}\n",
       "\n",
       "/* Span, style for the box shown on hovering the info icon */\n",
       ".sk-estimator-doc-link span {\n",
       "  display: none;\n",
       "  z-index: 9999;\n",
       "  position: relative;\n",
       "  font-weight: normal;\n",
       "  right: .2ex;\n",
       "  padding: .5ex;\n",
       "  margin: .5ex;\n",
       "  width: min-content;\n",
       "  min-width: 20ex;\n",
       "  max-width: 50ex;\n",
       "  color: var(--sklearn-color-text);\n",
       "  box-shadow: 2pt 2pt 4pt #999;\n",
       "  /* unfitted */\n",
       "  background: var(--sklearn-color-unfitted-level-0);\n",
       "  border: .5pt solid var(--sklearn-color-unfitted-level-3);\n",
       "}\n",
       "\n",
       ".sk-estimator-doc-link.fitted span {\n",
       "  /* fitted */\n",
       "  background: var(--sklearn-color-fitted-level-0);\n",
       "  border: var(--sklearn-color-fitted-level-3);\n",
       "}\n",
       "\n",
       ".sk-estimator-doc-link:hover span {\n",
       "  display: block;\n",
       "}\n",
       "\n",
       "/* \"?\"-specific style due to the `<a>` HTML tag */\n",
       "\n",
       "#sk-container-id-1 a.estimator_doc_link {\n",
       "  float: right;\n",
       "  font-size: 1rem;\n",
       "  line-height: 1em;\n",
       "  font-family: monospace;\n",
       "  background-color: var(--sklearn-color-background);\n",
       "  border-radius: 1rem;\n",
       "  height: 1rem;\n",
       "  width: 1rem;\n",
       "  text-decoration: none;\n",
       "  /* unfitted */\n",
       "  color: var(--sklearn-color-unfitted-level-1);\n",
       "  border: var(--sklearn-color-unfitted-level-1) 1pt solid;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 a.estimator_doc_link.fitted {\n",
       "  /* fitted */\n",
       "  border: var(--sklearn-color-fitted-level-1) 1pt solid;\n",
       "  color: var(--sklearn-color-fitted-level-1);\n",
       "}\n",
       "\n",
       "/* On hover */\n",
       "#sk-container-id-1 a.estimator_doc_link:hover {\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-3);\n",
       "  color: var(--sklearn-color-background);\n",
       "  text-decoration: none;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 a.estimator_doc_link.fitted:hover {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-3);\n",
       "}\n",
       "\n",
       ".estimator-table summary {\n",
       "    padding: .5rem;\n",
       "    font-family: monospace;\n",
       "    cursor: pointer;\n",
       "}\n",
       "\n",
       ".estimator-table details[open] {\n",
       "    padding-left: 0.1rem;\n",
       "    padding-right: 0.1rem;\n",
       "    padding-bottom: 0.3rem;\n",
       "}\n",
       "\n",
       ".estimator-table .parameters-table {\n",
       "    margin-left: auto !important;\n",
       "    margin-right: auto !important;\n",
       "}\n",
       "\n",
       ".estimator-table .parameters-table tr:nth-child(odd) {\n",
       "    background-color: #fff;\n",
       "}\n",
       "\n",
       ".estimator-table .parameters-table tr:nth-child(even) {\n",
       "    background-color: #f6f6f6;\n",
       "}\n",
       "\n",
       ".estimator-table .parameters-table tr:hover {\n",
       "    background-color: #e0e0e0;\n",
       "}\n",
       "\n",
       ".estimator-table table td {\n",
       "    border: 1px solid rgba(106, 105, 104, 0.232);\n",
       "}\n",
       "\n",
       ".user-set td {\n",
       "    color:rgb(255, 94, 0);\n",
       "    text-align: left;\n",
       "}\n",
       "\n",
       ".user-set td.value pre {\n",
       "    color:rgb(255, 94, 0) !important;\n",
       "    background-color: transparent !important;\n",
       "}\n",
       "\n",
       ".default td {\n",
       "    color: black;\n",
       "    text-align: left;\n",
       "}\n",
       "\n",
       ".user-set td i,\n",
       ".default td i {\n",
       "    color: black;\n",
       "}\n",
       "\n",
       ".copy-paste-icon {\n",
       "    background-image: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA0NDggNTEyIj48IS0tIUZvbnQgQXdlc29tZSBGcmVlIDYuNy4yIGJ5IEBmb250YXdlc29tZSAtIGh0dHBzOi8vZm9udGF3ZXNvbWUuY29tIExpY2Vuc2UgLSBodHRwczovL2ZvbnRhd2Vzb21lLmNvbS9saWNlbnNlL2ZyZWUgQ29weXJpZ2h0IDIwMjUgRm9udGljb25zLCBJbmMuLS0+PHBhdGggZD0iTTIwOCAwTDMzMi4xIDBjMTIuNyAwIDI0LjkgNS4xIDMzLjkgMTQuMWw2Ny45IDY3LjljOSA5IDE0LjEgMjEuMiAxNC4xIDMzLjlMNDQ4IDMzNmMwIDI2LjUtMjEuNSA0OC00OCA0OGwtMTkyIDBjLTI2LjUgMC00OC0yMS41LTQ4LTQ4bDAtMjg4YzAtMjYuNSAyMS41LTQ4IDQ4LTQ4ek00OCAxMjhsODAgMCAwIDY0LTY0IDAgMCAyNTYgMTkyIDAgMC0zMiA2NCAwIDAgNDhjMCAyNi41LTIxLjUgNDgtNDggNDhMNDggNTEyYy0yNi41IDAtNDgtMjEuNS00OC00OEwwIDE3NmMwLTI2LjUgMjEuNS00OCA0OC00OHoiLz48L3N2Zz4=);\n",
       "    background-repeat: no-repeat;\n",
       "    background-size: 14px 14px;\n",
       "    background-position: 0;\n",
       "    display: inline-block;\n",
       "    width: 14px;\n",
       "    height: 14px;\n",
       "    cursor: pointer;\n",
       "}\n",
       "</style><body><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>Pipeline(steps=[(&#x27;scale&#x27;, StandardScaler()),\n",
       "                (&#x27;classifier&#x27;,\n",
       "                 LogisticRegression(C=np.float64(3.7275937203149416),\n",
       "                                    max_iter=2000))])</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item sk-dashed-wrapped\"><div class=\"sk-label-container\"><div class=\"sk-label fitted sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" ><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label fitted sk-toggleable__label-arrow\"><div><div>Pipeline</div></div><div><a class=\"sk-estimator-doc-link fitted\" rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.7/modules/generated/sklearn.pipeline.Pipeline.html\">?<span>Documentation for Pipeline</span></a><span class=\"sk-estimator-doc-link fitted\">i<span>Fitted</span></span></div></label><div class=\"sk-toggleable__content fitted\" data-param-prefix=\"\">\n",
       "        <div class=\"estimator-table\">\n",
       "            <details>\n",
       "                <summary>Parameters</summary>\n",
       "                <table class=\"parameters-table\">\n",
       "                  <tbody>\n",
       "                    \n",
       "        <tr class=\"user-set\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('steps',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">steps&nbsp;</td>\n",
       "            <td class=\"value\">[(&#x27;scale&#x27;, ...), (&#x27;classifier&#x27;, ...)]</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('transform_input',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">transform_input&nbsp;</td>\n",
       "            <td class=\"value\">None</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('memory',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">memory&nbsp;</td>\n",
       "            <td class=\"value\">None</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('verbose',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">verbose&nbsp;</td>\n",
       "            <td class=\"value\">False</td>\n",
       "        </tr>\n",
       "    \n",
       "                  </tbody>\n",
       "                </table>\n",
       "            </details>\n",
       "        </div>\n",
       "    </div></div></div><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-estimator fitted sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-2\" type=\"checkbox\" ><label for=\"sk-estimator-id-2\" class=\"sk-toggleable__label fitted sk-toggleable__label-arrow\"><div><div>StandardScaler</div></div><div><a class=\"sk-estimator-doc-link fitted\" rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.7/modules/generated/sklearn.preprocessing.StandardScaler.html\">?<span>Documentation for StandardScaler</span></a></div></label><div class=\"sk-toggleable__content fitted\" data-param-prefix=\"scale__\">\n",
       "        <div class=\"estimator-table\">\n",
       "            <details>\n",
       "                <summary>Parameters</summary>\n",
       "                <table class=\"parameters-table\">\n",
       "                  <tbody>\n",
       "                    \n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('copy',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">copy&nbsp;</td>\n",
       "            <td class=\"value\">True</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('with_mean',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">with_mean&nbsp;</td>\n",
       "            <td class=\"value\">True</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('with_std',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">with_std&nbsp;</td>\n",
       "            <td class=\"value\">True</td>\n",
       "        </tr>\n",
       "    \n",
       "                  </tbody>\n",
       "                </table>\n",
       "            </details>\n",
       "        </div>\n",
       "    </div></div></div><div class=\"sk-item\"><div class=\"sk-estimator fitted sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-3\" type=\"checkbox\" ><label for=\"sk-estimator-id-3\" class=\"sk-toggleable__label fitted sk-toggleable__label-arrow\"><div><div>LogisticRegression</div></div><div><a class=\"sk-estimator-doc-link fitted\" rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.7/modules/generated/sklearn.linear_model.LogisticRegression.html\">?<span>Documentation for LogisticRegression</span></a></div></label><div class=\"sk-toggleable__content fitted\" data-param-prefix=\"classifier__\">\n",
       "        <div class=\"estimator-table\">\n",
       "            <details>\n",
       "                <summary>Parameters</summary>\n",
       "                <table class=\"parameters-table\">\n",
       "                  <tbody>\n",
       "                    \n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('penalty',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">penalty&nbsp;</td>\n",
       "            <td class=\"value\">&#x27;l2&#x27;</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('dual',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">dual&nbsp;</td>\n",
       "            <td class=\"value\">False</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('tol',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">tol&nbsp;</td>\n",
       "            <td class=\"value\">0.0001</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"user-set\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('C',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">C&nbsp;</td>\n",
       "            <td class=\"value\">np.float64(3.7275937203149416)</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('fit_intercept',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">fit_intercept&nbsp;</td>\n",
       "            <td class=\"value\">True</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('intercept_scaling',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">intercept_scaling&nbsp;</td>\n",
       "            <td class=\"value\">1</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('class_weight',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">class_weight&nbsp;</td>\n",
       "            <td class=\"value\">None</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('random_state',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">random_state&nbsp;</td>\n",
       "            <td class=\"value\">None</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('solver',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">solver&nbsp;</td>\n",
       "            <td class=\"value\">&#x27;lbfgs&#x27;</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"user-set\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('max_iter',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">max_iter&nbsp;</td>\n",
       "            <td class=\"value\">2000</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('multi_class',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">multi_class&nbsp;</td>\n",
       "            <td class=\"value\">&#x27;deprecated&#x27;</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('verbose',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">verbose&nbsp;</td>\n",
       "            <td class=\"value\">0</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('warm_start',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">warm_start&nbsp;</td>\n",
       "            <td class=\"value\">False</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('n_jobs',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">n_jobs&nbsp;</td>\n",
       "            <td class=\"value\">None</td>\n",
       "        </tr>\n",
       "    \n",
       "\n",
       "        <tr class=\"default\">\n",
       "            <td><i class=\"copy-paste-icon\"\n",
       "                 onclick=\"copyToClipboard('l1_ratio',\n",
       "                          this.parentElement.nextElementSibling)\"\n",
       "            ></i></td>\n",
       "            <td class=\"param\">l1_ratio&nbsp;</td>\n",
       "            <td class=\"value\">None</td>\n",
       "        </tr>\n",
       "    \n",
       "                  </tbody>\n",
       "                </table>\n",
       "            </details>\n",
       "        </div>\n",
       "    </div></div></div></div></div></div></div><script>function copyToClipboard(text, element) {\n",
       "    // Get the parameter prefix from the closest toggleable content\n",
       "    const toggleableContent = element.closest('.sk-toggleable__content');\n",
       "    const paramPrefix = toggleableContent ? toggleableContent.dataset.paramPrefix : '';\n",
       "    const fullParamName = paramPrefix ? `${paramPrefix}${text}` : text;\n",
       "\n",
       "    const originalStyle = element.style;\n",
       "    const computedStyle = window.getComputedStyle(element);\n",
       "    const originalWidth = computedStyle.width;\n",
       "    const originalHTML = element.innerHTML.replace('Copied!', '');\n",
       "\n",
       "    navigator.clipboard.writeText(fullParamName)\n",
       "        .then(() => {\n",
       "            element.style.width = originalWidth;\n",
       "            element.style.color = 'green';\n",
       "            element.innerHTML = \"Copied!\";\n",
       "\n",
       "            setTimeout(() => {\n",
       "                element.innerHTML = originalHTML;\n",
       "                element.style = originalStyle;\n",
       "            }, 2000);\n",
       "        })\n",
       "        .catch(err => {\n",
       "            console.error('Failed to copy:', err);\n",
       "            element.style.color = 'red';\n",
       "            element.innerHTML = \"Failed!\";\n",
       "            setTimeout(() => {\n",
       "                element.innerHTML = originalHTML;\n",
       "                element.style = originalStyle;\n",
       "            }, 2000);\n",
       "        });\n",
       "    return false;\n",
       "}\n",
       "\n",
       "document.querySelectorAll('.fa-regular.fa-copy').forEach(function(element) {\n",
       "    const toggleableContent = element.closest('.sk-toggleable__content');\n",
       "    const paramPrefix = toggleableContent ? toggleableContent.dataset.paramPrefix : '';\n",
       "    const paramName = element.parentElement.nextElementSibling.textContent.trim();\n",
       "    const fullParamName = paramPrefix ? `${paramPrefix}${paramName}` : paramName;\n",
       "\n",
       "    element.setAttribute('title', fullParamName);\n",
       "});\n",
       "</script></body>"
      ],
      "text/plain": [
       "Pipeline(steps=[('scale', StandardScaler()),\n",
       "                ('classifier',\n",
       "                 LogisticRegression(C=np.float64(3.7275937203149416),\n",
       "                                    max_iter=2000))])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "selected_model = Pipeline([\n",
    "    (\"scale\", StandardScaler()),\n",
    "    (\"classifier\", LogisticRegression(C=best_C, max_iter=2000)),\n",
    "])\n",
    "selected_model.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "tp4-023",
   "metadata": {},
   "source": [
    "## 5. From probabilities to a ROC operating point\n",
    "Compute the selected model's validation probabilities. Plot the [`roc_curve`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_curve.html) and report [`roc_auc_score`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_auc_score.html). The diagonal corresponds to random ranking, with an AUC of $0.5$. Because the sigmoid is increasing, the ROC is the same whether we pass `decision_function` scores or class 1 probabilities.\n",
    "\n",
    "Each threshold gives one point $(\\mathrm{FPR},\\mathrm{TPR})$ on this curve. Locate the operating point for $\\tau=0.5$ and compare it with $\\tau=0.8$.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "tp4-024",
   "metadata": {
    "tags": [
     "exercise"
    ]
   },
   "outputs": [],
   "source": [
    "# TODO: compute p_valid and z_valid from selected_model.\n",
    "# Use roc_curve(y_valid, p_valid) to obtain fpr and tpr.\n",
    "# Plot the ROC and the random-ranking diagonal.\n",
    "# Verify ROC-AUC is the same for z_valid and p_valid.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "tp4-025",
   "metadata": {
    "tags": [
     "correction"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation ROC-AUC: 0.996\n",
      "Same AUC with linear score: True\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "p_valid = selected_model.predict_proba(X_valid)[:, 1]\n",
    "z_valid = selected_model.decision_function(X_valid)\n",
    "fpr, tpr, roc_thresholds = roc_curve(y_valid, p_valid)\n",
    "auc_probability = roc_auc_score(y_valid, p_valid)\n",
    "auc_score = roc_auc_score(y_valid, z_valid)\n",
    "print(f\"Validation ROC-AUC: {auc_probability:.3f}\")\n",
    "print(\"Same AUC with linear score:\", np.isclose(auc_probability, auc_score))\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(6, 5))\n",
    "ax.plot(fpr, tpr, label=f\"Logistic model (AUC={auc_probability:.3f})\")\n",
    "ax.plot([0, 1], [0, 1], \"--\", color=\"gray\", label=\"Random ranking (AUC=0.5)\")\n",
    "ax.set(xlabel=\"False positive rate\", ylabel=\"True positive rate\",\n",
    "       title=\"Validation ROC curve\", xlim=(-0.01, 1.01), ylim=(-0.01, 1.01))\n",
    "ax.grid(alpha=0.25)\n",
    "ax.legend()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "tp4-026",
   "metadata": {
    "tags": [
     "exercise"
    ]
   },
   "outputs": [],
   "source": [
    "# TODO: for thresholds 0.5 and 0.8, compute predictions and report precision, recall, FPR and F1 for each threshold.\n",
    "# Explain the direction of movement on the ROC curve.\n",
    "# Verify that tau=0.8 corresponds to z >= log(0.8 / 0.2).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "tp4-027",
   "metadata": {
    "tags": [
     "correction"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tau=0.5: TP=42, FN= 1, FP= 2, TN=69; precision=0.955, recall=0.977, FPR=0.028, F1=0.966\n",
      "tau=0.8: TP=42, FN= 1, FP= 0, TN=71; precision=1.000, recall=0.977, FPR=0.000, F1=0.988\n",
      "z threshold for tau=0.8: 1.3862943611198906\n",
      "Same decisions: True\n",
      "Increasing the threshold cannot increase TPR or FPR; either can stay unchanged.\n"
     ]
    }
   ],
   "source": [
    "for threshold in (0.5, 0.8):\n",
    "    predictions = (p_valid >= threshold).astype(int)\n",
    "    tn, fp, fn, tp = confusion_matrix(y_valid, predictions).ravel()\n",
    "    print(\n",
    "        f\"tau={threshold:.1f}: TP={tp:2d}, FN={fn:2d}, \"\n",
    "        f\"FP={fp:2d}, TN={tn:2d}; \"\n",
    "        f\"precision={precision_score(y_valid, predictions, zero_division=0):.3f}, \"\n",
    "        f\"recall={recall_score(y_valid, predictions):.3f}, \"\n",
    "        f\"FPR={fp / (fp + tn):.3f}, \"\n",
    "        f\"F1={f1_score(y_valid, predictions):.3f}\"\n",
    "    )\n",
    "print(\"z threshold for tau=0.8:\", np.log(0.8 / 0.2))\n",
    "print(\"Same decisions:\", np.array_equal(\n",
    "    p_valid >= 0.8, z_valid >= np.log(0.8 / 0.2)\n",
    "))\n",
    "print(\"Increasing the threshold cannot increase TPR or FPR; either can stay unchanged.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "tp4-028",
   "metadata": {},
   "source": [
    "To make threshold selection explicit, suppose a false negative costs 5 and a false positive costs 1. On the validation subset only, evaluate candidate thresholds in `np.linspace(0.1, 0.9, 17)` and choose the one with the smallest total cost $5\\,\\mathrm{FN}+\\mathrm{FP}$. This illustrative cost ratio is **not** a clinical recommendation. Compare the chosen point with $\\tau=0.5$ on the ROC plot.\n",
    "\n",
    "If several thresholds have the same minimum cost, the code below chooses the first one. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "tp4-029",
   "metadata": {
    "tags": [
     "exercise"
    ]
   },
   "outputs": [],
   "source": [
    "candidate_thresholds = np.linspace(0.1, 0.9, 17)\n",
    "\n",
    "# TODO: compute validation cost 5 * FN + FP for each candidate threshold.\n",
    "# Store the costs in an array and select the first minimum with np.argmin.\n",
    "# Do not inspect the test set.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "tp4-030",
   "metadata": {
    "tags": [
     "correction"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation costs:\n",
      "  tau=0.10: cost=15\n",
      "  tau=0.15: cost=14\n",
      "  tau=0.20: cost=13\n",
      "  tau=0.25: cost=10\n",
      "  tau=0.30: cost=9\n",
      "  tau=0.35: cost=8\n",
      "  tau=0.40: cost=7\n",
      "  tau=0.45: cost=7\n",
      "  tau=0.50: cost=7\n",
      "  tau=0.55: cost=7\n",
      "  tau=0.60: cost=7\n",
      "  tau=0.65: cost=7\n",
      "  tau=0.70: cost=7\n",
      "  tau=0.75: cost=6\n",
      "  tau=0.80: cost=5\n",
      "  tau=0.85: cost=5\n",
      "  tau=0.90: cost=5\n",
      "Chosen threshold: 0.80\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "validation_costs = []\n",
    "for threshold in candidate_thresholds:\n",
    "    predictions = (p_valid >= threshold).astype(int)\n",
    "    tn, fp, fn, tp = confusion_matrix(y_valid, predictions).ravel()\n",
    "    validation_costs.append(5 * fn + fp)\n",
    "validation_costs = np.asarray(validation_costs)\n",
    "chosen_threshold = candidate_thresholds[np.argmin(validation_costs)]\n",
    "\n",
    "print(\"Validation costs:\")\n",
    "for threshold, cost in zip(candidate_thresholds, validation_costs):\n",
    "    print(f\"  tau={threshold:.2f}: cost={cost}\")\n",
    "print(f\"Chosen threshold: {chosen_threshold:.2f}\")\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(6, 5))\n",
    "ax.plot(fpr, tpr, label=\"Validation ROC\")\n",
    "ax.plot([0, 1], [0, 1], \"--\", color=\"gray\", label=\"Random ranking\")\n",
    "for threshold, color in ((0.5, \"tab:orange\"), (chosen_threshold, \"tab:red\")):\n",
    "    pred = (p_valid >= threshold).astype(int)\n",
    "    tn, fp, fn, tp = confusion_matrix(y_valid, pred).ravel()\n",
    "    ax.scatter(fp / (fp + tn), tp / (tp + fn), s=90, color=color,\n",
    "               label=f\"tau={threshold:.2f}\", zorder=3)\n",
    "ax.set(xlabel=\"False positive rate\", ylabel=\"True positive rate\",\n",
    "       title=\"Two decisions from the same fitted model\",\n",
    "       xlim=(-0.01, 1.01), ylim=(-0.01, 1.01))\n",
    "ax.grid(alpha=0.25)\n",
    "ax.legend()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "tp4-031",
   "metadata": {},
   "source": [
    "## 6. One final test evaluation\n",
    "\n",
    "Freeze the fitted model and the selected threshold. Evaluate them **once** on `X_test, y_test`. Report accuracy, precision, recall, F1, ROC-AUC and the confusion matrix. Compare the chosen threshold with the default `0.5` on the same test probabilities. The test results are an estimate of performance for this fixed protocol; do not tune either `C` or the threshold after seeing them. If the chosen threshold performs worse on test than on validation, report that discrepancy.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "tp4-032",
   "metadata": {
    "tags": [
     "exercise"
    ]
   },
   "outputs": [],
   "source": [
    "# TODO: compute p_test from selected_model without refitting it.\n",
    "# Compare tau=0.5 and chosen_threshold on the test set.\n",
    "# Report the requested metrics and confusion matrices.\n",
    "# State whether the cost-based choice changed the FP/FN trade-off.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "tp4-033",
   "metadata": {
    "tags": [
     "correction"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Test at tau=0.50\n",
      "Confusion matrix:\n",
      "              Predicted\n",
      "              0     1\n",
      "Actual 0     71     1\n",
      "       1      2    40\n",
      "Accuracy : 0.974\n",
      "Precision: 0.976\n",
      "Recall   : 0.952\n",
      "F1       : 0.964\n",
      "ROC-AUC  : 0.990\n",
      "Illustrative cost: 11\n",
      "\n",
      "Test at tau=0.80\n",
      "Confusion matrix:\n",
      "              Predicted\n",
      "              0     1\n",
      "Actual 0     71     1\n",
      "       1      5    37\n",
      "Accuracy : 0.947\n",
      "Precision: 0.974\n",
      "Recall   : 0.881\n",
      "F1       : 0.925\n",
      "ROC-AUC  : 0.990\n",
      "Illustrative cost: 26\n"
     ]
    }
   ],
   "source": [
    "p_test = selected_model.predict_proba(X_test)[:, 1]\n",
    "test_auc = roc_auc_score(y_test, p_test)\n",
    "for threshold in (0.5, chosen_threshold):\n",
    "    predictions = (p_test >= threshold).astype(int)\n",
    "    tn, fp, fn, tp = confusion_matrix(y_test, predictions).ravel()\n",
    "    print()\n",
    "    print(f\"Test at tau={threshold:.2f}\")\n",
    "    print(\"Confusion matrix:\")\n",
    "    print(\"              Predicted\")\n",
    "    print(\"              0     1\")\n",
    "    print(f\"Actual 0   {tn:4d}  {fp:4d}\")\n",
    "    print(f\"       1   {fn:4d}  {tp:4d}\")\n",
    "    print(f\"Accuracy : {accuracy_score(y_test, predictions):.3f}\")\n",
    "    print(f\"Precision: {precision_score(y_test, predictions, zero_division=0):.3f}\")\n",
    "    print(f\"Recall   : {recall_score(y_test, predictions):.3f}\")\n",
    "    print(f\"F1       : {f1_score(y_test, predictions):.3f}\")\n",
    "    print(f\"ROC-AUC  : {test_auc:.3f}\")\n",
    "    print(f\"Illustrative cost: {5 * fn + fp}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "tp4-034",
   "metadata": {},
   "source": [
    "### Takeaways\n",
    "\n",
    "1. What remains fixed when the decision threshold changes?\n",
    "2. Why can ROC-AUC remain constant while recall changes?\n",
    "3. Which choices used only training data, which used validation data, and what was reserved for test?\n",
    "4. Why do the reported metrics not establish clinical usefulness?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "tp4-035",
   "metadata": {
    "tags": [
     "correction"
    ]
   },
   "source": [
    "### Proposed answers\n",
    "\n",
    "The fitted coefficients and probabilities stay fixed when only the threshold changes. ROC-AUC measures ranking over all thresholds, while recall refers to one threshold. Cross-validation on the training subset selected `C`; validation selected the threshold; test was used once for final evaluation. In this particular split, the validation-selected threshold can have a higher cost on test than the default threshold: the small validation set gives a noisy choice. We report this result and do not retune on test. A teaching dataset, one random split and an invented error cost do not establish performance or suitability in clinical practice.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "tp4-036",
   "metadata": {
    "tags": [
     "optional"
    ]
   },
   "source": [
    "## Optional — Gradient of the logistic loss\n",
    "\n",
    "Raschka's derivation and the bonus CM03 slides show that, for one observation,\n",
    "\n",
    "$$\n",
    "\\frac{\\partial\\ell_i}{\\partial z_i}=p_i-y_i.\n",
    "$$\n",
    "\n",
    "Therefore, without regularization,\n",
    "\n",
    "$$\n",
    "\\nabla_{\\mathbf w}J=\\frac{1}{n}X^\\top(\\mathbf p-\\mathbf y),\n",
    "\\qquad\n",
    "\\frac{\\partial J}{\\partial b}=\\frac{1}{n}\\sum_i(p_i-y_i).\n",
    "$$\n",
    "\n",
    "On a tiny synthetic design matrix, compute these gradients at $\\mathbf w=0,b=0$ and make one gradient-descent step. This illustrates the **shape** of the update, not scikit-learn's numerical solver.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "tp4-037",
   "metadata": {
    "tags": [
     "exercise",
     "optional"
    ]
   },
   "outputs": [],
   "source": [
    "X_tiny = np.array([[1.0, 0.0], [0.0, 1.0], [1.0, 1.0], [-1.0, -1.0]])\n",
    "y_tiny = np.array([1, 1, 1, 0])\n",
    "w_tiny = np.zeros(2)\n",
    "b_tiny = 0.0\n",
    "learning_rate = 0.5\n",
    "\n",
    "# TODO: compute z, p, grad_w and grad_b.\n",
    "# TODO: update w_tiny and b_tiny once.\n",
    "# Compare mean binary_log_loss before and after the update.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "tp4-038",
   "metadata": {
    "tags": [
     "correction",
     "optional"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "grad_w: [-0.375 -0.375] grad_b: -0.25\n",
      "loss before: 0.6931; after one step: 0.5370\n"
     ]
    }
   ],
   "source": [
    "z_before = X_tiny @ w_tiny + b_tiny\n",
    "p_before = sigmoid(z_before)\n",
    "loss_before = binary_log_loss(y_tiny, p_before).mean()\n",
    "\n",
    "grad_w = X_tiny.T @ (p_before - y_tiny) / len(y_tiny)\n",
    "grad_b = np.mean(p_before - y_tiny)\n",
    "w_tiny -= learning_rate * grad_w\n",
    "b_tiny -= learning_rate * grad_b\n",
    "\n",
    "p_after = sigmoid(X_tiny @ w_tiny + b_tiny)\n",
    "loss_after = binary_log_loss(y_tiny, p_after).mean()\n",
    "print(\"grad_w:\", grad_w, \"grad_b:\", grad_b)\n",
    "print(f\"loss before: {loss_before:.4f}; after one step: {loss_after:.4f}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cedd0ae4",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "insa-iml-practicals (3.10.20)",
   "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.10.20"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}