From de78cbcc5fdada91a81eee4bd106acab82c21f3b Mon Sep 17 00:00:00 2001 From: Eric Zelikman Date: Tue, 17 Nov 2020 20:34:13 -0500 Subject: [PATCH] generative teaching networks notebook --- ...erative_Teaching_Networks_(Optional).ipynb | 907 ++++++++++++++++++ 1 file changed, 907 insertions(+) create mode 100644 C3W1_Generative_Teaching_Networks_(Optional).ipynb diff --git a/C3W1_Generative_Teaching_Networks_(Optional).ipynb b/C3W1_Generative_Teaching_Networks_(Optional).ipynb new file mode 100644 index 0000000..3f42af3 --- /dev/null +++ b/C3W1_Generative_Teaching_Networks_(Optional).ipynb @@ -0,0 +1,907 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "C3W1: Generative Teaching Networks (Optional).ipynb", + "provenance": [], + "collapsed_sections": [], + "toc_visible": true, + "machine_shape": "hm", + "include_colab_link": true + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "agrWjxVftMNN" + }, + "source": [ + "# Generative Teaching Networks (GTN)\n", + "\n", + "*Please note that this is an optional notebook, meant to introduce more advanced concepts if you're up for a challenge, so don't worry if you don't completely follow! The first author of this work, Felipe Such, reviewed this notebook for you.*\n", + "\n", + "### Goals \n", + "\n", + "In this notebook, you'll be implementing a Generative Teaching Network (GTN), first introduced in [Generative Teaching Networks: Accelerating Neural Architecture Search by Learning to Generate Synthetic Training Data](https://arxiv.org/abs/1912.07768) (Such et al. 2019). Essentially, a GTN is composed of a generator (i.e. teacher), which produces synthetic data, and a student, which is trained on this data for some task. The key difference between GTNs and GANs is that GTN models work cooperatively (as opposed to adversarially).\n", + "\n", + "Throughout this notebook, you'll gain (deeper) exposure to the following concepts:\n", + "\n", + "1. **End-to-End Data Augmentation.** Data augmentation refers to the generation of more data from existing data to *augment* the training set. Examples of this with images include operations like random cropping and flipping. In this sense, the generator performs data augmentation by synthesizing data as extra training data. GTNs differ from previous data augmentation approaches in that:\n", + " - The generator and student are trained together, as opposed to training and freezing the generator, then training the student.\n", + " - The real data plays a small role: it's only used once every several student updates to update the generator with respect to the student's performance.\n", + " - The generated data doesn't look realistic (see visualization later in notebook) yet it's more effective for training the student than real data is!\n", + "\n", + "2. **Curriculum Learning.** The generator not only can synthesize data from random noise, but also can learn this random noise, or *curriculum*. By backpropagating through the inputs, the generator can be trained to select the curricula that it deems will be best for student learning.\n", + "\n", + "3. **Meta-Learning.** Meta-learning refers to \"learning to learn,\" a broad field that optimizes over different learning tasks to find the best way to learn. You're probably an example of a good meta-learner :). A GTN accomplishes this by training the generator to understand how the student learns, demonstrated via curriculum learning.\n", + "\n", + "4. **Neural Architecture Search.** But wait, there's still more! The generator doesn't just guide student training, it also can help determine the optimal student architecture (i.e. which layers, network depth). This concept of learning the best architecture is called Neural Architecture Search, or NAS. Pretty convenient, huh!\n", + "\n", + "![Figure 1a from the paper](https://drive.google.com/uc?id=1y1eEkAkyDRHjX6NzAZkjsVZ8m6HEL557)\n", + "*Figure 1(a) from the [GTN paper](https://arxiv.org/pdf/1912.07768.pdf), providing an overview of the method*\n", + "\n", + "### Learning Objectives\n", + "\n", + "By the end of this notebook, you should:\n", + "\n", + "1. Understand the concepts of teaching networks, meta-learning, and neural architecture search, and how they relate to the objective of data augmentation.\n", + "2. Implement and train a GTN on MNIST, and observe how a GTN can accelerate training." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rVBfg9rgtR7h" + }, + "source": [ + "## Getting Started\n", + "\n", + "Start by running the following two cells. The first cell imports packages that you'll use and checks whether the package, [Higher](https://github.com/facebookresearch/higher) (by Facebook Research), is installed. Higher allows you to \"unroll\" inner gradient updates. Unrolling inner updates means that instead of computing updates in a loop where previous updates are overwritten (i.e. one step of traditional SGD), each update is stored, which makes it easier to compute and apply gradients to the generator through multiple updates of the student.\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "lekB0j-YtH3y", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "67579100-c3b9-4f01-a70c-a4db0c650fe0" + }, + "source": [ + "import os\n", + "import sys\n", + "import math\n", + "import random\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from PIL import Image\n", + "\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "import torch.optim as optim\n", + "from torch import Tensor\n", + "from torch.autograd import grad\n", + "\n", + "import torchvision\n", + "import torchvision.datasets as datasets\n", + "import torchvision.transforms as transforms\n", + "from torch.autograd import Variable\n", + "\n", + "if 'higher' not in sys.modules:\n", + " !pip install higher\n", + "import higher as higher\n", + "\n", + "print(sys.version)\n", + "print(torch.__version__)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Requirement already satisfied: higher in /usr/local/lib/python3.6/dist-packages (0.2.1)\n", + "Requirement already satisfied: torch in /usr/local/lib/python3.6/dist-packages (from higher) (1.6.0+cu101)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.6/dist-packages (from torch->higher) (1.18.5)\n", + "Requirement already satisfied: future in /usr/local/lib/python3.6/dist-packages (from torch->higher) (0.16.0)\n", + "3.6.9 (default, Oct 8 2020, 12:12:24) \n", + "[GCC 8.4.0]\n", + "1.6.0+cu101\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "10Wp24Y017h5" + }, + "source": [ + "# Set random seeds\n", + "random.seed(0)\n", + "torch.manual_seed(0)\n", + "np.random.seed(0)\n", + "\n", + "# Set important parameters\n", + "learning_rate = 1e-2\n", + "inner_loop_iterations = 32\n", + "outer_loop_iterations = 5\n", + "num_classes = 10\n", + "\n", + "noise_size = 64 # size of noise or curriculum vector\n", + "img_size = 28 # width / height of generated image\n", + "\n", + "inner_loop_batch_size = 128\n", + "outer_loop_batch_size = 128\n", + "\n", + "mnist_mean = 0.1307 # for normalizing mnist images\n", + "mnist_std = 0.3081 # for normalizing mnist images\n", + "\n", + "imgs_per_row = num_classes" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Mebq3wsH4HeJ" + }, + "source": [ + "### Dataset\n", + "\n", + "Download the MNIST dataset and organize it into a `torch.utils.data.Dataset` object. Then apply `torchvision.transforms` to convert raw PIL images to tensors." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "pc17E5a6tWWc", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "c76ead8b-b23c-4b08-f34c-35e28638b3c3" + }, + "source": [ + "# Initialize MNIST transforms\n", + "transform = transforms.Compose([\n", + " transforms.Lambda(lambda x: np.array(x)),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize((mnist_mean,), (mnist_std,)),\n", + "])\n", + "\n", + "# Create data splits\n", + "train = datasets.MNIST('./data', train=True, transform=transform, download=True)\n", + "train, val = torch.utils.data.random_split(train, [50000, 10000])\n", + "test = datasets.MNIST('./data', train=False, transform=transform, download=True)\n", + "print('Created train, val, and test datasets.')" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Created train, val, and test datasets.\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "TEHDEx0A4rg7" + }, + "source": [ + "### Dataloader\n", + "\n", + "Now wrap your dataset class in a `torch.utils.data.DataLoader` class, which will iterate over batches in training. This class increases memory access bandwidth so retrieving images from your dataset won't be a bottleneck in training. MNIST images are small, so the increase in memory retrieval speed should be relatively trivial." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "B6oWjCknt0-9" + }, + "source": [ + "train_loader = torch.utils.data.DataLoader(\n", + " train, batch_size=outer_loop_batch_size, shuffle=True, drop_last=True, num_workers=1, pin_memory=True,\n", + ")\n", + "\n", + "val_loader = torch.utils.data.DataLoader(\n", + " val, batch_size=outer_loop_batch_size, shuffle=True, drop_last=True, num_workers=1, pin_memory=True,\n", + ")\n", + "\n", + "test_loader = torch.utils.data.DataLoader(\n", + " test, batch_size=outer_loop_batch_size, shuffle=True, drop_last=True, num_workers=1, pin_memory=True,\n", + ")" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aVZMid8yMcqo" + }, + "source": [ + "## MNIST Classification\n", + "\n", + "In this next section, you'll implement and train a GTN on MNIST classification. Note that the student model for this task is a classifier. To extend GTNs to other datasets, you also want to check out the weight normalization technique in the paper --- for now on MNIST, you don't need to worry about this. Alright, let's get started with the generator and classifier's model architecture!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "NENBXah36vrh" + }, + "source": [ + "### Generator \n", + "\n", + "Let's now build the generator. For this task, the generator will consist of two fully connected blocks (each consisting of a fully connected layer, a leaky ReLU, and a batch normalization layer) and two convolutional blocks (each consisting of a convolutional layer, a batch normalization layer and a leaky ReLU). A tanh layer is applied to this output to center it around `0` with reasonable standard deviation." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "aKsF5G1V68sC" + }, + "source": [ + "class Teacher(nn.Module):\n", + " '''\n", + " Implements a Teacher module.\n", + " '''\n", + " def __init__(self):\n", + " super().__init__()\n", + "\n", + " conv1_filters = 64\n", + " fc1_size = 1024\n", + " \n", + " self.fc2_filters = 128\n", + " self.fc2_width = img_size\n", + " fc2_size = self.fc2_filters * self.fc2_width * self.fc2_width\n", + "\n", + " self.fc1 = nn.Linear(noise_size + num_classes, fc1_size)\n", + " nn.init.kaiming_normal_(self.fc1.weight, 0.1)\n", + " self.bn_fc1 = nn.BatchNorm1d(fc1_size, momentum=0.1)\n", + "\n", + " self.fc2 = nn.Linear(fc1_size, fc2_size)\n", + " nn.init.kaiming_normal_(self.fc2.weight, 0.1)\n", + " self.bn_fc2 = nn.BatchNorm2d(self.fc2_filters, momentum=0.1)\n", + "\n", + " self.conv1 = nn.Conv2d(self.fc2_filters, conv1_filters, 3, 1, padding=3 // 2)\n", + " self.bn_conv1 = nn.BatchNorm2d(conv1_filters, momentum=0.1)\n", + "\n", + " self.conv2 = nn.Conv2d(conv1_filters, 1, 3, 1, padding=3 // 2)\n", + " self.bn_conv2 = nn.BatchNorm2d(1, momentum=0.1)\n", + " \n", + " self.tanh = nn.Tanh()\n", + "\n", + " self.learner_optim_params = nn.Parameter(torch.tensor([0.02, 0.5]), True)\n", + "\n", + " def forward(self, x, target):\n", + " '''\n", + " Synthesizes a batch of training examples for the learner.\n", + " Args:\n", + " x (torch.tensor): shape (b, 64)\n", + " target (torch.tensor): shape (b, 10)\n", + " '''\n", + " # Fully connected block 1\n", + " x = torch.cat([x, target], dim=1) # shape (b, 64+10)\n", + " x = self.fc1(x) # shape (b, 1024)\n", + " x = F.leaky_relu(x, 0.1)\n", + " x = self.bn_fc1(x)\n", + "\n", + " # Fully connected block 2\n", + " x = self.fc2(x) # shape (b, 128*28*28)\n", + " x = F.leaky_relu(x, 0.1)\n", + " x = x.view( # shape (b, 128, 28, 28)\n", + " -1, self.fc2_filters, self.fc2_width, self.fc2_width\n", + " )\n", + " x = self.bn_fc2(x)\n", + "\n", + " # Convolutional block 1\n", + " x = self.conv1(x) # shape (b, 64, 28, 28)\n", + " x = self.bn_conv1(x)\n", + " x = F.leaky_relu(x, 0.1)\n", + "\n", + " # Convolutional block 2\n", + " x = self.conv2(x) # shape (b, 1, 28, 28)\n", + " x = self.bn_conv2(x)\n", + "\n", + " x = (self.tanh(x) + 1 - 2 * mnist_mean) / (2 * mnist_std)\n", + " return x, target " + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "uUzswqH-69P4" + }, + "source": [ + "### Classifier \n", + "\n", + "Now let's build the student model, a classifier. Be sure to randomize the number of convolutional filters in the first and second convolution layers so the teacher generalizes to other architectures. This is important since it'll help the teacher perform neural architecture search later.\n", + "\n", + "For MNIST classification, the classifier consists of two convolutional blocks (each consisting of a convolutional layer, a leaky ReLU, a batch normalization layer and a max pooling). After these layers, the output is flattened and passed through a fully connected layer, a batch normalization layer, and a softmax to generate probabilities per class." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "rZqp0lAz7CmR" + }, + "source": [ + "class Learner(nn.Module):\n", + " '''\n", + " Implements a Learner module.\n", + " '''\n", + " def __init__(self, num_conv1=None, num_conv2=None):\n", + " super().__init__()\n", + "\n", + " # Randomly select and evaluate convolutional depth\n", + " # for evaluation/comparison in neural architecture search\n", + " if num_conv1 is None:\n", + " conv1_filters = np.random.randint(32, 64)\n", + " else:\n", + " conv1_filters = num_conv1\n", + " if num_conv2 is None:\n", + " conv2_filters = np.random.randint(64, 128)\n", + " else:\n", + " conv2_filters = num_conv2\n", + "\n", + " self.conv1 = nn.Conv2d(1, conv1_filters, 3, 1)\n", + " self.bn1 = nn.BatchNorm2d(conv1_filters, momentum=0.1)\n", + "\n", + " self.conv2 = nn.Conv2d(conv1_filters, conv2_filters, 3, 1)\n", + " self.bn2 = nn.BatchNorm2d(conv2_filters, momentum=0.1)\n", + "\n", + " c1_size = (img_size - 3 + 1) // 2\n", + " c2_size = (c1_size - 3 + 1) // 2\n", + " \n", + " self.fc = nn.Linear(conv2_filters * c2_size * c2_size, num_classes)\n", + " self.bn3 = nn.BatchNorm1d(num_classes, momentum=0.1)\n", + " \n", + " self.activation = nn.LeakyReLU(0.1)\n", + "\n", + " def forward(self, x):\n", + " x = self.conv1(x)\n", + " x = self.activation(x)\n", + " x = self.bn1(x)\n", + " x = F.max_pool2d(x, 2)\n", + "\n", + " x = self.conv2(x)\n", + " x = self.activation(x)\n", + " x = self.bn2(x)\n", + " x = F.max_pool2d(x, 2)\n", + "\n", + " x = torch.flatten(x, 1)\n", + " x = self.fc(x)\n", + " x = self.bn3(x)\n", + "\n", + " return x" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "TjMifQZ3pO0e" + }, + "source": [ + "### Training \n", + "\n", + "*Note: can run on CPU but need high RAM version of Colab.*\n", + "\n", + "Now let's extend the inner loop implementation to train the outer loop loss function. After training the classifier on the synthetic data every `inner_loop_iterations`, evaluate the classifier on a batch of real data and backpropagate the resulting loss to the generator.\n", + "\n", + "After training for about 50 outer loop iterations, your validation accuracy should approach 90%. This means that your teacher is so good that it gets your student to a 90% validation accuracy with 32 iterations. That's pretty cool! Notice how the images don't look much like numbers. These images represent a compressed version of the training images with the most salient information needed for training." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "9KLgaZ8Q7EUj" + }, + "source": [ + "def generate_img(img_tensor):\n", + " '''\n", + " Function that renders an MNIST image.\n", + " '''\n", + " return torchvision.transforms.ToPILImage()(1 - ((img_tensor * mnist_std) + mnist_mean))" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "gSL8cTcH55bK" + }, + "source": [ + "teacher = Teacher()\n", + "params_to_train = list(teacher.parameters())\n", + "\n", + "# If we want to use a curriculum, we initialize the learnable parameters here\n", + "use_curriculum = True\n", + "if use_curriculum:\n", + " curriculum = nn.Parameter(torch.randn(inner_loop_iterations, inner_loop_batch_size, noise_size), requires_grad=True)\n", + " params_to_train += [curriculum]\n", + "\n", + "optimizer_teacher = optim.Adam(params_to_train, lr=learning_rate)\n", + "\n", + "# For each inner loop iterations, we use the same sequence of labels. \n", + "# This allows the curriculum vectors to train to stable labels \n", + "label = torch.tensor([x % num_classes for x in range(inner_loop_batch_size)])\n", + "\n", + "# For the inner loop loss, we use cross entropy\n", + "loss_fn = nn.CrossEntropyLoss()\n", + "\n", + "# Here we initialize iterators on the train and val datasets\n", + "train_iterator = iter(train_loader)\n", + "val_iterator = iter(val_loader)\n", + "test_iterator = iter(test_loader)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "ULasVbFGqCUd", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 523 + }, + "outputId": "9b7ecf41-a245-41d1-eb52-fdd304e7e663" + }, + "source": [ + "for it, real_data in enumerate(train_loader):\n", + "\n", + " teacher.train()\n", + " optimizer_teacher.zero_grad()\n", + "\n", + " # We also optimize the learner learning rate and momentum with the\n", + " # outer loop updates\n", + " learner_lr = teacher.learner_optim_params[0]\n", + " learner_momentum = teacher.learner_optim_params[1]\n", + "\n", + " # Here we sample a learner with random number of conv filters\n", + " learner = Learner()\n", + " inner_optim = optim.SGD(learner.parameters(), lr=learner_lr.item(), momentum=learner_momentum.item())\n", + " learner.train()\n", + "\n", + " inner_losses = []\n", + " with higher.innerloop_ctx(learner, inner_optim, override={'lr': [learner_lr], 'momentum': [learner_momentum]}) as (flearner, diffopt):\n", + " for step in range(inner_loop_iterations):\n", + "\n", + " # Data generation\n", + " if use_curriculum:\n", + " z_vec = curriculum[step]\n", + " else:\n", + " z_vec = torch.randn(inner_loop_batch_size, noise_size)\n", + "\n", + " one_hot = F.one_hot(label, num_classes)\n", + " \n", + " # Pass input to teacher to generate synthetic images\n", + " teacher_output, teacher_target = teacher(z_vec, one_hot)\n", + "\n", + " # ====== Show intermediate generated images ======\n", + " if step == 0:\n", + " print('------------------ Outer loop iteration', it + 1, '------------------')\n", + " print('Examples 0 - 9 from beginning of inner loop:')\n", + " background = Image.new('L', (img_size * imgs_per_row + imgs_per_row + 1, img_size + 2))\n", + " for i in range(imgs_per_row): # indexes column \n", + " background.paste(generate_img(teacher_output[i]), (i * 28 + i + 1, 1))\n", + " display(background)\n", + "\n", + " if step == (inner_loop_iterations - 1):\n", + " print('Examples 0 - 9 from end of inner loop:')\n", + " background = Image.new('L', (img_size * imgs_per_row + imgs_per_row + 1, img_size + 2))\n", + " for i in range(imgs_per_row): # indexes column\n", + " background.paste(generate_img(teacher_output[i]), (i * 28 + i + 1, 1))\n", + " display(background)\n", + "\n", + " # Pass teacher output to the learner \n", + " learner_output = flearner(teacher_output)\n", + " loss = loss_fn(learner_output, label)\n", + " diffopt.step(loss)\n", + "\n", + " inner_losses.append(loss.item())\n", + "\n", + " correct = 0\n", + " data, target = real_data\n", + " output = flearner(data)\n", + " loss = loss_fn(output, target)\n", + " pred = output.argmax(dim=1, keepdim=True)\n", + " correct += pred.eq(target.view_as(pred)).sum().item()\n", + "\n", + " accuracy_train = correct / target.shape[0]\n", + "\n", + " print(\"Inner loop losses:\", inner_losses)\n", + " print(\"Train accuracy:\", accuracy_train)\n", + "\n", + " # Compute accuracy on validation set\n", + " data, target = next(val_iterator)\n", + " print\n", + " output = flearner(data)\n", + " pred = output.argmax(dim=1, keepdim=True)\n", + " correct = pred.eq(target.view_as(pred)).sum().item()\n", + " accuracy = correct / outer_loop_batch_size\n", + " print(\"Val accuracy:\", accuracy)\n", + "\n", + " if (it == outer_loop_iterations - 1):\n", + " # Compute accuracy on test set\n", + " correct = 0\n", + " for i, (data, target) in enumerate(test_loader):\n", + " output = flearner(data)\n", + " pred = output.argmax(dim=1, keepdim=True)\n", + " correct += pred.eq(target.view_as(pred)).sum().item()\n", + " accuracy = correct / (outer_loop_batch_size * len(test_loader))\n", + " print(\"----------------------------------\")\n", + " print(\"Done training...\")\n", + " print(\"Final test accuracy:\", accuracy)\n", + "\n", + " # Final inner loop training curve\n", + " plt.plot(np.arange(len(inner_losses)), inner_losses)\n", + " plt.xlabel(\"Inner loop iteration\")\n", + " plt.ylabel(\"Cross entropy loss\")\n", + " plt.show()\n", + "\n", + " break\n", + "\n", + " loss.backward()\n", + "\n", + " optimizer_teacher.step()" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "------------------ Outer loop iteration 1 ------------------\n", + "Examples 0 - 9 from beginning of inner loop:\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "Examples 0 - 9 from end of inner loop:\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "Inner loop losses: [2.7236783504486084, 2.6256988048553467, 2.672574758529663, 2.6134140491485596, 2.596022844314575, 2.6138412952423096, 2.5911357402801514, 2.2683398723602295, 2.4912025928497314, 2.3700554370880127, 2.4646973609924316, 2.5557470321655273, 2.377898693084717, 2.389883518218994, 2.282891273498535, 2.1598823070526123, 2.371140241622925, 2.246856451034546, 2.4149580001831055, 2.284665107727051, 2.3528828620910645, 2.2198994159698486, 2.27508282661438, 2.162252426147461, 2.2586324214935303, 2.2811717987060547, 2.254401445388794, 2.224247455596924, 2.2326204776763916, 2.1681580543518066, 2.0837442874908447, 2.0746254920959473]\n", + "Train accuracy: 0.0703125\n", + "Val accuracy: 0.109375\n", + "------------------ Outer loop iteration 2 ------------------\n", + "Examples 0 - 9 from beginning of inner loop:\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "Examples 0 - 9 from end of inner loop:\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "Inner loop losses: [2.648425340652466, 2.265460252761841, 1.8753728866577148, 1.6502933502197266, 1.4719526767730713, 1.5776382684707642, 1.487295150756836, 1.3296877145767212, 1.3358333110809326, 1.2487596273422241, 1.285240888595581, 1.235264778137207, 1.3077187538146973, 1.296455979347229, 1.1424646377563477, 1.1681510210037231, 1.1846617460250854, 1.1983927488327026, 1.130386233329773, 1.113377332687378, 1.1521409749984741, 1.155056357383728, 1.1762973070144653, 1.0792546272277832, 1.0710194110870361, 1.050790548324585, 1.0769656896591187, 0.9832346439361572, 1.0515564680099487, 1.0672335624694824, 1.0967187881469727, 1.133283257484436]\n", + "Train accuracy: 0.6484375\n", + "Val accuracy: 0.640625\n", + "------------------ Outer loop iteration 3 ------------------\n", + "Examples 0 - 9 from beginning of inner loop:\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "Examples 0 - 9 from end of inner loop:\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "Inner loop losses: [2.6590287685394287, 1.7501730918884277, 1.6416189670562744, 1.4128144979476929, 1.2072248458862305, 1.2262474298477173, 1.166333556175232, 1.0464897155761719, 1.1477928161621094, 1.0602245330810547, 1.0258921384811401, 0.9966067671775818, 0.9745022654533386, 0.9789420366287231, 0.9151432514190674, 0.9637138843536377, 0.8352720737457275, 0.8378331065177917, 0.8227945566177368, 0.850355863571167, 0.8167492151260376, 0.8021303415298462, 0.7668197751045227, 0.7336200475692749, 0.7555335164070129, 0.741989016532898, 0.7746337056159973, 0.7558042407035828, 0.6931012272834778, 0.6824826002120972, 0.7050946950912476, 0.7332448363304138]\n", + "Train accuracy: 0.703125\n", + "Val accuracy: 0.765625\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mBMBPES6uZdm" + }, + "source": [ + "## Simple MNIST NAS\n", + "\n", + "The key idea of this paper is that performance of larger networks on teacher-generated data is a good proxy for performance on real data, allowing you to search over many more architectures with limited compute. In fact, Such et al. state,\n", + "\n", + "> We found that to achieve the same predictive power (rank correlation) as achieved with only 128 SGD steps on GTN-generated data, you would instead need 1200 SGD steps on real data.\n", + "\n", + "With enough compute, you could train the teacher on large networks sampled from a NAS space, gradually increasing the number of inner loop updates and architectures per outer loop update. This would provide an end-to-end NAS model. However, Such et al. found that this is prohibitively expensive. Thus, the teacher is only trained on small networks with the hope that it'll generalize well to larger, more powerful networks.\n", + "\n", + "Now let's implement a simple neural architecture search (NAS) with your GTN. In this search, you'll optimize the number of convolutional filters for the two-layer student network you trained your teacher on earlier." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "5hQn3a53uQVc", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "32cb8abb-1045-497d-e855-692135223928" + }, + "source": [ + "num_architectures = 10\n", + "\n", + "best_accuracy = 0\n", + "\n", + "for i in range(num_architectures):\n", + "\n", + " # Randomly sample architecture\n", + " conv1_filters = np.random.randint(1, 64)\n", + " conv2_filters = np.random.randint(1, 128)\n", + "\n", + " learner = Learner(conv1_filters, conv2_filters)\n", + " inner_optim = optim.SGD(learner.parameters(), lr=learner_lr.item(), momentum=learner_momentum.item())\n", + " learner.train()\n", + "\n", + " # For some reason if we don't use higher here, accuracy drops significantly\n", + " with higher.innerloop_ctx(learner, inner_optim, override={'lr': [learner_lr], 'momentum': [learner_momentum]}) as (flearner, diffopt):\n", + " for step in range(inner_loop_iterations):\n", + "\n", + " # Data generation\n", + " if use_curriculum:\n", + " z_vec = curriculum[step]\n", + " else:\n", + " z_vec = torch.randn(inner_loop_batch_size, noise_size)\n", + "\n", + " one_hot = F.one_hot(label, num_classes)\n", + "\n", + " # Pass input to teacher to generate synthetic images\n", + " teacher_output, teacher_target = teacher(z_vec, one_hot)\n", + "\n", + " # Pass teacher output to the learner\n", + " learner_output = flearner(teacher_output)\n", + " loss = loss_fn(learner_output, label)\n", + " diffopt.step(loss)\n", + "\n", + " # Compute accuracy on validation set\n", + " correct = 0\n", + " for val_idx, (data, target) in enumerate(val_loader, 0):\n", + " #if (val_idx == val_iterations): break\n", + " output = flearner(data)\n", + " pred = output.argmax(dim=1, keepdim=True)\n", + " correct += pred.eq(target.view_as(pred)).sum().item()\n", + " accuracy = correct / (outer_loop_batch_size * len(val_loader))\n", + "\n", + " if (accuracy > best_accuracy):\n", + " best_accuracy = accuracy\n", + " filter_counts = (conv1_filters, conv2_filters)\n", + "\n", + " print(\"------------------------- Architecture\", i + 1,\" -------------------------\")\n", + " print(\"Num conv1 filters:\", conv1_filters, \", Num conv2 filters:\", conv2_filters, \", Val accuracy:\", accuracy)\n", + "\n", + " \n", + " if (i == num_architectures - 1):\n", + " correct = 0\n", + " for test_idx, (data, target) in enumerate(test_loader, 0):\n", + " #if (test_idx == test_iterations): break\n", + " output = flearner(data)\n", + " pred = output.argmax(dim=1, keepdim=True)\n", + " correct += pred.eq(target.view_as(pred)).sum().item()\n", + " accuracy = correct / (outer_loop_batch_size * len(test_loader))\n", + " print(\"------------------------- Best architecture -------------------------\")\n", + " print(\"Num conv1 filters:\", filter_counts[0], \", Num conv2 filters:\", filter_counts[1], \", Test accuracy:\", accuracy)\n", + " " + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "------------------------- Architecture 1 -------------------------\n", + "Num conv1 filters: 22 , Num conv2 filters: 115 , Val accuracy: 0.8155048076923077\n", + "------------------------- Architecture 2 -------------------------\n", + "Num conv1 filters: 37 , Num conv2 filters: 88 , Val accuracy: 0.8197115384615384\n", + "------------------------- Architecture 3 -------------------------\n", + "Num conv1 filters: 7 , Num conv2 filters: 89 , Val accuracy: 0.8247195512820513\n", + "------------------------- Architecture 4 -------------------------\n", + "Num conv1 filters: 25 , Num conv2 filters: 13 , Val accuracy: 0.7846554487179487\n", + "------------------------- Architecture 5 -------------------------\n", + "Num conv1 filters: 59 , Num conv2 filters: 66 , Val accuracy: 0.8151041666666666\n", + "------------------------- Architecture 6 -------------------------\n", + "Num conv1 filters: 39 , Num conv2 filters: 40 , Val accuracy: 0.8113982371794872\n", + "------------------------- Architecture 7 -------------------------\n", + "Num conv1 filters: 24 , Num conv2 filters: 47 , Val accuracy: 0.8046875\n", + "------------------------- Architecture 8 -------------------------\n", + "Num conv1 filters: 25 , Num conv2 filters: 82 , Val accuracy: 0.8153044871794872\n", + "------------------------- Architecture 9 -------------------------\n", + "Num conv1 filters: 38 , Num conv2 filters: 26 , Val accuracy: 0.8151041666666666\n", + "------------------------- Architecture 10 -------------------------\n", + "Num conv1 filters: 14 , Num conv2 filters: 73 , Val accuracy: 0.8188100961538461\n", + "------------------------- Best architecture -------------------------\n", + "Num conv1 filters: 7 , Num conv2 filters: 89 , Test accuracy: 0.8350360576923077\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "TWzzqGHUiufO" + }, + "source": [ + "### Visualization \n", + "\n", + "The rows in the grid produced are images from equally-spaced inner loop iterations where the first row corresponds to the first inner loop iteration and the last row corresponds to the last. The columns correspond to classes where the first column is filled with 0's and the last colummn is filled with 9's." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "tcNX36MTglMe", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 482 + }, + "outputId": "2edfd256-a370-4df5-a74c-5db4fdf90213" + }, + "source": [ + "imgs_per_row = num_classes\n", + "rows = inner_loop_iterations // 2 * img_size + inner_loop_iterations // 2 + 1\n", + "cols = imgs_per_row * img_size + imgs_per_row + 1\n", + "background = Image.new('L', (cols, rows))\n", + "\n", + "for step in range(0, inner_loop_iterations, 2): # indexes row\n", + " if use_curriculum:\n", + " z_vec = curriculum[step]\n", + " else:\n", + " z_vec = torch.randn(inner_loop_batch_size, noise_size)\n", + "\n", + " one_hot = F.one_hot(label, num_classes)\n", + "\n", + " teacher_output, teacher_target = teacher(z_vec, one_hot)\n", + "\n", + " for i in range(imgs_per_row): # indexes column \n", + " background.paste(generate_img(teacher_output[i]), (i * img_size + i + 1, (step // 2) * img_size + (step // 2) + 1))\n", + "\n", + "display(background)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bgKEU1W4BL17" + }, + "source": [ + "### Conclusion\n", + "\n", + "Now you know how GTN-generated data augmentation can be useful for training classifiers quickly which in turn allows us to more efficiently search for best performing model architectures. You've seen how the whole process can be trained end-to-end, instead of training one model first, then another — you can certainly apply this principle elsewhere as you build your systems, merging different steps of the training process as you let the gradient flow all the way through your system! You've touched on evolving areas of research, such as curriculum learning, meta-learning, and neural architecture search (NAS), which you can also take to your other projects." + ] + } + ] +} \ No newline at end of file