From da781060e024016189ff6283063614aae56ae6a8 Mon Sep 17 00:00:00 2001 From: Oleg Sheynin Date: Fri, 7 Jun 2024 00:47:22 +0000 Subject: [PATCH] progress --- .../how-does-a-neural-net-really-work.ipynb | 3591 +++++++++++++++++ .../which-image-models-are-best.ipynb | 910 +++++ 2 files changed, 4501 insertions(+) create mode 100644 fastai/notebooks/Education/how-does-a-neural-net-really-work.ipynb create mode 100644 fastai/notebooks/Education/which-image-models-are-best.ipynb diff --git a/fastai/notebooks/Education/how-does-a-neural-net-really-work.ipynb b/fastai/notebooks/Education/how-does-a-neural-net-really-work.ipynb new file mode 100644 index 0000000..c5747ba --- /dev/null +++ b/fastai/notebooks/Education/how-does-a-neural-net-really-work.ipynb @@ -0,0 +1,3591 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3a825ca3", + "metadata": { + "papermill": { + "duration": 0.054714, + "end_time": "2022-08-25T20:07:33.291009", + "exception": false, + "start_time": "2022-08-25T20:07:33.236295", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "**Important**: The interactive features of this notebook don't work in Kaggle's *Reader* mode. They only work in *Edit* mode. Therefore, before starting reading this, please click \"**Copy & Edit**\" in the top right of this window, then in the menu click *Run* and then *Run all*. Then you'll be able to use all the interactive sliders in this notebook." + ] + }, + { + "cell_type": "markdown", + "id": "579020e7", + "metadata": { + "papermill": { + "duration": 0.052974, + "end_time": "2022-08-25T20:07:33.396018", + "exception": false, + "start_time": "2022-08-25T20:07:33.343044", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## Fitting a function with *gradient descent*" + ] + }, + { + "cell_type": "markdown", + "id": "ab5f159d", + "metadata": { + "papermill": { + "duration": 0.050597, + "end_time": "2022-08-25T20:07:33.498627", + "exception": false, + "start_time": "2022-08-25T20:07:33.448030", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "A neural network is just a mathematical function. In the most standard kind of neural network, the function:\n", + "\n", + "1. Multiplies each input by a number of values. These values are known as *parameters*\n", + "1. Adds them up for each group of values\n", + "1. Replaces the negative numbers with zeros\n", + "\n", + "This represents one \"layer\". Then these three steps are repeated, using the outputs of the previous layer as the inputs to the next layer. Initially, the parameters in this function are selected randomly. Therefore a newly created neural network doesn't do anything useful at all -- it's just random!\n", + "\n", + "To get the function to \"learn\" to do something useful, we have to change the parameters to make them \"better\" in some way. We do this using *gradient descent*. Let's see how this works..." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "3f292334", + "metadata": { + "_kg_hide-input": true, + "papermill": { + "duration": 2.927483, + "end_time": "2022-08-25T20:07:36.477711", + "exception": false, + "start_time": "2022-08-25T20:07:33.550228", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "from ipywidgets import interact\n", + "from fastai.basics import *\n", + "\n", + "plt.rc('figure', dpi=90)\n", + "\n", + "def plot_function(f, title=None, min=-2.1, max=2.1, color='r', ylim=None):\n", + " x = torch.linspace(min,max, 100)[:,None]\n", + " if ylim: plt.ylim(ylim)\n", + " plt.plot(x, f(x), color)\n", + " if title is not None: plt.title(title)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "f503eec4-46b5-4429-af0a-3c1507211db5", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([-2.1000, -2.0576, -2.0152, -1.9727, -1.9303, -1.8879, -1.8455, -1.8030,\n", + " -1.7606, -1.7182, -1.6758, -1.6333, -1.5909, -1.5485, -1.5061, -1.4636,\n", + " -1.4212, -1.3788, -1.3364, -1.2939, -1.2515, -1.2091, -1.1667, -1.1242,\n", + " -1.0818, -1.0394, -0.9970, -0.9545, -0.9121, -0.8697, -0.8273, -0.7848,\n", + " -0.7424, -0.7000, -0.6576, -0.6152, -0.5727, -0.5303, -0.4879, -0.4455,\n", + " -0.4030, -0.3606, -0.3182, -0.2758, -0.2333, -0.1909, -0.1485, -0.1061,\n", + " -0.0636, -0.0212, 0.0212, 0.0636, 0.1061, 0.1485, 0.1909, 0.2333,\n", + " 0.2758, 0.3182, 0.3606, 0.4030, 0.4455, 0.4879, 0.5303, 0.5727,\n", + " 0.6152, 0.6576, 0.7000, 0.7424, 0.7848, 0.8273, 0.8697, 0.9121,\n", + " 0.9545, 0.9970, 1.0394, 1.0818, 1.1242, 1.1667, 1.2091, 1.2515,\n", + " 1.2939, 1.3364, 1.3788, 1.4212, 1.4636, 1.5061, 1.5485, 1.5909,\n", + " 1.6333, 1.6758, 1.7182, 1.7606, 1.8030, 1.8455, 1.8879, 1.9303,\n", + " 1.9727, 2.0152, 2.0576, 2.1000])\n", + "tensor([[-2.1000],\n", + " [-2.0576],\n", + " [-2.0152],\n", + " [-1.9727],\n", + " [-1.9303],\n", + " [-1.8879],\n", + " [-1.8455],\n", + " [-1.8030],\n", + " [-1.7606],\n", + " [-1.7182],\n", + " [-1.6758],\n", + " [-1.6333],\n", + " [-1.5909],\n", + " [-1.5485],\n", + " [-1.5061],\n", + " [-1.4636],\n", + " [-1.4212],\n", + " [-1.3788],\n", + " [-1.3364],\n", + " [-1.2939],\n", + " [-1.2515],\n", + " [-1.2091],\n", + " [-1.1667],\n", + " [-1.1242],\n", + " [-1.0818],\n", + " [-1.0394],\n", + " [-0.9970],\n", + " [-0.9545],\n", + " [-0.9121],\n", + " [-0.8697],\n", + " [-0.8273],\n", + " [-0.7848],\n", + " [-0.7424],\n", + " [-0.7000],\n", + " [-0.6576],\n", + " [-0.6152],\n", + " [-0.5727],\n", + " [-0.5303],\n", + " [-0.4879],\n", + " [-0.4455],\n", + " [-0.4030],\n", + " [-0.3606],\n", + " [-0.3182],\n", + " [-0.2758],\n", + " [-0.2333],\n", + " [-0.1909],\n", + " [-0.1485],\n", + " [-0.1061],\n", + " [-0.0636],\n", + " [-0.0212],\n", + " [ 0.0212],\n", + " [ 0.0636],\n", + " [ 0.1061],\n", + " [ 0.1485],\n", + " [ 0.1909],\n", + " [ 0.2333],\n", + " [ 0.2758],\n", + " [ 0.3182],\n", + " [ 0.3606],\n", + " [ 0.4030],\n", + " [ 0.4455],\n", + " [ 0.4879],\n", + " [ 0.5303],\n", + " [ 0.5727],\n", + " [ 0.6152],\n", + " [ 0.6576],\n", + " [ 0.7000],\n", + " [ 0.7424],\n", + " [ 0.7848],\n", + " [ 0.8273],\n", + " [ 0.8697],\n", + " [ 0.9121],\n", + " [ 0.9545],\n", + " [ 0.9970],\n", + " [ 1.0394],\n", + " [ 1.0818],\n", + " [ 1.1242],\n", + " [ 1.1667],\n", + " [ 1.2091],\n", + " [ 1.2515],\n", + " [ 1.2939],\n", + " [ 1.3364],\n", + " [ 1.3788],\n", + " [ 1.4212],\n", + " [ 1.4636],\n", + " [ 1.5061],\n", + " [ 1.5485],\n", + " [ 1.5909],\n", + " [ 1.6333],\n", + " [ 1.6758],\n", + " [ 1.7182],\n", + " [ 1.7606],\n", + " [ 1.8030],\n", + " [ 1.8455],\n", + " [ 1.8879],\n", + " [ 1.9303],\n", + " [ 1.9727],\n", + " [ 2.0152],\n", + " [ 2.0576],\n", + " [ 2.1000]])\n" + ] + } + ], + "source": [ + "# ----- O.S.\n", + "min = -2.1\n", + "max = 2.1\n", + "print(torch.linspace(min,max, 100))\n", + "print(torch.linspace(min, max, 100)[:, None])" + ] + }, + { + "cell_type": "markdown", + "id": "4257b420", + "metadata": { + "papermill": { + "duration": 0.050319, + "end_time": "2022-08-25T20:07:36.579069", + "exception": false, + "start_time": "2022-08-25T20:07:36.528750", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "To learn how gradient descent works, we're going to start by fitting a quadratic, since that's a function most of us are probably more familiar with than a neural network. Here's the quadratic we're going to try to fit:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "2593774b", + "metadata": { + "papermill": { + "duration": 0.749326, + "end_time": "2022-08-25T20:07:37.379666", + "exception": false, + "start_time": "2022-08-25T20:07:36.630340", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfUAAAGLCAYAAADeYAugAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA3XAAAN1wFCKJt4AAA5Y0lEQVR4nO3deVxU9f7H8fe44QIKaKbkmqampaB209LUMpdblrlvLaammXgzbTMrNLS8ZZaS0YKZbZretI3udSlzLbVES8syVzR3BZFwGJjfH98fGIU64MCZOfN6Ph7nMcNwmPmwvvl+z3dxuN1utwAAgN8rYXUBAADAOwh1AABsglAHAMAmCHUAAGyCUAcAwCYIdQAAbIJQBwDAJgh1AABsglAHAMAmCHXAJvbt26ebbrpJV155pZo0aaJHHnlELBgJBBZCHbCJUqVKaerUqfrpp5+0adMmrVu3Th999JHVZQEoRoQ6YLGFCxfquuuuU+XKlVW2bFk1bNhQsbGxcjqdBXqe6tWrq2XLlpKkMmXKKCoqSsnJyV6vd8GCBbrtttt02WWXKTg4WC1atNAHH3zg9dcpiB07dmj48OFq2rSpSpYsqfbt21taD2CVUlYXAAS6Y8eO6cYbb9TDDz+s0NBQrV+/XjExMTp48KDi4uIK9ZzHjx/X4sWLtWTJEi9XK7344ouqW7eupk+fripVqigxMVEDBgzQ0aNHFR0d7fXX88TWrVuVmJioVq1aKTMz05IaAF/gYJc2wPc88cQTeuWVV3TixAk5HI4CfazT6VSXLl10yy23aOzYsR59zIoVK9ShQwePrsEfPXpUVapUyfPYgAEDtG7dOu3atatAtXqrpuzsbJUoYToee/XqpaNHj2rFihVeqwXwF3S/Az6ocuXKebrfv/76azkcDiUmJuY+tmvXLlWtWlWjR4/OfSwrK0sDBgxQZGSkx4FeUH8NdEmKiorSgQMH8jzmac3ekBPoQKDjNwHwEVlZWUpPT9fq1as1Y8YM3X///bmt9Hbt2qlDhw6aPHmyJCklJUW33nqr/vGPf2j69Om5zzF8+HCFhIRo2rRpxVr7unXr1KBBgzyPeVozAO8h1AEfUaFCBVWoUEFt27ZVu3bt9Pzzz+d5/8SJE7V27VotWbJEffr0UenSpTVv3jyVLFlSkrRmzRolJCRo48aNioqKUmRkpGbMmJHva7ndbrlcrtwjKytLkvI85nK5PKp7+fLlWrx4cb49AxequahqAgIV19QBH/H9998rPT1d69ev16RJkzRgwADNmjUrzzk333yz1q5dq9DQUH377beqUaNGoV5rzpw5Gjx48AXPu9Cfh927d+vaa6/Vddddp0WLFuV7jqc1e6smrqkjkDH6HfARzZs3lyS1adNGVapU0d13362xY8eqXr16uefUr19fy5Yt08svv1zoQJekbt26acOGDblvf/fddxoxYkSexy7k+PHj6tq1q2rXrq333nvvnOd5WrM3agICHaEO+KCcgN+1a1duqL/++uuaPXu2mjVrpoSEBA0dOrTQz1+5cmVVrlw59+20tDRJyp3nfiHp6em69dZb5XQ69dlnn6l8+fL5nleQmi+2JgCEOuCT1qxZI0mqW7euJGnp0qV64IEHlJCQoAYNGqh169b64osv1LVr12KvzeVyqXfv3vr111+1du1aVa1aNd/zfKlmIFAQ6oDFunTpoo4dO6pJkyYqWbKk1qxZo2nTpqlv376qV6+etm7dqt69e+vRRx/VXXfdJUnq2LGjYmJiLAnIkSNHKjExUS+//LKOHTumY8eO5b4vKipKQUFBxV5zenp67tS5/fv3KzU1VQsXLpQk/fOf/zxnTwJgO24AlpowYYK7SZMm7goVKrgrVarkjoqKcs+YMcPtdDrdhw4dctepU8fdu3dvd3Z2du7HfP31125J7s8++8wrNXz11VduT/8c1K5d2y0p32PXrl1eq7kgNe3ateu8NQGBgtHvAADYBPPUAQCwCUIdAACbINQBALAJQh0AAJsg1AEAsAlCHQAAmyDUAQCwCb9dUS5nn2kAAALFhZaW8dtQly78yQEAYBeeNGbpfgcAwCYIdQAAbIJQBwDAJgh1AABsglAHAMAmCHUAAGyCUAcAwCYIdQAAbIJQBwDAJgh1AABsglAHAMAmCHUAALzt44+l9PRif1lCHQAAb0pKkrp3lzp2LPaXJtQBAPCmN980t336FPtLO9x+un+pw+Fg61UAgG/54w+penVzu3+/VKWK157ak9yjpQ4AgLcsXCilpEg9eng10D1FqAMA4C05Xe9Dh1ry8nS/AwDgDdu3S40aSXXrSjt2SCW8226m+x0AgOKSkGBuhw71eqB7ipY6AAAXy+mUataUjh6V9u2TIiK8/hK01AEAKA6ffiodPizdckuRBLqnCHUAAC5WzgC5YcMsLYPudwAALsbevVKdOmZ++p49UqlSRfIydL8DAFDUEhIkt1u6554iC3RP0VIHAKCwXC7TSj9wQPrtNzOdrYh4taUeFxenli1bKigoSN27d899fO/evQoODs5zlCpVSrfddts5n6t9+/YKCgrK8zEHDhzwtBQAAHzDF1+Y5WA7dSrSQPeUx6EeERGhCRMmaNhfBgHUqlVLaWlpucfx48cVGhqqfv36nff5pk6dmufjIiwcLQgAQKG8/rq5ve8+a+v4fx53/vfo0UOSlJSUpOTk5HOet3jxYmVnZ+eeDwCALe3bJyUmStWqSd26WV2NpCIYKJeQkKCBAweqbNmy5z0vNjZW4eHhioqK0ty5c71dBgAARSshQcrOlu69Vypd2upqJHk51Pfs2aNly5Zp6AUWsn/22Wf122+/6dChQ3ruuecUHR2tRYsWnfdjYmJi5HA4cg8AACzjcuVdFtZHeDXU33rrLUVFRalZs2bnPa9169aqVKmSSpcurc6dO2v48OGaP3/+eT8mJiZGbrc79wAAwDL//a+UnOwzA+RyeC3Us7Oz9dZbb12wlZ5vERYtfA8AQKH42AC5HB6nqcvlUkZGhlwul7Kzs5WRkSGn05n7/qVLl+ro0aPq37//eZ/n5MmTSkxMVHp6urKysrR8+XLFx8erZ8+ehf8sAAAoLsnJ0uefS5deKp1n+rYVPA712NhYlStXTpMnT9ann36qcuXKqVOnTrnvT0hIUK9evVSpUqW/fWzXrl01ZcoUSVJmZqYmTpyoatWqKSwsTGPGjNGLL76o3r17e+HTAQCgiOUMkBs82GcGyOVgRTkAADz15xXkduyQLr+82F6atd8BAPCmzz83K8h17lysge4pQh0AAE/Fx5vbESOsreMc6H4HAMATO3dK9etLERHS7t3FviMb3e8AAHjLG2+YLVaHDbN8i9VzoaUOAMCFnDkj1awpHT8u7dkjXXZZsZdASx0AAG9YtEg6csRs3GJBoHuKUAcA4EJ8fIBcDrrfAQA4n59+kho3Nmu879ghWbS0Od3vAABcrJxW+vDhlgW6p2ipAwBwLqdPm2vof/xh1ny/5BLLSqGlDgDAxfjgAyklRerTx9JA9xShDgBAftxu6ZVXzP2RI62txUOEOgAA+fn2WykpSYqMlFq1sroajxDqAADkZ9YscztypORwWFuLhxgoBwDAXx09agbIlS1rtlmtUMHqihgoBwBAocyeLTmd0j33+ESge4qWOgAAf5aVJV1xhbRrl1l4plEjqyuSREsdAICC+9//TKDfeKPPBLqnCHUAAP4sZxrb/fdbW0ch0P0OAECOHTukBg2kiAjTWi9d2uqKctH9DgBAQbz6qll0ZsQInwp0T9FSBwBAMuu816hhbvftky691OqK8qClDgCAp95/Xzp50qzz7mOB7ila6gAAuN1mOdgtW6R163xyWVha6gAAeGL1ahPoLVpI115rdTWFRqgDABAXZ25HjfKbdd7zQ/c7ACCw7d8v1akjVapkBsiVK2d1Rfmi+x0AgAt5/XXJ5ZKGDvXZQPcULXUAQOA6c0aqVcvsyvbbb6bF7qNoqQMAcD4ffigdPizdfrtPB7qnCHUAQGByu6WXXzb3R4+2thYvIdQBAIHpm2+k776Trr5aatfO6mq8glAHAASmGTPM7ejRfj2N7c88DvW4uDi1bNlSQUFB6t69e573tW/fXkFBQQoODs49Dhw4cM7nSk1N1YABA1SxYkVdeumleuaZZwr9CQAAUGD790sLF0rh4dKAAVZX4zUeh3pERIQmTJigYcOG5fv+qVOnKi0tLfeIiIg453NFR0fr+PHj2rt3r1atWqU33nhDc+fOLXj1AAAURny8mcY2bJhUvrzV1XhNKU9P7NGjhyQpKSlJycnJhX7B9PR0zZs3T2vWrFFoaKhCQ0MVHR2thIQE3XXXXYV+XgAAPJKRIb32mlSihDRypNXVeJXXrqnHxsYqPDxcUVFR5211b9++XU6nU5GRkbmPRUZGasuWLed9/piYGDkcjtwDAIBCmTdPOnJEuuMOM0fdRrwS6s8++6x+++03HTp0SM8995yio6O1aNGifM9NS0tThQoVVKrU2U6C0NBQnTp16ryvERMTI7fbnXsAAFBgbvfZAXL/+pe1tRQBr4R669atValSJZUuXVqdO3fW8OHDNX/+/HzPDQ4OVnp6ulwuV+5jKSkpCgkJ8UYpAACc26pV0qZNZpvVNm2srsbrimRKW4kS537ahg0bqnTp0tq8eXPuY0lJSbr66quLohQAAM566SVzO2aMbaax/ZnHoe5yuZSRkSGXy6Xs7GxlZGTI6XTq5MmTSkxMVHp6urKysrR8+XLFx8erZ8+e+T5P+fLl1bdvXz355JNKSUnRr7/+qpkzZ2ro0KFe+6QAAPibnTulxYulSy+V+va1upoi4XGox8bGqly5cpo8ebI+/fRTlStXTp06dVJmZqYmTpyoatWqKSwsTGPGjNGLL76o3r17535s165dNWXKlNy34+LiVKlSJdWoUUPXX3+9hgwZwsh3AEDRmjnTXFMfOVIKCrK6miLBLm0AAPtLTZVq1JCcTmnvXqlqVasrKjB2aQMAQJLeeks6dUoaONAvA91TtNQBAPaWlSU1aGCuqW/eLDVtanVFhUJLHQCAzz4zgX7jjX4b6J4i1AEA9jZ9url98EFLyygOdL8DAOzr+++lFi2k+vWl7dvNeu9+iu53AEBge/FFcztmjF8HuqdoqQMA7Ck5WapbV6pY0Uxjq1DB6oouCi11AEDgmjnT7Jk+YoTfB7qnaKkDAOzn1CmpZk0pPV3avVuKiLC6ootGSx0AEJhmz5ZSUqQBA2wR6J6ipQ4AsJesLDPaffduKSlJatbM6oq8gpY6ACDwLFpkAr1jR9sEuqcIdQCAveRMY3voIWvrsADd7wAA+1i7Vrr+eunKK6WtWyWHw+qKvIbudwBAYHn+eXM7bpytAt1TtNQBAPbwyy9So0ZStWrSrl1SUJDVFXkVLXUAQOCYNk1yu6XRo20X6J6ipQ4A8H+HDkm1a0ulS0v79kmhoVZX5HW01AEAgSEuTjpzRho2zJaB7ila6gAA/3b6tFSrlllBbudOc9+GaKkDAOzvrbek48elfv1sG+ieoqUOAPBfLpfUoIEZ7b5pkxQZaXVFRYaWOgDA3hYuNIHesaOtA91ThDoAwD+53dLUqeb+Y49ZW4uPINQBAP5p6VKzC1uLFtKNN1pdjU8g1AEA/imnlf7oowG5JGx+GCgHAPA/GzZI//iH2Tf955+lkiWtrqjIMVAOAGBPOa30hx8OiED3FC11AIB/ydm4pWpVafduqWxZqysqFrTUAQD288ILZuT7gw8GTKB7ipY6AMB//P67VKeO2YVt796AWuedljoAwF5efFFyOqX77w+oQPeUx6EeFxenli1bKigoSN27d899/PDhwxo4cKBq1KihihUrKioqSp988sl5n6tOnToqV66cgoODFRwcrFC+MQCACzl+XHr1VdNKHzPG6mp8ksehHhERoQkTJmjYsGF5Hk9LS1NUVJS++eYbnTx5UpMmTVL//v21bdu28z7fBx98oLS0NKWlpenkyZOFKh4AEEBmzjQ7sg0ZIlWrZnU1PqmUpyf26NFDkpSUlKTk5OTcxy+//HKNGzcu9+1u3bqpYcOG+uabb9S4cWMvlgoACFhpadKMGWb62sMPW12Nz/L6NfXDhw/rp59+UtOmTc973vDhw1WlShW1bt1aiYmJ3i4DAGAnr79uut8HDDAD5ZAvr4a60+lUv3791KdPH7Vs2fKc573zzjvatWuX9u/fr+joaPXs2VMbNmw473PHxMTI4XDkHgCAAHHmjJnGJrFxywV4LdSdTqd69eql8uXL64033jjvuW3btlX58uUVFBSkAQMGqFu3bvrPf/5z3o+JiYmR2+3OPQAAAeLtt81UtjvukLise14eX1M/H6fTqd69e8vpdOrjjz9WmTJlCvTxJUowsw4AkA+X6+ySsI8/bm0tfsDjUHe5XLlHdna2MjIyVKJECTkcDvXp00enT5/WZ599pqCgoPM+z969e7V7925de+21KlGihBYtWqSPP/5YX3311UV/MgAAm5k/X9q5U7r5Zumaa6yuxud53ESOjY1VuXLlNHnyZH366acqV66cOnXqpLVr1+rjjz/WmjVrVKVKldy551OmTMn92CZNmui9996TZKbAjR49WpUrV9Yll1yiF154QR9++KFatWrl/c8OAOC/srOlyZPN/fHjra3FT7BMLADANy1cKPXuLbVpI61cGfB7pnuSe4Q6AMD3uN1SVJS0ebP03/9KnTtbXZHlWPsdAOCfPv/cBPo110idOlldjd8g1AEAvsXtlp55xtyfMCHgu90Lgu53AIBvWbrUtM6bNZM2bSLU/x/d7wAA/5PTSn/iCQK9gGipAwB8x8qVUrt20pVXSj/+KLE4WS5a6gAA/zJxorkdP55ALwRa6gAA37BqlXTDDdIVV0jbtkmlvLKSuW3QUgcA+I+cVvqTTxLohURLHQBgvdWrpbZtpfr1pZ9+ItTzQUsdAOAfclrpEyYQ6BeBljoAwFpr10rXXy/Vqyf9/DOhfg601AEAvo9WutfQUgcAWGfdOum666TLL5e2byfUz4OWOgDAt8XEmNsnniDQvYCWOgDAGjkj3rmW7hFa6gAA3/X002dvCXSvoKUOACh+K1ZIHTpIDRuaNd4J9QuipQ4A8D1ut/TUU+Y+rXSvoqUOAChey5ZJN98sNW4sbdkilSxpdUV+gZY6AMC3/LmVHhNDoHsZLXUAQPH573+lrl2lq6+WkpLYXrUAaKkDAHyH2212YJPMKnIEutfxFQUAFI/Fi6WNG6UWLaTu3a2uxpbofgcAFL2sLKlZM2nrVtMF37mz1RX5HbrfAQC+Yd48E+ht20qdOlldjW3RUgcAFK3MTKlRI2nnTmnlShPsKDBa6gAA6731lgn0Ll0I9CJGSx0AUHQyMqQrrpCSk88OkkOh0FIHAFgrPt4Eeo8eBHoxoKUOACgap05Jl18uHTsm/fCD1KSJ1RX5NVrqAADrTJsmHT0q3XUXgV5MaKkDALzv8GGpXj3J6ZR++UWqXdvqivyeV1vqcXFxatmypYKCgtT9LysBpaamasCAAapYsaIuvfRSPfPMM+d9roKeDwDwM5MnS2lp0siRBHox8ngT24iICE2YMEHLli1TcnJynvdFR0fr+PHj2rt3rw4fPqyOHTuqdu3auuuuu/J9roKeX+R27pSOHJGuvdaa1wcAO9m9W3r1VSkkRBo/3upqAorHod6jRw9JUlJSUp5QT09P17x587RmzRqFhoYqNDRU0dHRSkhIyDekC3p+kdu+3ewWVK+eGchRyuMvCQAgP089ZRacmTBBuuQSq6sJKBc9UG779u1yOp2KjIzMfSwyMlJbtmzxyvk5YmJi5HA4cg+vadBAatNG+vlns0ACAKDwtmyR3n3XhPmYMVZXE3AuOtTT0tJUoUIFlfpTCzc0NFSnTp3yyvk5YmJi5Ha7cw+vcTikf//b3H/6aen0ae89NwAEmvHjzRarEyaY7ncUq4sO9eDgYKWnp8vlcuU+lpKSopBzfDMLen6xaNlS6ttX+v136aWXrKsDAPzZ119Ln38u1akjDR9udTUB6aJDvWHDhipdurQ2b96c+1hSUpKuvvpqr5xfbCZPNtfTp0418yoBAJ5zu6WHHzb3p0yRgoKsrSdAeRzqLpdLGRkZcrlcys7OVkZGhpxOp8qXL6++ffvqySefVEpKin799VfNnDlTQ4cOzfd5Cnp+salXTxoxwqyAFBtrbS0A4G8WLJA2bDBLwfbta3U1gcvtoaefftotKc/Rrl07t9vtdqekpLj79evnDg4Odl9yySXuiRMn5vnYLl26uCdPnpz79oXO90QBSvfcoUNud3Cw2126tNv922/ef34AsKMzZ9zuyy93uyW3e/lyq6uxLU9yjxXl/uqZZ8x0jP79pfff9/7zA4DdzJwpjR4tde0qJSZaXY1teZJ7hPpfpaWZbQIPHjRdSS1bev81AMAuUlKk+vXNpi2bN5t1P1Ak2NClMIKDpUmTzP2xY83gDwBA/v79bzO4+J57CHQfQEs9Py6XFBkpbd0qLV4s3X570bwOAPizffukhg1N4+fXX6UaNayuyNZoqRdWqVLS88+b+488YpY7BADk9cQT0h9/SA89RKD7CFrq5+J2S507S0uXSnFx0gMPFN1rAYC/+e47M+aoalVpxw5WjysGDJS7WJs3S1FRUuXK5oe2UqWifT0A8Adut9Shg1lBLj6e1eOKCd3vF6tZMzP44+hR6bnnrK4GAHzDJ5+YQG/cWBoyxOpq8Ce01C9k/36zk1tWltnJrU6don9NAPBVmZnSVVdJv/xi5qR37Wp1RQGDlro3XHaZWc/4zBnp0UetrgYArBUfbwK9UyepSxerq8Ff0FL3xOnTZtrG/v3S6tXS9dcXz+sCgC85ccIsNHPypJSUxLz0YkZL3VsqVDh7Tf3BB6XsbEvLAQBLTJwoHT9urqMT6D6JlrqnsrOl1q2l9eult9+W7rqr+F4bAKz2888myMuXNwvNVK1qdUUBh5a6N5UoIb30krn/+ONmjXgACBQPPWRW23zySQLdhxHqBdG6tdSvn3TggFnvGAACwRdfmKN+fbMbG3wW3e8FtWeP1KiRuf/zz1Lt2sVfAwAUl8xMqWlT8/eOvTAsRfd7Uahd20xxy8gwtwBgZ7NmmUC/6SbpttusrgYXQEu9ME6fNq315GTpyy/NcokAYDdHj0pXXCGlpjKFzQfQUi8qFSpIL7xg7o8ebQaPAIDdPPGEmZM+fDiB7idoqReW2y21by+tXMkubgDs5/vvzS5sYWFmBbnKla2uKOCxS1tR27xZat7c7N7266/80AOwB7dbatNGWrtWevVVacQIqyuC6H4ves2amW6pEyfM3E0AsIN33zWBHhUlDRtmdTUoAFrqF+vYMTOQJCVF2rjR/BIAgL9KTTV7XRw8yF4XPoaWenGoXFmKjTXLyI4axbrwAPxbbKwJ9EGDCHQ/REvdG7KypGuukTZtkt56S7rnHqsrAoCC+/lns9BMUJC0fbsUEWF1RfgTWurFpWRJ6ZVXzP1HHjFTQADAn7jdZhZPZqb01FMEup8i1L2ldWvp3nulI0cYNAfA/8yfbxbTatzYbDENv0T3uzcdOSI1aGAGmnz3nRQZaXVFAHBhp06ZwXG//y599ZVZgwM+h+734nbJJdLkyWaw3AMPMGgOgH+IiTGBPnAgge7naKl7258Hzc2eLQ0ebHVFAHBuP/xgpuJWqGAGylWvbnVFOAda6lYoWdLsauRwmF3cjh2zuiIAyF/O4LisLGnSJALdBgj1otCqlXTffSbQH33U6moAIH9vvy2tWmVWx2T/Clug+72onDhhBp4cOWJ+adq0sboiADjr6FGzhfSxY2ZJ2Natra4IF1Cs3e/BwcF5jtKlS6tp06bnPP+ee+5RmTJl8nzMunXrvFWO9cLCpBdfNPdHjDBzPwHAVzzyiAn04cMJdBvxWqinpaXlOa688kr169fvvB8zcuTIPB/T2m4/WAMHSh06SFu3StOnW10NABgrV5rVL6tWlZ591upq4EVFck19/fr12rZtm+4J9OVSHQ6zbWGZMmbKyO7dVlcEINCdOWNa55JpbISFWVsPvKpIQj0hIUFdu3ZVxAWWGZw7d67Cw8PVpEkTTZs2Tdl2nNfdsKEZLPfHH9LIkWa0KQBY5fnnzdS1m2+W+ve3uhp4mddD/fTp05o3b56GDh163vNGjx6t7du368iRI0pISNDLL7+sl19++Zznx8TEyOFw5B5+Zfx4sz3rF1+YpRgBwAo7dphd2IKCzk69ha14ffT7nDlz9Pjjj2vfvn0qVaqUxx83a9YszZ07V998841H5/v86Pe/WrHCXF+vWlX66ScpPNzqigAEErdb6tjRrO/+zDPShAlWV4QCsmTxmTfffFN33313gQJdkkqUsPmU+fbtzYYvhw+bUacAUJzmzDGB3qQJf4NszKtJun37dq1du1ZDhgy54LkffvihUlNT5Xa7tXHjRj333HPq2bOnN8vxPc8/b1rqCQmm5Q4AxeHQIWnsWNPd/uabZvAubMmroZ6QkKC2bdvqiiuu+Nv7RowYoREjRuS+HRcXp1q1aikkJEQDBw7UyJEjNXbsWG+W43vCw6WccQP33SdlZFhbD4DA8K9/mQWxoqPNipewLVaUK25ut3TrrVJiohlAN3my1RUBsLPPPpO6dZNq1jRrZoSEWF0RCsmT3CPUrbBnj3TVVWaa24YNZockAPC2U6ekxo2l5GQT7rfcYnVFuAjs0uarateWnnvO7Ix0770sIQugaDz2mAn0/v0J9ABBS90q2dlmRPyqVaYLfvx4qysCYCc502grV5a2bTODdOHX6H73db/8YrY8zM6WNm0y3WQAcLFOn5aaNpV27pQ++EC6wD4c8A90v/u6Bg2kSZMkp1MaMsR0xwPAxZowwQT67bdLfftaXQ2KES11q7lcZtvDjRvNVq1jxlhdEQB/tmaN1LatVKmS6XavXt3qiuAldL/7ix9+kFq0kEqVkpKSTAseAArqjz+kyEhzaW/OHOnuu62uCF5E97u/uPpq6emnzS/kPffQDQ+gcJ5+2gR6167SXXdZXQ0sQEvdV/y5G/7556Vx46yuCIA/WbtWatPGLC7z449msRnYCt3v/mbbNrMQjcNhRsNfeaXVFQHwB6dPm273HTvodrcxut/9TePGZkvEM2dMN7zLZXVFAPzBY4+ZQO/WjW73AEdL3ddkZZkutG++kaZMkR5/3OqKAPiyL7+UbrrJbBi1datUrZrVFaGI0P3ur7ZvN11pWVnS+vXmPgD8VWqqGWi7d680f77Up4/VFaEI0f3urxo2lKZONWvCDxrEFq0A8jdmjAn0Pn0IdEiipe67srOlzp2lZcukhx6Spk2zuiIAvmTxYumOO0x3+w8/SFWqWF0Rihjd7/4uOdl0raWkSMuXm80ZAODgQfO34ehRKTHRzEuH7dH97u9q1JBmzZLcbjNFJSXF6ooAWM3tNls2Hz0qPfAAgY48CHVf17+/2WFp3z5p1CirqwFgtVdflb74QmrUSPr3v62uBj6G7nd/cPy42UZx/37p/fdN0AMIPNu3mwWqMjPNtNcWLayuCMWI7ne7CA+X5s41K82NGCHt3m11RQCKm9MpDRxo9oiYOJFAR74IdX9x443SI4+YeamDBrHaHBBonnhC+u47szjVo49aXQ18FN3v/sTplK67zvxiT5woPfWU1RUBKA5LlpgprqGh0ubNUq1aVlcECzClzY5++UVq3twsSLNypQl5APZ1+LAZU3PokLRggdSrl9UVwSJcU7ejBg2kGTPMErIDB0onT1pdEYCi4nZLgwebQB86lEDHBRHq/mjwYLMk5O7d0rBh5hcfgP3MmGEWl2nYUHrpJaurgR+g+91fpaSYqS27dpkFau6/3+qKAHjTd9+dvbz2zTfm9x0Bje53O6tUSZo3TypVymzqsHmz1RUB8JaUFNMb53RKL7xAoMNjhLo/+8c/zG5uZ86YPwBpaVZXBOBiud3mstrOnVKPHqwkiQIh1P3dmDHSLbeYUfEjR3J9HfB38fFmlHudOlJCgll0CvAQ19Tt4OhRKTLSLCP75pvSkCFWVwSgMJKSpFatzNbLq1eb3jjg/3FNPVBUqWKur5csaXZtSkqyuiIABZVzHf3MGbNRC4GOQiDU7aJNm7PX13v1YptWwJ/kzEf/9Vfp9tulf/3L6orgpwh1O3noIal7d+m338wfCC5PAP5h2jRp0SKpXj1pzhyuo6PQvBbq99xzj8qUKaPg4ODcY926dec8PzMzU6NGjVJYWJjCw8MVHR0tF5uUXByHQ3rrLfOHYdEiafp0qysCcCErV0qPPSaVLSv95z9mfXegkLzaUh85cqTS0tJyj9atW5/z3NjYWK1evVrbtm3T1q1btWrVKk2ZMsWb5QSm0FBp4UIpKMjs6rZypdUVATiX33+X+vY1yz7Hx0vNmlldEfycZd3vs2fP1oQJE1S9enVVr15dTzzxhBISEqwqx14iI6VXXzV/KHr3NqPiAfiWzEypXz/p4EEzL/3uu62uCDbg1VCfO3euwsPD1aRJE02bNk3Z2dn5nnfixAklJycrMjIy97HIyEjt3btXKecY4BUTEyOHw5F74AIGD5ZGjDA7PPXsaQbQAfAd48aZnrTmzc0a74AXeG2e+vfff6+aNWsqPDxcGzZsUJ8+fTRmzBiNGTPmb+fu27dPtWrV0pEjR1SlShVJ0pEjR1S1alXt27dPNWrUuHDhzFO/MKdTat9eWrdOuu8+6bXXrK4IgCTNnWta5lWqSBs3SrVrW10R/ECxzlNv3ry5LrnkEpUsWVKtWrXSY489pvnz5+d7bnBwsCTlaZXn3A8JCfFWSShTxlxfv/RS6fXXzcI0AKy1caP5J7tkSenDDwl0eFWRXVMvUeLcTx0WFqYaNWoo6U+LpCQlJalmzZqqVKlSUZUUmCIiTLCXKmUWpvnmG6srAgLX4cPSHXeYy2EvvCB16GB1RbAZr4X6hx9+qNTUVLndbm3cuFHPPfecevbsec7zBw8erMmTJ+vgwYM6ePCgpkyZoqFDh3qrHPxZmzZmL2an0/xBSU62uiIg8GRmmhXjkpOlQYNYYAZFwmvX1G+44QZt2bJFLpdLl112mYYMGaJx48bltthHjBghSYqPj5dk5qk/+OCDev/99yVJgwYN0vTp01WqVCnPCueaesG43Wbg3OuvSy1aSKtWSeXKWV0VEBjcbun++824lubNzbru/P6hgDzJPTZ0CSROp3TzzWbEbb9+0vvvs3IVUBzi4qToaDO+ZcMGqWZNqyuCHyLU8XdHjkjXXCPt2SNNmSI9/rjVFQH2tnSp1LWrGdeyYoXZhQ0oBEId+duyRbruOik9XfroI7NePADv++UX6dprpZMnpXfeMdfSgUJi61Xkr2lT8wfG7ZYGDpS++87qigD7OXFC6tbNBPpjjxHoKBaEeqC64w6zVWt6uvnDs2+f1RUB9uF0Sj16mJb67bdLkydbXRECBKEeyB5+WBo61Gwq0a2bdOqU1RUB/s/tNr9XK1ZIUVHSu+9K51m3A/AmftICmcMhzZol3XSTtHmz1L+/xPa3wMV55hlzeatmTemzz6T/X0ETKA4MlIO55te6tfTzz9LIkWb6DVPdgIJ7913pzjulkBAzF71pU6srgo0wUA6eCQ2VPv9cqlrVtNynTrW6IsD/rFgh3XuvWdN9wQICHZYg1GFcfrkJ9goVzNz1d96xuiLAf2zZYgbEZWaaf4w7d7a6IgQoQh1ntWxpWhglS5oWx7JlVlcE+L49e6QuXaTUVOnJJ80ObIBFuKaOv5s9WxoyxFwXXLlSioy0uiLANx07ZjZM+vln8zvzxhuMR0GR4Zo6Cufee6WYGDPFrUsXaccOqysCfE/OGg8//yzdeqsUH0+gw3K01JE/t9vsv/7qq1KdOtKaNWZvdgBntzFOTDRruS9fLpUvb3VVsDla6ig8h0OaOVPq21favdsM/Dl+3OqqAOtlZUl33WUCvXFjMxedQIePINRxbiVLSnPnmkD/8UfTxXj6tNVVAdZxu81aDvPnmx6sJUukypWtrgrIRajj/MqUkf7zH9PFuG6d6XLMyLC6KsAajz8uvf66VK2amR1y2WVWVwTkQajjwipUMHPYr77a7A3du7e5pggEkmefNQszhYWZFnq9elZXBPwNoQ7PhIeblkmjRuYa4sCBrBOPwDFtmjR+vPkHNzHR/IML+CBCHZ6rWtWM8q1XT1q4UBo82AwaAuxs5kxp3DipXLmzo90BH0Woo2AiIkyw16plNq+47z4pO9vqqoCiER8vjR4tlS0rffqpdMMNVlcEnBehjoKrXdsEe0SEWX1u2DCCHfaTkCDdf78ZLLp4sdmiGPBxhDoKp359syvVZZedXVaWrnjYxWuvSUOHSqVLm9kfbNACP0Goo/CuuOJssM+ZQ7DDHl55RRoxwrTQP/rIrM8A+AlCHRcnp8Veo4b09tvSPfcwKh7+66WXpFGjpKAg6eOPCXT4HUIdFy8n2GvWNIPn+vaVzpyxuiqgYP79b2nMmLOD4rp0sboioMAIdXhHvXrSqlUm4D/6SLr9drOLFeDr3G7piSekRx81a7gnJko332x1VUChsEsbvOv336VOncxa8W3bmhZPpUpWVwXkLztbio6WZs0yP6eJidJ111ldFZAvT3KPUIf3HTtmui43bpRatDB/KKtWtboqIK/MTLOA0nvvmZ/PJUukZs2srgo4J0Id1klNlbp1k1auNF3y//ufdPnlVlcFGOnpZuzHZ5+ZhZSWLTOzOQAfxn7qsE7FiibI77hD2rHDdGlu2mR1VYB05Ih0440m0Bs1klavJtBhG4Q6ik7ZstKCBdLw4dKhQ1K7dtKXX1pdFQLZzp3S9ddL335r/tFcs8bM2gBsglBH0SpZUnr1VSkmRjp1ylxrf+cdq6tCIPr+exPkv/4qde9uutzDw62uCvAqQh1Fz+GQnn7aLL2ZnS3ddZd5mzERKC6ffGI2Yzl0SBo50uwyWK6c1VUBXue1UD9z5oyGDRumunXrKiQkRI0aNdLs2bPPeX779u0VFBSk4ODg3OPAgQPeKge+6L77pM8/l0JCpEmTpDvvZJEaFC232+yF3r27dPq09OyzUlyc6UECbMhroe5yuVS9enUtW7ZMqampmjNnjsaOHaslS5ac82OmTp2qtLS03CMiIsJb5cBXde589jrme++ZRT6OHLG6KthRZqYZzzFunBnfsXCh9NhjpucIsCmvhXqFChU0adIk1atXTw6HQ61atVKHDh20evVqb70E7OLqq81ApZYtzSp011wjJSVZXRXsJGethDfekKpVM1Mre/a0uiqgyBXZNfWMjAytX79eTZs2Pec5sbGxCg8PV1RUlObOnXve54uJiZHD4cg94OeqV5e+/lrq10/as8eMSF6wwOqqYAdJSeYfxi+/NIvJrF9v3gYCQJEsPuN2u3XnnXdq//79Wr58uUqU+Pv/DuvWrVPjxo1Vvnx5ffnll+rTp4/mzJmjO+64w7PCWXzGHtxus5HG44+fXYN74kSueaJwPvjAbAH8xx9Snz7S7NlShQpWVwV4hSUryrndbo0cOVIbN27UsmXLVMnDdb8feeQR7d27V/PmzfPofELdZhITpf79zUp0nTqZ6+1VqlhdFfyFy2X+MXzhBalECTMg7uGHuX4OWyn2FeXcbrceeOABffvtt1qyZInHgS4p39Y8Asg//2m6SZs0MWtwN29urrsDF7J/v1kh7oUXpLAw6YsvpEceIdARkLyapKNGjdKaNWu0dOlShYWFnfO8kydPKjExUenp6crKytLy5csVHx+vngxkCWwNG5ogHzhQ2rfP7PI2cybz2XFuS5dKUVFmwGXz5mYToU6drK4KsIzXut/37NmjOnXqKCgoSKVKlcp9fNCgQYqPj1fXrl3Vtm1bjR8/XkeOHNGtt96qn376SZJUp04dPfjgg7r33ns9L5zud/tyu81CNf/6l+R0Sj16mFHMrP6FHFlZZq2DZ54xPy8jR5r56GXLWl0ZUGTYpQ3+bcMGMzp+506pRg3p3XfN+vEIbLt3m4WLVq+WgoOlN980O64BNscubfBv11xjdnYbNEhKTjbXTZ96ygyKQmB6/30zTW31aqlFC+m77wh04E8Idfi2ihXNBjBz50rly5vu1uuuk/7/0g0CxMmT5p+7gQPNxkCPPSatXSs1aGB1ZYBPofsd/mPHDrMZzLp1UlCQNGWKue7OnHZ7S0yUhg2TDhwwl2HeeUdq397qqoBiR/c77KV+fTPKeepUMzhq7FipQwcT9rCfkyelwYOlW24xgX7nndKWLQQ6cB601OGffvzRtNo3bTIjnp9+2oR86dJWVwZv+PhjM6L9wAGzdvvrr0vdulldFWApWuqwr6uuMnPan3nG7NH++ONm4BQL1vi3vXul2283W6XmtM63biXQAQ8R6vBfpUtLEyaYLtl27aQffpBat5YeeEA6ftzq6lAQLpf04otS48bSJ59Il18u/fe/ZoAk6xMAHiPU4f8aNpS++srMVw4NlWbNMqOiX3vNLFIC37ZsmRQZaS6fnDkjjR9vLq907mx1ZYDf4Zo67OXoUbPT2xtvmMF0UVHSyy+bJWfhW3bsMEH+ySfm7XbtpFdeMev/A/gbrqkj8FSpYlroGzaYrvhNm6QbbjDXaZnb7huOHjVhntPVXqeOtHCh6W0h0IGLQksd9pWdbVYgmzBB2rPHbMk5ZIgUEyNFRFhdXeBJS5OmT5eef94sIFOhgulqf+gh1mwHPMDa74AkZWSYbt3Jk6UTJ0yADB8uPfqoVL261dXZX3q6mZL27LPS4cNmgOPw4eYySbVqVlcH+A1CHfizEyfMwjVxcdLp02ZVupxwp+XufadOSa++anZPO3zY7G8+YIDZXe3yy62uDvA7hDqQnyNHTNDkhHuZMmZN8XHjzHVeXJzDh02Yz5hhphY6HFKfPqZlfvXVVlcH+C1CHTifI0fM3OhZs6TUVPPYP/95dvlZh8Pa+vzNjz9KL71ktsg9c8asyT9woLlu3rCh1dUBfo9QBzyRmmrmuL/0krRvn3msUSNpxAjp7rvN3Hfkz+k0S7q+9pq0fLl5LCTEDEgcPVqqW9fa+gAbIdSBgsjMlBYsMN3y69aZx8qVk/r1M+Hetq0ZQQ/pl1/MP0Jz5pgeD8lMTRs9Wrr3XqlSJSurA2yJUAcKa/Nmc1343XfNdXdJql3b7Ol9552B2Z38++/S/PlmmuCGDeaxkiWlW2+V7rvPrADHNrhAkSHUgYuVmmoWRpk7V/r667OPX3WV1KOHOZo2te/19z17zAIxixdLK1aYuf+SWYb3zjtNq5yZA0CxINQBb9q927Tc5883g8Jy1K0rde0qdepkBthVrGhZiRfN6TQ73S1dasJ88+az76teXerf30xLa97cvv/IAD6KUAeKyi+/SIsWSR99JK1ff/bxUqXM8rRt20pt2pj7vjzQLiPDLKW7dq0Z6LZy5dnLDZJpkd9+u3TbbeZzoXsdsAyhDhSHgwdNy/Z//5OWLDk7cEwyrdkmTcxe782amd3ImjWzZjvRtDSzN/mPP0pJSaZFnpRkBgjmCA42G6vcdJOZ3heIYwcAH0WoA8UtO9uE5po1Z4/du/9+3iWXSFdcIdWvb46aNc2SqdWrm9vwcLOcqqeyssxCL0eOmOP336Vdu84eO3acu45WraRrrzWXDq65pmCvC6DYEOqALzh40LSIk5LMNerNm6XffjPXr8+nbFkz5zskxNx3OMyUOofDhHh6ujn++MO0wnMGseXH4TBLs1511dnj2mvNNDSujQN+gVAHfFVWlpScbFrQO3ZI+/eb1vXBg+b2xAmzdnpqqlmd7VzKlDFz6UNCTKu7alVzW62aCey6dc1Ru7ZUvnyxfXoAvI9QB+zA6TSH222O7GwzYK1cOTMwD0BAINQBALAJT3KPNS8BALAJQh0AAJsg1AEAsAlCHQAAmyDUAQCwCa+GemZmpkaNGqWwsDCFh4crOjpaLpfros8FAAAX5tVQj42N1erVq7Vt2zZt3bpVq1at0pQpUy76XAAAcGFenades2ZNTZ8+Xb169ZIkLViwQOPGjdOePXsu6tx8C2eeOgAggBTrPPUTJ04oOTlZkZGRuY9FRkZq7969SklJKfS5OWJiYuRwOHIPAACQl9dCPS0tTZIU+qe9o3Punzp1qtDn5oiJiZHb7c49AABAXl4L9eDgYEnK09LOuR8SElLocwEAgGe8FuphYWGqUaOGkpKSch9LSkpSzZo1ValSpUKfCwAAPOPVLZ4GDx6syZMn6/rrr5ckTZkyRUOHDr3oc8+Fa+sAAJzl1VB/8skndezYMV155ZWSpEGDBmn8+PGSpBEjRkiS4uPjL3iuJ6y6rs6oe2vx9bce3wNr8fW3ni9/D/x261Wr+PI3MxDw9bce3wNr8fW3ni9/D1gmFgAAmyDUC+jpp5+2uoSAxtffenwPrMXX33q+/D2g+x0AAJugpQ4AgE0Q6gAA2AShDgCATRDqAADYBKEOAIBNEOqF8Pnnn+uGG25QWFiYqlatql69eik5OdnqsgLG77//rttuu00RERFyOBx59hBA0cnMzNSoUaMUFham8PBwRUdHy+VyWV1WwIiLi1PLli0VFBSk7t27W11OwDlz5oyGDRumunXrKiQkRI0aNdLs2bOtLutvCPVCSElJ0aOPPqp9+/Zp165dqlixovr06WN1WQGjRIkS6tKlixYvXmx1KQElNjZWq1ev1rZt27R161atWrVKU6ZMsbqsgBEREaEJEyZo2LBhVpcSkFwul6pXr65ly5YpNTVVc+bM0dixY7VkyRKrS8uDeepesGXLFkVFRenMmTMqVcqry+njAhwOhzZt2qTIyEirS7G9mjVravr06erVq5ckacGCBRo3bpz27NljcWWBJSYmRklJSfxT6wN69Oihq666SpMmTbK6lFy01L3g66+/1pVXXkmgw7ZOnDih5OTkPP88RUZGau/evUpJSbGuMMAiGRkZWr9+vZo2bWp1KXkQ6n9x6623yuFwnPPYvXt3nvM3bdqkJ598UtOnT7emYJsp6NcfxSMtLU2SFBoamvtYzv1Tp05ZUBFgHbfbraFDh+qKK65Qjx49rC4nD5qWf/H+++/L6XSe8/3h4eG593/44Qd17dpVcXFxuvnmm4ujPNsryNcfxSc4OFiSGU9SpUqV3PuSFBISYlldQHFzu90aOXKktm/frmXLlqlECd9qGxPqf1GxYkWPzvvhhx/UsWNHPffccxo0aFARVxU4PP36o3iFhYWpRo0aSkpKUr169SRJSUlJqlmzpipVqmRxdUDxcLvdeuCBB/Ttt99q+fLlPvmz71v/YviJrVu3qmPHjoqNjdXgwYOtLicgZWRkKCMjQ5LkdDqVkZGh7Oxsi6uyt8GDB2vy5Mk6ePCgDh48qClTpmjo0KFWlxUwXC6XMjIy5HK5lJ2drYyMjPP2asH7Ro0apTVr1mjp0qUKCwuzupx8Mfq9EAYPHqy3335b5cuXz/P4tm3bVKtWLYuqCiwOh+Nvj3311Vdq37598RcTIDIzM/Xggw/q/ffflyQNGjRI06dPZ4BoMYmJidHEiRPzPNauXTutWLHCmoICzJ49e1SnTh0FBQXl+ZkfNGiQ4uPjLawsL0IdAACboPsdAACbINQBALAJQh0AAJsg1AEAsAlCHQAAmyDUAQCwCUIdAACbINQBALAJQh0AAJsg1AEAsIn/Ax6SX0skcma/AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def f(x): return 3*x**2 + 2*x + 1\n", + "\n", + "plot_function(f, \"$3x^2 + 2x + 1$\")" + ] + }, + { + "cell_type": "markdown", + "id": "a6666634", + "metadata": { + "papermill": { + "duration": 0.053733, + "end_time": "2022-08-25T20:07:37.488295", + "exception": false, + "start_time": "2022-08-25T20:07:37.434562", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "This quadratic is of the form $ax^2+bx+c$, with parameters $a=3$, $b=2$, $c=1$. To make it easier to try out different quadratics for fitting a model to the data we'll create, let's create a function that calculates the value of a point on any quadratic:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "baa04765", + "metadata": { + "papermill": { + "duration": 0.060896, + "end_time": "2022-08-25T20:07:37.601523", + "exception": false, + "start_time": "2022-08-25T20:07:37.540627", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "def quad(a, b, c, x): return a*x**2 + b*x + c" + ] + }, + { + "cell_type": "markdown", + "id": "b766ac5c", + "metadata": { + "papermill": { + "duration": 0.052339, + "end_time": "2022-08-25T20:07:37.705955", + "exception": false, + "start_time": "2022-08-25T20:07:37.653616", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "If we fix some particular values of a, b, and c, then we'll have made a quadratic. To fix values passed to a function in python, we use the `partial` function, like so:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "73e48914", + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-25T20:07:37.813312Z", + "iopub.status.busy": "2022-08-25T20:07:37.812714Z", + "iopub.status.idle": "2022-08-25T20:07:37.817252Z", + "shell.execute_reply": "2022-08-25T20:07:37.816351Z" + }, + "papermill": { + "duration": 0.061101, + "end_time": "2022-08-25T20:07:37.819613", + "exception": false, + "start_time": "2022-08-25T20:07:37.758512", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "def mk_quad(a,b,c): return partial(quad, a,b,c)" + ] + }, + { + "cell_type": "markdown", + "id": "04a3095c", + "metadata": { + "papermill": { + "duration": 0.053165, + "end_time": "2022-08-25T20:07:37.924738", + "exception": false, + "start_time": "2022-08-25T20:07:37.871573", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "So for instance, we can recreate our previous quadratic:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "ac501308", + "metadata": { + "papermill": { + "duration": 0.217053, + "end_time": "2022-08-25T20:07:38.194697", + "exception": false, + "start_time": "2022-08-25T20:07:37.977644", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'mk_quad' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[11], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m f2 \u001b[38;5;241m=\u001b[39m \u001b[43mmk_quad\u001b[49m(\u001b[38;5;241m3\u001b[39m,\u001b[38;5;241m2\u001b[39m,\u001b[38;5;241m1\u001b[39m)\n\u001b[1;32m 2\u001b[0m plot_function(f2)\n", + "\u001b[0;31mNameError\u001b[0m: name 'mk_quad' is not defined" + ] + } + ], + "source": [ + "f2 = mk_quad(3,2,1)\n", + "plot_function(f2)" + ] + }, + { + "cell_type": "markdown", + "id": "cd409866", + "metadata": { + "papermill": { + "duration": 0.053255, + "end_time": "2022-08-25T20:07:38.302893", + "exception": false, + "start_time": "2022-08-25T20:07:38.249638", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "Now let's simulate making some noisy measurements of our quadratic `f`. We'll then use gradient descent to see if we can recreate the original function from the data.\n", + "\n", + "Here's a couple of functions to add some random noise to data:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "1ad970e9", + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-25T20:07:38.420964Z", + "iopub.status.busy": "2022-08-25T20:07:38.420337Z", + "iopub.status.idle": "2022-08-25T20:07:38.425847Z", + "shell.execute_reply": "2022-08-25T20:07:38.425170Z" + }, + "papermill": { + "duration": 0.065291, + "end_time": "2022-08-25T20:07:38.428511", + "exception": false, + "start_time": "2022-08-25T20:07:38.363220", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "def noise(x, scale): return np.random.normal(scale=scale, size=x.shape)\n", + "def add_noise(x, mult, add): return x * (1+noise(x,mult)) + noise(x,add)" + ] + }, + { + "cell_type": "markdown", + "id": "e40b2620", + "metadata": { + "papermill": { + "duration": 0.053241, + "end_time": "2022-08-25T20:07:38.534864", + "exception": false, + "start_time": "2022-08-25T20:07:38.481623", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "Let's use the now to create our noisy measurements based on the quadratic above:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "0b6ded02", + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-25T20:07:38.643829Z", + "iopub.status.busy": "2022-08-25T20:07:38.643229Z", + "iopub.status.idle": "2022-08-25T20:07:38.663046Z", + "shell.execute_reply": "2022-08-25T20:07:38.662166Z" + }, + "papermill": { + "duration": 0.077566, + "end_time": "2022-08-25T20:07:38.665781", + "exception": false, + "start_time": "2022-08-25T20:07:38.588215", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "np.random.seed(42)\n", + "\n", + "x = torch.linspace(-2, 2, steps=20)[:,None]\n", + "y = add_noise(f(x), 0.15, 1.5)" + ] + }, + { + "cell_type": "markdown", + "id": "5b4124ee", + "metadata": { + "papermill": { + "duration": 0.053058, + "end_time": "2022-08-25T20:07:38.774839", + "exception": false, + "start_time": "2022-08-25T20:07:38.721781", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "Here's the first few values of each of `x` and `y`:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "3051094d", + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-25T20:07:38.884832Z", + "iopub.status.busy": "2022-08-25T20:07:38.884552Z", + "iopub.status.idle": "2022-08-25T20:07:38.939146Z", + "shell.execute_reply": "2022-08-25T20:07:38.938247Z" + }, + "papermill": { + "duration": 0.111613, + "end_time": "2022-08-25T20:07:38.941649", + "exception": false, + "start_time": "2022-08-25T20:07:38.830036", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(tensor([[-2.0000],\n", + " [-1.7895],\n", + " [-1.5789],\n", + " [-1.3684],\n", + " [-1.1579]]),\n", + " tensor([[11.8690],\n", + " [ 6.5433],\n", + " [ 5.9396],\n", + " [ 2.6304],\n", + " [ 1.7947]], dtype=torch.float64))" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x[:5],y[:5]" + ] + }, + { + "cell_type": "markdown", + "id": "c8d53d17", + "metadata": { + "papermill": { + "duration": 0.053861, + "end_time": "2022-08-25T20:07:39.052282", + "exception": false, + "start_time": "2022-08-25T20:07:38.998421", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "As you can see, they're *tensors*. A tensor is just like an `array` in numpy (if you're not familiar with numpy, I strongly recommend reading [this great book](https://wesmckinney.com/book/), because it's a critical foundation for nearly all numeric programming in Python. Furthermore, PyTorch, which most researchers use for deep learning, is modeled closely on numpy.) A tensor can be a single number (a *scalar* or *rank-0 tensor*), a list of numbers (a *vector* or *rank-1 tensor*), a table of numbers (a *matrix* or *rank-2 tensor*), a table of tables of numbers (a *rank-3 tensor*), and so forth.\n", + "\n", + "We're not going to learn much about our data by just looking at the raw numbers, so let's draw a picture:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "29bed640", + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-25T20:07:39.162259Z", + "iopub.status.busy": "2022-08-25T20:07:39.161887Z", + "iopub.status.idle": "2022-08-25T20:07:39.371161Z", + "shell.execute_reply": "2022-08-25T20:07:39.369887Z" + }, + "papermill": { + "duration": 0.267753, + "end_time": "2022-08-25T20:07:39.373934", + "exception": false, + "start_time": "2022-08-25T20:07:39.106181", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(x,y);" + ] + }, + { + "cell_type": "markdown", + "id": "70935a05", + "metadata": { + "papermill": { + "duration": 0.054997, + "end_time": "2022-08-25T20:07:39.485480", + "exception": false, + "start_time": "2022-08-25T20:07:39.430483", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "How do we find values of a, b, and c which fit this data? One approach is to try a few values and see what fits. Here's a function which overlays a quadratic on top of our data, along with some sliders to change a, b, and c, and see how it looks:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "6f2e3097", + "metadata": { + "papermill": { + "duration": 0.25987, + "end_time": "2022-08-25T20:07:39.800933", + "exception": false, + "start_time": "2022-08-25T20:07:39.541063", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7d974699d3f24b00bca2c356f7f53d6a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=1.1, description='a', max=3.3000000000000003, min=-1.1), FloatSlider(v…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "@interact(a=1.1, b=1.1, c=1.1)\n", + "def plot_quad(a, b, c):\n", + " plt.scatter(x,y)\n", + " plot_function(mk_quad(a,b,c), ylim=(-3,13))" + ] + }, + { + "cell_type": "markdown", + "id": "5746e92a", + "metadata": { + "papermill": { + "duration": 0.057525, + "end_time": "2022-08-25T20:07:39.916141", + "exception": false, + "start_time": "2022-08-25T20:07:39.858616", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "**Reminder**: If the sliders above aren't working for you, that's because the interactive features of this notebook don't work in Kaggle's *Reader* mode. They only work in *Edit* mode. Please click \"**Copy & Edit**\" in the top right of this window, then in the menu click *Run* and then *Run all*. Then you'll be able to use all the interactive sliders in this notebook." + ] + }, + { + "cell_type": "markdown", + "id": "71b0c806", + "metadata": { + "papermill": { + "duration": 0.056913, + "end_time": "2022-08-25T20:07:40.029870", + "exception": false, + "start_time": "2022-08-25T20:07:39.972957", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "Try moving slider `a` a bit to the left. Does that look better or worse? How about if you move it a bit to the right? Find out which direction seems to improve the fit of the quadratic to the data, and move the slider a bit in that direction. Next, do the same for slider `b`: first figure out which direction improves the fit, then move it a bit in that direction. Then do the same for `c`.\n", + "\n", + "OK, now go back to slider `a` and repeat the process. Do it again for `b` and `c` as well.\n", + "\n", + "Did you notice that by going back and doing the sliders a second time that you were able to improve things a bit further? That's an important insight -- it's only after changing `b` and `c`, for instance, that you realise that `a` actually needs some adjustment based on those new values.\n", + "\n", + "One thing that's making this tricky is that we don't really have a great sense of whether our fit is really better or worse. It would be easier if we had a numeric measure of that. On easy metric we could use is *mean absolute error* -- which is the distance from each data point to the curve:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "df751d3b", + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-25T20:07:40.144056Z", + "iopub.status.busy": "2022-08-25T20:07:40.143468Z", + "iopub.status.idle": "2022-08-25T20:07:40.148008Z", + "shell.execute_reply": "2022-08-25T20:07:40.147308Z" + }, + "papermill": { + "duration": 0.064344, + "end_time": "2022-08-25T20:07:40.150158", + "exception": false, + "start_time": "2022-08-25T20:07:40.085814", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "def mae(preds, acts): return (torch.abs(preds-acts)).mean()" + ] + }, + { + "cell_type": "markdown", + "id": "ae8d2a03", + "metadata": { + "papermill": { + "duration": 0.057507, + "end_time": "2022-08-25T20:07:40.263936", + "exception": false, + "start_time": "2022-08-25T20:07:40.206429", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "We'll update our interactive function to print this at the top for us.\n", + "\n", + "Use this to repeat the approach we took before to try to find the best fit, but this time just use the value of the metric to decide which direction to move each slider, and how far to move it.\n", + "\n", + "This time around, try doing it in the opposite order: `c`, then `b`, then `a`.\n", + "\n", + "You'll probably find that you have to go through the set of sliders a couple of times to get the best fit." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "8ed292c2", + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-25T20:07:40.379145Z", + "iopub.status.busy": "2022-08-25T20:07:40.378537Z", + "iopub.status.idle": "2022-08-25T20:07:40.579146Z", + "shell.execute_reply": "2022-08-25T20:07:40.578110Z" + }, + "papermill": { + "duration": 0.261419, + "end_time": "2022-08-25T20:07:40.582142", + "exception": false, + "start_time": "2022-08-25T20:07:40.320723", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "63d8c4049a1746aca81f59dfd79e399e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=1.1, description='a', max=3.3000000000000003, min=-1.1), FloatSlider(v…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "@interact(a=1.1, b=1.1, c=1.1)\n", + "def plot_quad(a, b, c):\n", + " f = mk_quad(a,b,c)\n", + " plt.scatter(x,y)\n", + " loss = mae(f(x), y)\n", + " plot_function(f, ylim=(-3,12), title=f\"MAE: {loss:.2f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "2aeb0e32", + "metadata": { + "papermill": { + "duration": 0.056845, + "end_time": "2022-08-25T20:07:40.700029", + "exception": false, + "start_time": "2022-08-25T20:07:40.643184", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "In a modern neural network we'll often have tens of millions of parameters to fit, or more, and thousands or millions of data points to fit them to. We're not going to be able to do that by moving sliders around! We'll need to automate this process.\n", + "\n", + "Thankfully, that turns out to be pretty straightforward. We can use calculus to figure out, for each parameter, whether we should increase or decrease it.\n", + "\n", + "Uh oh, calculus! If you haven't touched calculus since school, you might be getting ready to run away at this point. But don't worry, we don't actually need much calculus at all. Just derivatives, which measure the rate of change of a function. We don't even need to calculate them ourselves, because the computer will do it for us! If you've forgotten what a derivitive is, then watch the first three of these fantastic [videos by Professor Dave](https://www.youtube.com/playlist?list=PLybg94GvOJ9ELZEe9s2NXTKr41Yedbw7M). It's only 15 minutes in total, so give it a go! Then come back here and we'll continue on our journey..." + ] + }, + { + "cell_type": "markdown", + "id": "fee30cd8", + "metadata": { + "papermill": { + "duration": 0.057563, + "end_time": "2022-08-25T20:07:40.816514", + "exception": false, + "start_time": "2022-08-25T20:07:40.758951", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## Automating gradient descent" + ] + }, + { + "cell_type": "markdown", + "id": "87c8c980", + "metadata": { + "papermill": { + "duration": 0.057092, + "end_time": "2022-08-25T20:07:40.931523", + "exception": false, + "start_time": "2022-08-25T20:07:40.874431", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "The basic idea is this: if we know the *gradient* of our `mae()` function *with respect to* our parameters, `a`, `b`, and `c`, then that means we know how adjusting (for instance) `a` will change the value of `mae()`. If, say, `a` has a *negative* gradient, then we know that increasing `a` will decrease `mae()`. Then we know that's what we need to do, since we trying to make `mae()` as low as possible.\n", + "\n", + "So, we find the gradient of `mae()` for each of our parameters, and then adjust our parameters a bit in the *opposite* direction to the sign of the gradient.\n", + "\n", + "To do this, first we need a function that takes all the parameters `a`, `b`, and `c` as a single vector input, and returns the value `mae()` based on those parameters:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "99e6873c", + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-25T20:07:41.048664Z", + "iopub.status.busy": "2022-08-25T20:07:41.048263Z", + "iopub.status.idle": "2022-08-25T20:07:41.053708Z", + "shell.execute_reply": "2022-08-25T20:07:41.052629Z" + }, + "papermill": { + "duration": 0.067504, + "end_time": "2022-08-25T20:07:41.055716", + "exception": false, + "start_time": "2022-08-25T20:07:40.988212", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "def quad_mae(params):\n", + " f = mk_quad(*params)\n", + " return mae(f(x), y)" + ] + }, + { + "cell_type": "markdown", + "id": "87f7a56d", + "metadata": { + "papermill": { + "duration": 0.056573, + "end_time": "2022-08-25T20:07:41.168543", + "exception": false, + "start_time": "2022-08-25T20:07:41.111970", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "Let's try it:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "8c24095c", + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-25T20:07:41.285912Z", + "iopub.status.busy": "2022-08-25T20:07:41.285610Z", + "iopub.status.idle": "2022-08-25T20:07:41.291918Z", + "shell.execute_reply": "2022-08-25T20:07:41.291201Z" + }, + "papermill": { + "duration": 0.068561, + "end_time": "2022-08-25T20:07:41.295489", + "exception": false, + "start_time": "2022-08-25T20:07:41.226928", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor(2.4219, dtype=torch.float64)" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "quad_mae([1.1, 1.1, 1.1])" + ] + }, + { + "cell_type": "markdown", + "id": "692e01e2", + "metadata": { + "papermill": { + "duration": 0.056523, + "end_time": "2022-08-25T20:07:41.410468", + "exception": false, + "start_time": "2022-08-25T20:07:41.353945", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "Yup, that's the same as the starting `mae()` we had in our plot before.\n", + "\n", + "We're first going to do exactly the same thing as we did manually -- pick some arbritrary starting point for our parameters. We'll put them all into a single tensor:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "e997eb4b", + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-25T20:07:41.528651Z", + "iopub.status.busy": "2022-08-25T20:07:41.528347Z", + "iopub.status.idle": "2022-08-25T20:07:41.532746Z", + "shell.execute_reply": "2022-08-25T20:07:41.531930Z" + }, + "papermill": { + "duration": 0.066122, + "end_time": "2022-08-25T20:07:41.534953", + "exception": false, + "start_time": "2022-08-25T20:07:41.468831", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "abc = torch.tensor([1.1,1.1,1.1])" + ] + }, + { + "cell_type": "markdown", + "id": "0b3e7e72", + "metadata": { + "papermill": { + "duration": 0.056943, + "end_time": "2022-08-25T20:07:41.653134", + "exception": false, + "start_time": "2022-08-25T20:07:41.596191", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "To tell PyTorch that we want it to calculate gradients for these parameters, we need to call `requires_grad_()`:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "d0917ae5", + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-25T20:07:41.772666Z", + "iopub.status.busy": "2022-08-25T20:07:41.772054Z", + "iopub.status.idle": "2022-08-25T20:07:41.778111Z", + "shell.execute_reply": "2022-08-25T20:07:41.777472Z" + }, + "papermill": { + "duration": 0.068716, + "end_time": "2022-08-25T20:07:41.780006", + "exception": false, + "start_time": "2022-08-25T20:07:41.711290", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([1.1000, 1.1000, 1.1000], requires_grad=True)" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "abc.requires_grad_()" + ] + }, + { + "cell_type": "markdown", + "id": "ac4495e1", + "metadata": { + "papermill": { + "duration": 0.056886, + "end_time": "2022-08-25T20:07:41.894138", + "exception": false, + "start_time": "2022-08-25T20:07:41.837252", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "We can now calculate `mae()`. Generally, when doing gradient descent, the thing we're trying to minimise is called the *loss*:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "503b5f3e", + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-25T20:07:42.010102Z", + "iopub.status.busy": "2022-08-25T20:07:42.009476Z", + "iopub.status.idle": "2022-08-25T20:07:42.018028Z", + "shell.execute_reply": "2022-08-25T20:07:42.017155Z" + }, + "papermill": { + "duration": 0.069517, + "end_time": "2022-08-25T20:07:42.020405", + "exception": false, + "start_time": "2022-08-25T20:07:41.950888", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor(2.4219, dtype=torch.float64, grad_fn=)" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "loss = quad_mae(abc)\n", + "loss" + ] + }, + { + "cell_type": "markdown", + "id": "c6e24654", + "metadata": { + "papermill": { + "duration": 0.05721, + "end_time": "2022-08-25T20:07:42.136775", + "exception": false, + "start_time": "2022-08-25T20:07:42.079565", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "To get PyTorch to now calculate the gradients, we need to call `backward()`" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "5fdbcd8f", + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-25T20:07:42.261189Z", + "iopub.status.busy": "2022-08-25T20:07:42.260839Z", + "iopub.status.idle": "2022-08-25T20:07:42.278941Z", + "shell.execute_reply": "2022-08-25T20:07:42.277808Z" + }, + "papermill": { + "duration": 0.087635, + "end_time": "2022-08-25T20:07:42.282776", + "exception": false, + "start_time": "2022-08-25T20:07:42.195141", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "loss.backward()" + ] + }, + { + "cell_type": "markdown", + "id": "ca33d7bf", + "metadata": { + "papermill": { + "duration": 0.060017, + "end_time": "2022-08-25T20:07:42.423013", + "exception": false, + "start_time": "2022-08-25T20:07:42.362996", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "The gradients will be stored for us in an attribute called `grad`:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "31a80ca2", + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-25T20:07:42.540364Z", + "iopub.status.busy": "2022-08-25T20:07:42.540046Z", + "iopub.status.idle": "2022-08-25T20:07:42.546911Z", + "shell.execute_reply": "2022-08-25T20:07:42.545989Z" + }, + "papermill": { + "duration": 0.068131, + "end_time": "2022-08-25T20:07:42.549131", + "exception": false, + "start_time": "2022-08-25T20:07:42.481000", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([-1.3529, -0.0316, -0.5000])" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "abc.grad" + ] + }, + { + "cell_type": "markdown", + "id": "540c5991", + "metadata": { + "papermill": { + "duration": 0.058756, + "end_time": "2022-08-25T20:07:42.665593", + "exception": false, + "start_time": "2022-08-25T20:07:42.606837", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "According to these gradients, all our parameters are a little low. So let's increase them a bit. If we subtract the gradient, multiplied by a small number, that should improve them a bit:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "ebd11e5b", + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-25T20:07:42.786333Z", + "iopub.status.busy": "2022-08-25T20:07:42.785688Z", + "iopub.status.idle": "2022-08-25T20:07:42.794518Z", + "shell.execute_reply": "2022-08-25T20:07:42.793337Z" + }, + "papermill": { + "duration": 0.073371, + "end_time": "2022-08-25T20:07:42.797430", + "exception": false, + "start_time": "2022-08-25T20:07:42.724059", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss=2.40\n" + ] + } + ], + "source": [ + "with torch.no_grad():\n", + " abc -= abc.grad*0.01\n", + " loss = quad_mae(abc)\n", + " \n", + "print(f'loss={loss:.2f}')" + ] + }, + { + "cell_type": "markdown", + "id": "76eec1c0", + "metadata": { + "papermill": { + "duration": 0.058037, + "end_time": "2022-08-25T20:07:42.913878", + "exception": false, + "start_time": "2022-08-25T20:07:42.855841", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "Yes, our loss has gone down!\n", + "\n", + "The \"small number\" we multiply is called the *learning rate*, and is the most important *hyper-parameter* to set when training a neural network.\n", + "\n", + "BTW, you'll see we had to wrap our calculation of the new parameters in `with torch.no_grad()`. That disables the calculation of gradients for any operations inside that context manager. We have to do that, because `abc -= abc.grad*0.01` isn't actually part of our quadratic model, so we don't want derivitives to include that calculation.\n", + "\n", + "We can use a loop to do a few more iterations of this:" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "cd493774", + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-25T20:07:43.035069Z", + "iopub.status.busy": "2022-08-25T20:07:43.034290Z", + "iopub.status.idle": "2022-08-25T20:07:43.047020Z", + "shell.execute_reply": "2022-08-25T20:07:43.046167Z" + }, + "papermill": { + "duration": 0.077071, + "end_time": "2022-08-25T20:07:43.049662", + "exception": false, + "start_time": "2022-08-25T20:07:42.972591", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "step=0; loss=2.40\n", + "step=1; loss=2.36\n", + "step=2; loss=2.30\n", + "step=3; loss=2.21\n", + "step=4; loss=2.11\n", + "step=5; loss=1.98\n", + "step=6; loss=1.85\n", + "step=7; loss=1.72\n", + "step=8; loss=1.58\n", + "step=9; loss=1.46\n" + ] + } + ], + "source": [ + "for i in range(10):\n", + " loss = quad_mae(abc)\n", + " loss.backward()\n", + " with torch.no_grad(): abc -= abc.grad*0.01\n", + " print(f'step={i}; loss={loss:.2f}')" + ] + }, + { + "cell_type": "markdown", + "id": "42a2f766", + "metadata": { + "papermill": { + "duration": 0.05823, + "end_time": "2022-08-25T20:07:43.166115", + "exception": false, + "start_time": "2022-08-25T20:07:43.107885", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "As you can see, our loss keeps going down!\n", + "\n", + "If you keep running this loop for long enough however, you'll see that the loss eventually starts increasing for a while. That's because once the parameters get close to the correct answer, our parameter updates will jump right over the correct answer! To avoid this, we need to decrease our learning rate as we train. This is done using a *learning rate schedule*, and can be automated in most deep learning frameworks, such as fastai and PyTorch." + ] + }, + { + "cell_type": "markdown", + "id": "b55006fa", + "metadata": { + "papermill": { + "duration": 0.058523, + "end_time": "2022-08-25T20:07:43.283176", + "exception": false, + "start_time": "2022-08-25T20:07:43.224653", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## How a neural network approximates any given function" + ] + }, + { + "cell_type": "markdown", + "id": "71aeaa95", + "metadata": { + "papermill": { + "duration": 0.063582, + "end_time": "2022-08-25T20:07:43.405325", + "exception": false, + "start_time": "2022-08-25T20:07:43.341743", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "But neural nets are much more convenient and powerful than this example showed, because we can learn much more than just a quadratic with them. How does *that* work?\n", + "\n", + "The trick is that a neural network is a very expressive function. In fact -- it's [infinitely expressive](https://en.wikipedia.org/wiki/Universal_approximation_theorem). A neural network can approximate any computable function, given enough parameters. A \"computable function\" can cover just about anything you can imagine: understand and translate human speech; paint a picture; diagnose a disease from medical imaging; write an essay; etc...\n", + "\n", + "The way a neural network approximates a function actually turns out to be very simple. The key trick is to combine two extremely basic steps:\n", + "\n", + "1. Matrix multiplication, which is just multiplying things together and then adding them up\n", + "1. The function $max(x,0)$, which simply replaces all negative numbers with zero.\n", + "\n", + "In PyTorch, the function $max(x,0)$ is written as `np.clip(x,0)`. The combination of a linear function and this *max()* is called a *rectified linear function*, and it can be implemented like this:" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "412da407", + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-25T20:07:43.525106Z", + "iopub.status.busy": "2022-08-25T20:07:43.524628Z", + "iopub.status.idle": "2022-08-25T20:07:43.529663Z", + "shell.execute_reply": "2022-08-25T20:07:43.528738Z" + }, + "papermill": { + "duration": 0.067748, + "end_time": "2022-08-25T20:07:43.532001", + "exception": false, + "start_time": "2022-08-25T20:07:43.464253", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "def rectified_linear(m,b,x):\n", + " y = m*x+b\n", + " return torch.clip(y, 0.)" + ] + }, + { + "cell_type": "markdown", + "id": "15315f97", + "metadata": { + "papermill": { + "duration": 0.058296, + "end_time": "2022-08-25T20:07:43.648566", + "exception": false, + "start_time": "2022-08-25T20:07:43.590270", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "Here's what it looks like:" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "570ab468", + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-25T20:07:43.768332Z", + "iopub.status.busy": "2022-08-25T20:07:43.767616Z", + "iopub.status.idle": "2022-08-25T20:07:43.920721Z", + "shell.execute_reply": "2022-08-25T20:07:43.919809Z" + }, + "papermill": { + "duration": 0.216463, + "end_time": "2022-08-25T20:07:43.923331", + "exception": false, + "start_time": "2022-08-25T20:07:43.706868", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_function(partial(rectified_linear, 1,1))" + ] + }, + { + "cell_type": "markdown", + "id": "b0f31c65", + "metadata": { + "papermill": { + "duration": 0.062016, + "end_time": "2022-08-25T20:07:44.046261", + "exception": false, + "start_time": "2022-08-25T20:07:43.984245", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "BTW, instead of `torch.clip(y, 0.)`, we can instead use `F.relu(x)`, which does exactly the same thing. In PyTorch, `F` refers to the `torch.nn.functional` module." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "9ec64961", + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-25T20:07:44.167767Z", + "iopub.status.busy": "2022-08-25T20:07:44.167152Z", + "iopub.status.idle": "2022-08-25T20:07:44.320639Z", + "shell.execute_reply": "2022-08-25T20:07:44.319555Z" + }, + "papermill": { + "duration": 0.217461, + "end_time": "2022-08-25T20:07:44.323347", + "exception": false, + "start_time": "2022-08-25T20:07:44.105886", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import torch.nn.functional as F\n", + "def rectified_linear2(m,b,x): return F.relu(m*x+b)\n", + "plot_function(partial(rectified_linear2, 1,1))" + ] + }, + { + "cell_type": "markdown", + "id": "546b3360", + "metadata": { + "papermill": { + "duration": 0.062441, + "end_time": "2022-08-25T20:07:44.446586", + "exception": false, + "start_time": "2022-08-25T20:07:44.384145", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "To understand how this function works, try using this interactive version to play around with the parameters `m` and `b`:" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "32d1b66e", + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-25T20:07:44.573708Z", + "iopub.status.busy": "2022-08-25T20:07:44.573014Z", + "iopub.status.idle": "2022-08-25T20:07:44.736021Z", + "shell.execute_reply": "2022-08-25T20:07:44.734530Z" + }, + "papermill": { + "duration": 0.230874, + "end_time": "2022-08-25T20:07:44.740440", + "exception": false, + "start_time": "2022-08-25T20:07:44.509566", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5a95997c90d54f3485a0188c269db968", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=1.5, description='m', max=4.5, min=-1.5), FloatSlider(value=1.5, descr…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "@interact(m=1.5, b=1.5)\n", + "def plot_relu(m, b):\n", + " plot_function(partial(rectified_linear, m,b), ylim=(-1,4))" + ] + }, + { + "cell_type": "markdown", + "id": "d8585a90", + "metadata": { + "papermill": { + "duration": 0.062979, + "end_time": "2022-08-25T20:07:44.876951", + "exception": false, + "start_time": "2022-08-25T20:07:44.813972", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "As you see, `m` changes the slope, and `b` changes where the \"hook\" appears. This function doesn't do much on its own, but look what happens when we add two of them together:" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "3b480ece", + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-25T20:07:45.003167Z", + "iopub.status.busy": "2022-08-25T20:07:45.002676Z", + "iopub.status.idle": "2022-08-25T20:07:45.257292Z", + "shell.execute_reply": "2022-08-25T20:07:45.256304Z" + }, + "papermill": { + "duration": 0.322162, + "end_time": "2022-08-25T20:07:45.259898", + "exception": false, + "start_time": "2022-08-25T20:07:44.937736", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b1f9d605473b42a6b897864fe5e8d75d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=-1.5, description='m1', max=1.5, min=-4.5), FloatSlider(value=-1.5, de…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def double_relu(m1,b1,m2,b2,x):\n", + " return rectified_linear(m1,b1,x) + rectified_linear(m2,b2,x)\n", + "\n", + "@interact(m1=-1.5, b1=-1.5, m2=1.5, b2=1.5)\n", + "def plot_double_relu(m1, b1, m2, b2):\n", + " plot_function(partial(double_relu, m1,b1,m2,b2), ylim=(-1,6))" + ] + }, + { + "cell_type": "markdown", + "id": "189ddba9", + "metadata": { + "papermill": { + "duration": 0.06207, + "end_time": "2022-08-25T20:07:45.384783", + "exception": false, + "start_time": "2022-08-25T20:07:45.322713", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "If you play around with that for a while, you notice something quite profound: with enough of these rectified linear functions added together, you could approximate any function with a single input, to whatever accuracy you like! Any time the function doesn't quite match, you can just add a few more additions to the mix to make it a bit closer. As an experiment, perhaps you'd like to try creating your own `plot_triple_relu` interactive function, and maybe even include the scatter plot of our data from before, to see how close you can get?\n", + "\n", + "This exact same approach can be expanded to functions of 2, 3, or more parameters." + ] + }, + { + "cell_type": "markdown", + "id": "59eb8223", + "metadata": { + "papermill": { + "duration": 0.061546, + "end_time": "2022-08-25T20:07:45.508441", + "exception": false, + "start_time": "2022-08-25T20:07:45.446895", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## How to recognise an owl" + ] + }, + { + "cell_type": "markdown", + "id": "22016a2e", + "metadata": { + "papermill": { + "duration": 0.062896, + "end_time": "2022-08-25T20:07:45.632618", + "exception": false, + "start_time": "2022-08-25T20:07:45.569722", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "OK great, we've created a nifty little example showing that we can drawing squiggly lines that go through some points. So what?\n", + "\n", + "Well... the truth is that actually drawing squiggly lines (or planes, or high-dimensional hyperplanes...) through some points is literally *all that deep learning does*! If your data points are, say, the RGB values of pixels in photos of owls, then you can create an owl-recogniser model by following the exact steps above.\n", + "\n", + "This may, at first, sound about as useful as the classic \"how to draw an owl\" guide:" + ] + }, + { + "attachments": { + "c66592d3-c997-4c72-aed4-2dea579b96e1.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "d80f352a", + "metadata": { + "papermill": { + "duration": 0.062224, + "end_time": "2022-08-25T20:07:45.757225", + "exception": false, + "start_time": "2022-08-25T20:07:45.695001", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "![image.png](attachment:c66592d3-c997-4c72-aed4-2dea579b96e1.png)" + ] + }, + { + "cell_type": "markdown", + "id": "ea696932", + "metadata": { + "papermill": { + "duration": 0.061443, + "end_time": "2022-08-25T20:07:45.884322", + "exception": false, + "start_time": "2022-08-25T20:07:45.822879", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "Students often ask me at this point \"OK Jeremy, but how do neural nets *actually work*\". But at a foundational level, there is no \"step 2\". We're done -- the above steps will, given enough time and enough data, create (for example) an owl recogniser, if you feed in enough owls (and non-owls).\n", + "\n", + "The devil, I guess, is in the \"given enough time and enough data\" part of the above sentence. There's a *lot* of tweaks we can make to reduce both of these things. For instance, instead of running our calculations on a normal CPU, as we've done above, we could do thousands of them simultaneously by taking advantage of a GPU. We could greatly reduce the amount of computation and data needed by using a convolution instead of a matrix multiplication, which basically means skipping over a bunch of the multiplications and additions for bits that you'd guess won't be important. We could make things much faster if, instead of starting with random parameters, we start with parameters of someone else's model that does something similar to what we want (this is called *transfer learning*).\n", + "\n", + "And, of course, there's lots of helpful software out there to do this stuff for you without too much fuss. Like, say, [fastai](https://docs.fast.ai).\n", + "\n", + "Learning these things is what we teach in our [course](https://course.fast.ai), which, like everything we make, is totally free. So if you're interested in learning more, do check it out!" + ] + }, + { + "cell_type": "markdown", + "id": "e97e11b3", + "metadata": { + "papermill": { + "duration": 0.061744, + "end_time": "2022-08-25T20:07:46.007428", + "exception": false, + "start_time": "2022-08-25T20:07:45.945684", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "As always, if you enjoyed this notebook, please upvote it to help others find it, and to encourage me to write more. If you upvote it, be careful you don't accidentally upvote your copy that's created when you click \"Copy & Edit\" -- you can find my original at [this link](https://www.kaggle.com/code/jhoward/how-does-a-neural-net-really-work)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f6ca74e0", + "metadata": { + "papermill": { + "duration": 0.061323, + "end_time": "2022-08-25T20:07:46.130052", + "exception": false, + "start_time": "2022-08-25T20:07:46.068729", + "status": "completed" + }, + "tags": [] + }, + "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.13" + }, + "papermill": { + "default_parameters": {}, + "duration": 24.478653, + "end_time": "2022-08-25T20:07:47.316654", + "environment_variables": {}, + "exception": null, + "input_path": "__notebook__.ipynb", + "output_path": "__notebook__.ipynb", + "parameters": {}, + "start_time": "2022-08-25T20:07:22.838001", + "version": "2.3.4" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "047448df85ff458fae024e80b07f52b7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "06ed31ded81d4a81a58b5f64df393aed": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0ae400dce73a456880e14358b485acd6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "160b4213858d4ed59cd2fc29d743532f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1ec0006ea87141eba6b31259c8a27278": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatSliderModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatSliderModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "FloatSliderView", + "continuous_update": true, + "description": "m1", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_06ed31ded81d4a81a58b5f64df393aed", + "max": 1.5, + "min": -4.5, + "orientation": "horizontal", + "readout": true, + "readout_format": ".2f", + "step": 0.1, + "style": "IPY_MODEL_dac6cfed65f14423bfc5e10f56c40d93", + "value": -1.5 + } + }, + "1fa6ffcba5bf4ed5b156407247c674e6": { + "model_module": "@jupyter-widgets/output", + "model_module_version": "1.0.0", + "model_name": "OutputModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/output", + "_model_module_version": "1.0.0", + "_model_name": "OutputModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/output", + "_view_module_version": "1.0.0", + "_view_name": "OutputView", + "layout": "IPY_MODEL_635fc5b32ed34503a10d3a3746645421", + "msg_id": "", + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": "
" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ] + } + }, + "2193e35abd0b4864a2973f8383e7c8af": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatSliderModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatSliderModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "FloatSliderView", + "continuous_update": true, + "description": "m", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_b268e6c4a51245f9b25377c2d11b45d9", + "max": 4.5, + "min": -1.5, + "orientation": "horizontal", + "readout": true, + "readout_format": ".2f", + "step": 0.1, + "style": "IPY_MODEL_4edbbf32cd6f488b9f8320163c15c9a0", + "value": 1.5 + } + }, + "2f3dfed7b1c948f187e62ad1edcf1a47": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2f97254dd29a440b99748acb514104c7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "SliderStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "SliderStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "", + "handle_color": null + } + }, + "31b51b7912a7430093714847f79d6510": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatSliderModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatSliderModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "FloatSliderView", + "continuous_update": true, + "description": "a", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_047448df85ff458fae024e80b07f52b7", + "max": 3.3000000000000003, + "min": -1.1, + "orientation": "horizontal", + "readout": true, + "readout_format": ".2f", + "step": 0.1, + "style": "IPY_MODEL_5bd537ec026b4284aeccabcc60c71f9a", + "value": 1.1 + } + }, + "33a4d8a5453849e98a903365b7972a13": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "38da57b137214461bc6dd50b2875cf10": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3a18f662232849c195519e89f2f2afc5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3d0fe90e14194622bfd103d86fd6188a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3e180d93a0464bf9b02ede014b756d90": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "VBoxModel", + "state": { + "_dom_classes": [ + "widget-interact" + ], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "VBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "VBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_caeb428a915d49d39d6cad488655d19c", + "IPY_MODEL_9f551acbb01243d68f6f4b828da53c67", + "IPY_MODEL_e8e488da9d4c4d499964e957990b2c93", + "IPY_MODEL_1fa6ffcba5bf4ed5b156407247c674e6" + ], + "layout": "IPY_MODEL_9e69a2220fd34b8e82c242222a6e5c94" + } + }, + "415b223406f042359022fadf91e316d1": { + "model_module": "@jupyter-widgets/output", + "model_module_version": "1.0.0", + "model_name": "OutputModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/output", + "_model_module_version": "1.0.0", + "_model_name": "OutputModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/output", + "_view_module_version": "1.0.0", + "_view_name": "OutputView", + "layout": "IPY_MODEL_2f3dfed7b1c948f187e62ad1edcf1a47", + "msg_id": "", + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": "
" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ] + } + }, + "4edbbf32cd6f488b9f8320163c15c9a0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "SliderStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "SliderStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "", + "handle_color": null + } + }, + "5345689157f8488bb319057298557e03": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "SliderStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "SliderStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "", + "handle_color": null + } + }, + "5a6e9e7d202740a9ad90c81e36ad4ea5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5a95997c90d54f3485a0188c269db968": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "VBoxModel", + "state": { + "_dom_classes": [ + "widget-interact" + ], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "VBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "VBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_2193e35abd0b4864a2973f8383e7c8af", + "IPY_MODEL_aacbd739e70d444eb50272489d225230", + "IPY_MODEL_667f08be6b744c888f1ab4c2242563d3" + ], + "layout": "IPY_MODEL_5a6e9e7d202740a9ad90c81e36ad4ea5" + } + }, + "5bd537ec026b4284aeccabcc60c71f9a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "SliderStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "SliderStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "", + "handle_color": null + } + }, + "635fc5b32ed34503a10d3a3746645421": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "63d8c4049a1746aca81f59dfd79e399e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "VBoxModel", + "state": { + "_dom_classes": [ + "widget-interact" + ], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "VBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "VBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_31b51b7912a7430093714847f79d6510", + "IPY_MODEL_732ef943dbd04219b5757ee038af5d21", + "IPY_MODEL_cebb7358f49c475691a3e8d1cf3a1472", + "IPY_MODEL_415b223406f042359022fadf91e316d1" + ], + "layout": "IPY_MODEL_160b4213858d4ed59cd2fc29d743532f" + } + }, + "667f08be6b744c888f1ab4c2242563d3": { + "model_module": "@jupyter-widgets/output", + "model_module_version": "1.0.0", + "model_name": "OutputModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/output", + "_model_module_version": "1.0.0", + "_model_name": "OutputModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/output", + "_view_module_version": "1.0.0", + "_view_name": "OutputView", + "layout": "IPY_MODEL_a4623a31093f413b8c3c8e3790533497", + "msg_id": "", + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": "
" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ] + } + }, + "67ad1674c8854f2a84f6c0324a7d6670": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "SliderStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "SliderStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "", + "handle_color": null + } + }, + "6a59e76c97f548318d016f6ba95068d0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "732ef943dbd04219b5757ee038af5d21": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatSliderModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatSliderModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "FloatSliderView", + "continuous_update": true, + "description": "b", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_3d0fe90e14194622bfd103d86fd6188a", + "max": 3.3000000000000003, + "min": -1.1, + "orientation": "horizontal", + "readout": true, + "readout_format": ".2f", + "step": 0.1, + "style": "IPY_MODEL_bfe1018a6e8543978e1d5423465db68c", + "value": 1.1 + } + }, + "7bc9f505b1284cb48e635b829d9fa631": { + "model_module": "@jupyter-widgets/output", + "model_module_version": "1.0.0", + "model_name": "OutputModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/output", + "_model_module_version": "1.0.0", + "_model_name": "OutputModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/output", + "_view_module_version": "1.0.0", + "_view_name": "OutputView", + "layout": "IPY_MODEL_b9f69cde590246cb81da87ed8b3b3237", + "msg_id": "", + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": "
" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ] + } + }, + "7eca316e516e4feda361aa1a0a351ba9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "SliderStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "SliderStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "", + "handle_color": null + } + }, + "8542b48d5b9e49c58a1994d4c2f9ce12": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8ace134e135347669e8c1d6fc94a68ed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatSliderModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatSliderModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "FloatSliderView", + "continuous_update": true, + "description": "m2", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_38da57b137214461bc6dd50b2875cf10", + "max": 4.5, + "min": -1.5, + "orientation": "horizontal", + "readout": true, + "readout_format": ".2f", + "step": 0.1, + "style": "IPY_MODEL_91cd167451bc4c348ac5da79584c0d91", + "value": 1.5 + } + }, + "8cd2fa5ca39f4c5b812d7b9dd04b5e69": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "SliderStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "SliderStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "", + "handle_color": null + } + }, + "91cd167451bc4c348ac5da79584c0d91": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "SliderStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "SliderStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "", + "handle_color": null + } + }, + "99d51ae0adbc4398864f14229221705d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "SliderStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "SliderStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "", + "handle_color": null + } + }, + "9e69a2220fd34b8e82c242222a6e5c94": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9f551acbb01243d68f6f4b828da53c67": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatSliderModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatSliderModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "FloatSliderView", + "continuous_update": true, + "description": "b", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_c2c06796e43a4694bb1ea360b46514af", + "max": 3.3000000000000003, + "min": -1.1, + "orientation": "horizontal", + "readout": true, + "readout_format": ".2f", + "step": 0.1, + "style": "IPY_MODEL_8cd2fa5ca39f4c5b812d7b9dd04b5e69", + "value": 1.1 + } + }, + "a4623a31093f413b8c3c8e3790533497": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "aacbd739e70d444eb50272489d225230": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatSliderModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatSliderModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "FloatSliderView", + "continuous_update": true, + "description": "b", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_33a4d8a5453849e98a903365b7972a13", + "max": 4.5, + "min": -1.5, + "orientation": "horizontal", + "readout": true, + "readout_format": ".2f", + "step": 0.1, + "style": "IPY_MODEL_5345689157f8488bb319057298557e03", + "value": 1.5 + } + }, + "b1f9d605473b42a6b897864fe5e8d75d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "VBoxModel", + "state": { + "_dom_classes": [ + "widget-interact" + ], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "VBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "VBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_1ec0006ea87141eba6b31259c8a27278", + "IPY_MODEL_d5c28a0e60b843bc8e9f0144e1f56e94", + "IPY_MODEL_8ace134e135347669e8c1d6fc94a68ed", + "IPY_MODEL_b4ddbf2c94414c3797daa09ae5f97ba0", + "IPY_MODEL_7bc9f505b1284cb48e635b829d9fa631" + ], + "layout": "IPY_MODEL_6a59e76c97f548318d016f6ba95068d0" + } + }, + "b268e6c4a51245f9b25377c2d11b45d9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b4ddbf2c94414c3797daa09ae5f97ba0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatSliderModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatSliderModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "FloatSliderView", + "continuous_update": true, + "description": "b2", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_3a18f662232849c195519e89f2f2afc5", + "max": 4.5, + "min": -1.5, + "orientation": "horizontal", + "readout": true, + "readout_format": ".2f", + "step": 0.1, + "style": "IPY_MODEL_67ad1674c8854f2a84f6c0324a7d6670", + "value": 1.5 + } + }, + "b9f69cde590246cb81da87ed8b3b3237": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bfe1018a6e8543978e1d5423465db68c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "SliderStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "SliderStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "", + "handle_color": null + } + }, + "c2c06796e43a4694bb1ea360b46514af": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c8e9fb88c06d47d59f53d33e6b6b1d9c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "SliderStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "SliderStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "", + "handle_color": null + } + }, + "caeb428a915d49d39d6cad488655d19c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatSliderModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatSliderModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "FloatSliderView", + "continuous_update": true, + "description": "a", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_d5af0e27eb3d4fc1a7968ff62d2c080b", + "max": 3.3000000000000003, + "min": -1.1, + "orientation": "horizontal", + "readout": true, + "readout_format": ".2f", + "step": 0.1, + "style": "IPY_MODEL_7eca316e516e4feda361aa1a0a351ba9", + "value": 1.1 + } + }, + "cebb7358f49c475691a3e8d1cf3a1472": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatSliderModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatSliderModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "FloatSliderView", + "continuous_update": true, + "description": "c", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_cf8284fe61144817abcc1867f9019844", + "max": 3.3000000000000003, + "min": -1.1, + "orientation": "horizontal", + "readout": true, + "readout_format": ".2f", + "step": 0.1, + "style": "IPY_MODEL_2f97254dd29a440b99748acb514104c7", + "value": 1.1 + } + }, + "cf8284fe61144817abcc1867f9019844": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d5af0e27eb3d4fc1a7968ff62d2c080b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d5c28a0e60b843bc8e9f0144e1f56e94": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatSliderModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatSliderModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "FloatSliderView", + "continuous_update": true, + "description": "b1", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_0ae400dce73a456880e14358b485acd6", + "max": 1.5, + "min": -4.5, + "orientation": "horizontal", + "readout": true, + "readout_format": ".2f", + "step": 0.1, + "style": "IPY_MODEL_c8e9fb88c06d47d59f53d33e6b6b1d9c", + "value": -1.5 + } + }, + "dac6cfed65f14423bfc5e10f56c40d93": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "SliderStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "SliderStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "", + "handle_color": null + } + }, + "e8e488da9d4c4d499964e957990b2c93": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatSliderModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatSliderModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "FloatSliderView", + "continuous_update": true, + "description": "c", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_8542b48d5b9e49c58a1994d4c2f9ce12", + "max": 3.3000000000000003, + "min": -1.1, + "orientation": "horizontal", + "readout": true, + "readout_format": ".2f", + "step": 0.1, + "style": "IPY_MODEL_99d51ae0adbc4398864f14229221705d", + "value": 1.1 + } + } + }, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/fastai/notebooks/Education/which-image-models-are-best.ipynb b/fastai/notebooks/Education/which-image-models-are-best.ipynb new file mode 100644 index 0000000..19d2ec4 --- /dev/null +++ b/fastai/notebooks/Education/which-image-models-are-best.ipynb @@ -0,0 +1,910 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "807ba781", + "metadata": { + "papermill": { + "duration": 0.034485, + "end_time": "2023-06-06T00:09:17.035990", + "exception": false, + "start_time": "2023-06-06T00:09:17.001505", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "*The data, concept, and initial implementation of this notebook was done in Colab by Ross Wightman, the creator of timm. I (Jeremy Howard) did some refactoring, curating, and expanding of the analysis, and added prose.*" + ] + }, + { + "cell_type": "markdown", + "id": "cb51ad49", + "metadata": { + "papermill": { + "duration": 0.03021, + "end_time": "2023-06-06T00:09:17.097808", + "exception": false, + "start_time": "2023-06-06T00:09:17.067598", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## timm\n", + "\n", + "[PyTorch Image Models](https://timm.fast.ai/) (timm) is a wonderful library by Ross Wightman which provides state-of-the-art pre-trained computer vision models. It's like Huggingface Transformers, but for computer vision instead of NLP (and it's not restricted to transformers-based models)!\n", + "\n", + "Ross has been kind enough to help me understand how to best take advantage of this library by identifying the top models. I'm going to share here so of what I've learned from him, plus some additional ideas." + ] + }, + { + "cell_type": "markdown", + "id": "248460f0", + "metadata": { + "papermill": { + "duration": 0.030863, + "end_time": "2023-06-06T00:09:17.159071", + "exception": false, + "start_time": "2023-06-06T00:09:17.128208", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## The data\n", + "\n", + "Ross regularly benchmarks new models as they are added to timm, and puts the results in a CSV in the project's GitHub repo. To analyse the data, we'll first clone the repo:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "cf208740", + "metadata": { + "papermill": { + "duration": 2.565717, + "end_time": "2023-06-06T00:09:19.755674", + "exception": false, + "start_time": "2023-06-06T00:09:17.189957", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/usr/bin/sh: 1: git: not found\n", + "[Errno 2] No such file or directory: 'pytorch-image-models/results'\n", + "/workspace/Education\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/conda/lib/python3.10/site-packages/IPython/core/magics/osm.py:393: UserWarning: using bookmarks requires you to install the `pickleshare` library.\n", + " bkms = self.shell.db.get('bookmarks', {})\n" + ] + } + ], + "source": [ + "! git clone --depth 1 https://github.com/rwightman/pytorch-image-models.git\n", + "%cd pytorch-image-models/results" + ] + }, + { + "cell_type": "markdown", + "id": "68fcf101", + "metadata": { + "papermill": { + "duration": 0.037981, + "end_time": "2023-06-06T00:09:19.832345", + "exception": false, + "start_time": "2023-06-06T00:09:19.794364", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "Using Pandas, we can read the two CSV files we need, and merge them together." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "df355a97", + "metadata": { + "execution": { + "iopub.execute_input": "2023-06-06T00:09:19.907795Z", + "iopub.status.busy": "2023-06-06T00:09:19.907457Z", + "iopub.status.idle": "2023-06-06T00:09:19.926381Z", + "shell.execute_reply": "2023-06-06T00:09:19.925291Z" + }, + "papermill": { + "duration": 0.058692, + "end_time": "2023-06-06T00:09:19.929054", + "exception": false, + "start_time": "2023-06-06T00:09:19.870362", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "df_results = pd.read_csv('results-imagenet.csv')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "4e25867e", + "metadata": { + "execution": { + "iopub.execute_input": "2023-06-06T00:09:20.006128Z", + "iopub.status.busy": "2023-06-06T00:09:20.005747Z", + "iopub.status.idle": "2023-06-06T00:09:20.022803Z", + "shell.execute_reply": "2023-06-06T00:09:20.021657Z" + }, + "papermill": { + "duration": 0.059181, + "end_time": "2023-06-06T00:09:20.025310", + "exception": false, + "start_time": "2023-06-06T00:09:19.966129", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "df_results['model_org'] = df_results['model'] \n", + "df_results['model'] = df_results['model'].str.split('.').str[0]" + ] + }, + { + "cell_type": "markdown", + "id": "b45c1928", + "metadata": { + "papermill": { + "duration": 0.035119, + "end_time": "2023-06-06T00:09:20.097374", + "exception": false, + "start_time": "2023-06-06T00:09:20.062255", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "We'll also add a \"family\" column that will allow us to group architectures into categories with similar characteristics:\n", + "\n", + "Ross has told me which models he's found the most usable in practice, so I'll limit the charts to just look at these. (I also include VGG, not because it's good, but as a comparison to show how far things have come in the last few years.)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "baa099eb", + "metadata": { + "execution": { + "iopub.execute_input": "2023-06-06T00:09:20.172024Z", + "iopub.status.busy": "2023-06-06T00:09:20.171675Z", + "iopub.status.idle": "2023-06-06T00:09:20.181011Z", + "shell.execute_reply": "2023-06-06T00:09:20.180119Z" + }, + "papermill": { + "duration": 0.049639, + "end_time": "2023-06-06T00:09:20.183317", + "exception": false, + "start_time": "2023-06-06T00:09:20.133678", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "def get_data(part, col):\n", + " df = pd.read_csv(f'benchmark-{part}-amp-nhwc-pt111-cu113-rtx3090.csv').merge(df_results, on='model')\n", + " df['secs'] = 1. / df[col]\n", + " df['family'] = df.model.str.extract('^([a-z]+?(?:v2)?)(?:\\d|_|$)')\n", + " df = df[~df.model.str.endswith('gn')]\n", + " df.loc[df.model.str.contains('in22'),'family'] = df.loc[df.model.str.contains('in22'),'family'] + '_in22'\n", + " df.loc[df.model.str.contains('resnet.*d'),'family'] = df.loc[df.model.str.contains('resnet.*d'),'family'] + 'd'\n", + " return df[df.family.str.contains('^re[sg]netd?|beit|convnext|levit|efficient|vit|vgg|swin')]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "71215c1e", + "metadata": { + "execution": { + "iopub.execute_input": "2023-06-06T00:09:20.258526Z", + "iopub.status.busy": "2023-06-06T00:09:20.257452Z", + "iopub.status.idle": "2023-06-06T00:09:20.299124Z", + "shell.execute_reply": "2023-06-06T00:09:20.298113Z" + }, + "papermill": { + "duration": 0.082408, + "end_time": "2023-06-06T00:09:20.301660", + "exception": false, + "start_time": "2023-06-06T00:09:20.219252", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "df = get_data('infer', 'infer_samples_per_sec')" + ] + }, + { + "cell_type": "markdown", + "id": "16c47388", + "metadata": { + "papermill": { + "duration": 0.03543, + "end_time": "2023-06-06T00:09:20.372280", + "exception": false, + "start_time": "2023-06-06T00:09:20.336850", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## Inference results" + ] + }, + { + "cell_type": "markdown", + "id": "8d097dee", + "metadata": { + "papermill": { + "duration": 0.035859, + "end_time": "2023-06-06T00:09:20.444242", + "exception": false, + "start_time": "2023-06-06T00:09:20.408383", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "Here's the results for inference performance (see the last section for training performance). In this chart:\n", + "\n", + "- the x axis shows how many seconds it takes to process one image (**note**: it's a log scale)\n", + "- the y axis is the accuracy on Imagenet\n", + "- the size of each bubble is proportional to the size of images used in testing\n", + "- the color shows what \"family\" the architecture is from.\n", + "\n", + "Hover your mouse over a marker to see details about the model. Double-click in the legend to display just one family. Single-click in the legend to show or hide a family.\n", + "\n", + "**Note**: on my screen, Kaggle cuts off the family selector and some plotly functionality -- to see the whole thing, collapse the table of contents on the right by clicking the little arrow to the right of \"*Contents*\"." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "4c2a97d1", + "metadata": { + "execution": { + "iopub.execute_input": "2023-06-06T00:09:20.518520Z", + "iopub.status.busy": "2023-06-06T00:09:20.518198Z", + "iopub.status.idle": "2023-06-06T00:09:22.319635Z", + "shell.execute_reply": "2023-06-06T00:09:22.318516Z" + }, + "papermill": { + "duration": 1.841847, + "end_time": "2023-06-06T00:09:22.322215", + "exception": false, + "start_time": "2023-06-06T00:09:20.480368", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "import plotly.express as px\n", + "w,h = 1000,800\n", + "\n", + "def show_all(df, title, size):\n", + " return px.scatter(df, width=w, height=h, size=df[size]**2, title=title,\n", + " x='secs', y='top1', log_x=True, color='family', hover_name='model_org', hover_data=[size])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "26c23a28", + "metadata": { + "execution": { + "iopub.execute_input": "2023-06-06T00:09:22.397315Z", + "iopub.status.busy": "2023-06-06T00:09:22.397009Z", + "iopub.status.idle": "2023-06-06T00:09:23.870864Z", + "shell.execute_reply": "2023-06-06T00:09:23.869937Z" + }, + "papermill": { + "duration": 1.515062, + "end_time": "2023-06-06T00:09:23.873393", + "exception": false, + "start_time": "2023-06-06T00:09:22.358331", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + " \n", + " " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "show_all(df, 'Inference', 'infer_img_size')" + ] + }, + { + "cell_type": "markdown", + "id": "d868f5e1", + "metadata": { + "papermill": { + "duration": 0.037784, + "end_time": "2023-06-06T00:09:23.950736", + "exception": false, + "start_time": "2023-06-06T00:09:23.912952", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "That number of families can be a bit overwhelming, so I'll just pick a subset which represents a single key model from each of the families that are looking best in our plot. I've also separated convnext models into those which have been pretrained on the larger 22,000 category imagenet sample (`convnext_in22`) vs those that haven't (`convnext`). (Note that many of the best performing models were trained on the larger sample -- see the papers for details before coming to conclusions about the effectiveness of these architectures more generally.)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "1a2b9819", + "metadata": { + "execution": { + "iopub.execute_input": "2023-06-06T00:09:24.034486Z", + "iopub.status.busy": "2023-06-06T00:09:24.033959Z", + "iopub.status.idle": "2023-06-06T00:09:24.037512Z", + "shell.execute_reply": "2023-06-06T00:09:24.036869Z" + }, + "papermill": { + "duration": 0.049404, + "end_time": "2023-06-06T00:09:24.039792", + "exception": false, + "start_time": "2023-06-06T00:09:23.990388", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "subs = 'levit|resnetd?|regnetx|vgg|convnext.*|efficientnetv2|beit|swin'" + ] + }, + { + "cell_type": "markdown", + "id": "89918e3b", + "metadata": { + "papermill": { + "duration": 0.038349, + "end_time": "2023-06-06T00:09:24.121056", + "exception": false, + "start_time": "2023-06-06T00:09:24.082707", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "In this chart, I'll add lines through the points of each family, to help see how they compare -- but note that we can see that a linear fit isn't actually ideal here! It's just there to help visually see the groups." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "594b9d99", + "metadata": { + "execution": { + "iopub.execute_input": "2023-06-06T00:09:24.200873Z", + "iopub.status.busy": "2023-06-06T00:09:24.200527Z", + "iopub.status.idle": "2023-06-06T00:09:24.207337Z", + "shell.execute_reply": "2023-06-06T00:09:24.206287Z" + }, + "papermill": { + "duration": 0.04978, + "end_time": "2023-06-06T00:09:24.210021", + "exception": false, + "start_time": "2023-06-06T00:09:24.160241", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "def show_subs(df, title, size):\n", + " df_subs = df[df.family.str.fullmatch(subs)]\n", + " return px.scatter(df_subs, width=w, height=h, size=df_subs[size]**2, title=title,\n", + " trendline=\"ols\", trendline_options={'log_x':True},\n", + " x='secs', y='top1', log_x=True, color='family', hover_name='model_org', hover_data=[size])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "41360002", + "metadata": { + "execution": { + "iopub.execute_input": "2023-06-06T00:09:24.287887Z", + "iopub.status.busy": "2023-06-06T00:09:24.287408Z", + "iopub.status.idle": "2023-06-06T00:09:26.028754Z", + "shell.execute_reply": "2023-06-06T00:09:26.027866Z" + }, + "papermill": { + "duration": 1.783648, + "end_time": "2023-06-06T00:09:26.031328", + "exception": false, + "start_time": "2023-06-06T00:09:24.247680", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "show_subs(df, 'Inference', 'infer_img_size')" + ] + }, + { + "cell_type": "markdown", + "id": "044f9ada", + "metadata": { + "papermill": { + "duration": 0.039246, + "end_time": "2023-06-06T00:09:26.112121", + "exception": false, + "start_time": "2023-06-06T00:09:26.072875", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "From this, we can see that the *levit* family models are extremely fast for image recognition, and clearly the most accurate amongst the faster models. That's not surprising, since these models are a hybrid of the best ideas from CNNs and transformers, so get the benefit of each. In fact, we see a similar thing even in the middle category of speeds -- the best is the ConvNeXt, which is a pure CNN, but which takes advantage of ideas from the transformers literature.\n", + "\n", + "For the slowest models, *beit* is the most accurate -- although we need to be a bit careful of interpreting this, since it's trained on a larger dataset (ImageNet-21k, which is also used for *vit* models).\n", + "\n", + "I'll add one other plot here, which is of speed vs parameter count. Often, parameter count is used in papers as a proxy for speed. However, as we see, there is a wide variation in speeds at each level of parameter count, so it's really not a useful proxy.\n", + "\n", + "(Parameter count may be be useful for identifying how much memory a model needs, but even for that it's not always a great proxy.)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "10ac5b5b", + "metadata": { + "execution": { + "iopub.execute_input": "2023-06-06T00:09:26.198946Z", + "iopub.status.busy": "2023-06-06T00:09:26.198348Z", + "iopub.status.idle": "2023-06-06T00:09:26.314035Z", + "shell.execute_reply": "2023-06-06T00:09:26.313164Z" + }, + "papermill": { + "duration": 0.16186, + "end_time": "2023-06-06T00:09:26.316322", + "exception": false, + "start_time": "2023-06-06T00:09:26.154462", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "px.scatter(df, width=w, height=h,\n", + " x='param_count_x', y='secs', log_x=True, log_y=True, color='infer_img_size',\n", + " hover_name='model_org', hover_data=['infer_samples_per_sec', 'family']\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "adddcfc5", + "metadata": { + "papermill": { + "duration": 0.040703, + "end_time": "2023-06-06T00:09:26.397893", + "exception": false, + "start_time": "2023-06-06T00:09:26.357190", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## Training results" + ] + }, + { + "cell_type": "markdown", + "id": "81a05be8", + "metadata": { + "papermill": { + "duration": 0.041581, + "end_time": "2023-06-06T00:09:26.480648", + "exception": false, + "start_time": "2023-06-06T00:09:26.439067", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "We'll now replicate the above analysis for training performance. First we grab the data:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "fbc3b0e3", + "metadata": { + "execution": { + "iopub.execute_input": "2023-06-06T00:09:26.571526Z", + "iopub.status.busy": "2023-06-06T00:09:26.571055Z", + "iopub.status.idle": "2023-06-06T00:09:26.599861Z", + "shell.execute_reply": "2023-06-06T00:09:26.598755Z" + }, + "papermill": { + "duration": 0.080089, + "end_time": "2023-06-06T00:09:26.602703", + "exception": false, + "start_time": "2023-06-06T00:09:26.522614", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "tdf = get_data('train', 'train_samples_per_sec')" + ] + }, + { + "cell_type": "markdown", + "id": "764ade98", + "metadata": { + "papermill": { + "duration": 0.041981, + "end_time": "2023-06-06T00:09:26.686571", + "exception": false, + "start_time": "2023-06-06T00:09:26.644590", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "Now we can repeat the same *family* plot we did above:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "bff04fca", + "metadata": { + "execution": { + "iopub.execute_input": "2023-06-06T00:09:26.773391Z", + "iopub.status.busy": "2023-06-06T00:09:26.773101Z", + "iopub.status.idle": "2023-06-06T00:09:27.009934Z", + "shell.execute_reply": "2023-06-06T00:09:27.008975Z" + }, + "papermill": { + "duration": 0.283234, + "end_time": "2023-06-06T00:09:27.012608", + "exception": false, + "start_time": "2023-06-06T00:09:26.729374", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "show_all(tdf, 'Training', 'train_img_size')" + ] + }, + { + "cell_type": "markdown", + "id": "a15756d3", + "metadata": { + "papermill": { + "duration": 0.043046, + "end_time": "2023-06-06T00:09:27.098532", + "exception": false, + "start_time": "2023-06-06T00:09:27.055486", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "...and we'll also look at our chosen subset of models:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "65a40fe0", + "metadata": { + "execution": { + "iopub.execute_input": "2023-06-06T00:09:27.185428Z", + "iopub.status.busy": "2023-06-06T00:09:27.185118Z", + "iopub.status.idle": "2023-06-06T00:09:27.389152Z", + "shell.execute_reply": "2023-06-06T00:09:27.388142Z" + }, + "papermill": { + "duration": 0.250038, + "end_time": "2023-06-06T00:09:27.391617", + "exception": false, + "start_time": "2023-06-06T00:09:27.141579", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "show_subs(tdf, 'Training', 'train_img_size')" + ] + }, + { + "cell_type": "markdown", + "id": "f9bb9e9a", + "metadata": { + "papermill": { + "duration": 0.042772, + "end_time": "2023-06-06T00:09:27.480454", + "exception": false, + "start_time": "2023-06-06T00:09:27.437682", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "Finally, we should remember that speed depends on hardware. If you're using something other than a modern NVIDIA GPU, your results may be different. In particular, I suspect that transformers-based models might have worse performance in general on CPUs (although I need to study this more to be sure)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d1274b15", + "metadata": { + "papermill": { + "duration": 0.042991, + "end_time": "2023-06-06T00:09:27.566602", + "exception": false, + "start_time": "2023-06-06T00:09:27.523611", + "status": "completed" + }, + "tags": [] + }, + "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.13" + }, + "papermill": { + "default_parameters": {}, + "duration": 23.634953, + "end_time": "2023-06-06T00:09:28.533193", + "environment_variables": {}, + "exception": null, + "input_path": "__notebook__.ipynb", + "output_path": "__notebook__.ipynb", + "parameters": {}, + "start_time": "2023-06-06T00:09:04.898240", + "version": "2.3.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}