Update code for MEAP v8

Author: elistevens

data/p1ch3/ourpoints.hdf5

@@ -1262,20 +1262,46 @@
    "cell_type": "code",
    "execution_count": 71,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(torch.Size([3, 2]), torch.Size([2, 3]))"
+      ]
+     },
+     "execution_count": 71,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "a = torch.ones(3, 2)\n",
-    "a_t = torch.transpose(a, 0, 1)"
+    "a_t = torch.transpose(a, 0, 1)\n",
+    "\n",
+    "a.shape, a_t.shape"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 72,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(torch.Size([3, 2]), torch.Size([2, 3]))"
+      ]
+     },
+     "execution_count": 72,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "a = torch.ones(3, 2)\n",
-    "a_t = a.transpose(0, 1)"
+    "a_t = a.transpose(0, 1)\n",
+    "\n",
+    "a.shape, a_t.shape"
    ]
   },
   {

data/p1ch3/ourpoints.t

@@ -293,14 +293,14 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "t_u_train = t_u[train_indices]\n",
-    "t_c_train = t_c[train_indices]\n",
+    "train_t_u = t_u[train_indices]\n",
+    "train_t_c = t_c[train_indices]\n",
     "\n",
-    "t_u_val = t_u[val_indices]\n",
-    "t_c_val = t_c[val_indices]\n",
+    "val_t_u = t_u[val_indices]\n",
+    "val_t_c = t_c[val_indices]\n",
     "\n",
-    "t_un_train = 0.1 * t_u_train\n",
-    "t_un_val = 0.1 * t_u_val"
+    "train_t_un = 0.1 * train_t_u\n",
+    "val_t_un = 0.1 * val_t_u"
    ]
   },
   {
@@ -309,21 +309,21 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "def training_loop(n_epochs, optimizer, params, t_u_train, t_u_val, t_c_train, t_c_val):\n",
+    "def training_loop(n_epochs, optimizer, params, train_t_u, val_t_u, train_t_c, val_t_c):\n",
     "    for epoch in range(1, n_epochs + 1):\n",
-    "        t_p_train = model(t_un_train, *params) # <1>\n",
-    "        loss_train = loss_fn(t_p_train, t_c_train)\n",
-    "\n",
-    "        t_p_val = model(t_un_val, *params) # <1>\n",
-    "        loss_val = loss_fn(t_p_val, t_c_val)\n",
+    "        train_t_p = model(train_t_u, *params) # <1>\n",
+    "        train_loss = loss_fn(train_t_p, train_t_c)\n",
+    "                             \n",
+    "        val_t_p = model(val_t_u, *params) # <1>\n",
+    "        val_loss = loss_fn(val_t_p, val_t_c)\n",
     "        \n",
     "        optimizer.zero_grad()\n",
-    "        loss_train.backward() # <2>\n",
+    "        train_loss.backward() # <2>\n",
     "        optimizer.step()\n",
     "\n",
     "        if epoch <= 3 or epoch % 500 == 0:\n",
     "            print('Epoch {}, Training loss {}, Validation loss {}'.format(\n",
-    "                epoch, float(loss_train), float(loss_val)))\n",
+    "                epoch, float(train_loss), float(val_loss)))\n",
     "            \n",
     "    return params"
    ]
@@ -368,10 +368,10 @@
     "    n_epochs = 3000, \n",
     "    optimizer = optimizer,\n",
     "    params = params,\n",
-    "    t_u_train = t_un_train, # <1> \n",
-    "    t_u_val = t_un_val, # <1> \n",
-    "    t_c_train = t_c_train,\n",
-    "    t_c_val = t_c_val)"
+    "    train_t_u = train_t_un, # <1> \n",
+    "    val_t_u = val_t_un, # <1> \n",
+    "    train_t_c = train_t_c,\n",
+    "    val_t_c = val_t_c)"
    ]
   },
   {
@@ -380,18 +380,18 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "def training_loop(n_epochs, optimizer, params, t_u_train, t_u_val, t_c_train, t_c_val):\n",
+    "def training_loop(n_epochs, optimizer, params, train_t_u, val_t_u, train_t_c, val_t_c):\n",
     "    for epoch in range(1, n_epochs + 1):\n",
-    "        t_p_train = model(t_un_train, *params)\n",
-    "        loss_train = loss_fn(t_p_train, t_c_train)\n",
+    "        train_t_p = model(train_t_u, *params)\n",
+    "        train_loss = loss_fn(train_t_p, train_t_c)\n",
     "\n",
     "        with torch.no_grad(): # <1>\n",
-    "            t_p_val = model(t_un_val, *params)\n",
-    "            loss_val = loss_fn(t_p_val, t_c_val)\n",
-    "            assert loss_val.requires_grad == False # <2>\n",
+    "            val_t_p = model(val_t_u, *params)\n",
+    "            val_loss = loss_fn(val_t_p, val_t_c)\n",
+    "            assert val_loss.requires_grad == False # <2>\n",
     "            \n",
     "        optimizer.zero_grad()\n",
-    "        loss_train.backward()\n",
+    "        train_loss.backward()\n",
     "        optimizer.step()"
    ]
   },