diff --git a/doc/pub/week41/ipynb/week41.ipynb b/doc/pub/week41/ipynb/week41.ipynb
index da86b2233..70d40c69a 100644
--- a/doc/pub/week41/ipynb/week41.ipynb
+++ b/doc/pub/week41/ipynb/week41.ipynb
@@ -15,10 +15,10 @@
    "id": "b0eae28d",
    "metadata": {},
    "source": [
-    "# Week 41 Constructing a Neural Network code, Tensor flow and start Convolutional Neural Networks\n",
+    "# Week 41 Constructing a Neural Network code\n",
     "**Morten Hjorth-Jensen**, Department of Physics, University of Oslo and Department of Physics and Astronomy and Facility for Rare Isotope Beams, Michigan State University\n",
     "\n",
-    "Date: **Oct 13, 2022**\n",
+    "Date: **Oct 14, 2022**\n",
     "\n",
     "Copyright 1999-2022, Morten Hjorth-Jensen. Released under CC Attribution-NonCommercial 4.0 license"
    ]
@@ -593,7 +593,29 @@
    "execution_count": 1,
    "id": "5f127181",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "inputs = (n_inputs, pixel_width, pixel_height) = (1797, 8, 8)\n",
+      "labels = (n_inputs) = (1797,)\n",
+      "X = (n_inputs, n_features) = (1797, 64)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x864 with 5 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "%matplotlib inline\n",
     "\n",
@@ -664,7 +686,16 @@
    "execution_count": 2,
    "id": "edd98947",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of training images: 1437\n",
