diff --git "a/midterm/midterm/take_at_home_(1).ipynb" "b/midterm/midterm/take_at_home_(1).ipynb"
--- "a/midterm/midterm/take_at_home_(1).ipynb"
+++ "b/midterm/midterm/take_at_home_(1).ipynb"
@@ -186,6 +186,13 @@
     "# write your code here"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Preprocessing"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 2,
@@ -372,19 +379,19 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/tmp/ipykernel_34276/1867621695.py:5: SettingWithCopyWarning: \n",
+      "/tmp/ipykernel_79816/1867621695.py:5: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame.\n",
       "Try using .loc[row_indexer,col_indexer] = value instead\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df2[x] = LabelEncoder().fit_transform(df2[x])\n",
-      "/tmp/ipykernel_34276/1867621695.py:5: SettingWithCopyWarning: \n",
+      "/tmp/ipykernel_79816/1867621695.py:5: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame.\n",
       "Try using .loc[row_indexer,col_indexer] = value instead\n",
       "\n",
       "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
       "  df2[x] = LabelEncoder().fit_transform(df2[x])\n",
-      "/tmp/ipykernel_34276/1867621695.py:5: SettingWithCopyWarning: \n",
+      "/tmp/ipykernel_79816/1867621695.py:5: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame.\n",
       "Try using .loc[row_indexer,col_indexer] = value instead\n",
       "\n",
