diff --git a/notebooks/08B Backpropagation/Neural Networks from Scratch.ipynb b/notebooks/08B Backpropagation/Neural Networks from Scratch.ipynb
index 8ddd94c20df31222307a640d3c23f42e38116dad..7d6a7e0243c4d93d66e338b381427695a72324cb 100644
--- a/notebooks/08B Backpropagation/Neural Networks from Scratch.ipynb	
+++ b/notebooks/08B Backpropagation/Neural Networks from Scratch.ipynb	
@@ -15,7 +15,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -50,7 +50,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {
     "solution2": "hidden",
     "solution2_first": true
@@ -59,9 +59,8 @@
    "source": [
     "def sigmoid(x):\n",
     "    # START YOUR CODE\n",
-    "    \n",
-    "    # END YOUR CODE\n",
-    "    pass"
+    "    return 1/(1+np.exp(-x))\n",
+    "    # END YOUR CODE"
    ]
   },
   {
@@ -85,6 +84,7 @@
    },
    "outputs": [],
    "source": [
+    "\n",
     "def sigmoid(x):\n",
     "  # activation function: f(x) = 1 / (1 + e^(-x))\n",
     "  return 1 / (1 + np.exp(-x))"
@@ -99,7 +99,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "metadata": {
     "solution2": "hidden",
     "solution2_first": true
@@ -116,9 +116,9 @@
     "        # weight inputs, add bias and apply the activation function\n",
     "        \n",
     "        # START YOUR CODE\n",
-    "    \n",
+    "        z = np.dot(self.weights, inputs) + self.bias\n",
     "        # END YOUR CODE\n",
-    "        pass"
+    "        return sigmoid(z)"
    ]
   },
   {
@@ -140,6 +140,7 @@
    },
    "outputs": [],
    "source": [
+    "\n",
     "class Neuron:\n",
     "    def __init__(self, weights, bias):\n",
     "        # weights as vector, bias as number, weights and input have same length\n",
@@ -162,22 +163,30 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "metadata": {
     "solution2": "hidden",
     "solution2_first": true
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Result of the feed-forward pass: 1.000000\n"
+     ]
+    }
+   ],
    "source": [
     "# Define the neuron as specified above\n",
-    "#bias = ...\n",
-    "#weights = ...\n",
-    "#neuron = ...\n",
+    "bias = 2\n",
+    "weights = [4, 5]\n",
+    "neuron = Neuron(weights=weights, bias=bias)\n",
     "\n",
     "# Run the feed-forward pass with the given input\n",
-    "#x = ...\n",
-    "#output_neuron = ...\n",
-    "#print(\"Result of the feed-forward pass: {:.6f}\".format(output_neuron))"
+    "x = [2, 3]\n",
+    "output_neuron = neuron.feedforward(inputs=x)\n",
+    "print(\"Result of the feed-forward pass: {:.6f}\".format(output_neuron))"
    ]
   },
   {
@@ -189,7 +198,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "metadata": {
     "jupyter": {
      "source_hidden": true
@@ -197,8 +206,17 @@
     "solution2": "hidden",
     "tags": []
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Result of the feed-forward pass: 1.000000\n"
+     ]
+    }
+   ],
    "source": [
+    "\n",
     "# Define the neuron as specified above\n",
     "bias = 2\n",
     "weights = np.asarray([4,5])\n",
@@ -226,7 +244,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -271,22 +289,30 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 8,
    "metadata": {
     "solution2": "hidden",
     "solution2_first": true
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Result of the feed-forward pass: 0.721633\n"
+     ]
+    }
+   ],
    "source": [
     "# Define the neural network as specified above\n",
-    "#bias = ...\n",
-    "#weights = ...\n",
-    "#network = ...\n",
+    "bias = 0\n",
+    "weights = np.asarray([0, 1])\n",
+    "network = FirstNeuralNetwork(weights=weights, bias=bias)\n",
     "\n",
     "# Run the feed-forward pass through the network\n",
-    "#x = ...\n",
-    "#output_nn = ...\n",
-    "#print(\"Result of the feed-forward pass: {:.6}\".format(output_nn))"
+    "x = np.asarray([2, 3])\n",
+    "output_nn = network.feedforward(x)\n",
+    "print(\"Result of the feed-forward pass: {:.6}\".format(output_nn))"
    ]
   },
   {
@@ -308,6 +334,7 @@
    },
    "outputs": [],
    "source": [
+    "\n",
     "# Define the neural network as specified above\n",
     "bias = 0\n",
     "weights = np.asarray([0,1])\n",
@@ -337,7 +364,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 9,
    "metadata": {
     "solution2": "hidden",
     "solution2_first": true
@@ -346,9 +373,8 @@
    "source": [
     "def mse_loss(y_true, y_pred):\n",
     "    # START YOUR CODE\n",
-    "    \n",
-    "    # END YOUR CODE\n",
-    "    pass"
+    "    return ((y_true - y_pred)**2).mean()\n",
+    "    # END YOUR CODE"
    ]
   },
   {
@@ -370,6 +396,7 @@
    },
    "outputs": [],
    "source": [
+    "\n",
     "def mse_loss(y_true, y_pred):\n",
     "    # y_true and y_pred are arrays of the same length\n",
     "    return ((y_true - y_pred) ** 2).mean()"
@@ -377,9 +404,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 10,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Calculated loss: 0.75\n"
+     ]
+    }
+   ],
    "source": [
     "y_true = np.array([1, 0, 0, 1])\n",
     "y_pred = np.array([0, 0, 1, 0])\n",
@@ -396,7 +431,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 11,
    "metadata": {
     "solution2": "hidden",
     "solution2_first": true
@@ -405,9 +440,8 @@
    "source": [
     "def deriv_sigmoid(x):\n",
     "    # START YOUR CODE\n",
-    "    \n",
-    "    # END YOUR CODE\n",
-    "    pass"
+    "    return sigmoid(x) * (1 - sigmoid(x))\n",
+    "    # END YOUR CODE"
    ]
   },
   {
@@ -429,6 +463,7 @@
    },
    "outputs": [],
    "source": [
+    "\n",
     "def deriv_sigmoid(x):\n",
     "    # derivative of the sigmoid: f'(x) = f(x) * (1 - f(x))\n",
     "    fx = sigmoid(x)\n",
@@ -445,7 +480,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -475,7 +510,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -510,7 +545,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 14,
    "metadata": {
     "solution2": "hidden",
     "solution2_first": true
@@ -520,9 +555,15 @@
     "class FullNeuralNetwork(FullNeuralNetwork):\n",
     "    def feedforward(self, x):\n",
     "        # START YOUR CODE\n",
-    "    \n",
+    "        z_h1 = np.dot([self.w1, self.w3], x) + self.b1\n",
+    "        out_h1 = sigmoid(z_h1)\n",
+    "        z_h2 = np.dot([self.w2, self.w4], x) + self.b2\n",
+    "        out_h2 = sigmoid(z_h2)\n",
+    "\n",
+    "        z_o1 = np.dot([self.w5, self.w6], [out_h1, out_h2]) + self.b3\n",
+    "        out_o1 = sigmoid(z_o1)\n",
     "        # END YOUR CODE\n",
-    "        pass"
+    "        return out_o1"
    ]
   },
   {
@@ -544,6 +585,7 @@
    },
    "outputs": [],
    "source": [
+    "\n",
     "class FullNeuralNetwork(FullNeuralNetwork):\n",
     "    def feedforward(self, x):\n",
     "        # Output of the hidden layers (h1, h2)\n",
@@ -598,7 +640,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -687,9 +729,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 16,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[ -3,  -4],\n",
+       "       [  8,  13],\n",
+       "       [  4,   8],\n",
+       "       [ -9, -17]])"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "data = np.array([\n",
     "  [60, 165], # Alice\n",
@@ -726,9 +782,116 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 17,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch: 0, Loss: 0.501208\n",
+      "Epoch: 10, Loss: 0.416580\n",
+      "Epoch: 20, Loss: 0.253564\n",
+      "Epoch: 30, Loss: 0.163328\n",
+      "Epoch: 40, Loss: 0.122460\n",
+      "Epoch: 50, Loss: 0.095930\n",
+      "Epoch: 60, Loss: 0.077223\n",
+      "Epoch: 70, Loss: 0.063652\n",
+      "Epoch: 80, Loss: 0.053565\n",
+      "Epoch: 90, Loss: 0.045886\n",
+      "Epoch: 100, Loss: 0.039909\n",
+      "Epoch: 110, Loss: 0.035161\n",
+      "Epoch: 120, Loss: 0.031321\n",
+      "Epoch: 130, Loss: 0.028166\n",
+      "Epoch: 140, Loss: 0.025536\n",
+      "Epoch: 150, Loss: 0.023317\n",
+      "Epoch: 160, Loss: 0.021424\n",
+      "Epoch: 170, Loss: 0.019793\n",
+      "Epoch: 180, Loss: 0.018375\n",
+      "Epoch: 190, Loss: 0.017134\n",
+      "Epoch: 200, Loss: 0.016038\n",
+      "Epoch: 210, Loss: 0.015065\n",
+      "Epoch: 220, Loss: 0.014196\n",
+      "Epoch: 230, Loss: 0.013416\n",
+      "Epoch: 240, Loss: 0.012712\n",
+      "Epoch: 250, Loss: 0.012074\n",
+      "Epoch: 260, Loss: 0.011493\n",
+      "Epoch: 270, Loss: 0.010963\n",
+      "Epoch: 280, Loss: 0.010477\n",
+      "Epoch: 290, Loss: 0.010030\n",
+      "Epoch: 300, Loss: 0.009617\n",
+      "Epoch: 310, Loss: 0.009235\n",
+      "Epoch: 320, Loss: 0.008881\n",
+      "Epoch: 330, Loss: 0.008552\n",
+      "Epoch: 340, Loss: 0.008245\n",
+      "Epoch: 350, Loss: 0.007959\n",
+      "Epoch: 360, Loss: 0.007690\n",
+      "Epoch: 370, Loss: 0.007439\n",
+      "Epoch: 380, Loss: 0.007202\n",
+      "Epoch: 390, Loss: 0.006980\n",
+      "Epoch: 400, Loss: 0.006770\n",
+      "Epoch: 410, Loss: 0.006572\n",
+      "Epoch: 420, Loss: 0.006385\n",
+      "Epoch: 430, Loss: 0.006207\n",
+      "Epoch: 440, Loss: 0.006039\n",
+      "Epoch: 450, Loss: 0.005880\n",
+      "Epoch: 460, Loss: 0.005728\n",
+      "Epoch: 470, Loss: 0.005583\n",
+      "Epoch: 480, Loss: 0.005446\n",
+      "Epoch: 490, Loss: 0.005314\n",
+      "Epoch: 500, Loss: 0.005189\n",
+      "Epoch: 510, Loss: 0.005069\n",
+      "Epoch: 520, Loss: 0.004955\n",
+      "Epoch: 530, Loss: 0.004845\n",
+      "Epoch: 540, Loss: 0.004740\n",
+      "Epoch: 550, Loss: 0.004639\n",
+      "Epoch: 560, Loss: 0.004542\n",
+      "Epoch: 570, Loss: 0.004449\n",
+      "Epoch: 580, Loss: 0.004360\n",
+      "Epoch: 590, Loss: 0.004274\n",
+      "Epoch: 600, Loss: 0.004191\n",
+      "Epoch: 610, Loss: 0.004111\n",
+      "Epoch: 620, Loss: 0.004034\n",
+      "Epoch: 630, Loss: 0.003960\n",
+      "Epoch: 640, Loss: 0.003889\n",
+      "Epoch: 650, Loss: 0.003820\n",
+      "Epoch: 660, Loss: 0.003753\n",
+      "Epoch: 670, Loss: 0.003688\n",
+      "Epoch: 680, Loss: 0.003626\n",
+      "Epoch: 690, Loss: 0.003565\n",
+      "Epoch: 700, Loss: 0.003507\n",
+      "Epoch: 710, Loss: 0.003450\n",
+      "Epoch: 720, Loss: 0.003395\n",
+      "Epoch: 730, Loss: 0.003342\n",
+      "Epoch: 740, Loss: 0.003290\n",
+      "Epoch: 750, Loss: 0.003240\n",
+      "Epoch: 760, Loss: 0.003192\n",
+      "Epoch: 770, Loss: 0.003144\n",
+      "Epoch: 780, Loss: 0.003098\n",
+      "Epoch: 790, Loss: 0.003054\n",
+      "Epoch: 800, Loss: 0.003010\n",
+      "Epoch: 810, Loss: 0.002968\n",
+      "Epoch: 820, Loss: 0.002927\n",
+      "Epoch: 830, Loss: 0.002887\n",
+      "Epoch: 840, Loss: 0.002848\n",
+      "Epoch: 850, Loss: 0.002810\n",
+      "Epoch: 860, Loss: 0.002773\n",
+      "Epoch: 870, Loss: 0.002737\n",
+      "Epoch: 880, Loss: 0.002702\n",
+      "Epoch: 890, Loss: 0.002667\n",
+      "Epoch: 900, Loss: 0.002634\n",
+      "Epoch: 910, Loss: 0.002601\n",
+      "Epoch: 920, Loss: 0.002569\n",
+      "Epoch: 930, Loss: 0.002538\n",
+      "Epoch: 940, Loss: 0.002508\n",
+      "Epoch: 950, Loss: 0.002478\n",
+      "Epoch: 960, Loss: 0.002449\n",
+      "Epoch: 970, Loss: 0.002421\n",
+      "Epoch: 980, Loss: 0.002393\n",
+      "Epoch: 990, Loss: 0.002366\n"
+     ]
+    }
+   ],
    "source": [
     "network = FullNeuralNetwork()\n",
     "history_loss = network.train(data=data, labels=labels)"
@@ -745,9 +908,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 18,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "plt.plot(history_loss)\n",
     "plt.title(\"Loss value over epochs\")\n",
@@ -765,18 +939,32 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 25,
    "metadata": {
     "solution2": "hidden",
     "solution2_first": true
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Emily  0.9443725848336709\n",
+      "Frank  0.03985586084797445\n"
+     ]
+    }
+   ],
    "source": [
     "emily = np.array([58, 160])  # 58 kg, 160 cm\n",
     "frank = np.array([70, 172])  # 70 kg, 172 cm\n",
     "\n",
+    "# Apply mean shift\n",
+    "emily = (emily - np.array([mean_weight, mean_height])).astype(int)\n",
+    "frank = (frank - np.array([mean_weight, mean_height])).astype(int)\n",
+    "\n",
     "# predict\n",
-    "# ..."
+    "print(\"Emily \",network.feedforward(emily))\n",
+    "print(\"Frank \", network.feedforward(frank))"
    ]
   },
   {
@@ -788,7 +976,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 27,
    "metadata": {
     "jupyter": {
      "source_hidden": true
@@ -796,8 +984,18 @@
     "solution2": "hidden",
     "tags": []
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Emily - Probability of being female is: 0.944\n",
+      "Frank - Probability of being female is: 0.040\n"
+     ]
+    }
+   ],
    "source": [
+    "\n",
     "emily = np.array([58, 160])  # 58 kg, 160 cm\n",
     "frank = np.array([70, 172])  # 70 kg, 172 cm\n",
     "\n",
@@ -827,6 +1025,31 @@
     ">Now answer the Ilias Quiz 08B Backpropagation - Notebook Verification using this notebook."
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.960860883153203\n"
+     ]
+    }
+   ],
+   "source": [
+    "peter = np.array([70, 180])\n",
+    "\n",
+    "# Normalisation\n",
+    "peter = (peter - np.array([mean_weight, mean_height])).astype(int)\n",
+    "\n",
+    "# Predict\n",
+    "prob_peter_beeing_female = network.feedforward(peter)\n",
+    "prob_peter_beeing_male = 1 - prob_peter_beeing_female\n",
+    "print(prob_peter_beeing_male)"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -851,7 +1074,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.12"
+   "version": "3.11.6"
   }
  },
  "nbformat": 4,