From 1b94fe37baa4113f736efa8cd1721c602a68b5cb Mon Sep 17 00:00:00 2001 From: Klaus Reygers Date: Mon, 20 Mar 2023 10:50:41 +0100 Subject: [PATCH] added notebook with simple neural network example --- notebooks/simple_neural_network.ipynb | 493 ++++++ ...ple_neural_network_exercise_solution.ipynb | 1320 +++++++++++++++++ 2 files changed, 1813 insertions(+) create mode 100755 notebooks/simple_neural_network.ipynb create mode 100755 notebooks/simple_neural_network_exercise_solution.ipynb diff --git a/notebooks/simple_neural_network.ipynb b/notebooks/simple_neural_network.ipynb new file mode 100755 index 0000000..8fbd480 --- /dev/null +++ b/notebooks/simple_neural_network.ipynb @@ -0,0 +1,493 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# A simple neural network with one hidden layer in pure Python\n", + "\n", + "## Introduction\n", + "We consider a simple feed-forward neural network with one hidden layer:" + ] + }, + { + "attachments": { + "48b1ed6e-8e2b-4883-82ac-a2bbed6e2885.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![nn.png](attachment:48b1ed6e-8e2b-4883-82ac-a2bbed6e2885.png)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this example the input vector of the neural network has two features, i.e., the input is a two-dimensional vector:\n", + "\n", + "$$\n", + "\\mathbf x = (x_0, x_1).\n", + "$$\n", + "\n", + "We consider a set of $n$ vectors as training data. The training data can therefore be written as a $n \\times 2$ matrix where each row represents a feature vector:\n", + "\n", + "$$ \n", + "X = \n", + "\\begin{pmatrix}\n", + "x_{00} & x_{01} \\\\\n", + "x_{10} & x_{11} \\\\\n", + "\\vdots & \\vdots \\\\\n", + "x_{m-1\\,0} & x_{m-1\\,1} \n", + "\\end{pmatrix} $$\n", + "\n", + "The known labels (1 = 'signal', 0 = 'background') are stored in a $n$-dimensional column vector $\\mathbf y$.\n", + "\n", + "In the following, $n_1$ denotes the number of neurons in the hidden layer. The weights for the connections from the input layer (layer 0) to the hidden layer (layer 0) are given by the following matrix:\n", + "\n", + "$$\n", + "W^{(1)} = \n", + "\\begin{pmatrix}\n", + "w_{00}^{(1)} \\dots w_{0 \\, n_1-1}^{(1)} \\\\\n", + "w_{10}^{(1)} \\dots w_{1 \\, n_1-1}^{(1)} \n", + "\\end{pmatrix}\n", + "$$\n", + "\n", + "Each neuron in the hidden layer is assigned a bias $\\mathbf b^{(1)} = (b^{(1)}_0, \\ldots, b^{(1)}_{n_1-1})$. The neuron in the output layer has the bias $\\mathbf b^{(2)}$. With that, the output values of the network for the matrix $X$ of input feature vectors is given by\n", + "\n", + "$$\n", + "\\begin{align}\n", + "Z^{(1)} &= X W^{(1)} + \\mathbf b^{(1)} \\\\\n", + "A^{(1)} &= \\sigma(Z^{(1)}) \\\\\n", + "Z^{(2)} &= A^{(1)} W^{(2)} + \\mathbf b^{(2)} \\\\\n", + "A^{(2)} &= \\sigma(Z^{(2)})\n", + "\\end{align}\n", + "$$\n", + "\n", + "The loss function for a given set of weights is given by\n", + "\n", + "$$ L = \\sum_{i=0}^{n-1} (y_\\mathrm{pred} - y_\\mathrm{true})^2 $$\n", + "\n", + "We can know calculate the gradient of the loss function w.r.t. the wights. With the definition $\\hat L = (y_\\mathrm{pred} - y_\\mathrm{true})^2$, the gradients for the weights from the output layer to the hidden layer are given by: \n", + "\n", + "$$ \\frac{\\partial \\tilde L}{\\partial w_i^{(2)}} = \\frac{\\partial \\tilde L}{a_k^{(2)}} \\frac{a_k^{(2)}}{\\partial w_i^{(2)}} = \\frac{\\partial \\tilde L}{a_k^{(2)}} \\frac{a_k^{(2)}}{z_k^{(2)}} \\frac{z_k^{(2)}}{\\partial w_i^{(2)}} = 2 (a_k^{(2)} - y_k) a_k^{(2)} (1 - a_k^{(2)}) a_{k,i}^{(1)}$$\n", + "\n", + "Applying the chain rule further, we also obtain the gradient for the weights from the input layer to the hidden layer read: \n", + "\n", + "$$ \\frac{\\partial \\tilde L}{\\partial w_{ij}^{(1)}} = \\frac{\\partial \\tilde L}{\\partial a_k^{(2)}} \\frac{\\partial a_k^{(2)}}{\\partial z_k^{(2)}} \\frac{\\partial z_k^{(2)}}{\\partial a_{k,j}^{(1)}} \\frac{\\partial a_{k,j}^{(1)}}{\\partial z_{k,j}^{(1)}} \\frac{\\partial z_{k,j}^{(1)}}{\\partial w_{ij}^{(1)}} $$" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## A simple neural network class" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# A simple feed-forward neutral network with on hidden layer\n", + "# see also https://towardsdatascience.com/how-to-build-your-own-neural-network-from-scratch-in-python-68998a08e4f6\n", + "\n", + "import numpy as np\n", + "\n", + "class NeuralNetwork:\n", + " def __init__(self, x, y):\n", + " n1 = 3 # number of neurons in the hidden layer\n", + " self.input = x\n", + " self.weights1 = np.random.rand(self.input.shape[1],n1)\n", + " self.bias1 = np.random.rand(n1)\n", + " self.weights2 = np.random.rand(n1,1)\n", + " self.bias2 = np.random.rand(1) \n", + " self.y = y\n", + " self.output = np.zeros(y.shape)\n", + " self.learning_rate = 0.01\n", + " self.n_train = 0\n", + " self.loss_history = []\n", + "\n", + " def sigmoid(self, x):\n", + " return 1/(1+np.exp(-x))\n", + "\n", + " def sigmoid_derivative(self, x):\n", + " return x * (1 - x)\n", + "\n", + " def feedforward(self):\n", + " self.layer1 = self.sigmoid(self.input @ self.weights1 + self.bias1)\n", + " self.output = self.sigmoid(self.layer1 @ self.weights2 + self.bias2)\n", + "\n", + " def backprop(self):\n", + "\n", + " # delta1: [m, 1], m = number of training data\n", + " delta1 = 2 * (self.y - self.output) * self.sigmoid_derivative(self.output)\n", + "\n", + " # Gradient w.r.t. weights from hidden to output layer: [n1, 1] matrix, n1 = # neurons in hidden layer\n", + " d_weights2 = self.layer1.T @ delta1\n", + " d_bias2 = np.sum(delta1) \n", + " \n", + " # shape of delta2: [m, n1], m = number of training data, n1 = # neurons in hidden layer\n", + " delta2 = (delta1 @ self.weights2.T) * self.sigmoid_derivative(self.layer1)\n", + " d_weights1 = self.input.T @ delta2\n", + " d_bias1 = np.ones(delta2.shape[0]) @ delta2 \n", + " \n", + " # update weights and biases\n", + " self.weights1 += self.learning_rate * d_weights1\n", + " self.weights2 += self.learning_rate * d_weights2\n", + "\n", + " self.bias1 += self.learning_rate * d_bias1\n", + " self.bias2 += self.learning_rate * d_bias2\n", + "\n", + " def train(self, X, y):\n", + " self.output = np.zeros(y.shape)\n", + " self.input = X\n", + " self.y = y\n", + " self.feedforward()\n", + " self.backprop()\n", + " self.n_train += 1\n", + " if (self.n_train %1000 == 0):\n", + " loss = np.sum((self.y - self.output)**2)\n", + " print(\"loss: \", loss)\n", + " self.loss_history.append(loss)\n", + " \n", + " def predict(self, X):\n", + " self.output = np.zeros(y.shape)\n", + " self.input = X\n", + " self.feedforward()\n", + " return self.output\n", + " \n", + " def loss_history(self):\n", + " return self.loss_history\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create toy data\n", + "We create three toy data sets\n", + "1. two moon-like distributions\n", + "2. circles\n", + "3. linearly separable data sets" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# https://scikit-learn.org/stable/auto_examples/classification/plot_classifier_comparison.html#sphx-glr-auto-examples-classification-plot-classifier-comparison-py\n", + "import numpy as np\n", + "from sklearn.datasets import make_moons, make_circles, make_classification\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "X, y = make_classification(\n", + " n_features=2, n_redundant=0, n_informative=2, random_state=1, n_clusters_per_class=1\n", + ")\n", + "rng = np.random.RandomState(2)\n", + "X += 2 * rng.uniform(size=X.shape)\n", + "linearly_separable = (X, y)\n", + "\n", + "datasets = [\n", + " make_moons(n_samples=200, noise=0.1, random_state=0),\n", + " make_circles(n_samples=200, noise=0.1, factor=0.5, random_state=1),\n", + " linearly_separable,\n", + "]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create training and test data set" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# datasets: 0 = moons, 1 = circles, 2 = linearly separable\n", + "X, y = datasets[1]\n", + "X_train, X_test, y_train, y_test = train_test_split(\n", + " X, y, test_size=0.4, random_state=42\n", + ")\n", + "\n", + "x_min, x_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5\n", + "y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Train the model" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss: 28.591431249971087\n", + "loss: 19.174944855091578\n", + "loss: 18.300519116661075\n", + "loss: 5.44035901972833\n", + "loss: 2.2654992441410906\n", + "loss: 1.6923656607186892\n", + "loss: 1.3715971480249087\n", + "loss: 1.1473150221090382\n", + "loss: 0.9774346378363713\n", + "loss: 0.8457117685917934\n", + "loss: 0.7429652120737472\n", + "loss: 0.6621808985042399\n", + "loss: 0.5977165926831687\n", + "loss: 0.545283043346378\n", + "loss: 0.5017902977940301\n", + "loss: 0.46506515287723293\n", + "loss: 0.4335772706016494\n", + "loss: 0.40623169342909965\n", + "loss: 0.3822273847227754\n", + "loss: 0.36096446182458697\n", + "loss: 0.3419836665195889\n", + "loss: 0.3249263905044797\n", + "loss: 0.3095077414631703\n", + "loss: 0.29549797484687557\n", + "loss: 0.282709394404349\n", + "loss: 0.27098690712728085\n", + "loss: 0.2602010759266338\n", + "loss: 0.2502429170283057\n", + "loss: 0.24101994107129043\n", + "loss: 0.23245309736167535\n", + "loss: 0.2244743850815736\n", + "loss: 0.2170249645242441\n", + "loss: 0.21005364833790718\n", + "loss: 0.2035156851277511\n", + "loss: 0.19737177048767093\n", + "loss: 0.19158723674048994\n", + "loss: 0.18613138439559326\n", + "loss: 0.1809769269368725\n", + "loss: 0.17609952694233805\n", + "loss: 0.17147740633361158\n", + "loss: 0.16709101719249247\n", + "loss: 0.16292276236867193\n", + "loss: 0.15895675725575403\n", + "loss: 0.15517862578972155\n", + "loss: 0.1515753250400271\n", + "loss: 0.1481349938036084\n", + "loss: 0.1448468214395504\n", + "loss: 0.1417009338445398\n", + "loss: 0.13868829400248622\n", + "loss: 0.13580061497353096\n", + "loss: 0.1330302835389617\n", + "loss: 0.1303702930059422\n", + "loss: 0.127814183912036\n", + "loss: 0.12535599156436183\n", + "loss: 0.12299019950967911\n", + "loss: 0.1207116981660866\n", + "loss: 0.11851574795923153\n", + "loss: 0.11639794640004714\n", + "loss: 0.11435419862018448\n", + "loss: 0.11238069094815246\n", + "loss: 0.11047386716576169\n", + "loss: 0.10863040713256283\n", + "loss: 0.10684720750694056\n", + "loss: 0.1051213643275356\n", + "loss: 0.10345015724866172\n", + "loss: 0.10183103524916717\n", + "loss: 0.10026160365640727\n", + "loss: 0.09873961234613571\n", + "loss: 0.09726294499576621\n", + "loss: 0.09582960928281026\n", + "loss: 0.09443772793285743\n", + "loss: 0.09308553053235864\n", + "loss: 0.0917713460310074\n", + "loss: 0.09049359586685884\n", + "loss: 0.08925078765463015\n", + "loss: 0.08804150938406197\n", + "loss: 0.08686442408087547\n", + "loss: 0.08571826488782217\n", + "loss: 0.08460183052776402\n", + "loss: 0.08351398111459095\n", + "loss: 0.08245363428124586\n", + "loss: 0.08141976159718958\n", + "loss: 0.08041138525037475\n", + "loss: 0.07942757497120295\n", + "loss: 0.07846744517812901\n", + "loss: 0.07753015232648876\n", + "loss: 0.0766148924438704\n", + "loss: 0.0757208988368859\n", + "loss: 0.07484743995559193\n", + "loss: 0.07399381740306453\n", + "loss: 0.07315936407873515\n", + "loss: 0.07234344244512234\n", + "loss: 0.07154544290849069\n", + "loss: 0.07076478230479659\n", + "loss: 0.07000090248301835\n", + "loss: 0.06925326897863726\n", + "loss: 0.06852136977065329\n", + "loss: 0.06780471411604974\n", + "loss: 0.06710283145614956\n", + "loss: 0.06641527038972668\n" + ] + } + ], + "source": [ + "y_train = y_train.reshape(-1, 1)\n", + "\n", + "nn = NeuralNetwork(X_train, y_train)\n", + "\n", + "for i in range(100000):\n", + " nn.train(X_train, y_train)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot the loss vs. the number of epochs" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'loss')" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "plt.plot(nn.loss_history)\n", + "plt.xlabel(\"# epochs / 1000\")\n", + "plt.ylabel(\"loss\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "from matplotlib.colors import ListedColormap\n", + "\n", + "cm = plt.cm.RdBu\n", + "cm_bright = ListedColormap([\"#FF0000\", \"#0000FF\"])\n", + "\n", + "xv = np.linspace(x_min, x_max, 10)\n", + "yv = np.linspace(y_min, y_max, 10)\n", + "Xv, Yv = np.meshgrid(xv, yv)\n", + "XYpairs = np.vstack([ Xv.reshape(-1), Yv.reshape(-1)])\n", + "zv = nn.predict(XYpairs.T)\n", + "Zv = zv.reshape(Xv.shape)\n", + "\n", + "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(9, 7))\n", + "ax.set_aspect(1)\n", + "cn = ax.contourf(Xv, Yv, Zv, cmap=\"coolwarm_r\", alpha=0.4)\n", + "\n", + "ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright, edgecolors=\"k\")\n", + "\n", + "# Plot the testing points\n", + "ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright, alpha=0.4, edgecolors=\"k\")\n", + "\n", + "ax.set_xlim(x_min, x_max)\n", + "ax.set_ylim(y_min, y_max)\n", + "# ax.set_xticks(())\n", + "# ax.set_yticks(())\n", + "\n", + "fig.colorbar(cn)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.9" + }, + "vscode": { + "interpreter": { + "hash": "b0fa6594d8f4cbf19f97940f81e996739fb7646882a419484c72d19e05852a7e" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/simple_neural_network_exercise_solution.ipynb b/notebooks/simple_neural_network_exercise_solution.ipynb new file mode 100755 index 0000000..686cf95 --- /dev/null +++ b/notebooks/simple_neural_network_exercise_solution.ipynb @@ -0,0 +1,1320 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# A simple neural network with one hidden layer in pure Python" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## A simple neural network class with ReLU activation function" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [], + "source": [ + "# A simple feed-forward neutral network with on hidden layer\n", + "# see also https://towardsdatascience.com/how-to-build-your-own-neural-network-from-scratch-in-python-68998a08e4f6\n", + "\n", + "import numpy as np\n", + "\n", + "class NeuralNetwork:\n", + " def __init__(self, x, y):\n", + " n1 = 4 # number of neurons in the hidden layer\n", + " self.input = x\n", + " self.weights1 = np.random.rand(self.input.shape[1],n1)\n", + " self.bias1 = np.random.rand(n1)\n", + " self.weights2 = np.random.rand(n1,1)\n", + " self.bias2 = np.random.rand(1) \n", + " self.y = y\n", + " self.output = np.zeros(y.shape)\n", + " self.learning_rate = 0.00001\n", + " self.n_train = 0\n", + " self.loss_history = []\n", + "\n", + " def relu(self, x):\n", + " return np.where(x>0, x, 0)\n", + " \n", + " def relu_derivative(self, x):\n", + " return np.where(x>0, 1, 0)\n", + "\n", + " def feedforward(self):\n", + " self.layer1 = self.relu(self.input @ self.weights1 + self.bias1)\n", + " self.output = self.relu(self.layer1 @ self.weights2 + self.bias2)\n", + "\n", + " def backprop(self):\n", + "\n", + " # delta1: [m, 1], m = number of training data\n", + " delta1 = 2 * (self.y - self.output) * self.relu_derivative(self.output)\n", + "\n", + " # Gradient w.r.t. weights from hidden to output layer: [n1, 1] matrix, n1 = # neurons in hidden layer\n", + " d_weights2 = self.layer1.T @ delta1\n", + " d_bias2 = np.sum(delta1) \n", + " \n", + " # shape of delta2: [m, n1], m = number of training data, n1 = # neurons in hidden layer\n", + " delta2 = (delta1 @ self.weights2.T) * self.relu_derivative(self.layer1)\n", + " d_weights1 = self.input.T @ delta2\n", + " d_bias1 = np.ones(delta2.shape[0]) @ delta2 \n", + " \n", + " # update weights and biases\n", + " self.weights1 += self.learning_rate * d_weights1\n", + " self.weights2 += self.learning_rate * d_weights2\n", + "\n", + " self.bias1 += self.learning_rate * d_bias1\n", + " self.bias2 += self.learning_rate * d_bias2\n", + "\n", + " def train(self, X, y):\n", + " self.output = np.zeros(y.shape)\n", + " self.input = X\n", + " self.y = y\n", + " self.feedforward()\n", + " self.backprop()\n", + " self.n_train += 1\n", + " if (self.n_train %1000 == 0):\n", + " loss = np.sum((self.y - self.output)**2)\n", + " print(\"loss: \", loss)\n", + " self.loss_history.append(loss)\n", + " \n", + " def predict(self, X):\n", + " self.output = np.zeros(y.shape)\n", + " self.input = X\n", + " self.feedforward()\n", + " return self.output\n", + " \n", + " def loss_history(self):\n", + " return self.loss_history\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create toy data\n", + "We create three toy data sets\n", + "1. two moon-like distributions\n", + "2. circles\n", + "3. linearly separable data sets" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [], + "source": [ + "# https://scikit-learn.org/stable/auto_examples/classification/plot_classifier_comparison.html#sphx-glr-auto-examples-classification-plot-classifier-comparison-py\n", + "import numpy as np\n", + "from sklearn.datasets import make_moons, make_circles, make_classification\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "X, y = make_classification(\n", + " n_features=2, n_redundant=0, n_informative=2, random_state=1, n_clusters_per_class=1\n", + ")\n", + "rng = np.random.RandomState(2)\n", + "X += 2 * rng.uniform(size=X.shape)\n", + "linearly_separable = (X, y)\n", + "\n", + "datasets = [\n", + " make_moons(n_samples=200, noise=0.1, random_state=0),\n", + " make_circles(n_samples=200, noise=0.1, factor=0.5, random_state=1),\n", + " linearly_separable,\n", + "]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create training and test data set" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [], + "source": [ + "# datasets: 0 = moons, 1 = circles, 2 = linearly separable\n", + "X, y = datasets[1]\n", + "X_train, X_test, y_train, y_test = train_test_split(\n", + " X, y, test_size=0.4, random_state=42\n", + ")\n", + "\n", + "x_min, x_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5\n", + "y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Train the model" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss: 34.671913102152374\n", + "loss: 31.424782860564203\n", + "loss: 29.772915496524135\n", + "loss: 28.762023680772913\n", + "loss: 28.00200726838712\n", + "loss: 27.32590942137339\n", + "loss: 26.752368734071535\n", + "loss: 26.230440689447903\n", + "loss: 25.673463509689576\n", + "loss: 25.012834504148312\n", + "loss: 24.289682045629544\n", + "loss: 23.555645514965384\n", + "loss: 22.76462670346343\n", + "loss: 21.904104226889068\n", + "loss: 20.943637847221698\n", + "loss: 19.89434572572985\n", + "loss: 18.727285500049177\n", + "loss: 17.485616842253226\n", + "loss: 16.142413632344777\n", + "loss: 14.852364407067075\n", + "loss: 13.635545514668182\n", + "loss: 12.456629856179049\n", + "loss: 11.347265353073684\n", + "loss: 10.419340643305858\n", + "loss: 9.610799938794724\n", + "loss: 8.897580679158944\n", + "loss: 8.258004600111189\n", + "loss: 7.684500186535497\n", + "loss: 7.1748549390018574\n", + "loss: 6.718209468903557\n", + "loss: 6.309864315153381\n", + "loss: 5.944399105330259\n", + "loss: 5.621553827962666\n", + "loss: 5.333909699361839\n", + "loss: 5.077286239602076\n", + "loss: 4.84889061532151\n", + "loss: 4.646022685947024\n", + "loss: 4.465758350759858\n", + "loss: 4.305913173647123\n", + "loss: 4.1640718175126095\n", + "loss: 4.039102963682375\n", + "loss: 3.9297524332426623\n", + "loss: 3.832402269592843\n", + "loss: 3.7453438160159322\n", + "loss: 3.6674507148484525\n", + "loss: 3.5977884037626\n", + "loss: 3.535827925326507\n", + "loss: 3.479967988008011\n", + "loss: 3.4291169910556207\n", + "loss: 3.3829982181684475\n", + "loss: 3.3416403251567335\n", + "loss: 3.304229099924413\n", + "loss: 3.2684585556590573\n", + "loss: 3.2354701067381977\n", + "loss: 3.2051369151544105\n", + "loss: 3.1772080296379404\n", + "loss: 3.1476337866558435\n", + "loss: 3.1193880834750365\n", + "loss: 3.0930575696528475\n", + "loss: 3.0684279860561725\n", + "loss: 3.0453159280825632\n", + "loss: 3.023566344470656\n", + "loss: 3.0031494958762517\n", + "loss: 2.9838385760074786\n", + "loss: 2.965539553283577\n", + "loss: 2.9481708868131866\n", + "loss: 2.9316489223756497\n", + "loss: 2.9158898824688726\n", + "loss: 2.900839148101508\n", + "loss: 2.8864469332954905\n", + "loss: 2.8726683402256388\n", + "loss: 2.8594627350494104\n", + "loss: 2.846788596539098\n", + "loss: 2.834699126928559\n", + "loss: 2.8238134101918453\n", + "loss: 2.8133709056375507\n", + "loss: 2.8032597976075766\n", + "loss: 2.793428392265398\n", + "loss: 2.7839305952541142\n", + "loss: 2.7747494784865347\n", + "loss: 2.765836907330045\n", + "loss: 2.757121848680945\n", + "loss: 2.7486569559419625\n", + "loss: 2.7404305726008564\n", + "loss: 2.732433904640994\n", + "loss: 2.724658913060166\n", + "loss: 2.717098191391666\n", + "loss: 2.709744869114474\n", + "loss: 2.7025925339845283\n", + "loss: 2.695634579597031\n", + "loss: 2.688854332606485\n", + "loss: 2.682427203225914\n", + "loss: 2.6764899407900025\n", + "loss: 2.6707857438883167\n", + "loss: 2.6652986297014336\n", + "loss: 2.6600185764704065\n", + "loss: 2.654938846386348\n", + "loss: 2.650048013830516\n", + "loss: 2.6434375100435394\n", + "loss: 2.6372726876694945\n", + "loss: 2.6315142701295082\n", + "loss: 2.6260949485933374\n", + "loss: 2.620971039483914\n", + "loss: 2.61174470987536\n", + "loss: 2.5984776428986\n", + "loss: 2.587556467070711\n", + "loss: 2.5779657263762803\n", + "loss: 2.5692396803357767\n", + "loss: 2.5611227223903583\n", + "loss: 2.5534830205555155\n", + "loss: 2.5462350514450636\n", + "loss: 2.539331795274396\n", + "loss: 2.5327378554215794\n", + "loss: 2.5264333984648015\n", + "loss: 2.5203974791572867\n", + "loss: 2.5146177883938456\n", + "loss: 2.5090780321819945\n", + "loss: 2.5037668178628807\n", + "loss: 2.4986865327324224\n", + "loss: 2.4938357429187015\n", + "loss: 2.4892125195154855\n", + "loss: 2.484814217154528\n", + "loss: 2.480624991605507\n", + "loss: 2.47663936164734\n", + "loss: 2.4728453322029287\n", + "loss: 2.469227702733714\n", + "loss: 2.465784971369546\n", + "loss: 2.4625031729417586\n", + "loss: 2.459373586417242\n", + "loss: 2.456395742549959\n", + "loss: 2.453556149147296\n", + "loss: 2.450848516477792\n", + "loss: 2.448257826886593\n", + "loss: 2.4457793902422473\n", + "loss: 2.4434057564290246\n", + "loss: 2.4411335977457957\n", + "loss: 2.43895711642629\n", + "loss: 2.4368736364557093\n", + "loss: 2.4348749182486014\n", + "loss: 2.432961782234024\n", + "loss: 2.4311267156550267\n", + "loss: 2.4293686022331507\n", + "loss: 2.4276818857227433\n", + "loss: 2.4260653790156557\n", + "loss: 2.4245172581509893\n", + "loss: 2.423035547508019\n", + "loss: 2.4216137562678623\n", + "loss: 2.420252690046535\n", + "loss: 2.4189495881209595\n", + "loss: 2.4176996906636115\n", + "loss: 2.4165033152293676\n", + "loss: 2.415355506487388\n", + "loss: 2.414254264583601\n", + "loss: 2.4131997637552898\n", + "loss: 2.4121900926116586\n", + "loss: 2.411220865950546\n", + "loss: 2.410291344402852\n", + "loss: 2.4094025182811554\n", + "loss: 2.4085499517354947\n", + "loss: 2.407731441094278\n", + "loss: 2.406946144975749\n", + "loss: 2.4061932934032764\n", + "loss: 2.4054693005333485\n", + "loss: 2.4047725159312234\n", + "loss: 2.404104507441233\n", + "loss: 2.4034628933277684\n", + "loss: 2.4028442537087553\n", + "loss: 2.4022504549932577\n", + "loss: 2.4016803840643326\n", + "loss: 2.4011319551366914\n", + "loss: 2.4006060782593357\n", + "loss: 2.400098897713013\n", + "loss: 2.39961231412508\n", + "loss: 2.3991458381267075\n", + "loss: 2.3986954028524448\n", + "loss: 2.3982632819114857\n", + "loss: 2.3978461833600178\n", + "loss: 2.3974452187294\n", + "loss: 2.3970596690136103\n", + "loss: 2.396686140489889\n", + "loss: 2.396328903510832\n", + "loss: 2.3959835555706825\n", + "loss: 2.39565059757921\n", + "loss: 2.3953300040263765\n", + "loss: 2.3950220475433692\n", + "loss: 2.3947263525017353\n", + "loss: 2.3944396560020063\n", + "loss: 2.3941632766670184\n", + "loss: 2.3938993096058816\n", + "loss: 2.39364294492824\n", + "loss: 2.3933965389172958\n", + "loss: 2.3931594462236814\n", + "loss: 2.392932651756755\n", + "loss: 2.392711772531679\n", + "loss: 2.3925004166785255\n", + "loss: 2.392296083041902\n", + "loss: 2.392100842332238\n", + "loss: 2.3919111950972347\n", + "loss: 2.3917290333380343\n", + "loss: 2.391553470675823\n", + "loss: 2.3913848103373843\n", + "loss: 2.391220583744764\n", + "loss: 2.3910649553444348\n", + "loss: 2.390914207314057\n", + "loss: 2.3907697541809365\n", + "loss: 2.390630728668481\n", + "loss: 2.390498495256061\n", + "loss: 2.390369937885896\n", + "loss: 2.390247045664548\n", + "loss: 2.3901273102670126\n", + "loss: 2.3900148760237014\n", + "loss: 2.389905238354612\n", + "loss: 2.3898001952359604\n", + "loss: 2.3896980625916764\n", + "loss: 2.3896010024421126\n", + "loss: 2.3895086082689625\n", + "loss: 2.389417860716362\n", + "loss: 2.3893319903283574\n", + "loss: 2.3892491959225457\n", + "loss: 2.3891687694660892\n", + "loss: 2.3890934197829052\n", + "loss: 2.389019136431073\n", + "loss: 2.388947788821395\n", + "loss: 2.3888805609783272\n", + "loss: 2.3888150688462746\n", + "loss: 2.3887518707039823\n", + "loss: 2.388691911298264\n", + "loss: 2.388634014187227\n", + "loss: 2.38857805590494\n", + "loss: 2.388523918864406\n", + "loss: 2.388473510627236\n", + "loss: 2.388423436117929\n", + "loss: 2.3883753262717216\n", + "loss: 2.3883303602155683\n", + "loss: 2.3882866724515304\n", + "loss: 2.388244442215278\n", + "loss: 2.3882033453528138\n", + "loss: 2.3881652931929307\n", + "loss: 2.38812677875453\n", + "loss: 2.388091060218199\n", + "loss: 2.388056092752744\n", + "loss: 2.3880237467127237\n", + "loss: 2.3879919924582405\n", + "loss: 2.387960763231075\n", + "loss: 2.387931658872838\n", + "loss: 2.3879034749475188\n", + "loss: 2.387875347245705\n", + "loss: 2.387849402809727\n", + "loss: 2.387823662709372\n", + "loss: 2.387799967311831\n", + "loss: 2.387776360266166\n", + "loss: 2.387754683818766\n", + "loss: 2.3877329827919898\n", + "loss: 2.3877121910475196\n", + "loss: 2.3876929899702644\n", + "loss: 2.3876729319637\n", + "loss: 2.387654431642712\n", + "loss: 2.387637541283918\n", + "loss: 2.387620354216107\n", + "loss: 2.387604686551482\n", + "loss: 2.3875886398363733\n", + "loss: 2.387573984851815\n", + "loss: 2.3875588098577873\n", + "loss: 2.3875448805324915\n", + "loss: 2.387532242680253\n", + "loss: 2.3875189700442068\n", + "loss: 2.387506861417358\n", + "loss: 2.387495291770735\n", + "loss: 2.387484231905034\n", + "loss: 2.3874731451723217\n", + "loss: 2.387462274358618\n", + "loss: 2.3874519373951664\n", + "loss: 2.3874425920575746\n", + "loss: 2.3874333869787168\n", + "loss: 2.3874249670575987\n", + "loss: 2.3874162377994788\n", + "loss: 2.3874073874920074\n", + "loss: 2.3873990135367182\n", + "loss: 2.3873914786024937\n", + "loss: 2.387384759212198\n", + "loss: 2.387377049938677\n", + "loss: 2.387371052646234\n", + "loss: 2.387363939101346\n", + "loss: 2.3873584890193866\n", + "loss: 2.3873519773705674\n", + "loss: 2.3873461623087593\n", + "loss: 2.387341023755127\n", + "loss: 2.387336250114317\n", + "loss: 2.3873309349740612\n", + "loss: 2.387325950896895\n", + "loss: 2.3873215752647576\n", + "loss: 2.3873160311256796\n", + "loss: 2.3873128208612444\n", + "loss: 2.3873084158082647\n", + "loss: 2.387304558605306\n", + "loss: 2.3872995395407717\n", + "loss: 2.387296679993435\n", + "loss: 2.387292629417728\n", + "loss: 2.3872890739934816\n", + "loss: 2.387285997937587\n", + "loss: 2.387283389935851\n", + "loss: 2.3872794993942383\n", + "loss: 2.387277790051124\n", + "loss: 2.387274775181382\n", + "loss: 2.387272183856358\n", + "loss: 2.387269056421407\n", + "loss: 2.3872664925693012\n", + "loss: 2.387264376208358\n", + "loss: 2.3872623679945018\n", + "loss: 2.3872600043678207\n", + "loss: 2.3872580041281823\n", + "loss: 2.387256273384648\n", + "loss: 2.3872533408675327\n", + "loss: 2.3872523812347737\n", + "loss: 2.3872500233166005\n", + "loss: 2.387247988754982\n", + "loss: 2.387246267292523\n", + "loss: 2.3872448527441414\n", + "loss: 2.387243735408723\n", + "loss: 2.387242025422281\n", + "loss: 2.3872406504464334\n", + "loss: 2.3872386748070245\n", + "loss: 2.3872386165309805\n", + "loss: 2.387237233810461\n", + "loss: 2.3872360479643593\n", + "loss: 2.38723476536898\n", + "loss: 2.387232724485056\n", + "loss: 2.3872322755810025\n", + "loss: 2.3872308935896562\n", + "loss: 2.387230374354215\n", + "loss: 2.3872289131536952\n", + "loss: 2.387227666907803\n", + "loss: 2.387227223159598\n", + "loss: 2.3872263094643955\n", + "loss: 2.3872251968418357\n", + "loss: 2.387224775014026\n", + "loss: 2.387224547860667\n", + "loss: 2.3872230838809783\n", + "loss: 2.3872229638510785\n", + "loss: 2.387221601841123\n", + "loss: 2.3872221053237612\n", + "loss: 2.3872210930668896\n", + "loss: 2.3872202490512318\n", + "loss: 2.3872195705964097\n", + "loss: 2.387219054999678\n", + "loss: 2.387218694718085\n", + "loss: 2.3872184895236703\n", + "loss: 2.3872184361150453\n", + "loss: 2.3872168420512097\n", + "loss: 2.38721707828012\n", + "loss: 2.3872157746881033\n", + "loss: 2.3872162871830027\n", + "loss: 2.3872152565137865\n", + "loss: 2.3872156550203423\n", + "loss: 2.387215262058789\n", + "loss: 2.3872146171203603\n", + "loss: 2.3872140924465817\n", + "loss: 2.387213692303668\n", + "loss: 2.3872134068601816\n", + "loss: 2.3872132382331945\n", + "loss: 2.3872131800547116\n", + "loss: 2.3872132336735374\n", + "loss: 2.3872122046766457\n", + "loss: 2.387211985620091\n", + "loss: 2.3872123543033004\n", + "loss: 2.3872111512061682\n", + "loss: 2.3872117185255872\n", + "loss: 2.387210711934733\n", + "loss: 2.3872114695614397\n", + "loss: 2.3872106483724744\n", + "loss: 2.3872106246269746\n", + "loss: 2.387210949823621\n", + "loss: 2.3872103921805325\n", + "loss: 2.387209923070608\n", + "loss: 2.387209539035157\n", + "loss: 2.387209233578181\n", + "loss: 2.387209278909502\n", + "loss: 2.3872091575872285\n", + "loss: 2.3872087902003143\n", + "loss: 2.387208796135135\n", + "loss: 2.387208863491243\n", + "loss: 2.3872090209788177\n", + "loss: 2.3872092395967757\n", + "loss: 2.387209509667974\n", + "loss: 2.3872081941411776\n", + "loss: 2.387208614493238\n", + "loss: 2.387209092011758\n", + "loss: 2.3872079707116916\n", + "loss: 2.387208566693145\n", + "loss: 2.3872075814397924\n", + "loss: 2.3872082912786885\n", + "loss: 2.3872074055895007\n", + "loss: 2.3872082394740444\n", + "loss: 2.3872074711869145\n", + "loss: 2.38720841308389\n", + "loss: 2.3872077482796317\n", + "loss: 2.3872071369801997\n", + "loss: 2.387208234823193\n", + "loss: 2.3872077218609924\n", + "loss: 2.3872072579088783\n", + "loss: 2.387206844007732\n", + "loss: 2.3872079496309033\n", + "loss: 2.3872078102348167\n", + "loss: 2.387207529575949\n", + "loss: 2.387207296171491\n", + "loss: 2.3872071039581373\n", + "loss: 2.38720695276087\n", + "loss: 2.3872068462090654\n", + "loss: 2.387206777400199\n", + "loss: 2.3872067479488583\n", + "loss: 2.3872067565550017\n", + "loss: 2.3872068036021385\n", + "loss: 2.3872068874369434\n", + "loss: 2.3872070087213757\n", + "loss: 2.3872071655473297\n", + "loss: 2.3872073550964092\n", + "loss: 2.387207093581078\n", + "loss: 2.3872061834452403\n", + "loss: 2.387206473681233\n", + "loss: 2.3872067944256044\n", + "loss: 2.387207150189065\n", + "loss: 2.3872065584074114\n", + "loss: 2.3872062931664226\n", + "loss: 2.3872067377036283\n", + "loss: 2.387207211254447\n", + "loss: 2.3872060575595855\n", + "loss: 2.3872065866005077\n", + "loss: 2.387207143362015\n", + "loss: 2.387206071870889\n", + "loss: 2.3872066797178375\n", + "loss: 2.3872065479626627\n", + "loss: 2.387206319019361\n", + "loss: 2.3872070019550087\n", + "loss: 2.3872060569372797\n", + "loss: 2.38720678668193\n", + "loss: 2.387205887930111\n", + "loss: 2.387206664076764\n", + "loss: 2.3872058107150407\n", + "loss: 2.3872066293892216\n", + "loss: 2.387205818746259\n", + "loss: 2.3872066801575853\n", + "loss: 2.3872059111197688\n", + "loss: 2.3872068126406196\n", + "loss: 2.387206081035995\n", + "loss: 2.3872068669685325\n", + "loss: 2.3872063280795652\n", + "loss: 2.3872056557817367\n", + "loss: 2.3872066491216897\n", + "loss: 2.387206011860928\n", + "loss: 2.387206535957502\n", + "loss: 2.3872064376325017\n", + "loss: 2.3872058508160308\n", + "loss: 2.3872069163305536\n", + "loss: 2.3872063735393425\n", + "loss: 2.387205832345839\n", + "loss: 2.387206677283909\n", + "loss: 2.3872064498889176\n", + "loss: 2.387205955600857\n", + "loss: 2.387205820939399\n", + "loss: 2.387206660636184\n", + "loss: 2.387206206604038\n", + "loss: 2.38720576900394\n", + "loss: 2.3872063117983804\n", + "loss: 2.3872065813147874\n", + "loss: 2.387206181466505\n", + "loss: 2.3872057946984633\n", + "loss: 2.3872058708004715\n", + "loss: 2.387206706121622\n", + "loss: 2.3872063554658762\n", + "loss: 2.3872060160821453\n", + "loss: 2.3872056878815267\n", + "loss: 2.3872059982983496\n", + "loss: 2.387206714970821\n", + "loss: 2.3872064188808673\n", + "loss: 2.3872061334063455\n", + "loss: 2.3872058573779524\n", + "loss: 2.3872055929594205\n", + "loss: 2.3872060525929197\n", + "loss: 2.3872067406100412\n", + "loss: 2.387206502734586\n", + "loss: 2.3872062762370385\n", + "loss: 2.387206057098045\n", + "loss: 2.3872058489669072\n", + "loss: 2.3872056488912214\n", + "loss: 2.3872054563548764\n", + "loss: 2.3872062535038063\n", + "loss: 2.387206745595907\n", + "loss: 2.3872065783271466\n", + "loss: 2.38720641696552\n", + "loss: 2.387206265759137\n", + "loss: 2.387206119480711\n", + "loss: 2.3872059828172514\n", + "loss: 2.387205852070047\n", + "loss: 2.387205730140802\n", + "loss: 2.387205613674655\n", + "loss: 2.3872055054664263\n", + "loss: 2.3872055703172705\n", + "loss: 2.387206001531239\n", + "loss: 2.3872064059032465\n", + "loss: 2.3872067748722134\n", + "loss: 2.387206704414516\n", + "loss: 2.387206632138044\n", + "loss: 2.3872065672351592\n", + "loss: 2.3872065077955\n", + "loss: 2.387206453507227\n", + "loss: 2.387206405811236\n", + "loss: 2.3872063624448145\n", + "loss: 2.387206324770439\n", + "loss: 2.387206293044411\n", + "loss: 2.387206266172666\n", + "loss: 2.387206246548697\n", + "loss: 2.3872062269091705\n", + "loss: 2.3872062166383956\n", + "loss: 2.3872062117393194\n", + "loss: 2.3872062110609655\n", + "loss: 2.3872062139535695\n", + "loss: 2.387206219909649\n", + "loss: 2.3872062285052236\n", + "loss: 2.387206240576973\n", + "loss: 2.3872062606586537\n", + "loss: 2.3872062832874716\n", + "loss: 2.3872063082635315\n", + "loss: 2.3872063391881677\n", + "loss: 2.387206373803312\n", + "loss: 2.3872064127175974\n", + "loss: 2.3872064540621514\n", + "loss: 2.3872064987956327\n", + "loss: 2.3872065498963284\n", + "loss: 2.3872066013767226\n", + "loss: 2.387206657950146\n", + "loss: 2.3872067182049292\n", + "loss: 2.387206672867762\n", + "loss: 2.3872063672970487\n", + "loss: 2.387206055011894\n", + "loss: 2.3872057237905118\n", + "loss: 2.3872054165649037\n", + "loss: 2.3872054954444497\n", + "loss: 2.387205575891558\n", + "loss: 2.3872056608606287\n", + "loss: 2.3872057469958534\n", + "loss: 2.387205835730483\n", + "loss: 2.3872059291294483\n", + "loss: 2.387206023172342\n", + "loss: 2.387206121095825\n", + "loss: 2.3872062219751333\n", + "loss: 2.3872063233856755\n", + "loss: 2.387206428473149\n", + "loss: 2.3872065378135736\n", + "loss: 2.387206647283522\n", + "loss: 2.387206749735465\n", + "loss: 2.3872062240356984\n", + "loss: 2.38720569664805\n", + "loss: 2.3872054625336876\n", + "loss: 2.387205583157073\n", + "loss: 2.3872057046336925\n", + "loss: 2.387205829508387\n", + "loss: 2.387205957406746\n", + "loss: 2.387206085740676\n", + "loss: 2.3872062170332273\n", + "loss: 2.387206349757113\n", + "loss: 2.387206484077489\n", + "loss: 2.387206620076463\n", + "loss: 2.387206742599622\n", + "loss: 2.38720610614635\n", + "loss: 2.3872054598822556\n", + "loss: 2.3872055360296702\n", + "loss: 2.3872056808451143\n", + "loss: 2.3872058264733313\n", + "loss: 2.3872059747774506\n", + "loss: 2.387206123890669\n", + "loss: 2.3872062756016943\n", + "loss: 2.387206426949868\n", + "loss: 2.3872065819415873\n", + "loss: 2.387206737478283\n", + "loss: 2.387206126865435\n", + "loss: 2.3872054054434018\n", + "loss: 2.3872055638677026\n", + "loss: 2.387205724088219\n", + "loss: 2.38720588669721\n", + "loss: 2.387206049768166\n", + "loss: 2.3872062148316706\n", + "loss: 2.3872063803883172\n", + "loss: 2.3872065476541806\n", + "loss: 2.3872067152675234\n", + "loss: 2.3872061646400056\n", + "loss: 2.3872054078993044\n", + "loss: 2.3872055802952357\n", + "loss: 2.3872057516280947\n", + "loss: 2.3872059245622954\n", + "loss: 2.3872060978440746\n", + "loss: 2.387206273640891\n", + "loss: 2.387206448981906\n", + "loss: 2.3872066283894027\n", + "loss: 2.387206516906132\n", + "loss: 2.387205699504398\n", + "loss: 2.3872055196151685\n", + "loss: 2.3872056996032054\n", + "loss: 2.3872058817924033\n", + "loss: 2.387206063764966\n", + "loss: 2.387206248517262\n", + "loss: 2.387206432649466\n", + "loss: 2.3872066179179283\n", + "loss: 2.387206522287034\n", + "loss: 2.3872056702282123\n", + "loss: 2.3872055324647627\n", + "loss: 2.38720572034085\n", + "loss: 2.3872059096035927\n", + "loss: 2.3872060985335164\n", + "loss: 2.387206289705417\n", + "loss: 2.387206481657449\n", + "loss: 2.3872066741473743\n", + "loss: 2.387206243340186\n", + "loss: 2.387205412579381\n", + "loss: 2.387205607172106\n", + "loss: 2.3872058001813334\n", + "loss: 2.3872059950155946\n", + "loss: 2.3872061909696214\n", + "loss: 2.387206387319673\n", + "loss: 2.3872065845641055\n", + "loss: 2.387206628280637\n", + "loss: 2.3872057223715246\n", + "loss: 2.3872055317401317\n", + "loss: 2.387205729959452\n", + "loss: 2.3872059297733506\n", + "loss: 2.3872061287534345\n", + "loss: 2.3872063300590187\n", + "loss: 2.3872065319453286\n", + "loss: 2.3872067329639384\n", + "loss: 2.3872059293532697\n", + "loss: 2.3872054909066573\n", + "loss: 2.3872056929994176\n", + "loss: 2.3872058959012414\n", + "loss: 2.3872060991225794\n", + "loss: 2.387206303755043\n", + "loss: 2.3872065090776227\n", + "loss: 2.387206713881384\n", + "loss: 2.3872060034612277\n", + "loss: 2.387205479096127\n", + "loss: 2.3872056842701372\n", + "loss: 2.3872058905037483\n", + "loss: 2.3872060971157936\n", + "loss: 2.3872063046852645\n", + "loss: 2.3872065130746725\n", + "loss: 2.387206720682877\n", + "loss: 2.3872059543810957\n", + "loss: 2.3872054920341013\n", + "loss: 2.387205699860994\n", + "loss: 2.387205909361374\n", + "loss: 2.387206118592575\n", + "loss: 2.387206328727607\n", + "loss: 2.38720654022318\n", + "loss: 2.3872067496108995\n", + "loss: 2.38720580949524\n", + "loss: 2.387205525406542\n", + "loss: 2.3872057364936534\n", + "loss: 2.3872059484123977\n", + "loss: 2.387206158732515\n", + "loss: 2.3872063716998198\n", + "loss: 2.387206584128892\n", + "loss: 2.3872065550645125\n", + "loss: 2.387205585137984\n", + "loss: 2.387205576467598\n", + "loss: 2.3872057895930716\n", + "loss: 2.3872060024345876\n", + "loss: 2.387206217104482\n", + "loss: 2.38720643053896\n", + "loss: 2.3872066462470087\n", + "loss: 2.3872062650681847\n", + "loss: 2.3872054287829734\n", + "loss: 2.387205644040444\n", + "loss: 2.387205857402579\n", + "loss: 2.3872060732060456\n", + "loss: 2.3872062890605856\n", + "loss: 2.3872065058667893\n", + "loss: 2.387206721085871\n", + "loss: 2.3872059173144433\n", + "loss: 2.3872055071105676\n", + "loss: 2.387205722800243\n", + "loss: 2.387205939850607\n", + "loss: 2.387206155334122\n", + "loss: 2.3872063740586773\n", + "loss: 2.38720659063653\n", + "loss: 2.3872065025409945\n", + "loss: 2.3872055102865852\n", + "loss: 2.387205597163091\n", + "loss: 2.3872058144515096\n", + "loss: 2.3872060323445647\n", + "loss: 2.38720625026218\n", + "loss: 2.387206468189427\n", + "loss: 2.3872066869296926\n", + "loss: 2.387206064964853\n", + "loss: 2.38720547798433\n", + "loss: 2.387205695647846\n", + "loss: 2.3872059148036042\n", + "loss: 2.387206132165185\n", + "loss: 2.3872063520034\n", + "loss: 2.387206571675985\n", + "loss: 2.387206580623468\n", + "loss: 2.387205582588098\n", + "loss: 2.3872055839413213\n", + "loss: 2.3872058020374514\n", + "loss: 2.3872060214815694\n", + "loss: 2.38720624240693\n", + "loss: 2.387206462370405\n", + "loss: 2.387206683255392\n", + "loss: 2.3872060762465175\n", + "loss: 2.3872054775249913\n", + "loss: 2.387205696602586\n", + "loss: 2.3872059172419493\n", + "loss: 2.3872061373373787\n", + "loss: 2.387206357728515\n", + "loss: 2.387206579560316\n", + "loss: 2.387206536499058\n", + "loss: 2.387205534906743\n", + "loss: 2.387205596098073\n", + "loss: 2.387205817218552\n", + "loss: 2.387206037559115\n", + "loss: 2.3872062589616636\n", + "loss: 2.3872064810746823\n", + "loss: 2.387206702376931\n", + "loss: 2.3872059789399236\n", + "loss: 2.3872054989934695\n", + "loss: 2.3872057193198266\n", + "loss: 2.3872059415304925\n", + "loss: 2.387206163057817\n", + "loss: 2.387206385045773\n", + "loss: 2.3872066064853166\n", + "loss: 2.38720640924132\n", + "loss: 2.3872054050281237\n", + "loss: 2.3872056266849664\n", + "loss: 2.3872058475459403\n", + "loss: 2.387206070207055\n", + "loss: 2.387206292224948\n", + "loss: 2.3872065152244177\n", + "loss: 2.3872067373632193\n", + "loss: 2.387205812795538\n", + "loss: 2.387205535628719\n", + "loss: 2.3872057581142827\n", + "loss: 2.387205979871331\n", + "loss: 2.387206202847354\n", + "loss: 2.38720642492102\n", + "loss: 2.3872066486900834\n", + "loss: 2.3872062143940815\n", + "loss: 2.3872054479581615\n", + "loss: 2.3872056700624618\n", + "loss: 2.387205892745017\n", + "loss: 2.3872061156322637\n", + "loss: 2.3872063392335336\n", + "loss: 2.3872065621484544\n", + "loss: 2.3872066127839506\n", + "loss: 2.387205593010971\n", + "loss: 2.3872055852578473\n", + "loss: 2.3872058079900116\n", + "loss: 2.3872060312398813\n", + "loss: 2.387206254831415\n", + "loss: 2.387206477626406\n", + "loss: 2.3872067013641285\n", + "loss: 2.387205974948894\n", + "loss: 2.3872055015373546\n", + "loss: 2.387205724165402\n", + "loss: 2.387205948609596\n", + "loss: 2.3872061711547934\n", + "loss: 2.3872063942990995\n", + "loss: 2.387206617976577\n", + "loss: 2.3872063484996606\n", + "loss: 2.387205419784946\n", + "loss: 2.387205643696668\n", + "loss: 2.38720586667547\n", + "loss: 2.387206089943084\n", + "loss: 2.387206312830524\n", + "loss: 2.3872065377208713\n", + "loss: 2.3872067192036486\n", + "loss: 2.3872056983399608\n", + "loss: 2.387205562202803\n", + "loss: 2.3872057863378924\n", + "loss: 2.387206009488842\n", + "loss: 2.3872062344077247\n", + "loss: 2.3872064585590174\n", + "loss: 2.3872066828857177\n", + "loss: 2.387206060927091\n", + "loss: 2.387205483917369\n", + "loss: 2.387205706729346\n", + "loss: 2.3872059309762115\n", + "loss: 2.387206154167569\n", + "loss: 2.387206379212923\n", + "loss: 2.387206603498562\n", + "loss: 2.387206412786183\n", + "loss: 2.38720540594447\n", + "loss: 2.387205630194073\n", + "loss: 2.3872058532972202\n", + "loss: 2.387206078179721\n", + "loss: 2.3872063011757954\n", + "loss: 2.3872065261212008\n", + "loss: 2.387206750494888\n", + "loss: 2.38720574408085\n", + "loss: 2.3872055526202605\n", + "loss: 2.387205776875942\n", + "loss: 2.3872060000469304\n", + "loss: 2.3872062251849693\n", + "loss: 2.3872064490769467\n", + "loss: 2.38720667505617\n", + "loss: 2.387206092621105\n", + "loss: 2.3872054778245344\n", + "loss: 2.387205700855323\n", + "loss: 2.387205925499759\n", + "loss: 2.387206149256795\n", + "loss: 2.3872063747392476\n", + "loss: 2.3872065982742674\n", + "loss: 2.387206435850997\n", + "loss: 2.3872054149088293\n", + "loss: 2.3872056262571535\n", + "loss: 2.387205849166078\n", + "loss: 2.3872060742134376\n", + "loss: 2.3872062979103035\n", + "loss: 2.387206523614174\n", + "loss: 2.3872067479852594\n", + "loss: 2.3872057530264144\n", + "loss: 2.387205550630556\n", + "loss: 2.3872057753165112\n", + "loss: 2.387205999046393\n", + "loss: 2.3872062242513152\n", + "loss: 2.387206448562063\n", + "loss: 2.3872066745566825\n", + "loss: 2.3872060933404238\n", + "loss: 2.387205477652032\n", + "loss: 2.38720570096479\n", + "loss: 2.3872059260253913\n", + "loss: 2.387206149856662\n", + "loss: 2.3872063756569637\n", + "loss: 2.3872066002677177\n", + "loss: 2.3872064248665876\n", + "loss: 2.3872054055763066\n", + "loss: 2.3872056285152192\n", + "loss: 2.387205852129036\n", + "loss: 2.387206076714375\n", + "loss: 2.3872063008900715\n", + "loss: 2.3872065262982316\n", + "loss: 2.3872067510414143\n", + "loss: 2.387205738066258\n", + "loss: 2.387205553932228\n", + "loss: 2.3872057787560985\n", + "loss: 2.387206002620486\n", + "loss: 2.3872062278227126\n", + "loss: 2.387206452219362\n", + "loss: 2.3872066785656476\n", + "loss: 2.3872060756651354\n", + "loss: 2.3872054817901702\n", + "loss: 2.387205705294623\n", + "loss: 2.387205930184685\n", + "loss: 2.3872061542181156\n", + "loss: 2.387206380162742\n", + "loss: 2.3872066048043825\n", + "loss: 2.3872064037912457\n", + "loss: 2.387205408672593\n", + "loss: 2.3872056335074885\n", + "loss: 2.38720585704452\n", + "loss: 2.3872060825534622\n", + "loss: 2.3872063070962546\n", + "loss: 2.3872065331763173\n", + "loss: 2.387206736126897\n", + "loss: 2.3872057102550297\n", + "loss: 2.387205560708403\n", + "loss: 2.387205785698165\n", + "loss: 2.3872060098092085\n", + "loss: 2.3872062357191077\n", + "loss: 2.3872064606568575\n", + "loss: 2.3872066856260075\n", + "loss: 2.3872060412743403\n", + "loss: 2.3872054896579566\n", + "loss: 2.387205713503783\n", + "loss: 2.387205938855604\n", + "loss: 2.3872061633253967\n", + "loss: 2.3872063880939898\n", + "loss: 2.387206613272621\n", + "loss: 2.3872063644496766\n", + "loss: 2.387205417523893\n", + "loss: 2.387205642655334\n", + "loss: 2.3872058668390554\n", + "loss: 2.3872060910716635\n", + "loss: 2.3872063157741197\n", + "loss: 2.387206542322383\n", + "loss: 2.387206692745429\n", + "loss: 2.3872056660868344\n", + "loss: 2.3872055706534514\n", + "loss: 2.3872057946635303\n", + "loss: 2.387206019070375\n", + "loss: 2.387206245277133\n", + "loss: 2.387206470316894\n", + "loss: 2.3872066957452835\n", + "loss: 2.3872059933352743\n", + "loss: 2.3872054990132523\n", + "loss: 2.387205722878048\n", + "loss: 2.387205948575221\n", + "loss: 2.387206173353647\n", + "loss: 2.3872063984591825\n", + "loss: 2.3872066226559827\n", + "loss: 2.3872063207497023\n", + "loss: 2.3872054272954717\n", + "loss: 2.3872056526531233\n", + "loss: 2.3872058770925495\n", + "loss: 2.3872061007027394\n", + "loss: 2.387206325498709\n", + "loss: 2.387206552189155\n", + "loss: 2.3872066470668103\n", + "loss: 2.387205618564661\n", + "loss: 2.387205580450609\n", + "loss: 2.3872058044940334\n", + "loss: 2.3872060289891905\n", + "loss: 2.387206255311463\n", + "loss: 2.387206480708284\n", + "loss: 2.387206705586487\n", + "loss: 2.3872059484852777\n", + "loss: 2.387205508896236\n", + "loss: 2.387205733053314\n", + "loss: 2.3872059590012453\n", + "loss: 2.38720618326989\n", + "loss: 2.387206408350126\n", + "loss: 2.3872066339450995\n", + "loss: 2.3872062743922324\n", + "loss: 2.3872054376631935\n", + "loss: 2.3872056632364425\n", + "loss: 2.3872058871467248\n", + "loss: 2.387206111855699\n", + "loss: 2.387206337069455\n", + "loss: 2.3872065625907197\n", + "loss: 2.387206598875525\n", + "loss: 2.3872055726406853\n", + "loss: 2.3872055914219663\n", + "loss: 2.3872058158103724\n", + "loss: 2.3872060406633677\n", + "loss: 2.3872062658126643\n", + "loss: 2.3872064913732993\n", + "loss: 2.3872067166127193\n", + "loss: 2.38720589721323\n", + "loss: 2.3872055203865594\n", + "loss: 2.3872057448636044\n", + "loss: 2.387205969632241\n", + "loss: 2.3872061948051737\n", + "loss: 2.387206419656803\n", + "loss: 2.3872066454234093\n", + "loss: 2.38720622109226\n", + "loss: 2.3872054496058155\n", + "loss: 2.387205673994574\n", + "loss: 2.387205898781459\n", + "loss: 2.3872061232475654\n", + "loss: 2.3872063486162522\n", + "loss: 2.3872065743640327\n", + "loss: 2.38720654403819\n", + "loss: 2.3872055202172575\n", + "loss: 2.3872056032796642\n", + "loss: 2.3872058273645207\n", + "loss: 2.387206052339985\n", + "loss: 2.3872062776900504\n", + "loss: 2.3872065035141774\n", + "loss: 2.3872067282141374\n", + "loss: 2.3872058427484215\n", + "loss: 2.387205531994678\n", + "loss: 2.387205756582158\n", + "loss: 2.387205981539894\n", + "loss: 2.3872062069646356\n", + "loss: 2.387206431282743\n", + "loss: 2.387206657412996\n", + "loss: 2.3872061679858723\n", + "loss: 2.3872054613328837\n", + "loss: 2.3872056859037873\n", + "loss: 2.3872059109348127\n", + "loss: 2.387206134876376\n", + "loss: 2.387206360603658\n", + "loss: 2.3872065860311924\n", + "loss: 2.3872064904558536\n", + "loss: 2.3872054658487727\n", + "loss: 2.3872056154159624\n", + "loss: 2.387205838986268\n", + "loss: 2.3872060643164303\n", + "loss: 2.38720629000679\n", + "loss: 2.387206515465516\n", + "loss: 2.3872067402918593\n", + "loss: 2.3872057868542456\n", + "loss: 2.3872055436974926\n", + "loss: 2.387205768622451\n", + "loss: 2.3872059939050634\n", + "loss: 2.3872062189566643\n", + "loss: 2.387206443389059\n", + "loss: 2.387206669729105\n", + "loss: 2.387206114421231\n", + "loss: 2.3872054733876444\n", + "loss: 2.3872056982757286\n", + "loss: 2.3872059236497964\n", + "loss: 2.3872061471739836\n", + "loss: 2.38720637304622\n", + "loss: 2.387206597910911\n", + "loss: 2.3872064349529696\n", + "loss: 2.3872054090077848\n", + "loss: 2.3872056281842866\n", + "loss: 2.387205851329026\n", + "loss: 2.387206076790427\n", + "loss: 2.387206301261524\n", + "loss: 2.387206527494985\n", + "loss: 2.3872067526753113\n", + "loss: 2.387205728959938\n" + ] + } + ], + "source": [ + "y_train = y_train.reshape(-1, 1)\n", + "\n", + "nn = NeuralNetwork(X_train, y_train)\n", + "\n", + "for i in range(1000000):\n", + " nn.train(X_train, y_train)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot the loss vs. the number of epochs" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'loss')" + ] + }, + "execution_count": 83, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "plt.plot(nn.loss_history)\n", + "plt.xlabel(\"# epochs / 1000\")\n", + "plt.ylabel(\"loss\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 84, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "from matplotlib.colors import ListedColormap\n", + "\n", + "cm = plt.cm.RdBu\n", + "cm_bright = ListedColormap([\"#FF0000\", \"#0000FF\"])\n", + "\n", + "xv = np.linspace(x_min, x_max, 10)\n", + "yv = np.linspace(y_min, y_max, 10)\n", + "Xv, Yv = np.meshgrid(xv, yv)\n", + "XYpairs = np.vstack([ Xv.reshape(-1), Yv.reshape(-1)])\n", + "zv = nn.predict(XYpairs.T)\n", + "Zv = zv.reshape(Xv.shape)\n", + "\n", + "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(9, 7))\n", + "ax.set_aspect(1)\n", + "cn = ax.contourf(Xv, Yv, Zv, cmap=\"coolwarm_r\", alpha=0.4)\n", + "\n", + "ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright, edgecolors=\"k\")\n", + "\n", + "# Plot the testing points\n", + "ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright, alpha=0.4, edgecolors=\"k\")\n", + "\n", + "ax.set_xlim(x_min, x_max)\n", + "ax.set_ylim(y_min, y_max)\n", + "# ax.set_xticks(())\n", + "# ax.set_yticks(())\n", + "\n", + "fig.colorbar(cn)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.9" + }, + "vscode": { + "interpreter": { + "hash": "b0fa6594d8f4cbf19f97940f81e996739fb7646882a419484c72d19e05852a7e" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}