diff --git a/Aufgabe 3/aufgabe03.ipynb b/Aufgabe 3/aufgabe03.ipynb index 0aba02d..f9f9ad9 100644 --- a/Aufgabe 3/aufgabe03.ipynb +++ b/Aufgabe 3/aufgabe03.ipynb @@ -2,20 +2,19 @@ "cells": [ { "cell_type": "code", - "execution_count": 174, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "from tqdm import tqdm\n", - "import matplotlib.pyplot as plt\n", "\n", "rng = np.random.default_rng()" ] }, { "cell_type": "code", - "execution_count": 175, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -26,9 +25,9 @@ "sigmoid = np.vectorize(lambda x : 1 / (1 + np.exp(-x)))\n", "\n", "def samples(n: int) -> list:\n", - " inputs = [rng.integers(0, 1, size=2, endpoint=True) for _ in range(n)]\n", - " outputs = [a ^ b for a, b in inputs]\n", - " return list(zip(inputs, outputs))\n", + " inputs = rng.integers(0, 1, size=(n, 2), endpoint=True)\n", + " outputs = inputs.T[0] ^ inputs.T[1]\n", + " return (inputs, outputs)\n", "\n", "# Aufgabe 3\n", "\n", @@ -45,7 +44,7 @@ }, { "cell_type": "code", - "execution_count": 184, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -54,9 +53,7 @@ "\n", "\n", "class NeuralNet:\n", - " def __init__(\n", - " self, inputs: int = 2, hidden_layers: list[tuple[int, Callable]] = None\n", - " ):\n", + " def __init__(self, inputs: int = 2, hidden_layers: list[tuple[int, Callable]] = None):\n", " \"\"\"\n", " Initializes the neural network.\n", " Hidden layers can be specified with the 'hidden_layers' parameter,\n", @@ -65,7 +62,7 @@ " activation function.\n", " \"\"\"\n", "\n", - " self.input_shape = (inputs, 1)\n", + " self.input_shape = (-1, inputs)\n", " self.layers = [] if hidden_layers is None else hidden_layers\n", " self.layers.append((1, sigmoid)) # Add output layer\n", "\n", @@ -76,9 +73,7 @@ " self.activation_functions.append(activation_function)\n", "\n", " num_layer_inputs = inputs if index == 0 else self.layers[index - 1][0]\n", - " self.weights.append(\n", - " rng.uniform(low=-1.0, high=1.0, size=(num_neurons, num_layer_inputs))\n", - " )\n", + " self.weights.append(rng.uniform(low=-1.0, high=1.0, size=(num_layer_inputs, num_neurons)))\n", "\n", " def forward_pass(self, x: np.array) -> tuple:\n", " \"\"\"\n", @@ -91,22 +86,20 @@ "\n", " Z = [] # linear values for each layer\n", " F = [x] # activation function values for each layer\n", - " for weights, activation_function in zip(\n", - " self.weights, self.activation_functions\n", - " ):\n", - " Z.append(np.matmul(weights, F[-1])) # linear\n", + " for weights, activation_function in zip(self.weights, self.activation_functions):\n", + " Z.append(np.matmul(F[-1], weights)) # linear\n", " F.append(activation_function(Z[-1]))\n", "\n", " return (Z, F)\n", "\n", - " def classify(self, x) -> float:\n", + " def classify(self, x: np.array) -> float:\n", " \"\"\"\n", - " Executes a forward pass, and returns the\n", - " classification result ŷ.\n", + " Executes a forward pass,\n", + " and returns the classification result ŷ.\n", " \"\"\"\n", - "\n", + " \n", " _, F = self.forward_pass(x)\n", - " ŷ = F[-1][0][0]\n", + " ŷ = F[-1].reshape(x.shape[0])\n", " return ŷ\n", "\n", " # Aufgabe 4\n", @@ -115,20 +108,23 @@ " Do a backward pass through the neural net.\n", " Returns the calculated weight difference.\n", " \"\"\"\n", + " x = np.reshape(x, self.input_shape)\n", + " batch_size = x.shape[0]\n", "\n", " Z, F = self.forward_pass(x)\n", "\n", " layer_errors = [None for _ in range(len(self.layers))]\n", - " layer_errors[-1] = F[-1] - y # ŷ - y\n", + " layer_errors[-1] = F[-1] - y.reshape((-1, 1)) # ŷ - y\n", "\n", " # Backpropagation\n", " for i in reversed(range(len(self.layers) - 1)):\n", " layer_errors[i] = np.multiply(\n", - " np.dot(self.weights[i + 1].T, layer_errors[i + 1]),\n", - " derivatives[self.activation_functions[i]](Z[i]),\n", + " self.weights[i + 1].T,\n", + " np.multiply(layer_errors[i + 1], derivatives[self.activation_functions[i]](Z[i])),\n", " )\n", "\n", - " Δweights = [np.dot(error, F[i].T) for i, error in enumerate(layer_errors)]\n", + " # Final weight updates, normalized\n", + " Δweights = [np.dot(F[i].T, error) / batch_size for i, error in enumerate(layer_errors)]\n", " return Δweights\n", "\n", " # Aufgabe 5\n", @@ -137,25 +133,19 @@ " Train the neural network with the given input data.\n", " \"\"\"\n", "\n", - " losses = []\n", + " x, y = data\n", " for epoch in tqdm(range(epochs)):\n", " for i in range(0, len(data), batch_size):\n", - " batch = data[i : i + batch_size]\n", - " Δweights = [ self.backward_pass(x, y) for x,y in batch ]\n", - " Δweights = list(zip(*Δweights))\n", - " Δweights = [ sum(Δw) / float(batch_size) for Δw in Δweights ]\n", - " \n", - " self.weights = [ w - learning_rate * Δw for w, Δw in zip(self.weights, Δweights) ]\n", + " x_batch = x[i : i + batch_size]\n", + " y_batch = y[i : i + batch_size]\n", + " Δweights = self.backward_pass(x_batch, y_batch)\n", "\n", - " L = 1 # todo\n", - " losses.append(L)\n", - "\n", - " return losses\n" + " self.weights = [w - learning_rate * Δw for w, Δw in zip(self.weights, Δweights, strict=True)]" ] }, { "cell_type": "code", - "execution_count": 177, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -165,96 +155,64 @@ "nn = NeuralNet(inputs=3, hidden_layers=[(4, sigmoid)])\n", "\n", "nn.weights = [\n", - " np.array([\n", - " [0.179, 0.044, 0.01], \n", - " [-0.186, -0.028, -0.035], \n", - " [-0.008, -0.063, -0.004], \n", - " [-0.048, -0.131, 0.088]\n", - " ]),\n", - " np.array([\n", - " [0.088, 0.171, 0.005, -0.04]\n", - " ]),\n", + " np.array([[0.179, -0.186, -0.008, -0.048], [0.044, -0.028, -0.063, -0.131], [0.01, -0.035, -0.004, 0.088]]),\n", + " np.array([[0.088], [0.171], [0.005], [-0.04]]),\n", "]\n", "\n", "# Make sure forward pass is correct\n", - "Z, F = nn.forward_pass(np.array([[7, 8, 10]]).T)\n", - "assert np.allclose(F[1], np.array([[0.845, 0.132, 0.354, 0.377]]).T, atol=0.01)\n", + "Z, F = nn.forward_pass(np.array([[7, 8, 10]]))\n", + "assert np.allclose(F[1], np.array([[0.845, 0.132, 0.354, 0.377]]), atol=0.01)\n", "assert np.allclose(F[2], np.array([[0.521]]), atol=0.01)\n", "\n", "# Make sure backward pass is correct\n", - "Δweights = nn.backward_pass(np.array([[7, 8, 10]]).T, 1)\n", - "assert np.allclose(Δweights[0], np.array([\n", - " [-0.039, -0.044, -0.055], \n", - " [-0.066, -0.075, -0.094], \n", - " [-0.004, -0.004, -0.005], \n", - " [0.032, 0.036, 0.046]\n", - " ]), atol=0.01)\n", - "assert np.allclose(Δweights[1], np.array([[-0.405, -0.063, -0.169, -0.181]]), atol=0.01)\n" + "Δweights = nn.backward_pass(np.array([[7, 8, 10], [7,8,10]]), np.array([[1], [1]]))\n", + "assert np.allclose(\n", + " Δweights[0],\n", + " np.array([[-0.039, -0.066, -0.004, 0.032], [-0.044, -0.075, -0.004, 0.036], [-0.055, -0.094, -0.005, 0.046]]),\n", + " atol=0.01,\n", + ")\n", + "assert np.allclose(Δweights[1], np.array([[-0.405], [-0.063], [-0.169], [-0.181]]), atol=0.01)\n", + "\n", + "# No output means success" ] }, { "cell_type": "code", - "execution_count": 180, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Correct classifications before training: 0.736\n" + "Correct classifications before training: 0.474\n" ] }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 80/80 [00:07<00:00, 10.29it/s]\n" + "100%|██████████| 80/80 [00:00<00:00, 3998.96it/s]" ] }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, { "name": "stdout", "output_type": "stream", "text": [ "Correct classifications after training: 1.0\n" ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] } ], "source": [ "# Aufgabe 4\n", + "# To update the weights after each backward pass, set the batch size to 1 (Aufgabe 4)\n", "\n", "test_data = samples(1_000)\n", "training_data = samples(100)\n", @@ -262,27 +220,23 @@ "# Updating weights after every backward pass\n", "nn = NeuralNet(hidden_layers=[(8, relu)])\n", "\n", - "correct = sum([round(nn.classify(x)) == y for x, y in test_data])\n", - "print(f\"Correct classifications before training: {correct/len(test_data)}\")\n", + "correct = sum(np.around(nn.classify(test_data[0])) == test_data[1])\n", + "print(f\"Correct classifications before training: {correct/test_data[0].shape[0]}\")\n", "\n", - "l = nn.train(training_data, batch_size=20, learning_rate=1, epochs=80)\n", + "nn.train(training_data, batch_size=20, learning_rate=1, epochs=80)\n", "\n", - "plt.figure(figsize=(10,6))\n", - "plt.scatter(range(80), l)\n", - "plt.show()\n", - "\n", - "correct = sum([round(nn.classify(x)) == y for x, y in test_data])\n", - "print(f\"Correct classifications after training: {correct/len(test_data)}\")\n" + "correct = sum(np.around(nn.classify(test_data[0])) == test_data[1])\n", + "print(f\"Correct classifications after training: {correct/test_data[0].shape[0]}\")\n" ] }, { "cell_type": "code", - "execution_count": 183, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -305,7 +259,7 @@ " for px in np.linspace(dim[0], dim[1], resolution):\n", " col = []\n", " for py in np.linspace(dim[2], dim[3], resolution):\n", - " col.append(nn.classify((px, py)))\n", + " col.append(nn.classify(np.array([[px, py]])))\n", " data.append(col)\n", " data = np.array(data)\n", "\n", @@ -333,7 +287,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.4" + "version": "3.10.1" }, "orig_nbformat": 4 },