@@ -732,16 +739,206 @@
    },
    "outputs": [],
    "source": [
-    "from sklearn.linear_model import LogisticRegression\n",
     "from sklearn.model_selection import train_test_split\n",
     "X = df3.drop(['PARASITE_STATUS'], axis=1)\n",
     "y = df3['PARASITE_STATUS']\n",
     "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Logreg Model"
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from sklearn.base import BaseEstimator, ClassifierMixin\n",
+    "from sklearn import metrics\n",
+    "\n",
+    "\n",
+    "class MyLogisticRegression(BaseEstimator, ClassifierMixin):\n",
+    "    def __init__(self, lr=0.01, batch_size=None, max_iter=100, tol=1e-4):\n",
+    "        self.lr = lr\n",
+    "        self.batch_size = batch_size\n",
+    "        self.max_iter = max_iter\n",
+    "        self.tol = tol\n",
+    "        self.f1_score_history = []\n",
+    "\n",
+    "    def _sigmoid(self, z):\n",
+    "        z = np.clip(z, -1e2, 1e2)\n",
+    "        return 1 / (1 + np.exp(-z))\n",
+    "\n",
+    "    def _add_intercept(self, X):\n",
+    "        return np.concatenate((np.ones((X.shape[0], 1)), X), axis=1)\n",
+    "\n",
+    "    def _compute_gradient(self, X, y):\n",
+    "        y_pred = self._sigmoid(np.dot(X, self.coef_))\n",
+    "        grad = np.dot(X.T, (y_pred - y)) / X.shape[0]\n",
+    "        return grad\n",
+    "\n",
+    "    def fit(self, X, y):\n",
+    "        X = self._add_intercept(X)\n",
+    "\n",
+    "        # Initialize weights to zeros\n",
+    "        self.coef_ = np.zeros(X.shape[1])\n",
+    "\n",
+    "        # Mini-batch gradient descent\n",
+    "        for epoch in range(self.max_iter):\n",
+    "            if self.batch_size is not None:\n",
+    "                batch_indices = np.random.choice(X.shape[0], size=self.batch_size, replace=False)\n",
+    "                X_batch = X[batch_indices]\n",
+    "                y_batch = y[batch_indices]\n",
+    "            else:\n",
+    "                X_batch = X\n",
+    "                y_batch = y\n",
+    "\n",
+    "            # Compute gradient\n",
+    "            grad = self._compute_gradient(X_batch, y_batch)\n",
+    "\n",
+    "            # Update weights\n",
+    "            self.coef_ -= self.lr * grad\n",
+    "\n",
+    "            # Check for convergence\n",
+    "            if np.abs(grad).max() < self.tol:\n",
+    "                break\n",
+    "                \n",
+    "            # Compute f1 score\n",
+    "            y_pred = self.predict(X_test)\n",
+    "            f1_score = metrics.f1_score(y_test, y_pred, average='weighted')\n",
+    "            self.f1_score_history.append({'epoch': epoch, 'f1 score': f1_score})\n",
+    "\n",
+    "\n",
+    "        return self\n",
+    "\n",
+    "    def predict(self, X):\n",
+    "        X = self._add_intercept(X)\n",
+    "        return np.round(self._sigmoid(np.dot(X, self.coef_)))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "## Test"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.9290780141843972"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "from sklearn.datasets import make_classification\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.metrics import accuracy_score\n",
+    "from sklearn.utils import check_random_state\n",
+    "\n",
+    "\n",
+    "#def test_minibatch_logistic_regression():\n",
+    "# Generate some random classification data\n",
+    "X, y = make_classification(n_samples=1000, n_features=10, random_state=42)\n",
+    "\n",
+    "# Split data into training and test sets\n",
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\n",
+    "\n",
+    "# Instantiate the MyLogisticRegression model\n",
+    "model = MyLogisticRegression(lr=0.01, batch_size=32, max_iter=100)\n",
+    "\n",
+    "# Fit the model on the training data\n",
+    "model.fit(X_train, y_train)\n",
+    "\n",
+    "# Predict the labels for the test data\n",
+    "y_pred = model.predict(X_test)\n",
+    "\n",
+    "# Check that the predicted labels are binary\n",
+    "assert set(np.unique(y_pred)) == {0, 1}\n",
+    "\n",
+    "# Calculate the accuracy of the predictions\n",
+    "accuracy = accuracy_score(y_test, y_pred)\n",
+    "\n",
+    "# Check that the accuracy is greater than chance level\n",
+    "assert accuracy > 0.5\n",
+    "\n",
+    "\n",
+    "from sklearn.metrics import precision_score, recall_score, f1_score\n",
+    "from sklearn.metrics import confusion_matrix\n",
+    "\n",
+    "y_pred = model.predict(X_test)\n",
+    "precision = precision_score(y_test, y_pred)\n",
+    "precision"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.8533333333333334"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "accuracy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[125,  10],\n",
+       "       [ 34, 131]])"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "confusion_matrix(y_test, y_pred)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
    "metadata": {
     "tags": []
    },
@@ -749,217 +946,161 @@
     {
      "data": {
       "text/html": [
-       "<style>#sk-container-id-2 {color: black;background-color: white;}#sk-container-id-2 pre{padding: 0;}#sk-container-id-2 div.sk-toggleable {background-color: white;}#sk-container-id-2 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-2 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-2 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-2 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-2 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-2 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-2 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-2 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-2 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-2 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-2 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-2 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-2 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-2 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-2 div.sk-item {position: relative;z-index: 1;}#sk-container-id-2 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-2 div.sk-item::before, #sk-container-id-2 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-2 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-2 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-2 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-2 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-2 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-2 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-2 div.sk-label-container {text-align: center;}#sk-container-id-2 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-2 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-2\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>Pipeline(steps=[(&#x27;preprocessor&#x27;, StandardScaler()),\n",
-       "                (&#x27;classifier&#x27;,\n",
-       "                 LogisticRegression(class_weight=&#x27;balanced&#x27;, max_iter=20000))])</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 sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-4\" type=\"checkbox\" ><label for=\"sk-estimator-id-4\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">Pipeline</label><div class=\"sk-toggleable__content\"><pre>Pipeline(steps=[(&#x27;preprocessor&#x27;, StandardScaler()),\n",
-       "                (&#x27;classifier&#x27;,\n",
-       "                 LogisticRegression(class_weight=&#x27;balanced&#x27;, max_iter=20000))])</pre></div></div></div><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-5\" type=\"checkbox\" ><label for=\"sk-estimator-id-5\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">StandardScaler</label><div class=\"sk-toggleable__content\"><pre>StandardScaler()</pre></div></div></div><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-6\" type=\"checkbox\" ><label for=\"sk-estimator-id-6\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">LogisticRegression</label><div class=\"sk-toggleable__content\"><pre>LogisticRegression(class_weight=&#x27;balanced&#x27;, max_iter=20000)</pre></div></div></div></div></div></div></div>"
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>epoch</th>\n",
+       "      <th>f1 score</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.830236</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>1</td>\n",
+       "      <td>0.846667</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>2</td>\n",
+       "      <td>0.846844</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>3</td>\n",
+       "      <td>0.846762</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>4</td>\n",
+       "      <td>0.850135</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
       ],
       "text/plain": [
-       "Pipeline(steps=[('preprocessor', StandardScaler()),\n",
-       "                ('classifier',\n",
-       "                 LogisticRegression(class_weight='balanced', max_iter=20000))])"
+       "   epoch  f1 score\n",
+       "0      0  0.830236\n",
+       "1      1  0.846667\n",
+       "2      2  0.846844\n",
+       "3      3  0.846762\n",
+       "4      4  0.850135"
       ]
      },
-     "execution_count": 19,
+     "execution_count": 11,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "from sklearn.pipeline import Pipeline #make_pipeline\n",
-    "from sklearn import preprocessing\n",
+    "f1s = pd.DataFrame(model.f1_score_history)\n",
+    "f1s.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## plot F1 vs iteration number"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import seaborn as sns\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "def plot_f1(f1s: pd.DataFrame):\n",
+    "    sns.scatterplot(x=f1s['epoch'], y=f1s['f1 score'])\n",
+    "    sns.lineplot(x=f1s['epoch'], y=f1s['f1 score'])\n",
+    "    plt.show()\n",
+    "plot_f1(f1s)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Hyperparameter optimization"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "#from sklearn.pipeline import Pipeline #make_pipeline\n",
+    "#from sklearn import preprocessing\n",
+    "#from sklearn.linear_model import LogisticRegression, SGDClassifier\n",
+    "\n",
+    "#i = 20000\n",
+    "\n",
+    "#pipe = Pipeline([\n",
+    "#    ('preprocessor', preprocessing.StandardScaler()),\n",
+    "#    ('classifier', LogisticRegression(max_iter=i, class_weight='balanced')),\n",
+    "#    ('classifier', MyLogisticRegression())\n",
+    "#])\n",
     "\n",
-    "i = 20000\n",
     "\n",
-    "pipe = Pipeline([\n",
-    "    ('preprocessor', preprocessing.StandardScaler()),\n",
-    "    ('classifier', LogisticRegression(max_iter=i, class_weight='balanced')),\n",
-    "])\n",
     "\n",
     "#model = LogisticRegression(penalty='l1', solver='saga', max_iter=i)\n",
-    "pipe.fit(X_train, y_train)"
+    "#pipe.fit(X_train, y_train)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 14,
    "metadata": {
     "scrolled": true,
     "tags": []
    },
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
-      "  warnings.warn(\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/model_selection/_validation.py:378: FitFailedWarning: \n",
-      "360 fits failed out of a total of 720.\n",
-      "The score on these train-test partitions for these parameters will be set to nan.\n",
-      "If these failures are not expected, you can try to debug them by setting error_score='raise'.\n",
-      "\n",
-      "Below are more details about the failures:\n",
-      "--------------------------------------------------------------------------------\n",
-      "360 fits failed with the following error:\n",
-      "Traceback (most recent call last):\n",
-      "  File \"/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/model_selection/_validation.py\", line 686, in _fit_and_score\n",
-      "    estimator.fit(X_train, y_train, **fit_params)\n",
-      "  File \"/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/pipeline.py\", line 405, in fit\n",
-      "    self._final_estimator.fit(Xt, y, **fit_params_last_step)\n",
-      "  File \"/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_logistic.py\", line 1162, in fit\n",
-      "    solver = _check_solver(self.solver, self.penalty, self.dual)\n",
-      "  File \"/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/linear_model/_logistic.py\", line 54, in _check_solver\n",
-      "    raise ValueError(\n",
-      "ValueError: Solver sag supports only 'l2' or 'none' penalties, got l1 penalty.\n",
-      "\n",
-      "  warnings.warn(some_fits_failed_message, FitFailedWarning)\n",
-      "/home/vagrant/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/model_selection/_search.py:952: UserWarning: One or more of the test scores are non-finite: [       nan 0.                nan 0.1590493         nan 0.\n",
-      "        nan 0.                nan 0.                nan 0.\n",
-      "        nan 0.                nan 0.                nan 0.\n",
-      "        nan 0.13518741        nan 0.13518741        nan 0.13518741\n",
-      "        nan 0.                nan 0.16160635        nan 0.\n",
-      "        nan 0.                nan 0.                nan 0.\n",
-      "        nan 0.                nan 0.                nan 0.18677466\n",
-      "        nan 0.13518741        nan 0.13518741        nan 0.13518741\n",
-      "        nan 0.                nan 0.16000688        nan 0.\n",
-      "        nan 0.                nan 0.                nan 0.\n",
-      "        nan 0.                nan 0.                nan 0.1923046\n",
-      "        nan 0.13081038        nan 0.13518741        nan 0.13518741\n",
-      "        nan 0.                nan 0.15892573        nan 0.\n",
-      "        nan 0.                nan 0.                nan 0.\n",
-      "        nan 0.                nan 0.                nan 0.1887408\n",
-      "        nan 0.13485348        nan 0.13518741        nan 0.13518741\n",
-      "        nan 0.                nan 0.12777313        nan 0.\n",
-      "        nan 0.                nan 0.                nan 0.\n",
-      "        nan 0.                nan 0.                nan 0.15035704\n",
-      "        nan 0.13619257        nan 0.13642988        nan 0.13518741\n",
-      "        nan 0.                nan 0.12412204        nan 0.\n",
-      "        nan 0.                nan 0.                nan 0.\n",
-      "        nan 0.                nan 0.                nan 0.11476747\n",
-      "        nan 0.14715202        nan 0.13721419        nan 0.13550537]\n",
-      "  warnings.warn(\n"
-     ]
-    },
     {
      "data": {
       "text/plain": [
-       "{'classifier__C': 0.01,\n",
-       " 'classifier__class_weight': {0: 1, 1: 10},\n",
-       " 'classifier__penalty': 'l2',\n",
-       " 'classifier__solver': 'sag'}"
+       "{'batch_size': 61, 'lr': 1}"
       ]
      },
-     "execution_count": 32,
+     "execution_count": 14,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -968,18 +1109,19 @@
     "from sklearn.model_selection import GridSearchCV\n",
     "import numpy as np\n",
     "\n",
-    "\n",
+    "# optimize hyperparameter batch size and learning rate\n",
     "param_grid = {\n",
-    "    'classifier__penalty': ['l1', 'l2'],\n",
-    "    'classifier__C': [1e-4, 1e-3, 1e-2, 0.1, 1, 10],\n",
-    "    'classifier__solver': ['sag'],\n",
-    "    'classifier__class_weight': [None, 'balanced', *[{0: 1, 1:10**x} for x in range(-5, 5)]],\n",
+    "    #'classifier__penalty': ['l1', 'l2'],\n",
+    "    #'classifier__C': [1e-4, 1e-3, 1e-2, 0.1, 1, 10],\n",
+    "    #'classifier__solver': ['sag'],\n",
+    "    #'classifier__class_weight': [None, 'balanced', *[{0: 1, 1:10**x} for x in range(-5, 5)]],\n",
     "    #'classifier__eta0': [10**x for x in range(-5, 5)],\n",
-    "    #'classifier__batch_size': np.linspace(1, X_train.shape[0], 10, dtype=int),\n",
+    "    'batch_size': np.linspace(1, X_train.shape[0], 70, dtype=int)[:10],\n",
+    "    'lr': [10**x for x in range(-5, 5)],\n",
     "}\n",
     "\n",
-    "#grid_search = GridSearchCV(pipe, param_grid, cv=5, scoring='roc_auc')\n",
-    "grid_search = GridSearchCV(pipe, param_grid, cv=5, scoring='f1', n_jobs=-1)\n",
+    "#grid_search = GridSearchCV(pipe, param_grid, cv=5, scoring='f1', n_jobs=-1)\n",
+    "grid_search = GridSearchCV(MyLogisticRegression(), param_grid, cv=5, scoring='f1', n_jobs=-1)\n",
     "\n",
     "grid_search.fit(X_train, y_train)\n",
     "grid_search.best_params_"
@@ -987,7 +1129,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": 15,
    "metadata": {
     "tags": []
    },
@@ -995,10 +1137,10 @@
     {
      "data": {
       "text/plain": [
-       "0.05732484076433121"
+       "0.8993288590604027"
       ]
      },
-     "execution_count": 35,
+     "execution_count": 15,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1014,7 +1156,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": 16,
    "metadata": {
     "tags": []
    },
@@ -1022,11 +1164,11 @@
     {
      "data": {
       "text/plain": [
-       "array([[ 27, 148],\n",
-       "       [420,   9]])"
+       "array([[ 31,  15],\n",
+       "       [120, 134]])"
       ]
      },
-     "execution_count": 36,
+     "execution_count": 16,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1037,7 +1179,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 17,
    "metadata": {
     "tags": []
    },
@@ -1045,185 +1187,121 @@
     {
      "data": {
       "text/plain": [
-       "\u001b[0;31mSignature:\u001b[0m\n",
-       "\u001b[0mconfusion_matrix\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n",
-       "\u001b[0;34m\u001b[0m    \u001b[0my_true\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
-       "\u001b[0;34m\u001b[0m    \u001b[0my_pred\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
-       "\u001b[0;34m\u001b[0m    \u001b[0;34m*\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
-       "\u001b[0;34m\u001b[0m    \u001b[0mlabels\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
-       "\u001b[0;34m\u001b[0m    \u001b[0msample_weight\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
-       "\u001b[0;34m\u001b[0m    \u001b[0mnormalize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
-       "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-       "\u001b[0;31mDocstring:\u001b[0m\n",
-       "Compute confusion matrix to evaluate the accuracy of a classification.\n",
-       "\n",
-       "By definition a confusion matrix :math:`C` is such that :math:`C_{i, j}`\n",
-       "is equal to the number of observations known to be in group :math:`i` and\n",
-       "predicted to be in group :math:`j`.\n",
-       "\n",
-       "Thus in binary classification, the count of true negatives is\n",
-       ":math:`C_{0,0}`, false negatives is :math:`C_{1,0}`, true positives is\n",
-       ":math:`C_{1,1}` and false positives is :math:`C_{0,1}`.\n",
-       "\n",
-       "Read more in the :ref:`User Guide <confusion_matrix>`.\n",
-       "\n",
-       "Parameters\n",
-       "----------\n",
-       "y_true : array-like of shape (n_samples,)\n",
-       "    Ground truth (correct) target values.\n",
-       "\n",
-       "y_pred : array-like of shape (n_samples,)\n",
-       "    Estimated targets as returned by a classifier.\n",
-       "\n",
-       "labels : array-like of shape (n_classes), default=None\n",
-       "    List of labels to index the matrix. This may be used to reorder\n",
-       "    or select a subset of labels.\n",
-       "    If ``None`` is given, those that appear at least once\n",
-       "    in ``y_true`` or ``y_pred`` are used in sorted order.\n",
-       "\n",
-       "sample_weight : array-like of shape (n_samples,), default=None\n",
-       "    Sample weights.\n",
-       "\n",
-       "    .. versionadded:: 0.18\n",
-       "\n",
-       "normalize : {'true', 'pred', 'all'}, default=None\n",
-       "    Normalizes confusion matrix over the true (rows), predicted (columns)\n",
-       "    conditions or all the population. If None, confusion matrix will not be\n",
-       "    normalized.\n",
-       "\n",
-       "Returns\n",
-       "-------\n",
-       "C : ndarray of shape (n_classes, n_classes)\n",
-       "    Confusion matrix whose i-th row and j-th\n",
-       "    column entry indicates the number of\n",
-       "    samples with true label being i-th class\n",
-       "    and predicted label being j-th class.\n",
-       "\n",
-       "See Also\n",
-       "--------\n",
-       "ConfusionMatrixDisplay.from_estimator : Plot the confusion matrix\n",
-       "    given an estimator, the data, and the label.\n",
-       "ConfusionMatrixDisplay.from_predictions : Plot the confusion matrix\n",
-       "    given the true and predicted labels.\n",
-       "ConfusionMatrixDisplay : Confusion Matrix visualization.\n",
-       "\n",
-       "References\n",
-       "----------\n",
-       ".. [1] `Wikipedia entry for the Confusion matrix\n",
-       "       <https://en.wikipedia.org/wiki/Confusion_matrix>`_\n",
-       "       (Wikipedia and other references may use a different\n",
-       "       convention for axes).\n",
-       "\n",
-       "Examples\n",
-       "--------\n",
-       ">>> from sklearn.metrics import confusion_matrix\n",
-       ">>> y_true = [2, 0, 2, 2, 0, 1]\n",
-       ">>> y_pred = [0, 0, 2, 2, 0, 2]\n",
-       ">>> confusion_matrix(y_true, y_pred)\n",
-       "array([[2, 0, 0],\n",
-       "       [0, 0, 1],\n",
-       "       [1, 0, 2]])\n",
-       "\n",
-       ">>> y_true = [\"cat\", \"ant\", \"cat\", \"cat\", \"ant\", \"bird\"]\n",
-       ">>> y_pred = [\"ant\", \"ant\", \"cat\", \"cat\", \"ant\", \"cat\"]\n",
-       ">>> confusion_matrix(y_true, y_pred, labels=[\"ant\", \"bird\", \"cat\"])\n",
-       "array([[2, 0, 0],\n",
-       "       [0, 0, 1],\n",
-       "       [1, 0, 2]])\n",
-       "\n",
-       "In the binary case, we can extract true positives, etc as follows:\n",
-       "\n",
-       ">>> tn, fp, fn, tp = confusion_matrix([0, 1, 0, 1], [1, 1, 1, 0]).ravel()\n",
-       ">>> (tn, fp, fn, tp)\n",
-       "(0, 2, 1, 1)\n",
-       "\u001b[0;31mFile:\u001b[0m      ~/.local/share/virtualenvs/midterm-5qaZhyTt/lib/python3.10/site-packages/sklearn/metrics/_classification.py\n",
-       "\u001b[0;31mType:\u001b[0m      function"
+       "array([0.87437186, 0.85714286, 0.84848485, 0.81818182, 0.88      ])"
       ]
      },
+     "execution_count": 17,
      "metadata": {},
-     "output_type": "display_data"
+     "output_type": "execute_result"
     }
    ],
    "source": [
-    "confusion_matrix?"
+    "from sklearn.model_selection import cross_val_score\n",
+    "\n",
+    "scores = cross_val_score(grid_search, X, y, cv=5)\n",
+    "scores"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 56,
-   "metadata": {
-    "tags": []
-   },
+   "execution_count": 18,
+   "metadata": {},
    "outputs": [
     {
      "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>epoch</th>\n",
+       "      <th>f1 score</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.809935</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>1</td>\n",
+       "      <td>0.856796</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>2</td>\n",
+       "      <td>0.850208</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>3</td>\n",
+       "      <td>0.846912</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>4</td>\n",
+       "      <td>0.850349</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
       "text/plain": [
-       "array([0.93046358, 0.93046358, 0.92880795, 0.93034826, 0.93034826])"
+       "   epoch  f1 score\n",
+       "0      0  0.809935\n",
+       "1      1  0.856796\n",
+       "2      2  0.850208\n",
+       "3      3  0.846912\n",
+       "4      4  0.850349"
       ]
      },
-     "execution_count": 56,
+     "execution_count": 18,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "from sklearn.model_selection import cross_val_score\n",
-    "\n",
-    "scores = cross_val_score(pipe, X, y, cv=5)\n",
-    "scores"
+    "best_f1 = pd.DataFrame(grid_search.best_estimator_.f1_score_history)\n",
+    "best_f1.head()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 19,
    "metadata": {
     "tags": []
    },
    "outputs": [
     {
      "data": {
+      "image/png": "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",
       "text/plain": [
-       "{'memory': None,\n",
-       " 'steps': [('preprocessor', StandardScaler()),\n",
-       "  ('classifier', LogisticRegression(class_weight='balanced', max_iter=200))],\n",
-       " 'verbose': False,\n",
-       " 'preprocessor': StandardScaler(),\n",
-       " 'classifier': LogisticRegression(class_weight='balanced', max_iter=200),\n",
-       " 'preprocessor__copy': True,\n",
-       " 'preprocessor__with_mean': True,\n",
-       " 'preprocessor__with_std': True,\n",
-       " 'classifier__C': 1.0,\n",
-       " 'classifier__class_weight': 'balanced',\n",
-       " 'classifier__dual': False,\n",
-       " 'classifier__fit_intercept': True,\n",
-       " 'classifier__intercept_scaling': 1,\n",
-       " 'classifier__l1_ratio': None,\n",
-       " 'classifier__max_iter': 200,\n",
-       " 'classifier__multi_class': 'auto',\n",
-       " 'classifier__n_jobs': None,\n",
-       " 'classifier__penalty': 'l2',\n",
-       " 'classifier__random_state': None,\n",
-       " 'classifier__solver': 'lbfgs',\n",
-       " 'classifier__tol': 0.0001,\n",
-       " 'classifier__verbose': 0,\n",
-       " 'classifier__warm_start': False}"
+       "<Figure size 640x480 with 1 Axes>"
       ]
      },
-     "execution_count": 12,
      "metadata": {},
-     "output_type": "execute_result"
+     "output_type": "display_data"
     }
    ],
    "source": [
-    "pipe.get_params()"
+    "plot_f1(best_f1)"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {