TP_01_Low level MLP in PyTorch.ipynb

{"cells":[{"attachments":{},"cell_type":"markdown","metadata":{"id":"baZyx5ZJQG5S"},"source":["# Multilayer Perceptron in PyTorch\n","\n","## Introduction\n","\n","### Goal\n","\n","Learn the basics of PyTorch (PT) by working on an artificial classification problem.\n","\n","### Plan\n","\n","In this tutorial we will create a set of synthetic data that we will use as an example problem.\n","Then we will create a MLP model and learn its parameters from the data. Finally we will visualize the different learning measures and the parameters of the model.\n","\n","In a second part we will modify our data and adapt the hyper-parameters (e.g. number of hidden neurons) of our model to allow better classification.\n","\n","In the next part we will use the basic functions of PT to understand our process and how PT works. But we will also mention the high level features and aids of PT that facilitate our tasks.\n","\n","### Requirements\n","\n","Python >=3.5\n","\n","Modules python:\n","\n","- pytorch >=1.0\n","- numpy\n","- matplotlib\n","\n","### Evaluation considerations\n","\n","- We take into account the correctness of the solutions but also their generality and quality of the code\n","- Comment and discuss on the results of all your exercises (in a cell immediately after the results). You may also state the difficulties encountered, lessons learned and your understanding of the problem and solution\n","- Clean-up your code before submission, do not leave unnecessary code attempts, or if you deem it important, leave them in a way that it is easily understood and with comments/discussion\n","- We also value the originality of the solutions, don't hesitate in performing unrequested additional tasks in relation to the exercises\n","- Non-advanced exercises will account for approx. 14/20 of the grade. Advanced exercises will contribute to the remaining score and may compensate for errors in the non-advanced ones\n","- You may receive help from colleagues on the non-advanced questions, but you must state who has helped you. Approximately 1/20 of the grade is assigned to those that help most.\n"]},{"cell_type":"code","execution_count":120,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":261,"status":"ok","timestamp":1671039100885,"user":{"displayName":"Maximilian Vieweg","userId":"02983195014981343408"},"user_tz":-60},"id":"1eVszkXOQG5a","outputId":"5d46569e-0c4a-4dc0-cb40-57d64b691ea1"},"outputs":[{"data":{"text/plain":["<torch._C.Generator at 0x7f0c4c7f6170>"]},"execution_count":120,"metadata":{},"output_type":"execute_result"}],"source":["import torch\n","import numpy as np\n","import matplotlib\n","\n","import matplotlib.pyplot as plt\n","import matplotlib.animation as animation\n","from IPython.display import HTML\n","\n","from pprint import pprint\n","\n","matplotlib.rcParams['animation.embed_limit'] = 2**128 # increasing the animation length limit for visualisations\n","torch.manual_seed(0) # random seed for reproducibility\n"]},{"cell_type":"markdown","metadata":{"id":"WHF8xURJ0592"},"source":["## 0. With a little help from my friends\n","\n","Write in the following cell the colleagues (if any) that have helped you with this lab assignment (comma separated if more than one and don't state more than 2).\n"]},{"cell_type":"code","execution_count":120,"metadata":{"executionInfo":{"elapsed":345,"status":"ok","timestamp":1671039101813,"user":{"displayName":"Maximilian Vieweg","userId":"02983195014981343408"},"user_tz":-60},"id":"8zbrUV1k1O2w"},"outputs":[],"source":[]},{"cell_type":"markdown","metadata":{"id":"Hl-Dp2HeQG5b"},"source":["## 1. Data generation\n","\n","In this part, we will generate a data set of 1000 points which is not linearly separable.\n","\n","#### Create the artificial data sets\n"]},{"cell_type":"markdown","metadata":{"id":"DQhMekl-yVK_"},"source":["### Exercise 1\n","\n","Create 1000 points of 2 dimensions $(x_0, x_1)$ with their coordinates between 0 et 1 $x_0, x_1 \\in [0, 1]$.\n"]},{"cell_type":"code","execution_count":121,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":29,"status":"ok","timestamp":1671039101813,"user":{"displayName":"Maximilian Vieweg","userId":"02983195014981343408"},"user_tz":-60},"id":"i-zDViPN0qSx","outputId":"df168e29-358b-4968-bf9e-bf7bd8ba482e"},"outputs":[{"name":"stdout","output_type":"stream","text":["tensor([[0.4963, 0.7682],\n","        [0.0885, 0.1320],\n","        [0.3074, 0.6341],\n","        ...,\n","        [0.2335, 0.8050],\n","        [0.5335, 0.5196],\n","        [0.3481, 0.8767]], requires_grad=True)\n"]}],"source":["# randn would return normal distribution not in range (0, 1)\n","artificial_data = torch.rand((1000, 2), requires_grad=True)\n","print(artificial_data)"]},{"cell_type":"markdown","metadata":{"id":"HRTz8o58yXxL"},"source":["### Exercise 2\n","\n","Assign to each point a binary class $y$ (0 ou 1) following the condition:\n","\n","$$\n","y = \\begin{cases}\n","1 &\\text{if $x_0 > 0.2$ et $x_1 > 0.4$}\\\\\n","0 &\\text{else}\n","\\end{cases}\n","$$\n"]},{"cell_type":"code","execution_count":122,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":27,"status":"ok","timestamp":1671039101813,"user":{"displayName":"Maximilian Vieweg","userId":"02983195014981343408"},"user_tz":-60},"id":"Enbr04ve0quQ","outputId":"288b3e66-a355-4b30-f85c-845cfb39476c"},"outputs":[{"name":"stdout","output_type":"stream","text":["torch.Size([1000, 1])\n"]}],"source":["\n","y_artificial_data = torch.empty((1000, 1))\n","\n","for i, point in enumerate(artificial_data):\n","    if point[0] > 0.2 and point[1] > 0.4:\n","        y_artificial_data[i] = 1\n","    else:\n","        y_artificial_data[i] = 0\n","\n","print(y_artificial_data.shape)\n","\n"]},{"cell_type":"markdown","metadata":{"id":"mtd_3ryAyZve"},"source":["### Exercise 3\n","\n","Create a matrix of data `data` with shape `(1000, 3)` with a point per row, the two first columns contain the points coordinates $(x_0, x_1)$ the last column contains the class $y$.\n"]},{"cell_type":"code","execution_count":123,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":25,"status":"ok","timestamp":1671039101814,"user":{"displayName":"Maximilian Vieweg","userId":"02983195014981343408"},"user_tz":-60},"id":"YB52NrlY0rKB","outputId":"3846fd65-96f5-4b5f-ad7c-bb1023a84cde"},"outputs":[{"name":"stdout","output_type":"stream","text":["tensor([[0.4963, 0.7682, 1.0000],\n","        [0.0885, 0.1320, 0.0000],\n","        [0.3074, 0.6341, 1.0000],\n","        ...,\n","        [0.2335, 0.8050, 1.0000],\n","        [0.5335, 0.5196, 1.0000],\n","        [0.3481, 0.8767, 1.0000]], grad_fn=<CatBackward0>)\n"]}],"source":["data = torch.concat((artificial_data, y_artificial_data), dim=1)\n","print(data)"]},{"cell_type":"markdown","metadata":{"id":"anzo4rKYybtj"},"source":["### Exercise 4\n","\n","Split the data into 3 sets (on matrix for each): 800 points for `train`, 100 points for `valid` and 100 for `test`\n"]},{"cell_type":"code","execution_count":124,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":22,"status":"ok","timestamp":1671039101814,"user":{"displayName":"Maximilian Vieweg","userId":"02983195014981343408"},"user_tz":-60},"id":"2BkA4tt90rtZ","outputId":"929894c3-486d-4f08-951f-aa343d471522"},"outputs":[{"name":"stdout","output_type":"stream","text":["tensor([[0.4199, 0.2041, 0.0000],\n","        [0.3942, 0.5369, 1.0000],\n","        [0.9209, 0.6883, 1.0000],\n","        ...,\n","        [0.2867, 0.6801, 1.0000],\n","        [0.9439, 0.8063, 1.0000],\n","        [0.1475, 0.9074, 0.0000]], grad_fn=<SplitWithSizesBackward0>)\n","tensor([[1.1638e-01, 3.5386e-01, 0.0000e+00],\n","        [3.5766e-01, 8.5988e-02, 0.0000e+00],\n","        [8.0740e-01, 2.6684e-02, 0.0000e+00],\n","        [8.7622e-01, 9.2126e-01, 1.0000e+00],\n","        [7.4385e-01, 6.4003e-04, 0.0000e+00],\n","        [2.1679e-01, 7.4055e-01, 1.0000e+00],\n","        [8.8018e-01, 1.2360e-03, 0.0000e+00],\n","        [8.4085e-01, 7.0293e-01, 1.0000e+00],\n","        [5.8068e-01, 6.2078e-01, 1.0000e+00],\n","        [9.0106e-02, 4.2292e-01, 0.0000e+00],\n","        [8.9178e-01, 7.5130e-01, 1.0000e+00],\n","        [5.2687e-01, 7.3711e-01, 1.0000e+00],\n","        [2.1784e-01, 3.4395e-01, 0.0000e+00],\n","        [9.3650e-01, 3.4504e-01, 0.0000e+00],\n","        [8.0114e-02, 2.7454e-01, 0.0000e+00],\n","        [1.8330e-02, 8.1625e-01, 0.0000e+00],\n","        [1.9328e-02, 7.7948e-01, 0.0000e+00],\n","        [7.8751e-01, 4.4370e-01, 1.0000e+00],\n","        [8.7487e-01, 2.4358e-01, 0.0000e+00],\n","        [4.5508e-01, 4.0005e-01, 1.0000e+00],\n","        [2.0479e-01, 1.0685e-02, 0.0000e+00],\n","        [9.8825e-01, 9.0109e-01, 1.0000e+00],\n","        [7.1734e-01, 4.5747e-01, 1.0000e+00],\n","        [6.6678e-01, 6.4995e-01, 1.0000e+00],\n","        [1.1234e-01, 3.4574e-01, 0.0000e+00],\n","        [6.9866e-01, 8.7790e-01, 1.0000e+00],\n","        [2.9389e-01, 5.1852e-01, 1.0000e+00],\n","        [7.8251e-01, 2.1018e-01, 0.0000e+00],\n","        [7.4185e-01, 9.3306e-01, 1.0000e+00],\n","        [5.0142e-01, 9.4946e-01, 1.0000e+00],\n","        [4.8613e-01, 1.6405e-01, 0.0000e+00],\n","        [5.2503e-01, 2.5591e-01, 0.0000e+00],\n","        [8.5793e-01, 4.4860e-01, 1.0000e+00],\n","        [7.4875e-01, 3.3679e-01, 0.0000e+00],\n","        [9.2543e-01, 5.6721e-01, 1.0000e+00],\n","        [1.7591e-01, 2.6983e-01, 0.0000e+00],\n","        [4.3548e-01, 5.5463e-01, 1.0000e+00],\n","        [5.8778e-02, 9.9220e-01, 0.0000e+00],\n","        [5.8325e-01, 7.1296e-01, 1.0000e+00],\n","        [8.1772e-01, 5.2390e-01, 1.0000e+00],\n","        [6.1099e-01, 2.2779e-01, 0.0000e+00],\n","        [3.3596e-01, 6.6760e-01, 1.0000e+00],\n","        [1.0482e-01, 9.0019e-01, 0.0000e+00],\n","        [9.9915e-01, 9.8834e-01, 1.0000e+00],\n","        [3.9710e-01, 8.7416e-01, 1.0000e+00],\n","        [4.4639e-01, 7.5175e-01, 1.0000e+00],\n","        [1.7643e-01, 9.7146e-01, 0.0000e+00],\n","        [7.4785e-01, 1.4971e-01, 0.0000e+00],\n","        [7.2310e-01, 8.4184e-01, 1.0000e+00],\n","        [2.3252e-01, 4.1208e-01, 1.0000e+00],\n","        [3.0944e-01, 3.9365e-01, 0.0000e+00],\n","        [6.5416e-01, 6.0821e-01, 1.0000e+00],\n","        [8.2191e-01, 8.4010e-01, 1.0000e+00],\n","        [5.2315e-01, 6.4385e-01, 1.0000e+00],\n","        [2.0495e-01, 4.9564e-01, 1.0000e+00],\n","        [6.5789e-01, 7.0462e-01, 1.0000e+00],\n","        [9.3249e-01, 4.6353e-01, 1.0000e+00],\n","        [7.4025e-01, 6.7658e-01, 1.0000e+00],\n","        [1.7528e-01, 8.4720e-01, 0.0000e+00],\n","        [2.1066e-01, 8.8645e-01, 1.0000e+00],\n","        [9.1377e-01, 4.0047e-01, 1.0000e+00],\n","        [5.2301e-01, 5.9785e-01, 1.0000e+00],\n","        [2.6243e-01, 4.0867e-02, 0.0000e+00],\n","        [6.8080e-01, 5.6331e-01, 1.0000e+00],\n","        [1.1233e-01, 5.0860e-01, 0.0000e+00],\n","        [5.4299e-01, 8.4741e-01, 1.0000e+00],\n","        [3.5381e-01, 1.2922e-02, 0.0000e+00],\n","        [1.4157e-01, 1.4383e-01, 0.0000e+00],\n","        [9.1060e-01, 6.9364e-01, 1.0000e+00],\n","        [8.3588e-01, 5.2169e-01, 1.0000e+00],\n","        [2.3348e-01, 8.0503e-01, 1.0000e+00],\n","        [5.7301e-01, 6.3005e-01, 1.0000e+00],\n","        [8.6783e-01, 2.0042e-01, 0.0000e+00],\n","        [4.5373e-01, 5.0253e-01, 1.0000e+00],\n","        [5.0839e-02, 2.6296e-01, 0.0000e+00],\n","        [1.6196e-01, 5.2322e-01, 0.0000e+00],\n","        [7.4682e-01, 4.7230e-01, 1.0000e+00],\n","        [1.1582e-01, 2.0624e-01, 0.0000e+00],\n","        [4.4312e-01, 6.4325e-01, 1.0000e+00],\n","        [6.0117e-01, 4.6669e-01, 1.0000e+00],\n","        [9.9269e-01, 1.8366e-01, 0.0000e+00],\n","        [9.6185e-01, 7.3583e-01, 1.0000e+00],\n","        [7.2425e-01, 1.4655e-01, 0.0000e+00],\n","        [1.1526e-01, 8.3567e-01, 0.0000e+00],\n","        [7.5712e-01, 3.0105e-01, 0.0000e+00],\n","        [5.6344e-01, 1.3980e-01, 0.0000e+00],\n","        [7.2624e-01, 7.0108e-01, 1.0000e+00],\n","        [6.6510e-01, 8.7511e-01, 1.0000e+00],\n","        [3.7484e-01, 2.5644e-01, 0.0000e+00],\n","        [7.4966e-01, 6.0465e-01, 1.0000e+00],\n","        [4.2398e-01, 1.5052e-01, 0.0000e+00],\n","        [2.0336e-01, 4.6882e-01, 1.0000e+00],\n","        [4.3372e-01, 2.4835e-01, 0.0000e+00],\n","        [3.4137e-02, 2.1488e-01, 0.0000e+00],\n","        [6.7657e-01, 2.9823e-01, 0.0000e+00],\n","        [2.8890e-01, 2.3422e-01, 0.0000e+00],\n","        [1.6112e-01, 7.3226e-01, 0.0000e+00],\n","        [8.1019e-01, 9.8010e-01, 1.0000e+00],\n","        [6.5938e-01, 7.6840e-01, 1.0000e+00],\n","        [4.6410e-01, 9.9462e-01, 1.0000e+00]],\n","       grad_fn=<SplitWithSizesBackward0>)\n","tensor([[0.4993, 0.3156, 0.0000],\n","        [0.2852, 0.2717, 0.0000],\n","        [0.6816, 0.9152, 1.0000],\n","        [0.4460, 0.1631, 0.0000],\n","        [0.2775, 0.2238, 0.0000],\n","        [0.7709, 0.2163, 0.0000],\n","        [0.4984, 0.5826, 1.0000],\n","        [0.8942, 0.8690, 1.0000],\n","        [0.3432, 0.4000, 1.0000],\n","        [0.7851, 0.9377, 1.0000],\n","        [0.4605, 0.3413, 0.0000],\n","        [0.5666, 0.2269, 0.0000],\n","        [0.4354, 0.1343, 0.0000],\n","        [0.9244, 0.7504, 1.0000],\n","        [0.6920, 0.1335, 0.0000],\n","        [0.2787, 0.2665, 0.0000],\n","        [0.0052, 0.2404, 0.0000],\n","        [0.1439, 0.3581, 0.0000],\n","        [0.8970, 0.8421, 1.0000],\n","        [0.7179, 0.0648, 0.0000],\n","        [0.4852, 0.5752, 1.0000],\n","        [0.9239, 0.5025, 1.0000],\n","        [0.4195, 0.0456, 0.0000],\n","        [0.5993, 0.0654, 0.0000],\n","        [0.9684, 0.3321, 0.0000],\n","        [0.4950, 0.4496, 1.0000],\n","        [0.3481, 0.8767, 1.0000],\n","        [0.6026, 0.5974, 1.0000],\n","        [0.7613, 0.0315, 0.0000],\n","        [0.9601, 0.4789, 1.0000],\n","        [0.6188, 0.9556, 1.0000],\n","        [0.0880, 0.7709, 0.0000],\n","        [0.4050, 0.8791, 1.0000],\n","        [0.4609, 0.8910, 1.0000],\n","        [0.9972, 0.2104, 0.0000],\n","        [0.8956, 0.2310, 0.0000],\n","        [0.6962, 0.8839, 1.0000],\n","        [0.0422, 0.3920, 0.0000],\n","        [0.9824, 0.8706, 1.0000],\n","        [0.2179, 0.7086, 1.0000],\n","        [0.2081, 0.9298, 1.0000],\n","        [0.9891, 0.0028, 0.0000],\n","        [0.2896, 0.3957, 0.0000],\n","        [0.6596, 0.5354, 1.0000],\n","        [0.4096, 0.8267, 1.0000],\n","        [0.4452, 0.3427, 0.0000],\n","        [0.6092, 0.1188, 0.0000],\n","        [0.4458, 0.2083, 0.0000],\n","        [0.8579, 0.6870, 1.0000],\n","        [0.8979, 0.7624, 1.0000],\n","        [0.2388, 0.6108, 1.0000],\n","        [0.4747, 0.5910, 1.0000],\n","        [0.3295, 0.7516, 1.0000],\n","        [0.8977, 0.8882, 1.0000],\n","        [0.6344, 0.9854, 1.0000],\n","        [0.1561, 0.9735, 0.0000],\n","        [0.6253, 0.7726, 1.0000],\n","        [0.2722, 0.4420, 1.0000],\n","        [0.3659, 0.5453, 1.0000],\n","        [0.4558, 0.1683, 0.0000],\n","        [0.2242, 0.9300, 1.0000],\n","        [0.9028, 0.0971, 0.0000],\n","        [0.5938, 0.3392, 0.0000],\n","        [0.2231, 0.2903, 0.0000],\n","        [0.1229, 0.0947, 0.0000],\n","        [0.0163, 0.4279, 0.0000],\n","        [0.8059, 0.1839, 0.0000],\n","        [0.9241, 0.7892, 1.0000],\n","        [0.1475, 0.2248, 0.0000],\n","        [0.5936, 0.4158, 1.0000],\n","        [0.4656, 0.9709, 1.0000],\n","        [0.0268, 0.9156, 0.0000],\n","        [0.5256, 0.7397, 1.0000],\n","        [0.7806, 0.5928, 1.0000],\n","        [0.9392, 0.6821, 1.0000],\n","        [0.8831, 0.9860, 1.0000],\n","        [0.7939, 0.5670, 1.0000],\n","        [0.6923, 0.2038, 0.0000],\n","        [0.7279, 0.0524, 0.0000],\n","        [0.9384, 0.4174, 1.0000],\n","        [0.1693, 0.2933, 0.0000],\n","        [0.3936, 0.6069, 1.0000],\n","        [0.4790, 0.1367, 0.0000],\n","        [0.5523, 0.5288, 1.0000],\n","        [0.2212, 0.0425, 0.0000],\n","        [0.3000, 0.6464, 1.0000],\n","        [0.0261, 0.0286, 0.0000],\n","        [0.4103, 0.2987, 0.0000],\n","        [0.7371, 0.3130, 0.0000],\n","        [0.1801, 0.1534, 0.0000],\n","        [0.5106, 0.0412, 0.0000],\n","        [0.1811, 0.0932, 0.0000],\n","        [0.3178, 0.7811, 1.0000],\n","        [0.7344, 0.8802, 1.0000],\n","        [0.8140, 0.6299, 1.0000],\n","        [0.1186, 0.7260, 0.0000],\n","        [0.6673, 0.7638, 1.0000],\n","        [0.9553, 0.0082, 0.0000],\n","        [0.0797, 0.5074, 0.0000],\n","        [0.6979, 0.4371, 1.0000]], grad_fn=<SplitWithSizesBackward0>)\n"]}],"source":["\n","\n","# Randomly sorting the data\n","random_indices = torch.randperm(len(data))\n","data = data[random_indices]\n","\n","train, valid, test = torch.split(data, (800, 100, 100), dim=0)\n","\n","for t in (train, valid, test):\n","    print(t)\n","\n"]},{"cell_type":"markdown","metadata":{"id":"5EqIDnEcydEg"},"source":["### Exercise 5\n","\n","Visualise the data using a scatter plot (`plt.scatter`).\n","\n","We expect to find something similar to this:\n","\n","![data.png](data:image/png;base64,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)\n"]},{"cell_type":"code","execution_count":125,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":265},"executionInfo":{"elapsed":20,"status":"ok","timestamp":1671039101815,"user":{"displayName":"Maximilian Vieweg","userId":"02983195014981343408"},"user_tz":-60},"id":"A0UiWGoUQG5c","outputId":"5529887b-8934-47fc-a1e8-c4e9c3dc89f1"},"outputs":[{"data":{"image/png":"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","text/plain":["<Figure size 432x288 with 1 Axes>"]},"metadata":{"needs_background":"light"},"output_type":"display_data"}],"source":["# Generate, split and plot the data\n","\n","\n","colors = ('r', 'g')\n","\n","for i, t in enumerate((train, valid, test)):\n","    is_condition = t[:, -1] == 1  # Class is set by last parameter in the data\n","\n","    # We choose columns conforming to this condition and choose column\n","    x_column_1 = t[is_condition][:, 0]\n","    y_column_1 = t[is_condition][:, 1]\n","\n","    x_column_2 = t[torch.logical_not(is_condition)][:, 0]\n","    y_column_2 = t[torch.logical_not(is_condition)][:, 1]\n","    \n","    # We detach and convert to numpy, since plt does not accept torch tensors\n","    plt.scatter(x_column_1.detach().numpy(),\n","                y_column_1.detach().numpy(), color='r')\n","    plt.scatter(x_column_2.detach().numpy(),\n","                y_column_2.detach().numpy(), color='b')\n","\n","plt.show()\n","\n"]},{"cell_type":"markdown","metadata":{"id":"lNfHChLIQG5c"},"source":["**Run the following cell to make sure you have done the previous exercises correctly.**\n"]},{"cell_type":"code","execution_count":126,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":20,"status":"ok","timestamp":1671039101816,"user":{"displayName":"Maximilian Vieweg","userId":"02983195014981343408"},"user_tz":-60},"id":"8G9UN-udQG5c","outputId":"c2c25d57-86cf-4dfd-8f69-3fd36f0d1cec"},"outputs":[{"name":"stdout","output_type":"stream","text":["Everything looks good!\n"]}],"source":["# Verification des dimensions des donnees\n","assert data.shape == (1000, 3)\n","\n","# Verification des division desd donnees\n","assert train.shape == (800, 3)\n","assert valid.shape == (100, 3)\n","assert test.shape == (100, 3)\n","\n","for dataset in [train, valid, test]:\n","    # Verification des classes\n","    assert (dataset[dataset[:, -1] == 1, 0] > 0.2).all()\n","    assert (dataset[dataset[:, -1] == 1, 1] > 0.4).all()\n","    assert ((dataset[dataset[:, -1] == 0, 0] <= 0.2) |\n","            (dataset[dataset[:, -1] == 0, 1] <= 0.4)).all()\n","\n","print('Everything looks good!')\n"]},{"cell_type":"markdown","metadata":{"id":"yG7aB7goQG5d"},"source":["## 2. Creating the model\n","\n","In this part, we will create, with PyTorch, a model to predict the class $y$ of a point using only its coordinates $(x_0, x_1)$.\n","\n","The model we will create to classify the data is a Multilayer Perceptron with a single hidden layer:\n","\n","\\begin{align}\n","h_1 &= \\sigma(x W_1 + b_1) \\\\\n","\\hat{y} &= \\sigma(h_1 W_2 + b_2) \\\\\n","& \\textrm{ avec } & \\\\\n","\\sigma(t) &= \\frac{1}{1+e^{-t}}\n","\\end{align}\n","\n","$\\hat{y}$ will the model's estimation for the class of the point.\n"]},{"cell_type":"markdown","metadata":{"id":"I-tG4sh-yflE"},"source":["### Exercise 6\n","\n","What are the model parameters?\n"]},{"cell_type":"markdown","metadata":{"id":"Cqcl06e6OTmY"},"source":["Answer:\n","\n","The model parameters are the weights W_1, W_2 and the corresponding biases b_1, b_2\n"]},{"cell_type":"markdown","metadata":{"id":"DWY9Z9waQG5d"},"source":["_Implementation en PyTorch_\n","\n","First we will do a low level implementation where we will only use the AutoDiff feature (which allows to automatically compute gradients) of PyTorch.\n","\n","PyTorch as une API similaire a celle de numpy. La grande difference etant que pour les symbols pour lesquels on voudra avoir un gradient, nous devons inclure l'argument nommé `requires_grad=True`.\n","\n","For example $W_1$ is a parameter of the model and we are interested in the gradient of the loss with respect to this symbol. So at initialization time we will add `requires_grad=True`.\n"]},{"cell_type":"markdown","metadata":{"id":"eP15YmPVyhYh"},"source":["### Exercise 7\n","\n","What the dimensions of each of these symbols: $x, y, W_1, b_1, W_2, b_2$?\n"]},{"cell_type":"markdown","metadata":{"id":"WXHPiV2COpsK"},"source":["Answer:\n","\n","x: (1; 2) # We take an input of a 2D point\n","\n","y: (1; 2) # Since we have two classes\n","\n","W_1: (2, 1) # The weight is connected to each input -> dim 2\n","\n","b_1: (1) # Scalar Value\n","\n","W_2: (2, 1) # The weight is connected to each middle layer node -> dim 2\n","\n","b_2: (1) # Scalar Value\n"]},{"cell_type":"markdown","metadata":{"id":"1lcpx1tt7zK9"},"source":["### Exercise 8\n","\n","Create a function that initializes and returns a tuple with the MLP parameters.\n"]},{"cell_type":"code","execution_count":127,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":11,"status":"ok","timestamp":1671039101816,"user":{"displayName":"Maximilian Vieweg","userId":"02983195014981343408"},"user_tz":-60},"id":"iNpJCrkxQG5f","outputId":"404f8a7b-7eb8-40a4-b4f4-144bcb5ca042"},"outputs":[{"name":"stdout","output_type":"stream","text":["[(tensor([[0.0812, 0.3791],\n","        [0.4516, 0.2695]], requires_grad=True),\n","  tensor([[0.8559],\n","        [0.7870]], requires_grad=True)),\n"," (tensor([[0.0587],\n","        [0.4500]], requires_grad=True),\n","  tensor([[0.6681]], requires_grad=True))]\n"]}],"source":["# Create the model\n","\n","def init_mlp(*args):\n","    \"\"\"\n","    Initialises a MLP and returns its parameters. \n","\n","    Parameters:\n","        args:iterable\n","            E.g. (2, 2, 1) nodes per layer, first number specifies inputs, lasat outputs, \n","            numbers between specify the hidden units per layer\n","    Returns:\n","        Tuple of these nodes as pytorch.tensor() s \n","    \"\"\"\n","    params = list()\n","\n","    n_before = args[0]\n","    for n in args[1:]:\n","        # The weights connect n_before nodes to the current n nodes\n","        weights = torch.rand((n_before, n), requires_grad=True)\n","\n","        # The biases only depend on the number of current nodes\n","        biases = torch.rand((n, 1), requires_grad=True)\n","        params.append((weights, biases))\n","        n_before = n\n","\n","    return tuple(params)\n","\n","\n","\n","params = list(init_mlp(2, 2, 1))\n","pprint(params)\n"]},{"cell_type":"markdown","metadata":{"id":"4RqH3NrNQG5f"},"source":["_Run a forward pass of the model on the following data points_\n","\n","### Exercise 8\n","\n","What is the desired response for the following points?\n","$$(0.1, 0.5), (0.3, 0.5), (0.3, 0.15), (0.1, 0.15)$$\n"]},{"cell_type":"markdown","metadata":{"id":"uciFcwQJQG5g"},"source":["(0.1, 0.5) -> 0\n","\n","(0.3, 0.5) -> 1\n","\n","(0.3, 0.15) -> 0\n","\n","(0.1, 0.15) -> 0\n"]},{"cell_type":"markdown","metadata":{"id":"NJfm4zW8QG5g"},"source":["### Exercise 9\n","\n","Execute the model on the previous points and print $\\hat{y}$\n"]},{"cell_type":"code","execution_count":128,"metadata":{"executionInfo":{"elapsed":391,"status":"ok","timestamp":1671039102198,"user":{"displayName":"Maximilian Vieweg","userId":"02983195014981343408"},"user_tz":-60},"id":"Bnn4vKY8QG5g"},"outputs":[],"source":["\n","# Create a function sigmoid(t) that computes the sigmoid function on t\n","\n","def sigmoid(t: float) -> float:\n","    \"\"\"\n","    Returns the sigmoid of the input t\n","\n","    Parameters: \n","        t: float\n","\n","    Returns: \n","        float(0, 1): sigmoid function at t\n","    \"\"\"\n","    return 1 / (1 + torch.exp(-t))\n","\n","# Create a function mlp(x, params) that computes the MLP outputs given the inputs x\n","def mlp(x, params):\n","    \"\"\"\n","    Returns the forward path of the neural network defined by params.\n","\n","    Parameters:\n","        x: \n","            Input vector \n","        params:\n","            Parameters of the neural network. Each layer is saved in a \n","            tuple consisting of the weights and bias tensor\n","\n","    \"\"\"\n","    for w, b in params:\n","        x = sigmoid(w.t() @ x + b)\n","    return x\n","\n","\n","# Create a tensor containing the previous points\n","points = artificial_data\n","\n","# Call and print output of mlp(points, params) (NOTE: use torch.no_grad())\n","output_mlp = []\n","with torch.no_grad():\n","    for p in points:\n","        p = p.reshape((2, 1))\n","        output_mlp.append(mlp(p, params))\n","\n","# pprint(output_mlp)\n","\n","\n"]},{"cell_type":"markdown","metadata":{"id":"8CxqH1VmQG5h"},"source":["We can observe that the results are not good, because they are far from the expected result.\n","\n","If we want to compute on our test data the performance of the model we will define an accuracy function, which takes a decision for each data based on $\\hat{y}$ and compares it to $y$.\n","\n","$$\n","\\text{accuracy} = \\frac{1}{N} \\sum_i^N (1 - abs(y - round(\\hat{y}_i)))\n","$$\n","\n","The accuracy represents the rate of correctly classified points. It will be $1$ if all points are correctly classified, $0$ if all are misclassified and $0.5$ if half are well classified.\n"]},{"cell_type":"markdown","metadata":{"id":"PATwbhk9zTAC"},"source":["### Exercise 10\n","\n","Implement the accuracy using Pytorch functions `torch.mean`, `torch.abs`, `torch.round`.\n"]},{"cell_type":"code","execution_count":129,"metadata":{"executionInfo":{"elapsed":7,"status":"ok","timestamp":1671039102198,"user":{"displayName":"Maximilian Vieweg","userId":"02983195014981343408"},"user_tz":-60},"id":"fpRGBsEuQG5h"},"outputs":[],"source":["def accuracy(estimated, reference):\n","    \n","    return torch.mean(1 - torch.abs(reference - torch.round(estimated)))\n","    \n"]},{"cell_type":"markdown","metadata":{"id":"QfC9Ux2DQG5i"},"source":["### Exercise 11\n","\n","Write a `score_model` function that evaluates the performance (accuracy) of the model on a given data set. Print the result\n"]},{"cell_type":"code","execution_count":130,"metadata":{"executionInfo":{"elapsed":7,"status":"ok","timestamp":1671039102199,"user":{"displayName":"Maximilian Vieweg","userId":"02983195014981343408"},"user_tz":-60},"id":"PnwzCrAqQG5i"},"outputs":[],"source":["def score_model(params, data):\n","    \"\"\"\n","    Returns the accuracy of the parameters on the given dataset. \n","\n","    Args:\n","        params: \n","        data: torch.tensor((n, 3)) in the format (x:float , y:float, 0 || 1)\n","    Returns: \n","        float, total accuracy of the dataset\n","    \"\"\"\n","    \n","    with torch.no_grad():\n","        # The data is contained in all the columns before the last one\n","        current_data = data[:, :-1].t()\n","        measured = data[:, -1]  # The class is contained in the final column\n","        estimated = mlp(current_data, params)\n","\n","    return accuracy(estimated, measured)\n","    \n","\n","# acc = score_model(params, train).item()\n","# print(f'score train: {acc:.2%}')\n"]},{"cell_type":"markdown","metadata":{"id":"wTxD2bI-QG5i"},"source":["### Exercise 12\n","\n","Do the same with `valid` and `test`\n"]},{"cell_type":"code","execution_count":131,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":7,"status":"ok","timestamp":1671039102199,"user":{"displayName":"Maximilian Vieweg","userId":"02983195014981343408"},"user_tz":-60},"id":"h3oaihg7QG5j","outputId":"7ccf8a0f-c71f-4097-e817-5e4246cf2748"},"outputs":[{"name":"stdout","output_type":"stream","text":["score valid: 54.00%\n","score test: 50.00%\n"]}],"source":["print(f'score valid: {score_model(params, valid):.2%}')\n","print(f'score test: {score_model(params, test):.2%}')"]},{"cell_type":"markdown","metadata":{"id":"NSPPgOsRQG5j"},"source":["### Exercise 13\n","\n","Explain the results.\n"]},{"cell_type":"markdown","metadata":{"id":"_xJMAkImfK5k"},"source":["The score of the model is given by comparing the binary cross entropy (BCE) between the estimation of the mulitlayer perceptron (MLP) with the measured value of the dataset. Its value lies between (0, 1), where a higher score relates to a better estimation.\n","\n","In the upper case a validation / test score of around 50% is measured, which was expected. Since the nodes of the MLP were instantiated randomly, we can expect the output of the model to output an approximately random output as well. Thus, obtaining a 50% success rate is not suprising.\n"]},{"cell_type":"markdown","metadata":{"id":"WSpMrc0rQG5j"},"source":["## 4. Training the model\n","\n","To find the best parameters for our model we will enter it with the training data. For this we will define a cost function to optimize.\n","\n","As we are trying to solve a binary classification task, we will use the crossentropy cost function:\n","\n","$$\n","L = \\sum -y \\log(\\hat{y}) - (1-y) \\log(1-\\hat{y})\n","$$\n"]},{"cell_type":"markdown","metadata":{"id":"uuu-XfWWzZKE"},"source":["### Exercise 14\n","\n","Implement the cost function in PyTorch.\n"]},{"cell_type":"code","execution_count":132,"metadata":{"executionInfo":{"elapsed":6,"status":"ok","timestamp":1671039102200,"user":{"displayName":"Maximilian Vieweg","userId":"02983195014981343408"},"user_tz":-60},"id":"RgFjHanWQG5k"},"outputs":[],"source":["def bce(est, ref):\n","    \n","    fudge = 0.00001  # Choose a small fudge to deal with where log is not defined\n","\n","    return torch.sum(- ref * torch.log(fudge + est) - (1 - ref) * torch.log(fudge + 1 - est))\n","    \n"]},{"cell_type":"markdown","metadata":{"id":"XoNA5imlQG5k"},"source":["To train our model by means of Gradient Descent (GD) we will iteratively update with small increments our parameters:\n","\n","\\begin{align}\n","W_1^n &= W_1^{n-1} - \\eta \\frac{\\delta L}{\\delta W_1} \\\\\n","b_1^n &= b_1^{n-1} - \\eta \\frac{\\delta L}{\\delta b_1} \\\\\n","W_2^n &= W_2^{n-1} - \\eta \\frac{\\delta L}{\\delta W_2} \\\\\n","b_2^n &= b_2^{n-1} - \\eta \\frac{\\delta L}{\\delta b_2}\n","\\end{align}\n","\n","Where $\\eta$ is our learning rate.\n","\n","We need to calculate the gradients:\n","\n","$$\n","\\frac{\\delta L}{\\delta W_1}, \\frac{\\delta L}{\\delta b_1}, \\frac{\\delta L}{\\delta W_2}, \\frac{\\delta L}{\\delta b_2}\n","$$\n","\n","For the gradients of the cost function with respect to the parameters, we could calculate them by hand. But we are lazy. So we will use PyTorch `error.backward()` will do this for us in an optimized way using Dynamic Programming (DP) and populate the tensors with the gradients.\n"]},{"cell_type":"markdown","metadata":{"id":"nKwH75ByQG5l"},"source":["Finally we will run a training of 10 `epochs` with a `batch_size=100`.\n","For this we will do the following steps:\n","\n","1. Calculate the number of iterations (`n_iterations`) per epoch (remember that an iteration is an update of the parameters and an epoch is a competing use of all our training data)\n","2. Create a session\n","3. Initialize the variables\n","4. For each epoch (`for epoch in range(n_epochs):`)\n","   1. Randomly reorder the `train` data (use `torch.randperm()`)\n","   2. Evaluate and print the model score on the training data\n","   3. For each iteration (`for iteration in range(n_iterations):`)\n","      1. Select a block of `batch_size` examples\n","      2. _Zero the gradients_\n","      3. Run the forward pass on the model (`mlp()`)\n","      4. Compute the loss (`bce()`)\n","      5. Compute the gradients\n","      6. _Update the parameters doing gradient descent_\n","\n","**Note:** Remember that PyTorch keeps track of all the operations you make with tensors to build the DAG graph. In some cases we want to avoid that, such as when setting the gradients to zero or performing the gradient descent update of the parameters. In those cases we may encapsulate the operations inside a `with torch.no_grad():` context clause. Furthermore the `grad` attribute of the tensors, may be `None` (no need to set to zero in this case) during the first run so one may do:\n","\n","```\n","with torch.no_grad():\n","    if param.grad is not None:\n","        param.grad.zero_()\n","\n","```\n","\n","**Note:** When performing the parameter update of gradient descent, make sure not to reassign to the parameter a new tensor object. To avoid doing so use an inplace operation:\n","\n","```\n","with torch.no_grad():\n","    param -= eta * param.grad\n","```\n","\n","If you erronously do this `param = param - eta * param.grad`, `param` will point to a new tensor, not the original parameters of the model.\n","\n","**Note:** Zero the gradients means accessing the gradient of each parameter and setting it to zero. We need this because PyTorch `.backward()` method accumulates the gradients instead of replacing them.\n"]},{"cell_type":"markdown","metadata":{"id":"51LU1uElzdXS"},"source":["### Exercise 15\n","\n","Implement and run a train loop for the model.\n"]},{"cell_type":"code","execution_count":133,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":3824,"status":"ok","timestamp":1671039106018,"user":{"displayName":"Maximilian Vieweg","userId":"02983195014981343408"},"user_tz":-60},"id":"BBdxxSawQG5m","outputId":"51640f36-86bd-475a-c5ed-3f300916ae20"},"outputs":[{"name":"stdout","output_type":"stream","text":["Epoch 0, Accuracy: 0.4712499976158142 \n"," \n","\n","Epoch 20, Accuracy: 0.84375 \n"," \n","\n","Epoch 40, Accuracy: 0.8675000071525574 \n"," \n","\n","Epoch 60, Accuracy: 0.8662499785423279 \n"," \n","\n","Epoch 80, Accuracy: 0.8637499809265137 \n"," \n","\n","score valid: 86.00%\n","score test: 91.00%\n"]}],"source":["def train_model_get_params(params, data, lr=0.05, n_epochs=100, batch_size=16):\n","    n_data = data.shape[0]\n","    n_iterations = n_data // batch_size\n","\n","    # For reusability in the next questions we comput the accuracy for each epoch\n","    # as well as the parameters for every epoch\n","    accuracy_per_epoch = {\"train\": [], \"valid\": [], \"test\": []}\n","    params_per_epoch = list()\n","\n","    \n","    for epoch in range(n_epochs):\n","        random_indices = torch.randperm(n_data)\n","        reference_data = data[random_indices]\n","\n","        for i in range(n_iterations - 1):\n","            # We use indexing to select each batch\n","            current_batch = reference_data[batch_size*i: batch_size*(i+1)]\n","            measured = current_batch[:, -1]  # last column contains class\n","            current_data = current_batch[:, :-1].t()  # rest contains data\n","\n","            with torch.no_grad():\n","                # 1. Zero the gradients of each of the parameters because .backward() accumulates them\n","                for w, b in params:\n","                    if w.grad is not None:\n","                        w.grad.zero_()\n","                    if b.grad is not None:\n","                        b.grad.zero_()\n","\n","            # 2. Run the forward pass on the model\n","            estimated = mlp(current_data, params)\n","\n","            # 3. Compute the error\n","            loss = bce(estimated, measured)\n","\n","            # 4. Compute the gradients\n","            loss.backward(retain_graph=True)\n","\n","            # 5. Update the parameters using their gradients\n","            with torch.no_grad():\n","                for w, b in params:\n","                    w -= lr * w.grad\n","                    b -= lr * b.grad\n","\n","        if epoch % 20 == 0:\n","            print(f\"Epoch {epoch}, Accuracy: {score_model(params, train)} \\n \\n\")\n","\n","        accuracy_per_epoch[\"train\"].append(score_model(params, train).data)\n","        accuracy_per_epoch[\"valid\"].append(score_model(params, valid).data)\n","        accuracy_per_epoch[\"test\"].append(score_model(params, test).data)\n","\n","        # Adding copies of params to the param list\n","        new_params = list()\n","        for w, b in params:\n","            new_params.append((w.detach().clone(), b.detach().clone()))\n","        params_per_epoch.append(new_params)\n","\n","    return params_per_epoch, accuracy_per_epoch\n","\n","\n","\n","params = list(init_mlp(2, 2, 1))\n","params_history, _ = train_model_get_params(params, train, lr=0.01, n_epochs=100)\n","\n","# print(params_history)\n","print(f'score valid: {score_model(params, valid):.2%}')\n","print(f'score test: {score_model(params, test):.2%}')\n"]},{"cell_type":"markdown","metadata":{"id":"XJBJUw3UHqSC"},"source":["The train_model_get_params function trains a model using mini-batch gradient descent. During each epoch the whole dataset is iterated over, then split up into batches to be processed seperately. Using pytorch's backward() function the gradient of the weights and biases with respect to the inputs can be determined in order to train the model. Additionally the accuracy per epoch is calculated for the training, test and validation set, as well as recording the params for each epoch for later processing.\n"]},{"cell_type":"markdown","metadata":{"id":"2dYT08APQG5m"},"source":["## 5. Visualizing the model\n","\n","To monitor the evolution of the learning of our model, we will visualize the value of the cost function, the classification score and the parameters of the first layer of our model.\n","\n","We will run our experiments with different values of the following hyperparameters to better understand their effect:\n","\n","- `learning_rate`\n","- `batch_size`\n","\n","**Visualization of the cost function**\n","\n","The cost function is the value we aim to reduce with the training iterations. To visualize it we will create an empty list (`couts = []`) at the beginning of our training and we will add (`couts.append(cout)`) the value resulting from the cost at each iteration. At the end of the training we will visualize the curve (`plt.plot(costs)`).\n","\n","### Exercise 16\n","\n","Rewrite the `train_model` function so that it returns the average loss of every epoch. Run it and plot the loss of a training procedure. While we are at it, make the printing optional with an additional keyword argument.\n"]},{"cell_type":"code","execution_count":134,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":3872,"status":"ok","timestamp":1671039109882,"user":{"displayName":"Maximilian Vieweg","userId":"02983195014981343408"},"user_tz":-60},"id":"XqDafc3QQG5m","outputId":"a5fb7d63-4f0e-4197-c3c6-e4bc05931ce5"},"outputs":[{"data":{"text/plain":["([(tensor([[-50.7224,   0.7088],\n","           [  1.3082, -54.0247]], requires_grad=True), tensor([[ 8.1729],\n","           [21.4918]], requires_grad=True)), (tensor([[-10.5382],\n","           [-12.2726]], requires_grad=True),\n","   tensor([[5.8780]], requires_grad=True))],\n"," [13.4185,\n","  12.437064,\n","  6.5611644,\n","  5.8521757,\n","  6.1834497,\n","  5.8076077,\n","  5.752036,\n","  3.9560034,\n","  3.6232271,\n","  2.342706,\n","  2.5174854,\n","  2.1213431,\n","  3.3665862,\n","  2.1238003,\n","  1.8930695,\n","  2.1481411,\n","  1.6882181,\n","  1.7960973,\n","  2.0467794,\n","  1.4240406,\n","  1.8102403,\n","  1.6394377,\n","  1.5611756,\n","  1.753942,\n","  1.6207271,\n","  1.7242662,\n","  1.3223833,\n","  1.0500636,\n","  1.4990724,\n","  1.7991594,\n","  1.9613872,\n","  1.5129808,\n","  1.3832513,\n","  1.5926737,\n","  1.3329636,\n","  1.3806715,\n","  1.9045023,\n","  1.3308798,\n","  1.4329858,\n","  1.7473769,\n","  1.6731449,\n","  1.4034281,\n","  1.1635321,\n","  1.5510583,\n","  1.25451,\n","  1.4923592,\n","  1.419495,\n","  0.966462,\n","  1.4042077,\n","  1.0585597,\n","  1.4500831,\n","  0.82638067,\n","  1.6051105,\n","  1.0968784,\n","  1.1580262,\n","  1.3854898,\n","  1.6186547,\n","  1.1777426,\n","  1.2917842,\n","  0.87362206,\n","  1.4936589,\n","  1.0001425,\n","  1.0374479,\n","  0.851347,\n","  0.9228847,\n","  0.90983576,\n","  1.0630033,\n","  1.2958874,\n","  1.3272302,\n","  0.8661041,\n","  1.5177541,\n","  1.0341799,\n","  0.9768889,\n","  0.9999594,\n","  1.5243714,\n","  1.1133655,\n","  1.1276865,\n","  0.80475736,\n","  0.99700606,\n","  0.75313956,\n","  1.1988372,\n","  0.84570235,\n","  1.02773,\n","  0.97198296,\n","  1.2069932,\n","  0.94568855,\n","  1.0676037,\n","  0.8665764,\n","  1.3233137,\n","  0.9692552,\n","  1.2113166,\n","  0.82129997,\n","  0.8071483,\n","  0.99459654,\n","  1.219298,\n","  1.0783464,\n","  0.8253635,\n","  1.1861768,\n","  1.0368088,\n","  1.2063643])"]},"execution_count":134,"metadata":{},"output_type":"execute_result"}],"source":["def train_model(params, data, lr=0.05, n_epochs=1, batch_size=16, print_meta=False):\n","    n_data = data.shape[0]\n","    n_iterations = n_data // batch_size\n","    loss_history = list()\n","\n","    for epoch in range(n_epochs):\n","        \n","\n","        # Randomly reorder the `train` data (use `torch.randperm()`)\n","        random_indices = torch.randperm(n_data)\n","        reference_data = data[random_indices]\n","\n","        # Evaluate and print the model score on the training data\n","        if print_meta and epoch % 10 == 0:\n","            pass\n","            #print(\n","                #f\"Epoch {epoch}, Accuracy: {score_model(params, train)} \\n \\n\")\n","\n","        loss_history_epoch = []\n","        \n","\n","        for i in range(n_iterations):\n","            \n","\n","            # 1. Select a block of `batch_size` examples\n","            current_batch = reference_data[batch_size*i: batch_size*(i+1)]\n","            current_data = current_batch[:, :-1].t()\n","            measured = current_batch[:, -1]\n","\n","            # 2. Run the forward pass on the model\n","            estimated = mlp(current_data, params)\n","\n","            # 3. Compute the error\n","            loss = bce(estimated, measured)\n","            loss_history_epoch.append(loss.data)\n","\n","            # 4. Zero the gradients of each of the parameters because .backward() accumulates them\n","            with torch.no_grad():\n","                for w, b in params:\n","                    if w.grad is not None:\n","                        w.grad.zero_()\n","                    if b.grad is not None:\n","                        b.grad.zero_()\n","\n","            # 5. Compute the gradients\n","            loss.backward(retain_graph=True)\n","\n","            # 6. Update the parameters using their gradients\n","            with torch.no_grad():\n","                for w, b in params:\n","                    w -= lr * w.grad\n","                    b -= lr * b.grad\n","\n","        loss_history.append(np.mean(loss_history_epoch))\n","\n","    return params, loss_history\n","\n","\n","params = list(init_mlp(2, 2, 1))\n","train_model(params, train, lr=0.5, n_epochs=100, print_meta=False)\n"]},{"cell_type":"markdown","metadata":{"id":"DBNHv7PZQG5n"},"source":["**Effect of the learning rate**\n","\n","We will run our learning with different learning rates to see its effect on the cost function.\n"]},{"cell_type":"markdown","metadata":{"id":"R4-uP7ngzlIh"},"source":["### Exercise 17\n","\n","Display the training loss curve for learning rates `[0.5, 0.05, 0.005, 0.0005]`\n"]},{"cell_type":"code","execution_count":135,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":296},"executionInfo":{"elapsed":19416,"status":"ok","timestamp":1671039129295,"user":{"displayName":"Maximilian Vieweg","userId":"02983195014981343408"},"user_tz":-60},"id":"NqJy3S7FQG5n","outputId":"6a60cd81-1086-4610-d4bd-f018e77d8f20"},"outputs":[{"data":{"text/plain":["Text(0.5, 0, 'Epoch')"]},"execution_count":135,"metadata":{},"output_type":"execute_result"},{"data":{"image/png":"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","text/plain":["<Figure size 432x288 with 1 Axes>"]},"metadata":{"needs_background":"light"},"output_type":"display_data"}],"source":["learning_rates = [0.5, 0.05, 0.005, 0.0005, 0.00005]\n","n_epochs = 100\n","batch_size = 16\n","\n","losses = {}\n","\n","# Train a model with each learning rate and populate losses with the learning rate as key and the loss series as values\n","\n","\n","for lr in learning_rates:\n","    params = list(init_mlp(2, 2, 1))\n","    _, loss = train_model(params, train, lr=lr, n_epochs=n_epochs)\n","    losses[lr] = loss\n","\n","\n","\n","plt.figure()\n","for lr, loss_curve in sorted(losses.items()):\n","    plt.plot(loss_curve, label=f'learning_rate={lr:.5f}')\n","\n","plt.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n","plt.ylabel('Loss function')\n","plt.xlabel('Epoch')\n"]},{"cell_type":"markdown","metadata":{"id":"fJ2sc1AOIX92"},"source":["During this exercise the loss function during the training is printed for different learning rates. Of these learning rates, the higher ones converge more quickly to a lower loss, where three different local minima can be seen. The smaller learning rates converge towards the first one, while the higher ones escape from it, staying around a different minimum for a few epochs, before falling even lower. Especially the lr=0.5 is notably, due to its raggedness. This may be due to the \"jumping\" around a local minimum.\n","\n","Later during the development the learning rate could be varied according to the progress of the training, starting with a higher learning rate to step over local minima.\n"]},{"cell_type":"markdown","metadata":{"id":"TqkH-hc6QG5n"},"source":["**Effect of batch size**\n","\n","We will now run our training with different batch sizes to see its effect on the cost function.\n","\n","### Exercise 18\n","\n","Display the cost function evaluated on all training data at each epoch for batch sizes `[n_data, 100, 50, 10, 5, 1]`\n"]},{"cell_type":"code","execution_count":136,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":296},"executionInfo":{"elapsed":68870,"status":"ok","timestamp":1671039198162,"user":{"displayName":"Maximilian Vieweg","userId":"02983195014981343408"},"user_tz":-60},"id":"ylk8AbYHQG5n","outputId":"aa903395-3a1d-4a93-c792-cacc8f537f71"},"outputs":[{"data":{"text/plain":["Text(0.5, 0, 'Epoch')"]},"execution_count":136,"metadata":{},"output_type":"execute_result"},{"data":{"image/png":"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","text/plain":["<Figure size 432x288 with 1 Axes>"]},"metadata":{"needs_background":"light"},"output_type":"display_data"}],"source":["n_data = train.shape[0]\n","\n","n_epochs = 100\n","batch_sizes = [n_data, 100, 50, 10, 1]\n","learning_rates = [0.00005, 0.0005, 0.05, 0.005, 0.5]\n","\n","losses = {}\n","\n","\n","for i, lr in enumerate(learning_rates):\n","    for j, bs in enumerate(batch_sizes):\n","        if j == i:\n","            params = list(init_mlp(2, 2, 1))\n","            _, loss = train_model(\n","                params, train, lr=lr, batch_size=bs, n_epochs=n_epochs, print_meta=False)\n","            losses[(bs, lr)] = loss\n","\n","# pprint(losses)\n","\n","\n","# Visualiser les courbes de cout\n","plt.figure()\n","for (bs, lr), loss_curve in sorted(losses.items()):\n","    plt.plot(loss_curve, label=f'batch_size={bs} lr={lr}')\n","\n","plt.grid()\n","plt.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n","plt.ylabel('Loss function')\n","plt.xlabel('Epoch')\n"]},{"cell_type":"markdown","metadata":{"id":"__vV4LrhJJNW"},"source":["The batch size and learning rate are varied during this exercise. The trend for lower losses for higher learning rates can be observed here as well. Smaller batch sizes correspond to a faster falling loss, while increasing the computational power needed.\n"]},{"cell_type":"markdown","metadata":{"id":"6F28JnevQG5o"},"source":["**Visualization of the performance**\n","\n","Another value worth monitoring is the classification accuracy of the model.\n"]},{"cell_type":"markdown","metadata":{"id":"tk3kRqmAzzI2"},"source":["### Exercise 19\n","\n","Visualize the accuracy on the train, valid and test data on each epoch\n"]},{"cell_type":"code","execution_count":137,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":800},"executionInfo":{"elapsed":12249,"status":"ok","timestamp":1671039210391,"user":{"displayName":"Maximilian Vieweg","userId":"02983195014981343408"},"user_tz":-60},"id":"mUZ4sN9lj5qp","outputId":"9ae503df-35e5-4cf0-d4de-07b0bb6e8118"},"outputs":[{"name":"stdout","output_type":"stream","text":["Epoch 0, Accuracy: 0.5287500023841858 \n"," \n","\n","Epoch 20, Accuracy: 0.8849999904632568 \n"," \n","\n","Epoch 40, Accuracy: 0.9700000286102295 \n"," \n","\n","Epoch 60, Accuracy: 0.9787499904632568 \n"," \n","\n","Epoch 80, Accuracy: 0.9837499856948853 \n"," \n","\n","Epoch 100, Accuracy: 0.9825000166893005 \n"," \n","\n","Epoch 120, Accuracy: 0.9825000166893005 \n"," \n","\n","Epoch 140, Accuracy: 0.9887499809265137 \n"," \n","\n","Epoch 160, Accuracy: 0.9825000166893005 \n"," \n","\n","Epoch 180, Accuracy: 0.987500011920929 \n"," \n","\n"]},{"data":{"image/png":"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","text/plain":["<Figure size 432x288 with 1 Axes>"]},"metadata":{"needs_background":"light"},"output_type":"display_data"}],"source":["n_data = train.shape[0]\n","\n","n_epochs = 200\n","batch_size = 10\n","learning_rate_value = 0.05\n","\n","accuracies = {}\n","\n","accuracies['train'] = []\n","accuracies['valid'] = []\n","accuracies['test'] = []\n","\n","\n","_, accuracies = train_model_get_params(\n","    init_mlp(2, 2, 1), train, lr=learning_rate_value, n_epochs=n_epochs, batch_size=batch_size\n",")\n","\n","accuracies.pop('loss', None)  # remove accumulated losses for the plot\n","\n","\n","\n","plt.figure()\n","for split, v in accuracies.items():\n","    plt.plot(v, label=split)\n","\n","plt.legend(loc='best')\n","plt.ylabel('Accuracy')\n","plt.xlabel('Epoch')\n","plt.show()\n"]},{"cell_type":"markdown","metadata":{"id":"g13CsH1LJqKJ"},"source":["The accuracy of the model applied to the training, validation and test set are plotted. As expected its value rises over each epoch, staying relatively constant towards the end of the training. Also, the worse accuracy of the validation set, compared to the training set can be seen.\n"]},{"cell_type":"markdown","metadata":{"id":"MG8Q7Rg-QG5o"},"source":["**Visualization of the model parameters**\n","\n","For pedagogical reasons we will now visualize the parameters of the model with its geometrical interpretation.\n","We will represent the parameters of the first layer of the MLP as a line (the decision boundary).\n"]},{"cell_type":"code","execution_count":138,"metadata":{"executionInfo":{"elapsed":22,"status":"ok","timestamp":1671039210393,"user":{"displayName":"Maximilian Vieweg","userId":"02983195014981343408"},"user_tz":-60},"id":"wR4So4BPQG5o"},"outputs":[],"source":["def plot_decision_boundaries(w, b, ax=None, **kwargs):\n","    ax = ax or plt.gca()\n","    x0, x1 = ax.get_xlim()\n","    y0, y1 = ax.get_ylim()\n","\n","    arts = []\n","    for i in range(w.shape[1]):\n","        w_i = w[:, i]\n","        if len(b.shape) == 1:\n","            b_i = b[i]\n","        else:\n","            b_i = b[:, i]\n","\n","        intersections = []\n","\n","        if w_i[1] != 0:\n","            yx0 = -w_i[0]/w_i[1] * x0 - b_i/w_i[1]\n","            yx1 = -w_i[0]/w_i[1] * x1 - b_i/w_i[1]\n","\n","            if y0 <= yx0 <= y1:\n","                intersections.append((x0, yx0))\n","\n","            if y0 <= yx1 <= y1:\n","                intersections.append((x1, yx1))\n","\n","        if w_i[0] != 0:\n","            xy0 = -w_i[1]/w_i[0] * y0 - b_i/w_i[0]\n","            xy1 = -w_i[1]/w_i[0] * y1 - b_i/w_i[0]\n","\n","            if x0 <= xy0 <= x1:\n","                intersections.append((xy0, y0))\n","\n","            if x0 <= xy1 <= x1:\n","                intersections.append((xy1, y1))\n","\n","        if len(intersections) == 2:\n","            xs, ys = zip(*intersections)\n","            lines, = ax.plot(xs, ys, **kwargs)\n","\n","            arts.append(lines)\n","\n","    ax.set_xlim([x0, x1])\n","    ax.set_ylim([y0, y1])\n","\n","    return arts\n","\n","\n","def plot_model_and_data(params, dat=None, sel=None, ax=None):\n","    w, b, _, _ = params\n","    ax = ax or plt.gca()\n","    ax.set_prop_cycle(None)\n","    prop_cycle = ax._get_patches_for_fill.prop_cycler\n","\n","    import itertools\n","    props = list(itertools.islice(prop_cycle, 3))\n","\n","    all_arts = []\n","\n","    if dat is not None:\n","        arts = ax.scatter(dat[dat[:, -1] == 1, 0], dat[dat[:, -1] == 1, 1],\n","                          facecolors='none', edgecolors=props[0]['color'], alpha=0.2)\n","        all_arts.append(arts)\n","\n","        arts = ax.scatter(dat[dat[:, -1] == 0, 0], dat[dat[:, -1] == 0, 1],\n","                          facecolors='none', edgecolors=props[1]['color'], alpha=0.2)\n","        all_arts.append(arts)\n","\n","    if sel is not None:\n","        arts = ax.scatter(sel[sel[:, -1] == 1, 0], sel[sel[:, -1] == 1, 1],\n","                          facecolors=props[0]['color'], edgecolors=props[0]['color'])\n","        all_arts.append(arts)\n","\n","        arts = ax.scatter(sel[sel[:, -1] == 0, 0], sel[sel[:, -1] == 0, 1],\n","                          facecolors=props[1]['color'], edgecolors=props[1]['color'])\n","        all_arts.append(arts)\n","\n","    line_arts = plot_decision_boundaries(w.detach().numpy(), b.detach().numpy(),\n","                                         ax=ax,\n","                                         color=props[2]['color'],\n","                                         linewidth=2.0)\n","\n","    all_arts += line_arts\n","\n","    return all_arts\n"]},{"cell_type":"markdown","metadata":{"id":"UwWIuxBxQG5p"},"source":["You can use the two functions created above to visualize a learning animation. You simply get the value returned by the function `plot_model_and_data(params, sel=train, ax=ax)` after each epoch.\n","\n","```\n","art = plot_model_and_data(params, sel=train, ax=ax)\n","arts.append(art)\n","```\n"]},{"cell_type":"markdown","metadata":{"id":"ozypxHeMz33d"},"source":["### Exercise 20\n","\n","Visualise the decision boundaries during a training procedure.\n"]},{"cell_type":"code","execution_count":139,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":18526,"status":"ok","timestamp":1671039228899,"user":{"displayName":"Maximilian Vieweg","userId":"02983195014981343408"},"user_tz":-60},"id":"HXlijb1fj5qq","outputId":"7a78713d-321d-48e2-be2d-a06444179a55"},"outputs":[{"name":"stdout","output_type":"stream","text":["Epoch 0, Accuracy: 0.8637499809265137 \n"," \n","\n","Epoch 20, Accuracy: 0.9787499904632568 \n"," \n","\n","Epoch 40, Accuracy: 0.9512500166893005 \n"," \n","\n","Epoch 60, Accuracy: 0.9850000143051147 \n"," \n","\n","Epoch 80, Accuracy: 0.9800000190734863 \n"," \n","\n","Epoch 100, Accuracy: 0.9649999737739563 \n"," \n","\n","Epoch 120, Accuracy: 0.9912499785423279 \n"," \n","\n","Epoch 140, Accuracy: 0.9862499833106995 \n"," \n","\n","Epoch 160, Accuracy: 0.981249988079071 \n"," \n","\n","Epoch 180, Accuracy: 0.9850000143051147 \n"," \n","\n","Epoch 200, Accuracy: 0.981249988079071 \n"," \n","\n","Epoch 220, Accuracy: 0.9937499761581421 \n"," \n","\n","Epoch 240, Accuracy: 0.9887499809265137 \n"," \n","\n","Epoch 260, Accuracy: 0.9800000190734863 \n"," \n","\n","Epoch 280, Accuracy: 0.9750000238418579 \n"," \n","\n","Epoch 300, Accuracy: 0.987500011920929 \n"," \n","\n","Epoch 320, Accuracy: 0.9837499856948853 \n"," \n","\n","Epoch 340, Accuracy: 0.9862499833106995 \n"," \n","\n","Epoch 360, Accuracy: 0.9962499737739563 \n"," \n","\n","Epoch 380, Accuracy: 0.9825000166893005 \n"," \n","\n","Epoch 400, Accuracy: 0.9900000095367432 \n"," \n","\n","Epoch 420, Accuracy: 0.981249988079071 \n"," \n","\n","Epoch 440, Accuracy: 0.9737499952316284 \n"," \n","\n","Epoch 460, Accuracy: 0.9825000166893005 \n"," \n","\n","Epoch 480, Accuracy: 0.9937499761581421 \n"," \n","\n"]}],"source":["params_per_epoch, _ = train_model_get_params(\n","    init_mlp(2, 2, 1), train, lr=0.5, n_epochs=500, batch_size=16\n",")"]},{"cell_type":"code","execution_count":140,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":689,"output_embedded_package_id":"1tt63Z4N8QZcCXI6zYiN2pz9_2awGWIcS"},"executionInfo":{"elapsed":74184,"status":"ok","timestamp":1671039303065,"user":{"displayName":"Maximilian Vieweg","userId":"02983195014981343408"},"user_tz":-60},"id":"CSxwMKCMQG5p","outputId":"c822a097-a263-4742-f163-bce57f37f7e0"},"outputs":[{"data":{"text/plain":["Output hidden; open in https://colab.research.google.com to view."]},"metadata":{},"output_type":"display_data"}],"source":["n_data = train.shape[0]\n","\n","n_epochs = 250\n","batch_size = 10\n","learning_rate_value = 0.005\n","\n","arts = []\n","fig, ax = plt.subplots()\n","\n","\n","\n","for i, param in enumerate(params_per_epoch):\n","    # changing params to conform to expected params in visualisation function\n","    layer_0 = param[0]\n","    w = layer_0[0]\n","    b = layer_0[1].t()\n","\n","    new_param = (w, b, torch.empty(()), torch.empty(()))\n","    art = plot_model_and_data(new_param, sel=train.detach().numpy(), ax=ax)\n","    arts.append(art)\n","\n","\n","\n","anim = animation.ArtistAnimation(\n","    fig, arts, interval=50, repeat_delay=3000, blit=True)\n","HTML(anim.to_jshtml())\n"]},{"cell_type":"markdown","metadata":{"id":"ycm_Gd_iKCzC"},"source":["During this exercise the training of the MLP was visualised. The weights and biases can be interpreted as parameters of linear functions. Plotting straight lines using these values over the training process allows for a visualisation of the training.\n"]},{"cell_type":"code","execution_count":141,"metadata":{"executionInfo":{"elapsed":22,"status":"ok","timestamp":1671039303066,"user":{"displayName":"Maximilian Vieweg","userId":"02983195014981343408"},"user_tz":-60},"id":"N6rJmGOKj5qr"},"outputs":[],"source":["def plot_decision_boundaries(w, b, ax=None, **kwargs):\n","    ax = ax or plt.gca()\n","    x0, x1 = ax.get_xlim()\n","    y0, y1 = ax.get_ylim()\n","\n","    arts = []\n","    for i in range(w.shape[1]):\n","        w_i = w[:, i]\n","        if len(b.shape) == 1:\n","            b_i = b[i]\n","        else:\n","            b_i = b[:, i]\n","\n","        intersections = []\n","\n","        if w_i[1] != 0:\n","            yx0 = -w_i[0]/w_i[1] * x0 - b_i/w_i[1]\n","            yx1 = -w_i[0]/w_i[1] * x1 - b_i/w_i[1]\n","\n","            if y0 <= yx0 <= y1:\n","                intersections.append((x0, yx0))\n","\n","            if y0 <= yx1 <= y1:\n","                intersections.append((x1, yx1))\n","\n","        if w_i[0] != 0:\n","            xy0 = -w_i[1]/w_i[0] * y0 - b_i/w_i[0]\n","            xy1 = -w_i[1]/w_i[0] * y1 - b_i/w_i[0]\n","\n","            if x0 <= xy0 <= x1:\n","                intersections.append((xy0, y0))\n","\n","            if x0 <= xy1 <= x1:\n","                intersections.append((xy1, y1))\n","\n","        if len(intersections) == 2:\n","            xs, ys = zip(*intersections)\n","            lines, = ax.plot(xs, ys, **kwargs)\n","\n","            arts.append(lines)\n","\n","    ax.set_xlim([x0, x1])\n","    ax.set_ylim([y0, y1])\n","\n","    return arts\n","\n","\n","def plot_model_and_data(params, dat=None, sel=None, ax=None):\n","    w, b, _, _ = params\n","    ax = ax or plt.gca()\n","    ax.set_prop_cycle(None)\n","    prop_cycle = ax._get_patches_for_fill.prop_cycler\n","\n","    import itertools\n","    props = list(itertools.islice(prop_cycle, 3))\n","\n","    all_arts = []\n","\n","    if dat is not None:\n","        arts = ax.scatter(dat[dat[:, -1] == 1, 0], dat[dat[:, -1] == 1, 1],\n","                          facecolors='none', edgecolors=props[0]['color'], alpha=0.2)\n","        all_arts.append(arts)\n","\n","        arts = ax.scatter(dat[dat[:, -1] == 0, 0], dat[dat[:, -1] == 0, 1],\n","                          facecolors='none', edgecolors=props[1]['color'], alpha=0.2)\n","        all_arts.append(arts)\n","\n","    if sel is not None:\n","        arts = ax.scatter(sel[sel[:, -1] == 1, 0], sel[sel[:, -1] == 1, 1],\n","                          facecolors=props[0]['color'], edgecolors=props[0]['color'])\n","        all_arts.append(arts)\n","\n","        arts = ax.scatter(sel[sel[:, -1] == 0, 0], sel[sel[:, -1] == 0, 1],\n","                          facecolors=props[1]['color'], edgecolors=props[1]['color'])\n","        all_arts.append(arts)\n","\n","    line_arts = plot_decision_boundaries(w.detach().numpy(), b.detach().numpy(),\n","                                         ax=ax,\n","                                         color=props[2]['color'],\n","                                         linewidth=2.0)\n","\n","    all_arts += line_arts\n","\n","    return all_arts\n"]},{"cell_type":"markdown","metadata":{"id":"okZJtV0y0XnE"},"source":["## Further exploration\n"]},{"cell_type":"markdown","metadata":{"id":"U43-gMwRnrGg"},"source":["### [Advanced] Exercise 21\n","\n","Create a new dataset as the one depicted below.\n","\n","It is similar to the first one we created, but for which we require more hidden units to classify correctly.\n","\n","Visualize the model being trained with an incrementing number of hidden units until reaching the theoretical minimum required amount.\n"]},{"cell_type":"code","execution_count":142,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":265},"executionInfo":{"elapsed":18,"status":"ok","timestamp":1671039303067,"user":{"displayName":"Maximilian Vieweg","userId":"02983195014981343408"},"user_tz":-60},"id":"7vBBOIJ4olRy","outputId":"02aa1a0d-744c-419a-881a-36f8f0b21e74"},"outputs":[{"data":{"image/png":"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","text/plain":["<Figure size 432x288 with 1 Axes>"]},"metadata":{"needs_background":"light"},"output_type":"display_data"}],"source":["# Creating a new Dataset\n","\n","# Originally I chose more points since the model was not converging fast enough, but leaving the number high\n","artificial_data = torch.rand((3_000, 2), requires_grad=True)\n","y_artificial_data = torch.empty((3_000, 1))\n","\n","for i, point in enumerate(artificial_data):\n","    # conditions for being in which category\n","    if point[0] > 0.2 and point[1] > 0.4 and point[0] < 0.9 and point[1] < 0.9:\n","        y_artificial_data[i] = 1\n","    else:\n","        y_artificial_data[i] = 0\n","\n","colors = ('r', 'g')\n","\n","data = torch.concat((artificial_data, y_artificial_data), dim=1)\n","\n","random_indices = torch.randperm(len(data))\n","data = data[random_indices]\n","\n","train, valid, test = torch.split(data, (2500, 250, 250), dim=0)\n","\n","for i, t in enumerate((train, valid, test)):\n","    is_condition = t[:, -1] == 1  # Class is set by last parameter in the data\n","\n","    # We choose columns conforming to this condition and choose column\n","    x_column = t[is_condition][:, 0]\n","    y_column = t[is_condition][:, 1]\n","\n","    x_column_ = t[torch.logical_not(is_condition)][:, 0]\n","    y_column_ = t[torch.logical_not(is_condition)][:, 1]\n","\n","    plt.scatter(x_column.detach().numpy(),\n","                y_column.detach().numpy(), color='r')\n","    plt.scatter(x_column_.detach().numpy(),\n","                y_column_.detach().numpy(), color='b')\n","\n","plt.show()\n"]},{"cell_type":"markdown","metadata":{"id":"rwyTIEeGKZ3g"},"source":["Similiarly to previous exercises random points were instatiated and categorised into a rectangular region with adjustable cutoff values.\n"]},{"cell_type":"code","execution_count":143,"metadata":{"executionInfo":{"elapsed":28,"status":"ok","timestamp":1671039303081,"user":{"displayName":"Maximilian Vieweg","userId":"02983195014981343408"},"user_tz":-60},"id":"lyI7sZnMSV1j"},"outputs":[],"source":["def plot_decision_boundaries(w, b, ax=None, **kwargs):\n","    ax = ax or plt.gca()\n","    x0, x1 = ax.get_xlim()\n","    y0, y1 = ax.get_ylim()\n","\n","    arts = []\n","    for i in range(w.shape[1]):\n","        w_i = w[:, i]\n","        if len(b.shape) == 1:\n","            b_i = b[i]\n","        else:\n","            b_i = b[:, i]\n","\n","        intersections = []\n","\n","        if w_i[1] != 0:\n","            yx0 = -w_i[0]/w_i[1] * x0 - b_i/w_i[1]\n","            yx1 = -w_i[0]/w_i[1] * x1 - b_i/w_i[1]\n","\n","            if y0 <= yx0 <= y1:\n","                intersections.append((x0, yx0))\n","\n","            if y0 <= yx1 <= y1:\n","                intersections.append((x1, yx1))\n","\n","        if w_i[0] != 0:\n","            xy0 = -w_i[1]/w_i[0] * y0 - b_i/w_i[0]\n","            xy1 = -w_i[1]/w_i[0] * y1 - b_i/w_i[0]\n","\n","            if x0 <= xy0 <= x1:\n","                intersections.append((xy0, y0))\n","\n","            if x0 <= xy1 <= x1:\n","                intersections.append((xy1, y1))\n","\n","        if len(intersections) == 2:\n","            xs, ys = zip(*intersections)\n","            lines, = ax.plot(xs, ys, **kwargs)\n","\n","            arts.append(lines)\n","\n","    ax.set_xlim([x0, x1])\n","    ax.set_ylim([y0, y1])\n","\n","    return arts\n","\n","\n","def plot_model_and_data(params, dat=None, sel=None, ax=None):\n","    w, b, w_2, b_2 = params\n","    ax = ax or plt.gca()\n","    ax.set_prop_cycle(None)\n","    prop_cycle = ax._get_patches_for_fill.prop_cycler\n","\n","    import itertools\n","    props = list(itertools.islice(prop_cycle, 3))\n","\n","    all_arts = []\n","\n","    if dat is not None:\n","        arts = ax.scatter(dat[dat[:, -1] == 1, 0], dat[dat[:, -1] == 1, 1],\n","                          facecolors='none', edgecolors=props[0]['color'], alpha=0.2)\n","        all_arts.append(arts)\n","\n","        arts = ax.scatter(dat[dat[:, -1] == 0, 0], dat[dat[:, -1] == 0, 1],\n","                          facecolors='none', edgecolors=props[1]['color'], alpha=0.2)\n","        all_arts.append(arts)\n","\n","    if sel is not None:\n","        arts = ax.scatter(sel[sel[:, -1] == 1, 0], sel[sel[:, -1] == 1, 1],\n","                          facecolors=props[0]['color'], edgecolors=props[0]['color'])\n","        all_arts.append(arts)\n","\n","        arts = ax.scatter(sel[sel[:, -1] == 0, 0], sel[sel[:, -1] == 0, 1],\n","                          facecolors=props[1]['color'], edgecolors=props[1]['color'])\n","        all_arts.append(arts)\n","\n","    line_arts = plot_decision_boundaries(w.detach().numpy(), b.detach().numpy(),\n","                                         ax=ax,\n","                                         color=props[2]['color'],\n","                                         linewidth=2.0)\n","    all_arts += line_arts\n","\n","    line_arts = plot_decision_boundaries(w_2.detach().numpy(), b_2.detach().numpy(),\n","                                         ax=ax,\n","                                         color=props[2]['color'],\n","                                         linewidth=2.0)\n","    all_arts += line_arts\n","\n","    return all_arts\n"]},{"cell_type":"code","execution_count":144,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":9662,"status":"ok","timestamp":1671039312716,"user":{"displayName":"Maximilian Vieweg","userId":"02983195014981343408"},"user_tz":-60},"id":"P36RMAFrhWnW","outputId":"8f7f7fac-0dd9-485d-ef54-5f98aebb7002"},"outputs":[{"name":"stdout","output_type":"stream","text":["Epoch 0, Accuracy: 0.7175999879837036 \n"," \n","\n","Epoch 20, Accuracy: 0.6556000113487244 \n"," \n","\n","Epoch 40, Accuracy: 0.8600000143051147 \n"," \n","\n","Epoch 60, Accuracy: 0.8564000129699707 \n"," \n","\n","Epoch 80, Accuracy: 0.9092000126838684 \n"," \n","\n","Epoch 100, Accuracy: 0.9083999991416931 \n"," \n","\n","Epoch 120, Accuracy: 0.8519999980926514 \n"," \n","\n","Epoch 140, Accuracy: 0.9279999732971191 \n"," \n","\n","Epoch 160, Accuracy: 0.9115999937057495 \n"," \n","\n","Epoch 180, Accuracy: 0.9531999826431274 \n"," \n","\n"]}],"source":["params_per_epoch, _ = train_model_get_params(\n","    # Decided on a structure with four hidden layers, since that is the minimum amount needed to \n","    # Split the rectangular area off\n","    init_mlp(2, 4, 1), train, lr=0.5, n_epochs=200, batch_size=16\n",")\n"]},{"cell_type":"code","execution_count":145,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":724,"output_embedded_package_id":"1dktdZVVo5YqBIIpny_0HxfuGsvRdwhf4"},"executionInfo":{"elapsed":32326,"status":"ok","timestamp":1671039345039,"user":{"displayName":"Maximilian Vieweg","userId":"02983195014981343408"},"user_tz":-60},"id":"b9HmGMWWSV1j","outputId":"02d671e7-2315-4a1b-9d20-3c13214c434a"},"outputs":[{"data":{"text/plain":["Output hidden; open in https://colab.research.google.com to view."]},"metadata":{},"output_type":"display_data"}],"source":["n_data = train.shape[0]\n","\n","n_epochs = 250\n","batch_size = 10\n","learning_rate_value = 0.005\n","\n","arts = []\n","fig, ax = plt.subplots()\n","\n","##\n","\n","for i, param in enumerate(params_per_epoch):\n","    if (i+1) % 100 == 0: \n","        print(f\"At epoch {i}\")\n","\n","    # changing params to conform to expected params in visualisation function\n","    layer = param[0]\n","    w_1 = layer[0][:, :2]\n","    b_1 = layer[1][:2].t()\n","    w_2 = layer[0][:, 2:]\n","    b_2 = layer[1][2:].t()\n","    new_param = (w_1, b_1, w_2, b_2)\n","\n","    art = plot_model_and_data(new_param, sel=train.detach().numpy(), ax=ax)\n","    arts.append(art)\n","\n","\n","\n","anim = animation.ArtistAnimation(fig, arts, interval=50, repeat_delay=3000, blit=True)\n","HTML(anim.to_jshtml())"]},{"cell_type":"markdown","metadata":{"id":"J6NAvQ7gKoNH"},"source":["The visualisation of the previous exercise was extended: As can be seen, the minimum amount of straight lines to seperate these two groups is four, leading to two weight and bias pairs.\n","\n","For increasing the speed of convergence a higher number of training points was chosen, in combination with the ideal parameters found during the previous exercises. However, the right-most line has not convergeed during the training. Keeping the y=mx+b analogy in mind, this could result from the necessity for high m and b values; the optimiser is caught in local minima and does not grow towards the necessary size.\n"]},{"cell_type":"markdown","metadata":{"id":"AZiG4CWAp91a"},"source":["### [Advanced] Exercise 22\n","\n","Implement another (or all) alternative optimizers that we have seen in the lecture. Plot the loss curves of them on a same plot together with vanilla SGD.\n"]},{"cell_type":"code","execution_count":146,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":660},"executionInfo":{"elapsed":133836,"status":"ok","timestamp":1671039478868,"user":{"displayName":"Maximilian Vieweg","userId":"02983195014981343408"},"user_tz":-60},"id":"kO0HER_eoqPz","outputId":"354ea7d9-51f5-416d-cf21-4709a35b66a6"},"outputs":[{"name":"stdout","output_type":"stream","text":["Working on learning rate 0.5\n","Working on learning rate 0.05\n","Working on learning rate 0.005\n","Working on learning rate 0.005\n","Working on learning rate 5e-05\n"]},{"data":{"image/png":"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","text/plain":["<Figure size 432x288 with 1 Axes>"]},"metadata":{"needs_background":"light"},"output_type":"display_data"},{"data":{"image/png":"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","text/plain":["<Figure size 432x288 with 1 Axes>"]},"metadata":{"needs_background":"light"},"output_type":"display_data"}],"source":["def train_model_momentum(params, data, lr=0.05, n_epochs=1, batch_size=16, gamma = 0.0, print_meta=False):\n","    n_data = data.shape[0]\n","    n_iterations = n_data // batch_size\n","    loss_history = list()\n","\n","    # The momentum depends on the previous state, which is saved in the same \n","    # format as params\n","    momentum = [0] * len(params)\n","    for i, (w, b) in enumerate(params):\n","        momentum[i] = [torch.randn_like(w), torch.randn_like(b)]\n","    \n","    for epoch in range(n_epochs):\n","        ##\n","\n","        # Randomly reorder the `train` data (use `torch.randperm()`)\n","        random_indices = torch.randperm(n_data)\n","        reference_data = data[random_indices]\n","\n","        # Evaluate and print the model score on the training data\n","        if print_meta and epoch % 10 == 0:\n","            print(f\"Epoch {epoch}, Accuracy: {score_model(params, train)} \\n \\n\")\n","\n","        loss_history_epoch = list()\n","            \n","        \n","        for i in range(n_iterations - 1):\n","            ##\n","\n","            # 1. Select a block of `batch_size` examples\n","            current_batch = reference_data[batch_size*i : batch_size*(i+1)]\n","            current_data = current_batch[:, :-1].t()\n","            measured = current_batch[:, -1]\n","        \n","            # 2. Run the forward pass on the model\n","            estimated = mlp(current_data, params)\n","\n","            # 3. Compute the error\n","            loss = bce(estimated, measured)\n","            loss_history_epoch.append(loss)\n","\n","            # 4. Zero the gradients of each of the parameters because .backward() accumulates them\n","            with torch.no_grad():\n","                for w, b in params: \n","                    if w.grad is not None:\n","                        w.grad.zero_()\n","                    if b.grad is not None:\n","                        b.grad.zero_()\n","\n","            # 5. Compute the gradients\n","            loss.backward(retain_graph=True)\n","\n","            # 6. Update the parameters using their gradients\n","            with torch.no_grad():\n","                for (w, b), (m_w_old, m_b_old) in zip(params, momentum):\n","                    m_w = gamma * m_w_old + lr * w.grad \n","                    m_b = gamma * m_b_old + lr * b.grad \n","\n","                    m_w_old = w \n","                    m_b_old = b\n","\n","                    w -= m_w\n","                    b -= m_b\n","\n","\n","        loss_history.append(np.mean([l.data for l in loss_history_epoch if l]))\n","    \n","    return params, loss_history\n","\n","\n","learning_rates = [0.5, 0.05, 0.005, 0.005, 0.00005]\n","n_epochs = 100\n","batch_size = 16\n","\n","losses_momentum = {}\n","losses_normal = {}\n","\n","# Train a model with each learning rate and populate losses with the learning rate as key and the loss series as values\n","##\n","\n","for lr in learning_rates:\n","    print(f\"Working on learning rate {lr}\")\n","    params = list(init_mlp(2, 2, 1))\n","    _, loss = train_model_momentum(params, train, lr=lr, n_epochs=100, print_meta=False)\n","    losses_momentum[lr] = loss\n","\n","    params = list(init_mlp(2, 2, 1))\n","    _, loss = train_model_momentum(params, train, lr=lr, n_epochs=100, print_meta=False)\n","    losses_normal[lr] = loss\n","\n","    #print(f\"Current loss: {loss}\")\n","    \n","\n","\n","plt.figure(1)\n","for lr, loss_curve in sorted(losses_normal.items()):\n","    plt.plot(loss_curve, label=f'learning_rate={lr:.5f}')\n","\n","plt.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n","plt.ylabel('Loss function')\n","plt.xlabel('Epoch')\n","plt.title(\"Normal SGD Optimiser\")\n","plt.show()\n","\n","\n","for lr, loss_curve in sorted(losses_momentum.items()):\n","    plt.plot(loss_curve, label=f'learning_rate={lr:.5f}')\n","\n","plt.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n","plt.ylabel('Loss function')\n","plt.xlabel('Epoch')\n","plt.title(\"Momentum SGD Optimiser\")\n","plt.show()"]},{"cell_type":"markdown","metadata":{"id":"V4Q5MdMwL0nk"},"source":["During this exercise the vanilla stochastic gradient descent (Vanilla SGD) was improved, by adding the momentum to the descent step. Essentially the momentum of the previous iteration is added to the current step, making the step more steady.\n","\n","As can be seen in the upper figures, using a momentum does not make a huge different for most learning rates in our example. The only visible difference can be seen at lr=0.05, however they still converge to the same value. \n"]}],"metadata":{"celltoolbar":"Create Assignment","colab":{"collapsed_sections":["eP15YmPVyhYh","4RqH3NrNQG5f","NJfm4zW8QG5g","PATwbhk9zTAC"],"provenance":[{"file_id":"1ewkZ4uv1RVqtSL4xyVsDo4upN4_Wn-nW","timestamp":1669112367708},{"file_id":"1cZURToPM-hJ78OYG0kcP0pc66o4slNUI","timestamp":1637569945940}]},"kernelspec":{"display_name":"Python 3.10.8 64-bit","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.8"},"latex_envs":{"LaTeX_envs_menu_present":true,"autoclose":false,"autocomplete":false,"bibliofile":"biblio.bib","cite_by":"apalike","current_citInitial":1,"eqLabelWithNumbers":true,"eqNumInitial":1,"hotkeys":{"equation":"Ctrl-E","itemize":"Ctrl-I"},"labels_anchors":false,"latex_user_defs":false,"report_style_numbering":false,"user_envs_cfg":false},"vscode":{"interpreter":{"hash":"aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"}}},"nbformat":4,"nbformat_minor":0}