takotab/normalize batch in model.ipynb

## normalize batch in model.ipynb
{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/tako/dev/env37/lib/python3.7/site-packages/pandas/compat/__init__.py:117: UserWarning: Could not import the lzma module. Your installed Python is incomplete. Attempting to use lzma compression will result in a RuntimeError.\n",
      "  warnings.warn(msg)\n"
     ]
    }
   ],
   "source": [
    "from fastcore.utils import *\n",
    "from fastcore.imports import *\n",
    "from fastai2.basics import *\n",
    "from torch.autograd import Variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I have data that has a new bias every datapoint. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_data(l=100, bias = 100):         \n",
    "    return (torch.randn(l)*.1+ torch.arange(l) + torch.randn(1)*bias)[None,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[62.3799, 63.4259, 64.3857, 65.5097, 66.4785, 67.4576, 68.6136, 69.4785,\n",
      "         70.4420]]) tensor([72.4677])\n",
      "tensor([[-94.4864, -93.5647, -92.4024, -91.5976, -90.7541, -89.6858, -88.5592,\n",
      "         -87.2961, -86.6319]]) tensor([-84.5226])\n",
      "tensor([[540.6299, 541.7110, 542.7780, 543.7479, 544.9114, 545.7786, 546.7360,\n",
      "         547.7943, 548.6898]]) tensor([550.7460])\n"
     ]
    }
   ],
   "source": [
    "for i in [100, 200, 300]:\n",
    "    x = make_data(l=11, bias = i)\n",
    "    x, y= x[:,:9], x[:,-1]\n",
    "    print(x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a rather simple example but is I hope you understand the idea. \n",
    "It does not really help to normalize over the dataset/batch. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[ 0.3367,  0.3413,  0.3461,  0.3512,  0.3544,  0.3603,  0.3642,  0.3699,\n",
       "           0.3743],\n",
       "         [ 0.9650,  0.9696,  0.9749,  0.9784,  0.9840,  0.9884,  0.9937,  0.9993,\n",
       "           1.0025],\n",
       "         [-1.3572, -1.3527, -1.3492, -1.3442, -1.3401, -1.3345, -1.3304, -1.3262,\n",
       "          -1.3197]]), tensor([ 0.3828,  1.0130, -1.3115]))"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xb, yb = [], []\n",
    "for i in [100, 200, 300]:\n",
    "    x = make_data(l=11, bias = i)\n",
    "    x, y= x[:,:9], x[:,-1]\n",
    "    xb.append(x)\n",
    "    yb.append(y)\n",
    "xb, yb = torch.cat(xb), torch.cat(yb)\n",
    "(xb-xb.mean())/xb.std(), (yb-xb.mean())/xb.std()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It does help to do this per item: scale the input, run the model, and scale back to match the (should be) prediction. This really help the model to train better and there is no leakage since no y data is used to scale the prediction. \n",
    "\n",
    "I did this in `create_item`. For examle:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[-1.4768, -1.1911, -0.7628, -0.3886,  0.0444,  0.3560,  0.7571,  1.1187,\n",
       "           1.5430],\n",
       "         [-1.5020, -1.2109, -0.7504, -0.3387,  0.0050,  0.4018,  0.7681,  1.1345,\n",
       "           1.4926],\n",
       "         [-1.4600, -1.1334, -0.7901, -0.3764, -0.0726,  0.3756,  0.7257,  1.1631,\n",
       "           1.5681]]), tensor([2.2095, 2.3414, 2.2393]))"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xb, yb = [], []\n",
    "for i in [100, 200, 300]:\n",
    "    x = make_data(l=11, bias = i)\n",
    "    x, y= x[:,:9], x[:,-1]\n",
    "    xb.append((x-x.mean())/x.std())\n",
    "    yb.append((y-x.mean())/x.std())\n",
    "xb, yb = torch.cat(xb), torch.cat(yb)\n",
    "(xb-xb.mean())/xb.std(), (yb-xb.mean())/xb.std()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Only this would not work well for predictions (in production or kaggle) because it is not part of encode/decode procces. This also means it does not show the data correcly (only normalized). So I do not really like that option."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I'm having some problem to implementing any other solution however. I first did this with a `ItemTransform` during `after_batch` only it assumes the last encoded is the one that needs to be decoded. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NormalizeTS(ItemTransform):\n",
    "    \"Normalize the Time-Series.\"\n",
    "    def __init__(self, verbose=False, make_ones=True, eps=1e-7, mean = None):\n",
    "        \"\"\"\n",
    "        `make_ones` will make the std 1 if the std is smaller than `10*eps`. \n",
    "        This is for blok seqences to not magnify the `y` part of the data.\n",
    "        \n",
    "        `mean` will set a mean instead of the mean of the x value.\n",
    "        \"\"\"\n",
    "        store_attr(self,'verbose, make_ones, eps, mean')\n",
    "        self.m, self.s = 0, 0\n",
    "        \n",
    "    def encodes(self, o):         \n",
    "        self.m, self.s = torch.mean(o[0],-1,keepdim=True), o[0].std(-1,keepdim=True) +self.eps\n",
    "        if self.verbose:\n",
    "            print('encodes',type(o),[a.shape for a in o], self.m,self.s) \n",
    "        if self.mean:\n",
    "            self.m = o[0][self.mean]\n",
    "        if self.make_ones:\n",
    "            self.s[self.s < self.eps*10] = 1\n",
    "            if self.verbose:\n",
    "                print(o[0])\n",
    "                print(f\"made {self.s < self.eps*10} to ones due to setting `make_ones`\")\n",
    "                print(f\"m:{self.m}\\n s:{self.s}\")\n",
    "        return Tuple([(o[i]-self.m)/self.s for i in range(len(o))])\n",
    "    \n",
    "    def decodes(self, o): \n",
    "        if o[0].is_cuda:\n",
    "            self.m, self.s = to_device(self.m,'cuda'), to_device(self.s,'cuda')\n",
    "            if sum([a.is_cuda for a in o]) != len(o):\n",
    "                o = Tuple([to_device(a,'cuda') for a in o])\n",
    "        else:\n",
    "            if sum([a.is_cuda==False for a in o]) != len(o):\n",
    "                o = Tuple([to_cpu(a) for a in o])\n",
    "            self.m, self.s = to_cpu(self.m), to_cpu(self.s)\n",
    "        if self.verbose:\n",
    "            print('decodes',type(o),[a.shape for a in o], 'shape m/s',self.m.shape)\n",
    "        return Tuple([(o[i]*self.s)+self.m for i in range(len(o))])\n",
    "        \n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor(-47.7861), tensor(2.9995))"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class CustumData(TfmdDL):\n",
    "    def __init__(self, *args,norm = False,**kwargs):\n",
    "        self.norm = norm\n",
    "        super().__init__(*args,**kwargs)\n",
    "        \n",
    "    def create_item(self, idx):\n",
    "        i = 10+np.random.randint(85)\n",
    "        xy = (self.dataset[idx][0,i-10:i], self.dataset[idx][:,i])\n",
    "        if self.norm:\n",
    "            m, s =torch.mean(xy[0], ), torch.std(xy[0],) + 1e-7\n",
    "            xy = ((xy[0]-m)/s,(xy[1]-m)/s)\n",
    "        return xy\n",
    "\n",
    "for o in CustumData([make_data(100)]):\n",
    "    break\n",
    "o[0].mean(), o[0].std()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[torch.Size([64, 10]), torch.Size([64, 1])]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(tensor(-1.4901e-08), tensor(0.9494))"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for o in CustumData([make_data()]*100, after_batch = NormalizeTS()):\n",
    "    print([a.shape for a in o])\n",
    "    break\n",
    "o[0].mean(), o[0].std()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Net(Module):\n",
    "    def __init__(self, norm = False):\n",
    "        self.l = LinBnDrop(10,1)\n",
    "        self.eps = Variable(tensor(1e-7), requires_grad=False)\n",
    "        self.m =   Variable(tensor(1e-7), requires_grad=False)\n",
    "        self.s =   Variable(tensor(1e-7), requires_grad=False)\n",
    "        self.norm = norm\n",
    "        \n",
    "    def forward(self, x):    \n",
    "        if self.norm:\n",
    "            self.m, self.s = torch.mean(x,-1,keepdim=True), x.std(-1,keepdim=True) + self.eps\n",
    "            x = (x-self.m)/self.s\n",
    "        res= self.l(x)\n",
    "        if self.norm:\n",
    "            return (x*self.s)+self.m\n",
    "        return res\n",
    "    \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(#4) [0,6.641168594360352,0.5923767685890198,'00:00']\n",
      "(#4) [1,3.8963358402252197,0.4767536520957947,'00:00']\n",
      "(#4) [2,2.7912161350250244,0.006060589570552111,'00:00']\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "m = Net()\n",
    "data = DataLoaders(*[CustumData([make_data(100,bias = i)]*100, after_batch = NormalizeTS()) for i in [100,200]])\n",
    "learn = Learner(data, m, F.mse_loss)\n",
    "\n",
    "learn.fit(3, .5)\n",
    "learn.recorder.plot_loss()    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(#4) [0,1235.869140625,2710.02880859375,'00:00']\n",
      "(#4) [1,946.7556762695312,56322.80078125,'00:00']\n",
      "(#4) [2,694.0796508789062,29347.955078125,'00:00']\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "m = Net()\n",
    "data = DataLoaders(*[CustumData([make_data(100,bias = i)]*100) for i in [100,200]])\n",
    "learn = Learner(data, m, F.mse_loss)\n",
    "\n",
    "learn.fit(3, .5)\n",
    "learn.recorder.plot_loss()   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You see the difference above"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Alternative"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I would like to do the normalization inside the model but this gives different problems. Any ideas?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "class tensorT(torch.Tensor):\n",
    "    def show(self,ctx=None):\n",
    "        if ctx is None:\n",
    "            f, ctx = plt.subplots()\n",
    "        ctx.plot(self)\n",
    "        \n",
    "a = tensorT([1,2,3])\n",
    "a.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(#4) [0,3909.198974609375,834.8953857421875,'00:00']\n",
      "(#4) [1,2315.303466796875,82.82062530517578,'00:00']\n",
      "(#4) [2,1505.5465087890625,121.20492553710938,'00:00']\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "m = Net()\n",
    "data = DataLoaders(*[TfmdDL(make_data(1000, norm = False)) for _ in range(2)])\n",
    "learn = Learner(data, m, F.mse_loss)\n",
    "\n",
    "learn.fit(3, .5)\n",
    "learn.recorder.plot_loss()       \n",
    "learn.show_results(max_n=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(#3) [0,1712.11279296875,'00:00']\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/tako/dev/env37/lib/python3.7/site-packages/fastai2/learner.py:256: UserWarning: Using a target size (torch.Size([64, 1])) that is different to the input size (torch.Size([64, 10])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  self.loss = self.loss_func(self.pred, *self.yb); self('after_loss')\n"
     ]
    },
    {
     "ename": "RuntimeError",
     "evalue": "element 0 of tensors does not require grad and does not have a grad_fn",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-126-27c359b9161c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mlearn\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mLearner\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mm\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mF\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmse_loss\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mlearn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m3\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      6\u001b[0m \u001b[0mlearn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrecorder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot_loss\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      7\u001b[0m \u001b[0mlearn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow_results\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmax_n\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/dev/env37/lib/python3.7/site-packages/fastai2/learner.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, n_epoch, lr, wd, cbs, reset_opt)\u001b[0m\n\u001b[1;32m    293\u001b[0m                     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    294\u001b[0m                         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mepoch\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mepoch\u001b[0m\u001b[0;34m;\u001b[0m          \u001b[0mself\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'begin_epoch'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 295\u001b[0;31m                         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_do_epoch_train\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    296\u001b[0m                         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_do_epoch_validate\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    297\u001b[0m                     \u001b[0;32mexcept\u001b[0m \u001b[0mCancelEpochException\u001b[0m\u001b[0;34m:\u001b[0m   \u001b[0mself\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'after_cancel_epoch'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/dev/env37/lib/python3.7/site-packages/fastai2/learner.py\u001b[0m in \u001b[0;36m_do_epoch_train\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    268\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    269\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdl\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain\u001b[0m\u001b[0;34m;\u001b[0m                        \u001b[0mself\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'begin_train'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 270\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mall_batches\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    271\u001b[0m         \u001b[0;32mexcept\u001b[0m \u001b[0mCancelTrainException\u001b[0m\u001b[0;34m:\u001b[0m                         \u001b[0mself\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'after_cancel_train'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    272\u001b[0m         \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m                                             \u001b[0mself\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'after_train'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/dev/env37/lib/python3.7/site-packages/fastai2/learner.py\u001b[0m in \u001b[0;36mall_batches\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    246\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mall_batches\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\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    247\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_iter\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdl\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 248\u001b[0;31m         \u001b[0;32mfor\u001b[0m \u001b[0mo\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdl\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mone_batch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mo\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    249\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    250\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mone_batch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\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~/dev/env37/lib/python3.7/site-packages/fastai2/learner.py\u001b[0m in \u001b[0;36mone_batch\u001b[0;34m(self, i, b)\u001b[0m\n\u001b[1;32m    256\u001b[0m             \u001b[0mself\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[0mloss_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpred\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0myb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m;\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'after_loss'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    257\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtraining\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mreturn\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 258\u001b[0;31m             \u001b[0mself\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[0mself\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'after_backward'\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    259\u001b[0m             \u001b[0mself\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[0mself\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'after_step'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    260\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mopt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzero_grad\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~/dev/env37/lib/python3.7/site-packages/torch/tensor.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(self, gradient, retain_graph, create_graph)\u001b[0m\n\u001b[1;32m    164\u001b[0m                 \u001b[0mproducts\u001b[0m\u001b[0;34m.\u001b[0m \u001b[0mDefaults\u001b[0m \u001b[0mto\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    165\u001b[0m         \"\"\"\n\u001b[0;32m--> 166\u001b[0;31m         \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mautograd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgradient\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\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    167\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    168\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mregister_hook\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhook\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~/dev/env37/lib/python3.7/site-packages/torch/autograd/__init__.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables)\u001b[0m\n\u001b[1;32m     97\u001b[0m     Variable._execution_engine.run_backward(\n\u001b[1;32m     98\u001b[0m         \u001b[0mtensors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgrad_tensors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 99\u001b[0;31m         allow_unreachable=True)  # allow_unreachable flag\n\u001b[0m\u001b[1;32m    100\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    101\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mRuntimeError\u001b[0m: element 0 of tensors does not require grad and does not have a grad_fn"
     ]
    }
   ],
   "source": [
    "m = Net(norm = True)\n",
    "data = DataLoaders(*[TfmdDL(make_data(norm = False)) for _ in range(2)])\n",
    "learn = Learner(data, m, F.mse_loss)\n",
    "\n",
    "learn.fit(3)\n",
    "learn.recorder.plot_loss()         \n",
    "learn.show_results(max_n=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "env37",
   "language": "python",
   "name": "env37"
  },
  "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}