+      "Number of test images: 360\n"
+     ]
+    }
+   ],
    "source": [
     "from sklearn.model_selection import train_test_split\n",
     "\n",
@@ -882,7 +913,24 @@
    "execution_count": 4,
    "id": "16a29f53",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "probabilities = (n_inputs, n_categories) = (1437, 10)\n",
+      "probability that image 0 is in category 0,1,2,...,9 = \n",
+      "[5.41511965e-04 2.17174962e-03 8.84355903e-03 1.44970586e-03\n",
+      " 1.10378326e-04 5.08318298e-09 2.03256632e-04 1.92507116e-03\n",
+      " 9.84443254e-01 3.11507992e-04]\n",
+      "probabilities sum up to: 1.0\n",
+      "\n",
+      "predictions = (n_inputs) = (1437,)\n",
+      "prediction for image 0: 8\n",
+      "correct label for image 0: 6\n"
+     ]
+    }
+   ],
    "source": [
     "# setup the feed-forward pass, subscript h = hidden layer\n",
     "\n",
@@ -1061,7 +1109,30 @@
    "execution_count": 5,
    "id": "36ca3c90",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Old accuracy on training data: 0.1440501043841336\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
+      "  return 1/(1 + np.exp(-x))\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "New accuracy on training data: 0.10438413361169102\n"
+     ]
+    }
+   ],
    "source": [
     "# to categorical turns our integer vector into a onehot representation\n",
     "from sklearn.metrics import accuracy_score\n",
@@ -1292,7 +1363,15 @@
    "execution_count": 7,
    "id": "e32c4a43",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Accuracy score on test set:  0.9361111111111111\n"
+     ]
+    }
+   ],
    "source": [
     "epochs = 100\n",
     "batch_size = 100\n",
@@ -1328,7 +1407,556 @@
    "execution_count": 8,
    "id": "f0748a05",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  1e-05\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on test set:  0.11666666666666667\n",
+      "\n",
+      "Learning rate  =  1e-05\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on test set:  0.20833333333333334\n",
+      "\n",
+      "Learning rate  =  1e-05\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on test set:  0.12222222222222222\n",
+      "\n",
+      "Learning rate  =  1e-05\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on test set:  0.14722222222222223\n",
+      "\n",
+      "Learning rate  =  1e-05\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on test set:  0.17777777777777778\n",
+      "\n",
+      "Learning rate  =  1e-05\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on test set:  0.16111111111111112\n",
+      "\n",
+      "Learning rate  =  1e-05\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on test set:  0.20277777777777778\n",
+      "\n",
+      "Learning rate  =  0.0001\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on test set:  0.5305555555555556\n",
+      "\n",
+      "Learning rate  =  0.0001\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on test set:  0.5944444444444444\n",
+      "\n",
+      "Learning rate  =  0.0001\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on test set:  0.5888888888888889\n",
+      "\n",
+      "Learning rate  =  0.0001\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on test set:  0.6111111111111112\n",
+      "\n",
+      "Learning rate  =  0.0001\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on test set:  0.5222222222222223\n",
+      "\n",
+      "Learning rate  =  0.0001\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on test set:  0.5555555555555556\n",
+      "\n",
+      "Learning rate  =  0.0001\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on test set:  0.8055555555555556\n",
+      "\n",
+      "Learning rate  =  0.001\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on test set:  0.85\n",
+      "\n",
+      "Learning rate  =  0.001\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on test set:  0.85\n",
+      "\n",
+      "Learning rate  =  0.001\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on test set:  0.875\n",
+      "\n",
+      "Learning rate  =  0.001\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on test set:  0.8666666666666667\n",
+      "\n",
+      "Learning rate  =  0.001\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on test set:  0.8638888888888889\n",
+      "\n",
+      "Learning rate  =  0.001\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on test set:  0.9555555555555556\n",
+      "\n",
+      "Learning rate  =  0.001\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on test set:  0.925\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on test set:  0.9527777777777777\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on test set:  0.925\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on test set:  0.9388888888888889\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on test set:  0.9333333333333333\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on test set:  0.9694444444444444\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on test set:  0.8277777777777777\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on test set:  0.28888888888888886\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
+      "  return 1/(1 + np.exp(-x))\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  0.1\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on test set:  0.09166666666666666\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
+      "  return 1/(1 + np.exp(-x))\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  0.1\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on test set:  0.08611111111111111\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
+      "  return 1/(1 + np.exp(-x))\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  0.1\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on test set:  0.09166666666666666\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
+      "  return 1/(1 + np.exp(-x))\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  0.1\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on test set:  0.11666666666666667\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
+      "  return 1/(1 + np.exp(-x))\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  0.1\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on test set:  0.10555555555555556\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
+      "  return 1/(1 + np.exp(-x))\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  0.1\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on test set:  0.08888888888888889\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
+      "  return 1/(1 + np.exp(-x))\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  0.1\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on test set:  0.09166666666666666\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
+      "  return 1/(1 + np.exp(-x))\n",
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n",
+      "  exp_term = np.exp(self.z_o)\n",
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/1630775253.py:44: RuntimeWarning: invalid value encountered in true_divide\n",
+      "  self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  1.0\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on test set:  0.07777777777777778\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
+      "  return 1/(1 + np.exp(-x))\n",
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n",
+      "  exp_term = np.exp(self.z_o)\n",
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/1630775253.py:44: RuntimeWarning: invalid value encountered in true_divide\n",
+      "  self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  1.0\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on test set:  0.07777777777777778\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
+      "  return 1/(1 + np.exp(-x))\n",
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n",
+      "  exp_term = np.exp(self.z_o)\n",
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/1630775253.py:44: RuntimeWarning: invalid value encountered in true_divide\n",
+      "  self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  1.0\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on test set:  0.07777777777777778\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
+      "  return 1/(1 + np.exp(-x))\n",
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n",
+      "  exp_term = np.exp(self.z_o)\n",
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/1630775253.py:44: RuntimeWarning: invalid value encountered in true_divide\n",
+      "  self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  1.0\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on test set:  0.07777777777777778\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
+      "  return 1/(1 + np.exp(-x))\n",
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n",
+      "  exp_term = np.exp(self.z_o)\n",
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/1630775253.py:44: RuntimeWarning: invalid value encountered in true_divide\n",
+      "  self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  1.0\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on test set:  0.07777777777777778\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
+      "  return 1/(1 + np.exp(-x))\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  1.0\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on test set:  0.125\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
+      "  return 1/(1 + np.exp(-x))\n",
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n",
+      "  exp_term = np.exp(self.z_o)\n",
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/1630775253.py:44: RuntimeWarning: invalid value encountered in true_divide\n",
+      "  self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  1.0\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on test set:  0.07777777777777778\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
+      "  return 1/(1 + np.exp(-x))\n",
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n",
+      "  exp_term = np.exp(self.z_o)\n",
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/1630775253.py:44: RuntimeWarning: invalid value encountered in true_divide\n",
+      "  self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  10.0\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on test set:  0.07777777777777778\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
+      "  return 1/(1 + np.exp(-x))\n",
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n",
+      "  exp_term = np.exp(self.z_o)\n",
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/1630775253.py:44: RuntimeWarning: invalid value encountered in true_divide\n",
+      "  self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  10.0\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on test set:  0.07777777777777778\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
+      "  return 1/(1 + np.exp(-x))\n",
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n",
+      "  exp_term = np.exp(self.z_o)\n",
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/1630775253.py:44: RuntimeWarning: invalid value encountered in true_divide\n",
+      "  self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  10.0\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on test set:  0.07777777777777778\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
+      "  return 1/(1 + np.exp(-x))\n",
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n",
+      "  exp_term = np.exp(self.z_o)\n",
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/1630775253.py:44: RuntimeWarning: invalid value encountered in true_divide\n",
+      "  self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  10.0\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on test set:  0.07777777777777778\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
+      "  return 1/(1 + np.exp(-x))\n",
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n",
+      "  exp_term = np.exp(self.z_o)\n",
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/1630775253.py:44: RuntimeWarning: invalid value encountered in true_divide\n",
+      "  self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  10.0\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on test set:  0.07777777777777778\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
+      "  return 1/(1 + np.exp(-x))\n",
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n",
+      "  exp_term = np.exp(self.z_o)\n",
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/1630775253.py:44: RuntimeWarning: invalid value encountered in true_divide\n",
+      "  self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  10.0\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on test set:  0.07777777777777778\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
+      "  return 1/(1 + np.exp(-x))\n",
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n",
+      "  exp_term = np.exp(self.z_o)\n",
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/1630775253.py:44: RuntimeWarning: invalid value encountered in true_divide\n",
+      "  self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  10.0\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on test set:  0.07777777777777778\n",
+      "\n"
+     ]
+    }
+   ],
    "source": [
     "eta_vals = np.logspace(-5, 1, 7)\n",
     "lmbd_vals = np.logspace(-5, 1, 7)\n",
@@ -1365,7 +1993,46 @@
    "execution_count": 9,
    "id": "78b7dc25",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
+      "  return 1/(1 + np.exp(-x))\n",
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
+      "  return 1/(1 + np.exp(-x))\n",
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
+      "  return 1/(1 + np.exp(-x))\n",
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
+      "  return 1/(1 + np.exp(-x))\n",
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
+      "  return 1/(1 + np.exp(-x))\n",
+      "/var/folders/jy/g42mrgv128v34gnnhxwk9nrc0000gp/T/ipykernel_21083/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
+      "  return 1/(1 + np.exp(-x))\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x720 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x720 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# visual representation of grid search\n",
     "# uses seaborn heatmap, you can also do this with matplotlib imshow\n",
@@ -1427,7 +2094,512 @@
    "execution_count": 10,
    "id": "481e8a94",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/MortenImac/anaconda3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  1e-05\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on test set:  0.18333333333333332\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/MortenImac/anaconda3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  1e-05\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on test set:  0.18611111111111112\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/MortenImac/anaconda3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  1e-05\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on test set:  0.13055555555555556\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/MortenImac/anaconda3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  1e-05\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on test set:  0.24444444444444444\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/MortenImac/anaconda3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  1e-05\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on test set:  0.23333333333333334\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/MortenImac/anaconda3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  1e-05\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on test set:  0.12777777777777777\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/MortenImac/anaconda3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  1e-05\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on test set:  0.1527777777777778\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/MortenImac/anaconda3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  0.0001\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on test set:  0.9111111111111111\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/MortenImac/anaconda3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  0.0001\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on test set:  0.8888888888888888\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/MortenImac/anaconda3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  0.0001\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on test set:  0.8722222222222222\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/MortenImac/anaconda3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  0.0001\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on test set:  0.8305555555555556\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/MortenImac/anaconda3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  0.0001\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on test set:  0.8888888888888888\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/MortenImac/anaconda3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  0.0001\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on test set:  0.8805555555555555\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/MortenImac/anaconda3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  0.0001\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on test set:  0.8944444444444445\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/MortenImac/anaconda3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  0.001\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on test set:  0.975\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/MortenImac/anaconda3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  0.001\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on test set:  0.9777777777777777\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/MortenImac/anaconda3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  0.001\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on test set:  0.9805555555555555\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/MortenImac/anaconda3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  0.001\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on test set:  0.9861111111111112\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/MortenImac/anaconda3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  0.001\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on test set:  0.9805555555555555\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/MortenImac/anaconda3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  0.001\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on test set:  0.9777777777777777\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/MortenImac/anaconda3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  0.001\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on test set:  0.9444444444444444\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/MortenImac/anaconda3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  0.01\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on test set:  0.9861111111111112\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on test set:  0.9888888888888889\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on test set:  0.9888888888888889\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on test set:  0.9861111111111112\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on test set:  0.9888888888888889\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on test set:  0.9722222222222222\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on test set:  0.9527777777777777\n",
+      "\n",
+      "Learning rate  =  0.1\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on test set:  0.8944444444444445\n",
+      "\n",
+      "Learning rate  =  0.1\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on test set:  0.9166666666666666\n",
+      "\n",
+      "Learning rate  =  0.1\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on test set:  0.9027777777777778\n",
+      "\n",
+      "Learning rate  =  0.1\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on test set:  0.8555555555555555\n",
+      "\n",
+      "Learning rate  =  0.1\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on test set:  0.9444444444444444\n",
+      "\n",
+      "Learning rate  =  0.1\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on test set:  0.925\n",
+      "\n",
+      "Learning rate  =  0.1\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on test set:  0.8527777777777777\n",
+      "\n",
+      "Learning rate  =  1.0\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on test set:  0.175\n",
+      "\n",
+      "Learning rate  =  1.0\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on test set:  0.125\n",
+      "\n",
+      "Learning rate  =  1.0\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on test set:  0.17222222222222222\n",
+      "\n",
+      "Learning rate  =  1.0\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on test set:  0.10833333333333334\n",
+      "\n",
+      "Learning rate  =  1.0\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on test set:  0.09166666666666666\n",
+      "\n",
+      "Learning rate  =  1.0\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on test set:  0.1638888888888889\n",
+      "\n",
+      "Learning rate  =  1.0\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on test set:  0.11944444444444445\n",
+      "\n",
+      "Learning rate  =  10.0\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on test set:  0.19722222222222222\n",
+      "\n",
+      "Learning rate  =  10.0\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on test set:  0.18055555555555555\n",
+      "\n",
+      "Learning rate  =  10.0\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on test set:  0.10555555555555556\n",
+      "\n",
+      "Learning rate  =  10.0\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on test set:  0.19166666666666668\n",
+      "\n",
+      "Learning rate  =  10.0\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on test set:  0.09722222222222222\n",
+      "\n",
+      "Learning rate  =  10.0\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on test set:  0.08333333333333333\n",
+      "\n",
+      "Learning rate  =  10.0\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on test set:  0.10555555555555556\n",
+      "\n"
+     ]
+    }
+   ],
    "source": [
     "from sklearn.neural_network import MLPClassifier\n",
     "# store models for later use\n",
@@ -1460,7 +2632,28 @@
    "execution_count": 11,
    "id": "2177962e",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x720 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x720 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# optional\n",
     "# visual representation of grid search\n",
@@ -1605,7 +2798,19 @@
    "execution_count": 12,
    "id": "4dd40dc9",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[0.80625657 0.36420967]\n",
+      " [0.90297441 0.30170017]\n",
+      " [0.89823921 0.28566769]\n",
+      " [0.93420126 0.25920793]]\n",
+      "[0 0 0 0]\n"
+     ]
+    }
+   ],
    "source": [
     "\"\"\"\n",
     "Simple code that tests XOR, OR and AND gates with linear regression\n",
@@ -1695,7 +2900,278 @@
    "execution_count": 13,
    "id": "a70e4f4f",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  1e-05\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  1e-05\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  1e-05\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  1e-05\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  1e-05\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  1e-05\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  1e-05\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  0.0001\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  0.0001\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  0.0001\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  0.0001\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  0.0001\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  0.0001\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  0.0001\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  0.001\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  0.001\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  0.001\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  0.001\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  = "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/MortenImac/anaconda3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n",
+      "/Users/MortenImac/anaconda3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n",
+      "/Users/MortenImac/anaconda3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n",
+      "/Users/MortenImac/anaconda3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n",
+      "/Users/MortenImac/anaconda3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 0.001\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  0.001\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  0.001\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on data set:  0.25\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on data set:  0.75\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on data set:  0.75\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on data set:  "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/MortenImac/anaconda3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n",
+      "/Users/MortenImac/anaconda3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n",
+      "/Users/MortenImac/anaconda3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.5\n",
+      "\n",
+      "Learning rate  =  0.01\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  0.1\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  0.1\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  0.1\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on data set:  1.0\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/MortenImac/anaconda3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n",
+      "/Users/MortenImac/anaconda3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:692: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Learning rate  =  0.1\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on data set:  1.0\n",
+      "\n",
+      "Learning rate  =  0.1\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  0.1\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  0.1\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  1.0\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on data set:  0.75\n",
+      "\n",
+      "Learning rate  =  1.0\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on data set:  0.75\n",
+      "\n",
+      "Learning rate  =  1.0\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on data set:  0.75\n",
+      "\n",
+      "Learning rate  =  1.0\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  1.0\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  1.0\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  1.0\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  10.0\n",
+      "Lambda =  1e-05\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  10.0\n",
+      "Lambda =  0.0001\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  10.0\n",
+      "Lambda =  0.001\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  10.0\n",
+      "Lambda =  0.01\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  10.0\n",
+      "Lambda =  0.1\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  10.0\n",
+      "Lambda =  1.0\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n",
+      "Learning rate  =  10.0\n",
+      "Lambda =  10.0\n",
+      "Accuracy score on data set:  0.5\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x720 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# import necessary packages\n",
     "import numpy as np\n",