{ "cells": [ { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from fastai import *\n", "from fastai.vision import *" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The blog can be found at this [link]()." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Code for Weight Standardization\n", "class Conv2d(nn.Conv2d):\n", " def __init__(self, in_channels, out_channels, kernel_size, stride=1,\n", " padding=0, dilation=1, groups=1, bias=True):\n", " super().__init__(in_channels, out_channels, kernel_size, stride,\n", " padding, dilation, groups, bias)\n", "\n", " def forward(self, x):\n", " weight = self.weight\n", " weight_mean = weight.mean(dim=1, keepdim=True).mean(dim=2,\n", " keepdim=True).mean(dim=3, keepdim=True)\n", " weight = weight - weight_mean\n", " std = weight.view(weight.size(0), -1).std(dim=1).view(-1, 1, 1, 1) + 1e-5\n", " weight = weight / std.expand_as(weight)\n", " return F.conv2d(x, weight, self.bias, self.stride,\n", " self.padding, self.dilation, self.groups)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Define model\n", "I test with Resnet-18" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "class BasicBlock(nn.Module):\n", " expansion = 1\n", " def __init__(self, inplanes, planes, stride=1, downsample=None, groups=1, norm_layer=None, use_ws=False):\n", " super().__init__()\n", " if use_ws:\n", " my_conv = Conv2d\n", " else:\n", " my_conv = nn.Conv2d\n", " \n", " if norm_layer is None:\n", " norm_layer = nn.BatchNorm2d\n", " if groups != 1:\n", " raise ValueError('BasicBlock only supports groups=1')\n", " # Both self.conv1 and self.downsample layers downsample the input when stride != 1\n", " self.conv1 = my_conv(inplanes, planes, kernel_size=3, stride=stride, padding=1, groups=groups, bias=False)\n", " self.bn1 = norm_layer(planes)\n", " self.relu = nn.ReLU(inplace=True)\n", " self.conv2 = my_conv(planes, planes, kernel_size=3, padding=1, groups=groups, bias=False)\n", " self.bn2 = norm_layer(planes)\n", " self.downsample = downsample\n", " self.stride = stride\n", "\n", " def forward(self, x):\n", " identity = x\n", "\n", " out = self.conv1(x)\n", " out = self.bn1(out)\n", " out = self.relu(out)\n", "\n", " out = self.conv2(out)\n", " out = self.bn2(out)\n", "\n", " if self.downsample is not None:\n", " identity = self.downsample(x)\n", "\n", " out += identity\n", " out = self.relu(out)\n", "\n", " return out\n", " \n", "class ResNet(nn.Module):\n", " def __init__(self, block, layers, use_ws=False, num_classes=1000, zero_init_residual=False,\n", " groups=1, width_per_group=64, norm_layer=None):\n", " super().__init__()\n", " if norm_layer is None:\n", " norm_layer = nn.BatchNorm2d\n", " \n", " if use_ws:\n", " self.my_conv = Conv2d\n", " else:\n", " self.my_conv = nn.Conv2d\n", " self.use_ws = use_ws\n", " \n", " planes = [int(width_per_group * groups * 2 ** i) for i in range(4)]\n", " self.inplanes = planes[0]\n", " self.conv1 = self.my_conv(3, planes[0], kernel_size=3, stride=1, padding=0,\n", " bias=False)\n", " self.bn1 = norm_layer(planes[0])\n", " self.relu = nn.ReLU(inplace=True)\n", "\n", " self.layer1 = self._make_layer(block, planes[0], layers[0], groups=groups, norm_layer=norm_layer)\n", " self.layer2 = self._make_layer(block, planes[1], layers[1], stride=2, groups=groups, norm_layer=norm_layer)\n", " self.layer3 = self._make_layer(block, planes[2], layers[2], stride=2, groups=groups, norm_layer=norm_layer)\n", " self.layer4 = self._make_layer(block, planes[3], layers[3], stride=2, groups=groups, norm_layer=norm_layer)\n", " self.avgpool = nn.AdaptiveAvgPool2d((1, 1))\n", " self.fc = nn.Linear(planes[3] * block.expansion, num_classes)\n", "\n", " for m in self.modules():\n", " if isinstance(m, nn.Conv2d) or isinstance(m, Conv2d):\n", " nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')\n", " elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):\n", " nn.init.constant_(m.weight, 1)\n", " nn.init.constant_(m.bias, 0)\n", "\n", " # Zero-initialize the last BN in each residual branch,\n", " # so that the residual branch starts with zeros, and each residual block behaves like an identity.\n", " # This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677\n", " if zero_init_residual:\n", " for m in self.modules():\n", " if isinstance(m, Bottleneck):\n", " nn.init.constant_(m.bn3.weight, 0)\n", " elif isinstance(m, BasicBlock):\n", " nn.init.constant_(m.bn2.weight, 0)\n", "\n", " def _make_layer(self, block, planes, blocks, stride=1, groups=1, norm_layer=None):\n", " if norm_layer is None:\n", " norm_layer = nn.BatchNorm2d\n", " downsample = None\n", " if stride != 1 or self.inplanes != planes * block.expansion:\n", " downsample = nn.Sequential(\n", " self.my_conv(self.inplanes, planes * block.expansion, kernel_size=1, stride=stride, bias=False),\n", " norm_layer(planes * block.expansion),\n", " )\n", "\n", " layers = []\n", " layers.append(block(self.inplanes, planes, stride, downsample, groups, norm_layer, use_ws=self.use_ws))\n", " self.inplanes = planes * block.expansion\n", " for _ in range(1, blocks):\n", " layers.append(block(self.inplanes, planes, groups=groups, norm_layer=norm_layer, use_ws=self.use_ws))\n", "\n", " return nn.Sequential(*layers)\n", "\n", " def forward(self, x):\n", " x = self.conv1(x)\n", " x = self.bn1(x)\n", " x = self.relu(x)\n", "\n", " x = self.layer1(x)\n", " x = self.layer2(x)\n", " x = self.layer3(x)\n", " x = self.layer4(x)\n", "\n", " x = self.avgpool(x)\n", " x = x.view(x.size(0), -1)\n", " x = self.fc(x)\n", "\n", " return x" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "resnet18 = ResNet(BasicBlock, [2, 2, 2, 2], num_classes=10)\n", "resnet18_ws = ResNet(BasicBlock, [2, 2, 2, 2], num_classes=10, use_ws=True)\n", "\n", "# Save state dict, so we have same model weights\n", "state_dict = resnet18.state_dict()\n", "resnet18_ws.load_state_dict(state_dict)\n", "\n", "def get_models():\n", " resnet18 = ResNet(BasicBlock, [2, 2, 2, 2], num_classes=10)\n", " resnet18_ws = ResNet(BasicBlock, [2, 2, 2, 2], num_classes=10, use_ws=True)\n", "\n", " # Save state dict, so we have same model weights\n", " state_dict = resnet18.state_dict()\n", " resnet18_ws.load_state_dict(state_dict)\n", " \n", " return resnet18, resnet18_ws" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Load data" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# For the data I use CIFAR-10\n", "path = Path('/home/kushaj/Desktop/Data/cifar10/')\n", "src = (ImageList.from_folder(path)\n", " .split_by_folder()\n", " .label_from_folder())" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "data = (src.transform(size=(32, 32))\n", " .databunch(path, 64)\n", " .normalize(cifar_stats))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Start experimentation" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# The paper proved that Weight standardization smoothened the loss surface.\n", "# If that is true then we should be able to train our model with higher \n", "# learning rate. So we test that now using lr_find" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "learn = Learner(data, resnet18)\n", "learn_ws = Learner(data, resnet18_ws)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/html": [], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n" ] } ], "source": [ "# First I test for model with only Batch Norm\n", "learn.lr_find()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "lr_find = learn.recorder.plot(return_fig=True)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/html": [], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n" ] } ], "source": [ "learn_ws.lr_find()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEKCAYAAAD9xUlFAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3Xl4XFd9//H3V/u+2JJsWbbs2EmcPXaiJGQBEgghpBAIZW1J2dqU0rIU6EaeUgoPLUtZUiiFNGyhof2RBQgpgZgQk9VJbMe7k3hNLFuyJEvWPlpmvr8/5kqRFcmWbd2ZO9Ln9Tzz5M695977HcWar84595xj7o6IiAhAVroDEBGR6FBSEBGRUUoKIiIySklBRERGKSmIiMgoJQURERmlpCAiIqOUFEREZJSSgoiIjMpJdwDHq6qqypcsWZLuMEREMsq6deva3L36WOVCSwpmVgA8DOQH97nL3f9pkrJvA+4ELnL3tUe77pIlS1i79qhFRERkHDN7YSrlwqwpDACvcfceM8sFHjWz+919zdhCZlYKfBR4MsRYRERkCkLrU/CknuBtbvCaaPa9zwNfBmJhxSIiIlMTakezmWWb2QagBVjl7k+OO74SWOTu94UZh4iITE2oScHd4+6+AlgIXGxm54wcM7Ms4OvAJ491HTO7yczWmtna1tbW8AIWEZnlUvJIqrsfBlYD147ZXQqcA6w2s73AK4B7zaxhgvNvdfcGd2+orj5m57mIiJyg0JKCmVWbWUWwXQhcDTw7ctzdO929yt2XuPsSYA1w/bGePhIRkfCEWVOoBR4ys03A0yT7FO4zs8+Z2fUh3ldERE5QaI+kuvsmYOUE+z8zSfkrw4pFRCTT3fLbHVywuIJXnhZuE7qmuRARibjheIJbHnyep/e0h34vJQURkYhr7Rkg4TC/vDD0eykpiIhEXFNncmxvbXlB6PdSUhARibjmICnMK1NSEBGZ9VRTEBGRUQe7YuTnZFFRlBv6vZQUREQirqkzRm15AWYW+r2UFEREIq65s5/5KWg6AiUFEZHIa+qMMT8FncygpCAiEmmJhHOwK5aSMQqgpCAiEmntfYMMxT0lTx6BkoKISKSNjFFQn4KIiIyOUVCfgoiI0NzZD6Rm4BooKYiIRFpzV4ycLGNuSX5K7qekICISYU2dMeaVFZCdFf7ANVBSEBGJtObOWMo6mUFJQUQk0ppTOHANlBRERCLL3WnuUk1BRESArtgwfYPxlD15BEoKIiKRleqBa6CkICISWU0pHqMASgoiIpF1sCt1y3COUFIQEYmops4YZlBTqqQgIjLrNXfGqCrJJy8ndV/Vod3JzArM7Ckz22hmW83snyco8wkz22Zmm8zsQTNbHFY8IiKZZmQZzlQKM/0MAK9x9/OBFcC1ZvaKcWWeARrc/TzgLuDLIcYjIpJRDnalduAahJgUPKkneJsbvHxcmYfcvS94uwZYGFY8IiKZpinFU1xAyH0KZpZtZhuAFmCVuz95lOIfBO4PMx4RkUzRNzhMZ//QzEoK7h539xUkawAXm9k5E5Uzs/cADcBXJjl+k5mtNbO1ra2t4QUsIhIRIwPXZlKfwih3PwysBq4df8zMrgZuBq5394FJzr/V3RvcvaG6ujrUWEVEomB0NHNZYUrvG+bTR9VmVhFsFwJXA8+OK7MS+C7JhNASViwiIpmmuSv1U1wA5IR47VrgR2aWTTL5/NTd7zOzzwFr3f1eks1FJcCdZgbwortfH2JMIiIZIdVrM48ILSm4+yZg5QT7PzNm++qw7i8iksmaO2NUFOVSmJed0vtqRLOISAQ1pXhxnRFKCiIiEdTc1Z/yJ49ASUFEJJKaDseorUjtk0egpCAiEjmxoTiHegepVfORiIiMrKOgmoKIiIw+jqo+BRERGV2GM9UD10BJQUQkclRTEBGRUc2dMcoLcynKC3PSiYkpKYiIRMyBw6lfcW2EkoKISMSka+AaKCmIiERO0+EY88tT/zgqKCmIiETKyMC1BaopiIhIS1dyrbF0PI4KSgoiIpFyIBijUKvmIxERGV2buUI1BRGRWe+lmoKSgojIrJfOgWugpCAiEinpHLgGSgoiIpHS3NWftiePQElBRCRSmjtjaXvyCJQUREQiY2A4TlvPoJqPREQEDnYmB64pKYiISNoHroGSgohIZIwMXFNHs4iIpHXFtRGhJQUzKzCzp8xso5ltNbN/nqBMvpn9PzPbaWZPmtmSsOIREYm6ps5+ygpyKM5Pz8A1CLemMAC8xt3PB1YA15rZK8aV+SDQ4e6nAl8HvhRiPCIikdbUGWNBRfr6EyDEpOBJPcHb3ODl44q9GfhRsH0X8Fozs7BiEhGJsqbO9A5cg5D7FMws28w2AC3AKnd/clyROmAfgLsPA53A3Amuc5OZrTWzta2trWGGLCKSNsmBazM4Kbh73N1XAAuBi83snHFFJqoVjK9N4O63unuDuzdUV1eHEaqISFq9NHBthjYfjeXuh4HVwLXjDjUCiwDMLAcoB9pTEZOISJSMDFybsc1HZlZtZhXBdiFwNfDsuGL3Au8Ntt8G/M7dX1ZTEBGZ6ZqCgWsL0lxTCPO5p1rgR2aWTTL5/NTd7zOzzwFr3f1e4HvAj81sJ8kawrtCjEdEJLKau5JjFOaV5ac1jtCSgrtvAlZOsP8zY7ZjwNvDikFEJFO0diebj2pKZ2jzkYiITF1L9wB5OVmUFaZv4BooKYiIREJLV4ya0nzSPVRLSUFEJAJaugeoKU1vfwIoKYiIREIyKaS3PwGUFEREIqGlK0ZNmp88AiUFEZG0iw3F6YoNq/lIRESi8zgqKCmIiKRdS3dy4Fq1mo9EROSlmoKSgojIrNcSJIVqJQUREWnpGiDLYG6xkoKIyKzX0h2jqiSf7Kz0LzyppCAikmYt3QORGKMASgoiImnX0hWN0cygpCAiknZRmfcIlBRERNJqOJ7gUK+SgoiIAId6B3GH6jI1H4mIzHotXdEZuAZKCiIiaTUyxYWSgoiIvDTFhZqPRERkZIqLqpK8NEeSNKWkYGbLzCw/2L7SzD5qZhXhhiYiMvO1dMeoKMolPyc73aEAU68p3A3EzexU4HvAKcBPQotKRGSWSA5ci0Z/Akw9KSTcfRi4AfiGu/81UBteWCIis0NU1mYeMdWkMGRm7wbeC9wX7MsNJyQRkdmjNUKjmWHqSeH9wKXAF9x9j5mdAvz30U4ws0Vm9pCZbTezrWb2sQnKlJvZL81sY1Dm/cf/EUREMpO709o9EIkV10bkTKWQu28DPgpgZpVAqbt/8RinDQOfdPf1ZlYKrDOzVcG1RvwlsM3d32Rm1cBzZnaHuw8e/0cREcksh/uGGIwnMq/5yMxWm1mZmc0BNgI/MLOvHe0cd29y9/XBdjewHagbXwwoNTMDSoB2kslERGTGa4nQMpwjptp8VO7uXcBbgR+4+4XA1VO9iZktAVYCT4479C3gTOAAsBn4mLsnJjj/JjNba2ZrW1tbp3pbEZFIi9poZph6Usgxs1rgHbzU0TwlZlZC8pHWjweJZazXAxuABcAK4FtmVjb+Gu5+q7s3uHtDdXX18dxeRCSyRuc9ishoZph6Uvgc8Btgl7s/bWZLgR3HOsnMckkmhDvc/Z4JirwfuMeTdgJ7gDOmGJOISEYbaT6qjlBNYaodzXcCd455vxv4w6OdE/QTfA/Y7u6T9T+8CLwWeMTM5gHLgd1TiUlEJNO1dg9QlJdNSf6UvopTYkqRmNlC4JvA5SQ7hx8l2f7feJTTLgduBDab2YZg36eBegB3/w7weeCHZrYZMODv3L3tRD6IiEimaemORao/AaaYFIAfkJzW4u3B+/cE+1432Qnu/ijJL/pJufsB4JopxiAiMqNEbTQzTL1Podrdf+Duw8Hrh4B6fEVETkLUBq7B1JNCm5m9x8yyg9d7gENhBiYiMpO5Oy1d0Ws+mmpS+ADJx1GbgSbgbSSfHBIRkRNwuG+I3sE4dRWF6Q7lCFNKCu7+ortf7+7V7l7j7m8hOZBNREROwL6OPgAWVhalOZIjnczKa5+YtihERGaZfe39ACyak4E1hUkc9ckiERGZ3EhNYdGcmVNT8GmLQkRkltnX3kd5YS5lBdFamuao4xTMrJuJv/wNiFadR0Qkg+zr6I9c0xEcIym4e2mqAhERmU0a2/tYPj96X7En03wkIiInIJFwGjv6I9efAEoKIiIp19I9wGA8waLK6DUfKSmIiKTY6BgF1RRERGRfe/A4asQGroGSgohIyo0MXFuo5iMREdnX0UdNaT4FudnpDuVllBRERFJsX3tfJJ88AiUFEZGUa+zoj+STR6CkICKSUkPxBE2d0RyjAEoKIiIpdeBwPwmP5pNHoKQgIpJSo08eRXDeI1BSEBFJqdEps1VTEBGRfe195GQZteUF6Q5lQkoKIiIptK+jnwUVheRkR/PrN5pRiYjMUMkxCtHsTwAlBRGRlGrs6ItsfwKEmBTMbJGZPWRm281sq5l9bJJyV5rZhqDM78OKR0Qk3XoHhmnrGYzsGAU4xsprJ2kY+KS7rzezUmCdma1y920jBcysAvg2cK27v2hmNSHGIyKSVo0d0Z0Ib0RoNQV3b3L39cF2N7AdqBtX7I+Ae9z9xaBcS1jxiIik2+iU2RGuKaSkT8HMlgArgSfHHTodqDSz1Wa2zsz+JBXxiIikQ9THKEC4zUcAmFkJcDfwcXfvmuD+FwKvBQqBJ8xsjbs/P+4aNwE3AdTX14cdsohIKPa191OYm01VSV66Q5lUqDUFM8slmRDucPd7JijSCPza3XvdvQ14GDh/fCF3v9XdG9y9obq6OsyQRURC8/Tedk6fV4KZpTuUSYX59JEB3wO2u/vXJin2C+CVZpZjZkXAJST7HkREZpSdLd1s3t/Jm85fkO5QjirM5qPLgRuBzWa2Idj3aaAewN2/4+7bzezXwCYgAdzm7ltCjElEJC1+9sx+sgyuXzFLk4K7Pwocs47k7l8BvhJWHCIi6ZZIOD9/5gBXnFZNTWk05zwaoRHNIiIhe2pvO/sP9/PWleOfyo8eJQURkZD9bP1+ivKyuebseekO5ZiUFEREQhQbivOrzU1ce858ivJCHwVw0pQURERC9OD2FroHhnnryoXpDmVKlBRERKZRc2eMtp6B0fc/e6aReWX5XLpsbhqjmrro12VERDJE3+Awr/va7+keGGZhZSErFlWw+rlWPnDFKWRnRXfA2lhKCiIi02T1c610DwzzvsuW0NIdY/0LHWSZ8fYLM6PpCJQURESmza82NzG3OI9/fONZozWDoXiC3IguvTmRzIlURCTCYkNxHnq2hWvOnn9EU1EmJQRQUhARmRaP7GijdzDOG86Zn+5QToqSgojINLh/cxPlhbkZ85TRZJQURERO0uBwglXbD/K6s+ZlXHPReJkdvYhIBDy2q43u2DDXnZvZTUegpCAictJ+vbmZ0vwcLj+1Kt2hnDQlBRGRkzAcT/DAtmZee2YN+TnZ6Q7npCkpiIichCf3tNPRN8S159SmO5RpocFrIiInoKN3kF9uOsAPH99LUV42Vy6fGevHKymIiByHw32D3PzzLazaepDBeIKzF5TxtXesoCA385uOQElBROS4fPfh3dy/uYn3XraEt1+4iLMWlKU7pGmlpCAiMkX9g3F+8uSLvP7s+fzTm85OdzihUEeziMgU3fNMI539Q3zgilPSHUpolBREZEZKJJwt+zs5NGbBm5O93vcf3cO5deU0LK6clmtGkZqPRGTGcXc++8ut3P7ECwAsmlPIikWVnDG/lDnFeVQW5TG3JI/Ta0opL8qd0jUf2dnGrtZevv7O8zHLjAVzToSSgojMOD98fC+3P/EC7764niVzi9iw7zBr97bzy40HjihnBmfVlvGKpXO5bNlcrjitatIBaN9/dA/Vpfn8wbkLUvER0kZJQURmlAe3H+Tz923j9WfP4wtvOYesMWsb9A/G6egbpL13kNaeATbuO8ya3Yf48ZoX+N6jeygvzOVN59fy1gsWsnJRxWiNYGdLN79/vpVPvu508nJmdqt7aEnBzBYBtwPzgQRwq7vfMknZi4A1wDvd/a6wYhKRmW3L/k4+8j/PcE5dOd9458ojEgJAYV42hXmFLKgoBOCq5TVAcoGcNbsP8bNn9nPXukb+e82LzC8r4NyF5ZxXV87m/Z3k5WTxR5fUp/wzpVqYNYVh4JPuvt7MSoF1ZrbK3beNLWRm2cCXgN+EGIuIzGDuzv1bmvnHn2+hojCX2/6kgcK8qQ8mK8jN5srlNVy5vIbu2BD3b27m0Z1tbNnfyaptBwF410WLmFuSH9ZHiIzQkoK7NwFNwXa3mW0H6oBt44p+BLgbuCisWERkZuiKDXHHmhc5raaECxdXUlmcx4HD/XzmF1v47fYWzl5Qxi3vWkFNWcEJ36O0IJd3XLSId1y0CIDu2BA7WnpYPq90uj5GpKWkT8HMlgArgSfH7a8DbgBeg5KCiBzDN1bt4PuP7Rl9f2pNCU2H+4m7c/N1Z/L+y5eQM82L3JQW5HJB/cx9BHW80JOCmZWQrAl83N27xh3+BvB37h4/2iNeZnYTcBNAff3Mb9MTkZfb197Hj9fs5a0X1PHOhkWsfaGDp/e2s3xeKX//hjNYNKco3SHOCKEmBTPLJZkQ7nD3eyYo0gD8b5AQqoDrzGzY3X8+tpC73wrcCtDQ0OBhxiwi0fS1Vc+TZcbfvH45teWFXLI0s9dCjqownz4y4HvAdnf/2kRl3P2UMeV/CNw3PiGIiGw90MnPN+znQ69eRm15YbrDmdHCrClcDtwIbDazDcG+TwP1AO7+nRDvLSIzyJd//RxlBbl86NXL0h3KjBfm00ePAlMeC+7u7wsrFhHJXI/vbOP3z7dy83VnUl44tSkp5MRpRLOIRFLPwDAPbj/ILQ/uoK6ikBsvXZzukGYFJQURSTt3p6kzxs6WHna29PD4rkM8vKOVweEENaX5fOlt582Ylc2iTklBRNLq6b3t3HT7Wjr6hkb3LSgv4D2XLOa6c+dzQX3ly6arkPAoKWSIRMJxIFu/HDKD9A/G+dSdGynOz+ETrzudU2tKObWmhKqSvBk9PXWUKSmkSCLhvNjex7PN3RzsigWvAQaG45QW5FJWmENpfg7DCad3YJiegThdsSFaumI0dSbLxxNOdWk+88oKqCktAJyegWF6B+Kj16ksyqW8MDlXfHVJPjVl+aPnzCsroCRf/8slOr7+2+d54VAfP/mzS7hsWVW6wxFmUVJo6xng2aZuTp9XQnVp/rT9FdLU2c/GfYc52DVAa3fy1TcUJzfLyM3OIivL2NPWw9b9XXQPDI+el5Nl1JTmU5CbTVdsmK7YEIPDCQAKc7Mpzs+htCCHeWX5NCyuZH55ITlZRkt3jOauARo7+sgyoyQ/h6qSPPJzsumKDXHgcIxtB7po6x0cvd5YJfk5VJfmU5SXTXFeDoV52STcOdw3RHvvIF39Q8wpyeOUqmKWVpWwpKqIsoLcZPn8HApys8nLziIvJ/maV5ZPUd6s+Wck02jjvsPc9shu3n1xvRJChMya3+bHdrbxsf9NDpeoKMrl9HmlnFZTwilVxZxSVcySqmJqywuO+IJzd7r6h9nX0ceh3kFiQ3EGhhP0DQyzsbGTJ3a1sfdQ32j5LIOqknyK83MYiicYjjvDiQR1lUW8eeUCzq0r56zacmorCphTlPeydtKB4Tg5WVnT0kTk7nTFhmntjtHSNUBL9wAHu2I0d8Vo7R6gfzBO7+Awh/sGwYy5JXmcWlNCeWEurT0D7G7tZc3uQ8SGXp5YxqstL2BpdTH1c4rIMsMBdyjIzaK2vID55YXUlhewrLqEOcV5J/3ZJPMNDif427s2UVNawD9cd0a6w5ExZk1SuHJ5DT/500t4/mA3zx3s4fmD3dy3qYnO/qEjyhXkZjG3OJ/i/GyaDseO+Ot+rNL8HC5ZOof3vGIxFy2ZQ11lIZVFeSf1hT7Zik8nwswoL8ylvDCXU2tObHbHRMJp6x2gdyBO78AwvQPD9A/FGYo7Q/EEA8Nx9nf0s7u1l11tvaza1oK7k6yEGX2Dw/QNxo+4Zk1pPmfUlnHG/GRSPm1esg1ZzVqzy3+u3sVzB7u57U8aKCvQ2IMomTW/ieWFuVx2ahWXnXpkNbWjd5A9h3rZ09pLS/cA7b0DHOodpCc2zKVL57JoThELKwupLs0nPyebgtws8nOyWVBROOM7fbOyLNl3cYIzBrs73QPDNHfGOHC4n50tPWxv6ubZ5i5++NghBuMv1UIWVhZybl055wSvc+vKVauYofa19/EfD+3kTecv4Oqz5qU7HBln1iSFyVQW51FZnDerpsZNFTOjrCCXsoJkc92VwSpXAMPxBC+297GjpYcdB7vZ3tzNlv2d3L+lebTMgvICzqkr57yF5bzytGrOrSvXo4kzwFd+8xxZWXDzdWemOxSZwKxPCpIeOdlZLK0uYWl1Ca8/e/7o/s7+IbYe6GTr/i427+9ky4FOVm0/yL898Dxzi/N49fJqrjlrHledUTOtzW2SGpsaD3PvxgP81VWnMr/8xBfCkfAoKUiklBfmctmyqiOeRmnvHeTh51t56LkWfvdsC/es3095YS5vPC+5wPoF9RV6pj0DuDv/8qvtzC3O489fvTTd4cgklBQk8uYU5/GWlXW8ZWUdw/EEj+86xD3rG7l7fSN3PPkiZ9WW8RdXLuO6c2tnfD9PJnvouRbW7G7nc28+m1J1LkeWuWfWmjUNDQ2+du3adIchEdAdG+L/NjVx6yO72d3ay5K5Rfz5q5fx1gvq1LQUMcPxBG+45RGGE84Df/0qcqd5yUw5NjNb5+4NxyynpCCZLp5wHtjazLdX72Lz/k5qywv481ct5V0X12sStTTq7B9iT1sve9p6eGLXIX66tpH//OMLeMO5tekObVZSUpBZx915ZEcb3/zdDp7e20FVST4fevVS3vOKxUoOIXN37lzXyJpdh9h7qJe9h/po7x0cPZ6dZVx7zny+9e6V6v9JEyUFmdXW7D7EN3+3g8d2HqKuopBPvO503rKyTn0OIbn9ib185hdbmVeWH0yPUsySuUUsrU7OGlA/p4i8HDUZpZOSggjJ6U2+eP+zbN7fyRnzS3njebWjX1SL5xZRmJutv1xP0uM727jx+09x1fJqbr2xQWNJIkpJQSSQSDj/t7mJWx7cwc6WniOOZVlyAsLCvBwWzy3ihpV1vOn8BVr2cYpeONTLm//jMWpK87nnw5drupIIU1IQmUDvwHDQ+dnLvo4++gbi9A/F6RuMs/6FDp472E1+ThavP3s+N166mIbFlapJTKI7NsRbv/04rT0D3PuXV1A/tyjdIclRTDUpKK3LrFKcnzM6v9J47s7m/Z3cubaRX2zYz70bD7CyvoKbXrmUa86er/6IMZo7Y3z4jnXsaevl9g9erIQwg6imIDKBvsFh7lrXyG2P7OHF9j6WzC3iE9cs543n1s76NvPHd7Xx0f95hr7BOF99+/l6xDRDqPlIZBrEE85vtjbz7w/u4Nnmbs5bWM7fv+GMyC8KMxRPsO1AF+te6GDdix109g2xaE4hi+YUUT+niHMWlLN4btGkTWPuzvMHe3h0ZxuJhFNZnMec4ly27u/i6799nlOqivnujRee8LTsknpKCiLTKJ5wfv7Mfr76wHMc6Iyxsr6CC+orOW9hcprvU6qK09L3EBuKs+NgD9ubu9jd2svetl72Hkr2mQwEK+/VVRRSVZJHY0c/h8aMHagpzeeiU+awYmEFeTlZxBNOwp3dbb2sfraFA52xCe/5B+fV8qU/PE+dyhlGSUEkBLGhOLc/sZf7tzSz7UDX6BfvuXXlfPzq03jNGTXTkhw6+4d4cPtBcrKzWFZdzLLqEvJzstjT1stTe9p5am87mxo72d3aQyL4Fc7NNhbNKeKUucnVBFfUV3Dh4kpqywtHr9s7MMzeQ71s2Hc4eZ097TSN+/IvzsvmitOquGp5Da9eXk1Jfg4dvUO09w2ScGflIk1AmInSnhTMbBFwOzAfSAC3uvst48r8MfB3wdse4C/cfePRrqukIFExFE+ws6WHp/e2j/Y9nLewnA9feSpnLyhjXlnB6ICt2FCcxo5+Gjv66BuMjy7XmnCnoijZNDOnOJ89bT3cvX4/q7YdPGKNbbPk+trdseRKgHOL81hZX8lZtaWcWVvGGbVl1M8pOu7OcHeno28Idyc7yzAzivOyydHcRDNOFJJCLVDr7uvNrBRYB7zF3beNKXMZsN3dO8zsDcBn3f2So11XSUGiaCie4Gfr9/PNh3awr71/dH9VST5ZBi3dA1O+VmVRLtefv4AbLlhIfk4Wu1p72NXSS0t3jHPqyrloyRyWVaenuUoyV9ofSXX3JqAp2O42s+1AHbBtTJnHx5yyBlgYVjwiYcrNzuIdFy3ihgvqeHJ3O/sP99HcOUBzVz9DcWdRZRGL5hSysLKIssIccrKyyM02DONw/yDtvclXeWEurzyt+ogpIc6sLUvjJ5PZJiU9RWa2BFgJPHmUYh8E7k9FPCJhyc3O4orTju/JpHr0jL9ER+hJwcxKgLuBj7t71yRlriKZFK6Y5PhNwE0A9fX1IUUqIiKh9iaZWS7JhHCHu98zSZnzgNuAN7v7oYnKuPut7t7g7g3V1dXhBSwiMsuFlhQs2Qv2PZIdyV+bpEw9cA9wo7s/H1YsIiIyNWE2H10O3AhsNrMNwb5PA/UA7v4d4DPAXODbwZMUw1PpHRcRkXCE+fTRo8BRn5lz9z8F/jSsGERE5PhohIqIiIxSUhARkVFKCiIiMirjJsQzs1bgMNA57lD5MfYda3vsviqg7ThDm+j+Uzk+XXGfSMxHi+tYx8fvP9p7xX3suI51/ETinmif4j728eP5nRz7frriDuu75DR3f/nqUuO5e8a9SE6ud1z7jrU9bt/a6YhpKsenK+4TiXk64z7ae8Wdnrgn2ae4j3H8eH4nw4g7Fd8lR3tlavPRL09g37G2Jzr/ZGOayvGZEvfR3ivuye831eMnEvdkn+VEzKa4j+d3cuz76Yo7Fd8lk8q45qNUMLO1nmHjJTIxZlDcqaa4UysT487UmkLYbk13ACcgE2MGxZ1qiju1Mi5u1RRERGTxsU0kAAAHAklEQVSUagoiIjJqRicFM/u+mbWY2ZYTOPdCM9tsZjvN7N9tzDJXZvYRM3vOzLaa2ZenN+pw4jazz5rZfjPbELyuy4S4xxz/lJm5mR3fYgVTu3cYP+/Pm9mm4Gf9gJktyJC4v2Jmzwax/8zMKjIk7rcHv48JM5u2NvyTiXWS673XzHYEr/eO2X/Uf/8pdSKPeWXKC3gVcAGw5QTOfQq4lOT8TfcDbwj2XwX8FsgP3tdkSNyfBT6VaT/v4Ngi4DfAC0BVJsQNlI0p81HgOxkS9zVATrD9JeBLGRL3mcByYDXQkO5YgziWjNs3B9gd/Lcy2K482udKx2tG1xTc/WGgfew+M1tmZr82s3Vm9oiZnTH+vGB96TJ3f8KT/8duB94SHP4L4IvuPhDcoyVD4g5diHF/HfhbIJQOsDDi9iMXlCoOI/aQ4n7A3YeDoqEskRtS3Nvd/bmoxDqJ1wOr3L3d3TuAVcC16f69HW9GJ4VJ3Ap8xN0vBD4FfHuCMnVA45j3jcE+gNOBV5rZk2b2ezO7KNRoX3KycQP8VdAs8H0zqwwv1COcVNxmdj2w3903hh3oOCf98zazL5jZPuCPSU4TnwrT8e9kxAdI3RK50xl32KYS60TqgH1j3o/EH5XPBaRojeaosOTSoJcBd45pssufqOgE+0b+0sshWfV7BXAR8FMzWxpk+FBMU9z/CXw+eP954Kskf+lDc7Jxm1kRcDPJJo2UmaafN+5+M3Czmf0D8FfAP01zqEcGM01xB9e6GRgG7pjOGCcynXGH7Wixmtn7gY8F+04FfmVmg8Aed7+ByeNP++caa1YlBZI1o8PuvmLsTjPLBtYFb+8l+QU6ttq8EDgQbDcC9wRJ4CkzS5Cc36Q1ynG7+8Ex5/0XcF+I8Y442biXAacAG4NfwIXAejO72N2bIxz3eD8B/o+QkwLTFHfQAfpG4LVh/rEzxnT/vMM0YawA7v4D4AcAZrYaeJ+77x1TpBG4csz7hST7HhpJ/+d6Sbo6M1L1ApYwppMIeBx4e7BtwPmTnPc0ydrASMfPdcH+DwGfC7ZPJ1kdtAyIu3ZMmb8G/jcTft7jyuwlhI7mkH7ep40p8xHgrgyJ+1pgG1AdRrxh/zthmjuaTzRWJu9o3kOypaEy2J4zlc+VyldabpqyDwf/AzQBQySz8QdJ/uX5a2Bj8I//M5Oc2wBsAXYB3+KlgX55wH8Hx9YDr8mQuH8MbAY2kfyrqzYT4h5XZi/hPH0Uxs/77mD/JpJzztRlSNw7Sf6hsyF4hfHUVBhx3xBcawA4CPwmnbEyQVII9n8g+BnvBN5/PP/+U/XSiGYRERk1G58+EhGRSSgpiIjIKCUFEREZpaQgIiKjlBRERGSUkoLMCGbWk+L73WZmZ03TteKWnE11i5n98lgzk5pZhZl9eDruLTKeHkmVGcHMety9ZBqvl+MvTQwXqrGxm9mPgOfd/QtHKb8EuM/dz0lFfDK7qKYgM5aZVZvZ3Wb2dPC6PNh/sZk9bmbPBP9dHux/n5ndaWa/BB4wsyvNbLWZ3WXJNQbuGJnnPtjfEGz3BJPfbTSzNWY2L9i/LHj/tJl9boq1mSd4aTLAEjN70MzWW3Ku/TcHZb4ILAtqF18Jyv5NcJ9NZvbP0/hjlFlGSUFmsluAr7v7RcAfArcF+58FXuXuK0nOXvovY865FHivu78meL8S+DhwFrAUuHyC+xQDa9z9fOBh4M/G3P+W4P7HnMsmmOvntSRHnAPEgBvc/QKS63h8NUhKfw/scvcV7v43ZnYNcBpwMbACuNDMXnWs+4lMZLZNiCezy9XAWWNmsywzs1KgHPiRmZ1GcjbK3DHnrHL3sfPnP+XujQBmtoHkPDiPjrvPIC9NMLgOeF2wfSkvzYv/E+DfJomzcMy115GcZx+S8+D8S/AFnyBZg5g3wfnXBK9ngvclJJPEw5PcT2RSSgoyk2UBl7p7/9idZvZN4CF3vyFon1895nDvuGsMjNmOM/HvzJC/1Dk3WZmj6Xf3FWZWTjK5/CXw7yTXYagGLnT3ITPbCxRMcL4B/+ru3z3O+4q8jJqPZCZ7gOQ6BgCY2ch0x+XA/mD7fSHefw3JZiuAdx2rsLt3kly681NmlksyzpYgIVwFLA6KdgOlY079DfCBYK5/zKzOzGqm6TPILKOkIDNFkZk1jnl9guQXbEPQ+bqN5LTnAF8G/tXMHgOyQ4zp48AnzOwpoBboPNYJ7v4Mydk330VygZsGM1tLstbwbFDmEPBY8AjrV9z9AZLNU0+Y2WbgLo5MGiJTpkdSRUISrBzX7+5uZu8C3u3ubz7WeSLppD4FkfBcCHwreGLoMCEvfyoyHVRTEBGRUepTEBGRUUoKIiIySklBRERGKSmIiMgoJQURERmlpCAiIqP+Py1ykkhIPzCVAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "lr_find_ws = learn_ws.recorder.plot(return_fig=True)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# There is some reason to believe that we can train at higher learning rate\n", "# but the proof is not much significant.\n", "\n", "# So how about we train them for some epochs and see which gives smalle loss." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/html": [ "Total time: 09:15

\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
epochtrain_lossvalid_losstime
01.0733061.09583703:04
10.6678100.68897603:05
20.3894540.50819803:05
" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "learn.fit_one_cycle(3, max_lr=0.0005)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/html": [ "Total time: 10:31

\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
epochtrain_lossvalid_losstime
01.0298791.03303003:28
10.6393640.66607003:27
20.3675260.50451503:34
" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# For now let's test with the same learning rate\n", "learn_ws.fit_one_cycle(3, max_lr=0.0005)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's try out for smaller batch size like 2" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "data = (src.transform(size=(32, 32))\n", " .databunch(path, 2)\n", " .normalize(cifar_stats))\n", "\n", "resnet18_micro, resnet18_ws_micro = get_models()\n", "\n", "learn_micro = Learner(data, resnet18_micro)\n", "learn_ws_micro = Learner(data, resnet18_ws_micro)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/html": [], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n" ] } ], "source": [ "learn_micro.lr_find()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "

" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "learn_micro.recorder.plot()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/html": [], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n" ] } ], "source": [ "learn_ws_micro.lr_find()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEKCAYAAAD9xUlFAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3Xl8XHW9//HXJ/u+NWmbNm3Tli600NKFTRYBUVERRVBB8YqIuHHdr/eH3stVvOpFr/uGqCggCLIpIAoi9mKFAulOaWlL17RJmn3f5/P7Y6ZpCEmbtjkzmeT9fDzm0TPnnJnzSZrkPd/z/Z7vMXdHREQEICHWBYiIyOihUBARkT4KBRER6aNQEBGRPgoFERHpo1AQEZE+CgUREemjUBARkT4KBRER6ZMU6wKOVmFhoZeWlsa6DBGRuLJ69eoady860n5xFwqlpaWUlZXFugwRkbhiZruHs59OH4mISB+FgoiI9FEoiIhIH4WCiIj0USiIiEgfhYKIiPRRKIiISB+FgohIHPj+k1sp21UX+HHi7uI1EZHxZtP+Rr7/5DYMY3lpQaDHUktBRGSU++nfXyE7NYmrzyoN/FgKBRGRUWz7gWYee7GCf3ndDHLTkwM/nkJBRGQU+8nfXyEtKZEPnz0rKsdTKIiIjFK7alr547p9XHXGdAoyU6JyTIWCiMgo9bMVr5CUmMBHzo1OKwEUCiIio9K+hnYeWFPOladOY2J2WtSOq1AQERmF7nhmF2bw0dfPjupxFQoiIqPQqp11LJ2ez5S89KgeV6EgIjLKdHT38tL+RpZMz4/6sRUKIiKjzEsVTXT3OqdMy4v6sRUKIiKjzNo9DQAsma5QEBEZ99buqWdKbhqTcqI36ugghYKIyCizbm9DTPoTIOBQMLNdZrbRzNaZWdkg283Mfmhm281sg5ktDbIeEZHR7kBzB+X17TE5dQTRmTr7fHevGWLbW4A5kcfpwM8i/4qIjEvrIv0JsehkhtifPnoHcIeHrQLyzKw4xjWJiMTMur0NJCUYJ03Njcnxgw4FB54ws9Vmdt0g26cCe/s9L4+sExEZl9buaeDE4hzSkhNjcvygQ+Esd19K+DTRJ83s3AHbbZDX+MAVZnadmZWZWVl1dXUQdYqIxFxvyNlQ3hCz/gQIOBTcfX/k3wPAQ8BpA3YpB6b1e14C7B/kfW519+XuvryoqCiockVEAnWguYMtlU1Dbt92oJnWrt6Y9SdAgB3NZpYJJLh7c2T5TcBNA3Z7GLjezO4h3MHc6O4VQdUkIhJtbV09PL6pkofW7mfltmpCDtedO4t/v2g+iQmvPlly6KK12AxHhWBHH00CHjKzg8e5293/YmYfA3D3W4DHgLcC24E24EMB1iMiElXNHd288btPU9nUwdS8dD5x3gnUtXVx69M72FrVzA+vXEJO2qFbbK7b00BeRjKlEzJiVnNgoeDuO4DFg6y/pd+yA58MqgYRkVgq211PZVMH3758EZctLSEh0jJYUJzDVx7exDt/8k++ddkilkzPJzHBWLu3nlOm5RH5MB0T0bhOQURkXCrbVUdigvG2RcV9gQBw1RkzOGFiFp+4aw2X3/IsOWlJnDFrAtsOtPC2k6fEsGKFgohIYF7YVc9JU3LISHntn9ozZk3gqc+/nqe31fDPbTWs3F6DO5w9Z0IMKj1EoSAiEoCunhDr9zZw1RkzhtwnLyOFSxZP4ZLFU3B3Wrt6yUqN7Z/lWF/RLCIyJr24v5HOnhCnlg5vJJGZxTwQQKEgIhKIsl11ACybURDjSo6OQkFEJAAv7KpnZmEmRdmpsS7lqCgURERGmLtTtquO5TNidxHasVIoiIiMsFeqW6lv62b5MPsTRhOFgojICDvYn7C8NL76E0ChICJy3Brbu1/1/IVd9RRkpjCrMDNGFR07hYKIyHH4y4sVnHLTE9y5anffurLd4f6EWE5XcaxiPyhWRCSO3f38XtzhP//wIolmXLhgIrtr27jq9KEvWhvNFAoiIsfoQFMHK7dVc925s9hW1cyXHtrI01snA8RlJzMoFEREjtnD6/cTcnjvqdOYmpfOR+9czV82VZKalMDCKbG5x/LxUiiIiByjB9fsY3FJLrOLsgD4+QeW8fn71pOdmkRKUnx22SoURESOwcuVzbxU0cRX3r6gb11aciI/ed/SGFZ1/OIzykREYuzBteUkJhgXL47t/Q9GmkJBROQo9YacP67dz+vnFlGYFV9zGx2JQkFE5Cit2lFLZVMHly6ZGutSRpxCQUTkKD24Zh/ZqUm8ccGkWJcy4hQKIiJHwd3560uVvGnhZNKSE2NdzohTKIiIHIWmjh6aOno4sTg71qUEQqEgInIUKhs7AJiUkxbjSoKhUBAROQqVTeFQKM5VKBwTM0s0s7Vm9ugg2642s2ozWxd5XBt0PSIix6OysR0Yuy2FaFzR/GlgM5AzxPZ73f36KNQhInLcKhs7gbEbCoG2FMysBHgb8MsgjyMiEi2VTe0UZqXG7dxGRxL0V/V94ItA6DD7XGZmG8zsfjObFnA9IiLHpaKxg8m5Y+sq5v4CCwUzuxg44O6rD7PbI0Cpuy8CngRuH+K9rjOzMjMrq66uDqBaEZHhqWzsYHJOeqzLCEyQLYWzgEvMbBdwD3CBmf22/w7uXuvunZGnvwCWDfZG7n6ruy939+VFRUUBliwicniVTWopHBN3v8HdS9y9FLgCeMrdr+q/j5kV93t6CeEOaRGRUamju5eGtm6Kc8duSyHq91Mws5uAMnd/GPiUmV0C9AB1wNXRrkdEZLgOXrg2eYyOPIIohYK7rwBWRJZv7Lf+BuCGaNQgImNPa2cP7/vlcyycksNX3r4w8BFBFQdDYYxeuAa685qIxLFv/nkz6/c2sH5vAzuqW7jlqmXkZaQEdryqprEfCmNzoK2IjHkrt9Xw21V7uPbsmXzvvYtZs7uBd/30GXbVtAZ2zIpxcPpIoSAicae5o5t/f2ADswoz+cKb53HpkhJ+e+3p1Ld1celP/8m6vQ2BHLeqqYPstCQyU8fuSRaFgojEnW88tpmKxnb+9z2L++5pcNrMAh76xFlkpSXx/l+sYtWO2hE/bkVj+5idCO8ghYKIxJV/bKvmd8/v5SPnzmLp9PxXbSstzOS+j76O4rx0Pnjb8/z95QMjeuzKxo4xO+fRQQoFEYkr97ywl4nZqXz2wrmDbp+cm8a9153BCROzuO6OMh7dsH/Ejl3Z1KGWgojIaLJmdz2nz5pw2FthTshK5e6PnMHikjyuv3st3358C70hP67j9vSGqG7uHNOdzKBQEJE4sr+hnYrGDpZNzzvivrnpyfz22tN57/Jp/OTvr3DNb16goa3rmI9d3dJJyGHyGL6aGRQKIhJHVu+uB2DZjIJh7Z+WnMjNly/iG5eezDOv1PD2H6/k5crmYzr2weGoOn0kIjJKrN5dT3pyIvOLs4/qde87fTr3fvRMOrtDXH7LMzx3DCOTxvq9mQ9SKIhI3Fizp57F03JJTjz6P11Lp+fz4Cdex8TsVD5w2/P8eWPFUb2+Ui0FEZHRo62rh037m1g2I//IOw+hJD+D+z/2Ok6aksMn7l7DHc/uGvZrK5s6SElKIC8j+ZiPHw8UCiISFzaUN9Ib8tdcm3C08jNTuOvaM3jD/Enc+MdN/ODJbbgfeWRSZWN4OKqZHdfxRzuFgojEhYOdzEuOMxQA0lMSueWqpVy2tITvPbmVrz26mdARhqyG77g2tk8dgWZJFZE4sWZ3PbOKMinIHJlZUJMSE/j25YvISU/itn/upLmjm2++62SShuivqGhqP+5WSjxQKIjIqOfurNlTz4UnThrR901IMG68eAG56cl8/8ltbKls5srTpnPx4mJy0g71Hbg7VY2dY3rK7IN0+khERr2dNa3Ut3UfVyfzUMyMz1w4l++8ezGdPb186aGNnPb1J/nc79dR2xK+hXxdaxddvSGdPhIRGQ0OXbQW3Omby5aV8K6lU9lQ3sjvy/Zy/+pytlW18LvrzqCyaXwMRwW1FEQkDqzZU09OWhKzi7ICPY6ZsXhaHl+/9GR+dtVSXqpo4qN3lrGntg0Y+1NcgFoKIhIHVu+uZ+mMfBISojcc9IL5k/jWZYv4/H3rebmyBRjbd1w7SC0FERnVGtu72VrVwrIYjPy5bFkJX3rrfGpaOklMMIqyU6NeQ7SppSAio9r2A+FP6Qum5MTk+NedO5u2rl42VzSRGMWWSqwoFERkVDs4AmhiduxO3XxmiBv6jEU6fSQio1pta/geCBOyRuaiNTm8wEPBzBLNbK2ZPTrItlQzu9fMtpvZc2ZWGnQ9IhJfDrYURupKZjm8aLQUPg1sHmLbh4F6dz8B+B5wcxTqEZE4UtPSRXZq0mFvvykjJ9BQMLMS4G3AL4fY5R3A7ZHl+4E32FifglBEjkpta5dOHUVR0C2F7wNfBEJDbJ8K7AVw9x6gEZgQcE0iEkdqWzqZkDX2h4KOFoGFgpldDBxw99WH222Qda+Zv9bMrjOzMjMrq66uHrEaRWT0q23pYoL6E6ImyJbCWcAlZrYLuAe4wMx+O2CfcmAagJklAblA3cA3cvdb3X25uy8vKioKsGQRGW1qW9VSiKbAQsHdb3D3EncvBa4AnnL3qwbs9jDwwcjy5ZF9jnwLJBEZF3pDTl1rF4XqU4iaqF+8ZmY3AWXu/jDwK+BOM9tOuIVwRbTrEZHRq6Gti5Cj00dRFJVQcPcVwIrI8o391ncA745GDSISfw5duKbTR9GiK5pFZNSqiVy4piGp0TOsUDCz2WaWGlk+z8w+ZWZ5wZYmIuNdbUu4pVColkLUDLel8ADQa2YnEO4HmAncHVhVIiIcmuJCfQrRM9xQCEUuLrsU+L67fxYoDq4sEZFwn0KCQV6GQiFahhsK3WZ2JeHhowcntksOpiQRkbCali4KMlPGxX0MRovhhsKHgDOBr7v7TjObCQy8EE1EZETVtnQyIVP9CdE0rCGp7v4S8CkAM8sHst39f4IsTEREk+FF33BHH60wsxwzKwDWA782s+8GW5qIjHeaDC/6hnv6KNfdm4B3Ab9292XAhcGVJSKiyfBiYbihkGRmxcB7ONTRLCISmI7uXpo7ezTvUZQNNxRuAh4HXnH3F8xsFrAtuLJEZLyr0xQXMTHcjub7gPv6Pd8BXBZUUSIiB69m1umj6BpuR3OJmT1kZgfMrMrMHojcalNEJBA1rQfnPVJLIZqGe/ro14TvfTCF8C00H4msExEJxKF5j9RSiKbhhkKRu//a3Xsij98AugWaiASmb94jtRSiarihUGNmV5lZYuRxFVAbZGEiMr7VtnaRmpRAZkpirEsZV4YbCtcQHo5aCVQQvnXmh4IqSkSkpqWTwqxUzDTvUTQNKxTcfY+7X+LuRe4+0d3fSfhCNhGRQNS2aIqLWDieO699bsSqEBEZoLa1U8NRY+B4QkFtOhEJTLiloE7maDueUPARq0JEpB931+mjGDlsKJhZs5k1DfJoJnzNgojIUQuFnJseeYl1exsG3d7c2UNXb4gitRSi7rCh4O7Z7p4zyCPb3Yc1RYaIyEAb9zVy2z93cs1vXmBPbdtrtvdNcaGWQtQdz+kjEZFjsnJ7DQA9vSGuuf0Fmjq6X7W978I13XUt6hQKIhJ1/9hWzYLiHG75wDJ21bTyybvW0NMb6tteo5ZCzAQWCmaWZmbPm9l6M9tkZl8dZJ+rzazazNZFHtcGVY+IjA6tnT2s3l3POXMKed3sQr5+6Un8Y1sNX33kJdzD41dqI5PhFapPIeqC7BfoBC5w9xYzSwZWmtmf3X3VgP3udffrA6xDREaR53fW0d3rnD2nEID3njqdHdWt/PzpHUzJS+fj583u61PIz1BLIdoCCwUPR35L5Gly5KFhrCLj3D+21ZCalMCppQV96/79ovlUNHZw81+2MCErhdqWTnLTk0lJ0hnuaAt0BJGZJQKrgROAn7j7c4PsdpmZnQtsBT7r7nsHeZ/rgOsApk+fHmDFIhK0ldurOW1mAWnJhya6S0gw/vfdi6lv6+KGBzcyNS9d/QkxEmgMu3uvu58ClACnmdlJA3Z5BCh190XAk8DtQ7zPre6+3N2XFxVpxm6ReFXZ2MHWqhbOPqHwNdtSkhK45aplnDQlhz11bRRq5FFMRKVt5u4NwArgogHra929M/L0F8CyaNQjIrFxcCjqwf6EgTJTk7jt6lOZMzGLOZOyolmaRAR2+sjMioBud28ws3TgQuDmAfsUu3tF5OklwOag6hGR2Fu5rZrCrBROnJwz5D4TslL586fPITFB06vFQpB9CsXA7ZF+hQTg9+7+qJndBJS5+8PAp8zsEqAHqAOuDrAeEYmhUMhZub2Ws04oJOEIf/CTEtXBHCtBjj7aACwZZP2N/ZZvAG4IqgYRGT22VDZT09I5aH+CjB6KYxGJipXbqwE4Z44Gi4xmCgURiYrndtQxuyiTyblpsS5FDkOhICJRsbmiiZOn5sa6DDkChYKIBK6xrZv9jR3MLx561JGMDgoFEQnclsomAOZPzo5xJXIkCgURCdyWymYATlRLYdRTKIhI4LZUNpGfkczEbE1dMdopFEQkcJsrmpk/OQczXaU82ikURCRQoZDzcmUz84vVnxAPFAoiEqg9dW20d/cedr4jGT0UCiISqL6RR2opxAWFgogEanNFMwkGcyYqFOKBQkFEArWlsonSwkzSUxKPvLPEnEJBRAK1pbJZ/QlxRKEgIoFp7exhd22brmSOIwoFEQnMy1XhK5k151H8UCiISGC2VERCQS2FuKFQEJHAbKlsIis1iZL89FiXIsOkUBCRwGypaGb+5GxNbxFHFAoiEgh3Z3Nlky5aizMKBREJxP7GDpo7epiv4ahxRaEgIoHYWN4IwIlqKcQVhYKIBOLvWw6QnZrEyVPzYl2KHAWFgoiMuFDI+duWA5w7r4iUJP2ZiSeB/W+ZWZqZPW9m681sk5l9dZB9Us3sXjPbbmbPmVlpUPWISPRs2NdITUsnF544MdalyFEKMsI7gQvcfTFwCnCRmZ0xYJ8PA/XufgLwPeDmAOsRkSj52+YqEgzOm6tQiDeBhYKHtUSeJkcePmC3dwC3R5bvB95gGtAsEvf++lIVy0sLyM9MiXUpcpQCPdlnZolmtg44APzV3Z8bsMtUYC+Au/cAjcCEQd7nOjMrM7Oy6urqIEsWkeNUXt/GlspmnTqKU4GGgrv3uvspQAlwmpmdNGCXwVoFA1sTuPut7r7c3ZcXFRUFUaqIjJCnthwA4A0nTopxJXIsojIswN0bgBXARQM2lQPTAMwsCcgF6qJRk4gcv501rTy6YT/uhz7LPbn5ADMLM5ldlBXDyuRYBTn6qMjM8iLL6cCFwJYBuz0MfDCyfDnwlPf/6RKRUau6uZP3/WIV19+9lv/+02ZCIaels4dVr9Tq1FEcSwrwvYuB280skXD4/N7dHzWzm4Ayd38Y+BVwp5ltJ9xCuCLAekRkhHT29PLx366mvq2Ld5wyhV+t3EljezfnzSuiqzekU0dxLLBQcPcNwJJB1t/Yb7kDeHdQNYjIyHN3/uuPmyjbXc+PrlzCxYuKmVmYyfef3MZjGyvITU9m+Yz8WJcpx0iXGorIUbnj2d3c88Jerj//BN6+eApmxmcunMuNFy+grauXC+ZPJClRf1riVZCnj0RkjNlW1cxNj77EhSdO4nNvnPuqbdecPZPlpflML8iIUXUyEhQKIjJsv1q5k+RE41uXLyIh4bUjyheVaPK7eKc2nogMS01LJw+u3ce7lpZQoCuVxyyFgogMy12r9tDVE+Kas2bGuhQJkEJBRI6os6eXO1ft5rx5RZwwUReljWUKBRE5oofX7aempZNrz54V61IkYAoFETksd+dXK3cyf3I2Z53wmvkqZYxRKIjIYT37Si1bKpu55qyZaGb7sU+hICKH9fOnd1CYlcIlp0yJdSkSBQoFERnSP7ZV839bq7n2nFmkJSfGuhyJAoWCiAyqpzfEfz+6mekFGXzorNJYlyNRolAQkUH97oW9vFzVzJfeeiKpSWoljBcKBRF5jcb2br77xMucMauANy/UNNjjiUJBRF7jR3/bRkN7N/958QKNOBpnFAoi8iov7W/iN8/s4opTp7FwSm6sy5Eo0yypIgJAKOTc8ewuvvnnLeSmJ/O5N86LdUkSAwoFEaGisZ1/u28DK7fXcP68Im6+bBFF2amxLktiQKEgMs49vH4///HQRnpCzjcuPZkrT5umfoRxTKEgMk41tnfzX398kT+s28+S6Xl87z2nUFqYGeuyJMYUCiLj0No99Vx/91oqmzr47IVz+eT5s3VfZQEUCiLjTl1rFx+5YzXpKQnc/7EzWTI9P9YlySiiUBAZR9yd//jDRhrbu7jzw2dzYnFOrEuSUUbtRZFx5OH1+3lsYyWffeNcBYIMKrBQMLNpZvZ3M9tsZpvM7NOD7HOemTWa2brI48ag6hEZ7yobO/jPP7zI0ul5fPTc2bEuR0apIE8f9QCfd/c1ZpYNrDazv7r7SwP2+4e7XxxgHSLjnrvzxQc20N3rfOc9p5CYoCGnMrjAWgruXuHuayLLzcBmYGpQxxORod313B6e3lrNDW+dz0wNO5XDiEqfgpmVAkuA5wbZfKaZrTezP5vZwiFef52ZlZlZWXV1dYCViow9O2ta+fqfNnPOnEKuOn1GrMuRUS7wUDCzLOAB4DPu3jRg8xpghrsvBn4E/GGw93D3W919ubsvLyoqCrZgkTGkpzfEZ+9dR0pSAt++fDEJOm0kRxBoKJhZMuFAuMvdHxy43d2b3L0lsvwYkGxmhUHWJDKe/GzFK6zb28B/v/MkJuemxbociQOBdTRbePKUXwGb3f27Q+wzGahydzez0wiHVG1QNYnEkwPNHdxXVs6qHbXkpCWTn5lMQUYKHT0h9ta1UV7fTlVTB9MKMlg4JYeFU3I4YWI2hVkpFGSmsKumjR/8bRuXLJ7C2xdPifWXI3EiyNFHZwEfADaa2brIui8B0wHc/RbgcuDjZtYDtANXuLsHWNOIcHdNGCaBWb27jttW7uLxTZX0hJwTi3PY39BOfVs39W1dJCcmUJKfzrT8DOZNzmZ3bSsPrC7njmd7X/Nek3PS+No7TorBVyHxKrBQcPeVwGH/crr7j4EfB1XDSCqvb+PxTVU8vqmStXvqOfuEQj5w5gxeP3fiq4b3DQyMUMgpr29n0/5GXqpooifkzJuUzdxJ2cyemKl738qrvLivkXff8iw56clc/bpSrjx9OrOLsvq294Ycg9f0DYRCzu66NnbWtFDX2k19axeN7d28ffEUcjOSo/xVSDwbN9NcbK1q5p7n97Kgr5mdRXJiAh3dvVQ2dlDV1EF9W1ffp7G6li6qmjupauqgsrGDPXVtAMyblM3ly6bx5OYqrvlNGSX56bxu9gQqGjsor29nX307PaEQyYkJpCQl0Bty2rrCn+ASEwwDekLhxlBSgnH2nEIuXTKVNy2YTHqKAmI8C4Wc//jDixRkpvC3z5036B/zoa4vSEgwZhZmaripHLdxEwqvHGjh7ud309EdAiAlMYH0lEQa27sH3T89OZFJOalMzEljUUku7z99Om9eOLlvauGbehfyxKYq7ly1i6e2HGBqXjoLinN404JJpCQl0NUToqs3hGHMmZTFwik5zJ2UTYIZu2pbebmymY37Gnl0/X4+fc86slKTuPDEiSydkc/JU3M5sTiHtGSFxHhyb9le1u1t4LvvWaxP9xIzFgen8F9l+fLlXlZWdkyv7Q05O2taw6dy9jfR1tXL5Nw0JmanMiknjQlZKeRnhB/R+tQeCjnP7azjwTXlPLXlALWtXUD4E+Gy6fm8bVExbzlpMhNzNHJkLKtv7eL876xg7qRs7r3uDPVZyYgzs9XuvvyI+42nUBjt3J39jR1sLG9kQ3kDT26uYmtVC2awfEY+0woyIqGVTEKCcaCpk+rmTqpbOinJS2dZaT6nlhYwvSCDtXsaeHZHLat21NLTG2JRSR6Lp+WyqCSPqXnpaoWMMjc8uIHfl5Xz2KfOYd7k7FiXI2OQQmGM2FrVzJ82VLBiazU1zZ3Ut3X19VFkpSYxMTuVCVkp7Kxpo6al81WvTTBYOCWX9ORENu5rpL370OiUzJREJmSlkpGSSEd3L61dvbR19lCSn8E5cwo5Z24Rp5bm09zRQ3l9ePhjTUsX7V09ffs2d/bQ0tFDS2d4nbsTcscdEsxITjRSkhJISUpkal46s4symVWUyZyJ2ZTkpw/5abiysYMVLx/g/7ZW097dy1tOmsxFC4tjfkqlsrGDLZVNtHf10tHTS0d3iIyUREryM5hWkE5RVuoxfcJfu6eed/3sGT581kz+4+IFAVQuolAY0zp7eukNORkph7qE3J3dtW28sKuOPXVtLCrJ47SZBeSmh/+Q9vSG2F7dwsbyRg40d1Lb0kVdayctnT1kpCSRmZpIenISW6uaeX5XHV09oSGPn5xopCcnkp2WTHZaEtlpSWSkJJFgYBbuTA+5093rdPWG6OjuZU9dGw1th/pvJmSmsHhaHqdMyyMlKYHKxg72N7Szq7aVrVUtQHg4ZUpSAnvq2khONF4/t4ji3PRD/TUGcyZmM784mxMn55CVlkRtSye1rV3Ut3aRYOFQSk5MIDstiZmFma9qIe2qaWXFywdYt7eBouxUSgszKZ2QSVZqUmTQQRe1LV1s3NdI2a569jW0H/b/JSMlkYsWTuaqM2ewZFresALileoW3v+L53Ccv33+PLJSx003n0SZQkGOWXtXL8/trGX93kYKMpMpyc9gan46E7NTyUhJIiXp2C6Er2vtYkd1C1sqm1m3t4F1exvYfiAcANmpSRTnpTElL50zZk3gvHlFzJsUPo2yobyRh9fv5y8vVtLW1RNpfYQ786uaOg93yFcxg2n5GcwqymRPbRs7aloBmJSTSn1b95BBOCknleUzClg2I5+TpuaSnZZEWnIiackJtHT0sLe+jb117WypbOKR9RW0dPawcEoOV542nTcumMSkIfqDNlc08YFfhacDu/PDp+v+BhIohYLEheaOcOshO+3YTg01tnXzclUzmyuaaO/upTArtW/AgLvT1ROiu9epb+ti+4EWtle3sKO6lYnjwrkkAAAI6klEQVTZqVwwfyLnzStixoRMQiGnsqmDXTWttHb1UpCZTH5GChMyU8lJTxr2aaGWzh7+uG4fdz67my2VzQAsnJLDG+ZPZMmMfGYVZjI1L51N+5v4l9ueJz05kbs+cvqrrkUQCYJCQSSG3J2tVS08teUAT22pYvXueiKXp5CcaBjGpNxU7r72DKYVZMS2WBkXhhsKOoEpEgAzY97kbOZNzubj582msa2brQea2Vndyo6aVlo6u7n+/DmapE5GHYWCSBTkZiRzamkBp5YWxLoUkcOKyk12REQkPigURESkj0JBRET6KBRERKSPQkFERPooFEREpI9CQURE+igURESkT9xNc2Fm1UAD0DhgU+4R1h1p+eC/hUDNMZQ22PGHs33g+sM9H1hr/3XHUnc0a+6/HIvvtX4+9PNxuO3x+PNxNDUDzHH33CNW4u5x9wBuPdp1R1ru92/ZSNU0nO0D1x/u+cBaj7fuaNYc6++1fj708zHWfj6OpubhHOPgI15PHz1yDOuOtDzY64+3puFsH7j+cM8Hq/V46o5mzf2XY/G91s/H0dPPx/CXR3vNwzkGEIenj4JmZmU+jJkER5t4rFs1R0881q2aYyNeWwpBujXWBRyjeKxbNUdPPNatmmNALQUREemjloKIiPQZ06FgZreZ2QEze/EYXrvMzDaa2XYz+6H1ux+jmf2rmb1sZpvM7FsjW3UwdZvZV8xsn5mtizzeOtpr7rf9C2bmZlY4chUH9n3+mpltiHyPnzCzKXFQ87fNbEuk7ofMLG8kaw6w7ndHfgdDZjZi5/GPp9Yh3u+DZrYt8vhgv/WH/bmPmWMZPhUvD+BcYCnw4jG89nngTMCAPwNviaw/H3gSSI08nxgndX8F+EI8fa8j26YBjwO7gcLRXjOQ02+fTwG3xEHNbwKSIss3AzfHw88HcCIwD1gBLI91rZE6SgesKwB2RP7NjyznH+7rivVjTLcU3P1poK7/OjObbWZ/MbPVZvYPM5s/8HVmVkz4l/tZD//v3QG8M7L548D/uHtn5BgH4qTuQAVY8/eALwIj3vkVRM3u3tRv18yRrjugmp9w957IrquAkpGsOcC6N7v7y6Ol1iG8Gfiru9e5ez3wV+CiWP6uHsmYDoUh3Ar8q7svA74A/HSQfaYC5f2el0fWAcwFzjGz58zs/8zs1ECrPeR46wa4PnKK4DYzyw+u1D7HVbOZXQLsc/f1QRfaz3F/n83s62a2F3g/cGOAtR40Ej8bB11D+FNrNIxk3UEbTq2DmQrs7ff8YP2j5et6jXF1j2YzywJeB9zX7/Rd6mC7DrLu4Ce+JMLNwDOAU4Hfm9msSNoHYoTq/hnwtcjzrwHfIfwHIBDHW7OZZQBfJnxqIypG6PuMu38Z+LKZ3QBcD/zXCJd6qJARqjnyXl8GeoC7RrLGwYxk3UE7XK1m9iHg05F1JwCPmVkXsNPdL2Xo+mP+dQ1lXIUC4ZZRg7uf0n+lmSUCqyNPHyb8B7R/E7oE2B9ZLgcejITA82YWIjzfSfVortvdq/q97hfAowHWC8df82xgJrA+8otYAqwxs9PcvXKU1jzQ3cCfCDAUGKGaIx2gFwNvCPIDTj8j/b0O0qC1Arj7r4FfA5jZCuBqd9/Vb5dy4Lx+z0sI9z2UE/uva3Cx7tQI+gGU0q/DCHgGeHdk2YDFQ7zuBcKtgYOdQG+NrP8YcFNkeS7hpqHFQd3F/fb5LHDPaK95wD67GOGO5oC+z3P67fOvwP1xUPNFwEtA0UjXGo2fD0a4o/lYa2XojuadhM8u5EeWC4b7cx+LR8wLCPSLg98BFUA34WT+MOFPn38B1kd+EW4c4rXLgReBV4Afc+hCvxTgt5Fta4AL4qTuO4GNwAbCn8CKR3vNA/bZxciPPgri+/xAZP0GwnPNTI2DmrcT/nCzLvIY0RFTAdZ9aeS9OoEq4PFY1sogoRBZf03ke7wd+NDR/NzH4qErmkVEpM94HH0kIiJDUCiIiEgfhYKIiPRRKIiISB+FgoiI9FEoyJhgZi1RPt4vzWzBCL1Xr4VnVX3RzB450iylZpZnZp8YiWOLDKQhqTImmFmLu2eN4Psl+aFJ4gLVv3Yzux3Y6u5fP8z+pcCj7n5SNOqT8UUtBRmzzKzIzB4wsxcij7Mi608zs2fMbG3k33mR9Veb2X1m9gjwhJmdZ2YrzOx+C99v4K6Dc95H1i+PLLdEJsFbb2arzGxSZP3syPMXzOymYbZmnuXQhIBZZvY3M1tj4Xn33xHZ53+A2ZHWxbcj+/5b5DgbzOyrI/htlHFGoSBj2Q+A77n7qcBlwC8j67cA57r7EsKzmH6j32vOBD7o7hdEni8BPgMsAGYBZw1ynExglbsvBp4GPtLv+D+IHP+I89pE5v15A+ErzgE6gEvdfSnh+3h8JxJK/w94xd1Pcfd/M7M3AXOA04BTgGVmdu6RjicymPE2IZ6MLxcCC/rNbJljZtlALnC7mc0hPDNlcr/X/NXd+8+l/7y7lwOY2TrCc+KsHHCcLg5NMLgaeGNk+UwOzZF/N/C/Q9SZ3u+9VxOecx/Cc+J8I/IHPkS4BTFpkNe/KfJYG3meRTgknh7ieCJDUijIWJYAnOnu7f1XmtmPgL+7+6WR8/Mr+m1uHfAenf2Wexn8d6bbD3XODbXP4bS7+ylmlks4XD4J/JDw/RiKgGXu3m1mu4C0QV5vwDfd/edHeVyR19DpIxnLniB8PwMAzOzg1Me5wL7I8tUBHn8V4dNWAFccaWd3byR8C88vmFky4ToPRALhfGBGZNdmILvfSx8HronM+4+ZTTWziSP0Ncg4o1CQsSLDzMr7PT5H+A/s8kjn60uEpz0H+BbwTTP7J5AYYE2fAT5nZs8DxUDjkV7g7msJz8R5BeGb3Sw3szLCrYYtkX1qgX9GhrB+292fIHx66lkz2wjcz6tDQ2TYNCRVJCCRu8e1u7ub2RXAle7+jiO9TiSW1KcgEpxlwI8jI4YaCPD2pyIjRS0FERHpoz4FERHpo1AQEZE+CgUREemjUBARkT4KBRER6aNQEBGRPv8f8OKr6NDRuBYAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "learn_ws_micro.recorder.plot()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Here the only difference that I could notice is, in case of learn_micro\n", "# the learn diverged more quickly, than in case of learn_ws_micro. This \n", "# fact supports the idea presented in the paper, as the only reason the loss\n", "# did not diverge in the second case was, because Weight Standardization made\n", "# the loss surface smoother." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/html": [ "Total time: 55:13

\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
epochtrain_lossvalid_losstime
01.3730901.24679218:28
10.9184760.80218218:21
20.5506640.69517218:24
" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "learn_micro.fit_one_cycle(3, max_lr=0.00005)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/html": [ "Total time: 1:36:51

\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
epochtrain_lossvalid_losstime
01.3075341.20180731:50
10.8357800.79331731:37
20.6656570.67058133:23
" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "learn_ws_micro.fit_one_cycle(3, max_lr=0.00005)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "resnet18_micro, resnet18_ws_micro = get_models()\n", "learn_ws_micro2 = Learner(data, resnet18_ws_micro)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/html": [ "Total time: 1:04:50

\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
epochtrain_lossvalid_losstime
01.0332720.98506233:18
10.5751970.64489331:32
" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "learn_ws_micro2.fit_one_cycle(2, max_lr=0.001)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "learn_micro2 = Learner(data, resnet18_micro)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/html": [ "Total time: 37:23

\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
epochtrain_lossvalid_losstime
01.0565600.94875018:56
10.6986300.67741418:27
" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "learn_micro2.fit_one_cycle(2, max_lr=0.001)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "data = (src.transform(size=(32, 32))\n", " .databunch(path, 256)\n", " .normalize(cifar_stats))\n", "\n", "resnet18_large, resnet18_ws_large = get_models()\n", "learner_large = Learner(data, resnet18_large)\n", "learner_ws_large = Learner(data, resnet18_ws_large)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/html": [], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n" ] } ], "source": [ "learner_large.lr_find()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "

" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "learner_large.recorder.plot()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/html": [], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n" ] } ], "source": [ "learner_ws_large.lr_find()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "learner_ws_large.recorder.plot()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/html": [ "Total time: 29:12

\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
epochtrain_lossvalid_losstime
01.1479501.41068102:54
10.8895521.47275102:55
20.7072130.76119102:55
30.5671780.72567802:55
40.4317060.67262602:55
50.2848870.56330202:55
60.1439740.58136602:54
70.0407670.66814102:54
80.0068950.65457102:55
90.0016250.66359202:54
" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "learner_large.fit_one_cycle(10, max_lr=1e-2)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "

\n", " \n", " \n", " 60.00% [6/10 18:03<12:02]\n", "
\n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
epochtrain_lossvalid_losstime
01.1921421.23980103:00
10.8940160.90009003:00
20.7334480.88846003:00
30.6176780.72622303:00
40.5148120.62370303:00
50.3723820.58061803:00

\n", "\n", "

\n", " \n", " \n", " Interrupted\n", "
\n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "ename": "KeyboardInterrupt", "evalue": "", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mlearner_ws_large\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_one_cycle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmax_lr\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m5e-2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;32m~/anaconda3/envs/PyTorch/lib/python3.7/site-packages/fastai/train.py\u001b[0m in \u001b[0;36mfit_one_cycle\u001b[0;34m(learn, cyc_len, max_lr, moms, div_factor, pct_start, final_div, wd, callbacks, tot_epochs, start_epoch)\u001b[0m\n\u001b[1;32m 20\u001b[0m callbacks.append(OneCycleScheduler(learn, max_lr, moms=moms, div_factor=div_factor, pct_start=pct_start,\n\u001b[1;32m 21\u001b[0m final_div=final_div, tot_epochs=tot_epochs, start_epoch=start_epoch))\n\u001b[0;32m---> 22\u001b[0;31m \u001b[0mlearn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcyc_len\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmax_lr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mwd\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mwd\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcallbacks\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcallbacks\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 23\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 24\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mlr_find\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlearn\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mLearner\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstart_lr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mFloats\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1e-7\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mend_lr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mFloats\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnum_it\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m100\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstop_div\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mbool\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mwd\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/anaconda3/envs/PyTorch/lib/python3.7/site-packages/fastai/basic_train.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, epochs, lr, wd, callbacks)\u001b[0m\n\u001b[1;32m 189\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mdefaults\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mextra_callbacks\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mcallbacks\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mdefaults\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mextra_callbacks\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 190\u001b[0m fit(epochs, self.model, self.loss_func, opt=self.opt, data=self.data, metrics=self.metrics,\n\u001b[0;32m--> 191\u001b[0;31m callbacks=self.callbacks+callbacks)\n\u001b[0m\u001b[1;32m 192\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 193\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mcreate_opt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mFloats\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mwd\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mFloats\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0.\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m->\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/anaconda3/envs/PyTorch/lib/python3.7/site-packages/fastai/basic_train.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(epochs, model, loss_func, opt, data, callbacks, metrics)\u001b[0m\n\u001b[1;32m 92\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mxb\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0myb\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mprogress_bar\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain_dl\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparent\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mpbar\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 93\u001b[0m \u001b[0mxb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0myb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcb_handler\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mon_batch_begin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mxb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0myb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 94\u001b[0;31m \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mloss_batch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mxb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0myb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mloss_func\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mopt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcb_handler\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 95\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mcb_handler\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mon_batch_end\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mloss\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mbreak\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 96\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/anaconda3/envs/PyTorch/lib/python3.7/site-packages/fastai/basic_train.py\u001b[0m in \u001b[0;36mloss_batch\u001b[0;34m(model, xb, yb, loss_func, opt, cb_handler)\u001b[0m\n\u001b[1;32m 30\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 31\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mopt\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 32\u001b[0;31m \u001b[0mloss\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mskip_bwd\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcb_handler\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mon_backward_begin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mloss\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 33\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mskip_bwd\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 34\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mcb_handler\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mon_backward_end\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mopt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/anaconda3/envs/PyTorch/lib/python3.7/site-packages/fastai/callback.py\u001b[0m in \u001b[0;36mon_backward_begin\u001b[0;34m(self, loss)\u001b[0m\n\u001b[1;32m 272\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mon_backward_begin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mloss\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mTensor\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m->\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 273\u001b[0m \u001b[0;34m\"Handle gradient calculation on `loss`.\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 274\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msmoothener\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_value\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdetach\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcpu\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 275\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstate_dict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'last_loss'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstate_dict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'smooth_loss'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mloss\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msmoothener\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msmooth\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 276\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'backward_begin'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcall_mets\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mKeyboardInterrupt\u001b[0m: " ] } ], "source": [ "learner_ws_large.fit_one_cycle(10, max_lr=5e-2)" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" } }, "nbformat": 4, "nbformat_minor": 2 }