{"cells": [{"cell_type": "markdown", "id": "82d98719", "metadata": {"papermill": {"duration": 0.035642, "end_time": "2021-09-16T12:16:52.160477", "exception": false, "start_time": "2021-09-16T12:16:52.124835", "status": "completed"}, "tags": []}, "source": ["\n", "# Tutorial 12: Meta-Learning - Learning to Learn\n", "\n", "* **Author:** Phillip Lippe\n", "* **License:** CC BY-SA\n", "* **Generated:** 2021-09-16T14:05:22.989408\n", "\n", "In this tutorial, we will discuss algorithms that learn models which can quickly adapt to new classes and/or tasks with few samples.\n", "This area of machine learning is called _Meta-Learning_ aiming at \"learning to learn\".\n", "Learning from very few examples is a natural task for humans. In contrast to current deep learning models, we need to see only a few examples of a police car or firetruck to recognize them in daily traffic.\n", "This is crucial ability since in real-world application, it is rarely the case that the data stays static and does not change over time.\n", "For example, an object detection system for mobile phones trained on data from 2000 will have troubles detecting today's common mobile phones, and thus, needs to adapt to new data without excessive label effort.\n", "The optimization techniques we have discussed so far struggle with this because they only aim at obtaining a good performance on a test set that had similar data.\n", "However, what if the test set has classes that we do not have in the training set?\n", "Or what if we want to test the model on a completely different task?\n", "We will discuss and implement three common Meta-Learning algorithms for such situations.\n", "This notebook is part of a lecture series on Deep Learning at the University of Amsterdam.\n", "The full list of tutorials can be found at https://uvadlc-notebooks.rtfd.io.\n", "\n", "\n", "---\n", "Open in [{height=\"20px\" width=\"117px\"}](https://colab.research.google.com/github/PytorchLightning/lightning-tutorials/blob/publication/.notebooks/course_UvA-DL/12-meta-learning.ipynb)\n", "\n", "Give us a \u2b50 [on Github](https://www.github.com/PytorchLightning/pytorch-lightning/)\n", "| Check out [the documentation](https://pytorch-lightning.readthedocs.io/en/latest/)\n", "| Join us [on Slack](https://join.slack.com/t/pytorch-lightning/shared_invite/zt-pw5v393p-qRaDgEk24~EjiZNBpSQFgQ)"]}, {"cell_type": "markdown", "id": "e2d3a687", "metadata": {"papermill": {"duration": 0.0331, "end_time": "2021-09-16T12:16:52.228612", "exception": false, "start_time": "2021-09-16T12:16:52.195512", "status": "completed"}, "tags": []}, "source": ["## Setup\n", "This notebook requires some packages besides pytorch-lightning."]}, {"cell_type": "code", "execution_count": 1, "id": "545bd2a7", "metadata": {"colab": {}, "colab_type": "code", "execution": {"iopub.execute_input": "2021-09-16T12:16:52.298786Z", "iopub.status.busy": "2021-09-16T12:16:52.298307Z", "iopub.status.idle": "2021-09-16T12:16:52.300509Z", "shell.execute_reply": "2021-09-16T12:16:52.300893Z"}, "id": "LfrJLKPFyhsK", "lines_to_next_cell": 0, "papermill": {"duration": 0.039119, "end_time": "2021-09-16T12:16:52.301090", "exception": false, "start_time": "2021-09-16T12:16:52.261971", "status": "completed"}, "tags": []}, "outputs": [], "source": ["# ! pip install --quiet \"pytorch-lightning>=1.3\" \"seaborn\" \"matplotlib\" \"torchmetrics>=0.3\" \"torchvision\" \"torch>=1.6, <1.9\""]}, {"cell_type": "markdown", "id": "cb2f6a4e", "metadata": {"papermill": {"duration": 0.033496, "end_time": "2021-09-16T12:16:52.368396", "exception": false, "start_time": "2021-09-16T12:16:52.334900", "status": "completed"}, "tags": []}, "source": ["Meta-Learning offers solutions to these situations, and we will discuss three popular algorithms: __Prototypical Networks__ ([Snell et al., 2017](https://arxiv.org/pdf/1703.05175.pdf)), __Model-Agnostic Meta-Learning / MAML__ ([Finn et al., 2017](http://proceedings.mlr.press/v70/finn17a.html)), and __Proto-MAML__ ([Triantafillou et al., 2020](https://openreview.net/pdf?id=rkgAGAVKPr)).\n", "We will focus on the task of few-shot classification where the training and test set have distinct sets of classes.\n", "For instance, we would train the model on the binary classifications of cats-birds and flowers-bikes, but during test time, the model would need to learn from 4 examples each the difference between dogs and otters, two classes we have not seen during training (Figure credit - [Lilian Weng](https://lilianweng.github.io/lil-log/2018/11/30/meta-learning.html)).\n", "\n", "
\n", "\n", "A different setup, which is very common in Reinforcement Learning and recently Natural Language Processing, is to aim at few-shot learning of a completely new task.\n", "For example, an robot agent that learned to run, jump and pick up boxes, should quickly adapt to collecting and stacking boxes.\n", "In NLP, we can think of a model which was trained sentiment classification, hatespeech detection and sarcasm classification, to adapt to classifying the emotion of a text.\n", "All methods we will discuss in this notebook can be easily applied to these settings since we only use a different definition of a 'task'.\n", "For few-shot classification, we consider a task to distinguish between $M$ novel classes.\n", "Here, we would not only have novel classes, but also a completely different dataset.\n", "\n", "First of all, let's start with importing our standard libraries. We will again be using PyTorch Lightning."]}, {"cell_type": "code", "execution_count": 2, "id": "0df60d32", "metadata": {"execution": {"iopub.execute_input": "2021-09-16T12:16:52.444515Z", "iopub.status.busy": "2021-09-16T12:16:52.442499Z", "iopub.status.idle": "2021-09-16T12:16:54.162754Z", "shell.execute_reply": "2021-09-16T12:16:54.162330Z"}, "papermill": {"duration": 1.760704, "end_time": "2021-09-16T12:16:54.162869", "exception": false, "start_time": "2021-09-16T12:16:52.402165", "status": "completed"}, "tags": []}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["/tmp/ipykernel_3920/3072189054.py:29: DeprecationWarning: `set_matplotlib_formats` is deprecated since IPython 7.23, directly use `matplotlib_inline.backend_inline.set_matplotlib_formats()`\n", " set_matplotlib_formats(\"svg\", \"pdf\") # For export\n", "Global seed set to 42\n"]}, {"name": "stdout", "output_type": "stream", "text": ["Device: cuda:0\n"]}, {"data": {"text/plain": [""]}, "metadata": {}, "output_type": "display_data"}], "source": ["import json\n", "import os\n", "import random\n", "import urllib.request\n", "from collections import defaultdict\n", "from copy import deepcopy\n", "from statistics import mean, stdev\n", "from urllib.error import HTTPError\n", "\n", "import matplotlib\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import pytorch_lightning as pl\n", "import seaborn as sns\n", "import torch\n", "import torch.nn.functional as F\n", "import torch.optim as optim\n", "import torch.utils.data as data\n", "import torchvision\n", "from IPython.display import set_matplotlib_formats\n", "from PIL import Image\n", "from pytorch_lightning.callbacks import LearningRateMonitor, ModelCheckpoint\n", "from torchvision import transforms\n", "from torchvision.datasets import CIFAR100, SVHN\n", "from tqdm.auto import tqdm\n", "\n", "plt.set_cmap(\"cividis\")\n", "# %matplotlib inline\n", "set_matplotlib_formats(\"svg\", \"pdf\") # For export\n", "matplotlib.rcParams[\"lines.linewidth\"] = 2.0\n", "sns.reset_orig()\n", "\n", "# Import tensorboard\n", "# %load_ext tensorboard\n", "\n", "# Path to the folder where the datasets are/should be downloaded (e.g. CIFAR10)\n", "DATASET_PATH = os.environ.get(\"PATH_DATASETS\", \"data/\")\n", "# Path to the folder where the pretrained models are saved\n", "CHECKPOINT_PATH = os.environ.get(\"PATH_CHECKPOINT\", \"saved_models/MetaLearning/\")\n", "\n", "# Setting the seed\n", "pl.seed_everything(42)\n", "\n", "# Ensure that all operations are deterministic on GPU (if used) for reproducibility\n", "torch.backends.cudnn.determinstic = True\n", "torch.backends.cudnn.benchmark = False\n", "\n", "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n", "print(\"Device:\", device)"]}, {"cell_type": "markdown", "id": "d75da604", "metadata": {"papermill": {"duration": 0.03505, "end_time": "2021-09-16T12:16:54.233351", "exception": false, "start_time": "2021-09-16T12:16:54.198301", "status": "completed"}, "tags": []}, "source": ["Training the models in this notebook can take between 2 and 8 hours, and the evaluation time of some algorithms is in the span of couples of minutes.\n", "Hence, we download pre-trained models and results below."]}, {"cell_type": "code", "execution_count": 3, "id": "1ff5e574", "metadata": {"execution": {"iopub.execute_input": "2021-09-16T12:16:54.309827Z", "iopub.status.busy": "2021-09-16T12:16:54.309348Z", "iopub.status.idle": "2021-09-16T12:16:55.155188Z", "shell.execute_reply": "2021-09-16T12:16:55.155577Z"}, "papermill": {"duration": 0.887716, "end_time": "2021-09-16T12:16:55.155716", "exception": false, "start_time": "2021-09-16T12:16:54.268000", "status": "completed"}, "tags": []}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["Downloading https://raw.githubusercontent.com/phlippe/saved_models/main/tutorial16/ProtoNet.ckpt...\n"]}, {"name": "stdout", "output_type": "stream", "text": ["Downloading https://raw.githubusercontent.com/phlippe/saved_models/main/tutorial16/ProtoMAML.ckpt...\n"]}, {"name": "stdout", "output_type": "stream", "text": ["Downloading https://raw.githubusercontent.com/phlippe/saved_models/main/tutorial16/tensorboards/ProtoNet/events.out.tfevents.ProtoNet...\n", "Downloading https://raw.githubusercontent.com/phlippe/saved_models/main/tutorial16/tensorboards/ProtoMAML/events.out.tfevents.ProtoMAML...\n", "Downloading https://raw.githubusercontent.com/phlippe/saved_models/main/tutorial16/protomaml_fewshot.json...\n"]}, {"name": "stdout", "output_type": "stream", "text": ["Downloading https://raw.githubusercontent.com/phlippe/saved_models/main/tutorial16/protomaml_svhn_fewshot.json...\n"]}], "source": ["# Github URL where saved models are stored for this tutorial\n", "base_url = \"https://raw.githubusercontent.com/phlippe/saved_models/main/tutorial16/\"\n", "# Files to download\n", "pretrained_files = [\n", " \"ProtoNet.ckpt\",\n", " \"ProtoMAML.ckpt\",\n", " \"tensorboards/ProtoNet/events.out.tfevents.ProtoNet\",\n", " \"tensorboards/ProtoMAML/events.out.tfevents.ProtoMAML\",\n", " \"protomaml_fewshot.json\",\n", " \"protomaml_svhn_fewshot.json\",\n", "]\n", "# Create checkpoint path if it doesn't exist yet\n", "os.makedirs(CHECKPOINT_PATH, exist_ok=True)\n", "\n", "# For each file, check whether it already exists. If not, try downloading it.\n", "for file_name in pretrained_files:\n", " file_path = os.path.join(CHECKPOINT_PATH, file_name)\n", " if \"/\" in file_name:\n", " os.makedirs(file_path.rsplit(\"/\", 1)[0], exist_ok=True)\n", " if not os.path.isfile(file_path):\n", " file_url = base_url + file_name\n", " print(\"Downloading %s...\" % file_url)\n", " try:\n", " urllib.request.urlretrieve(file_url, file_path)\n", " except HTTPError as e:\n", " print(\n", " \"Something went wrong. Please try to download the file from the GDrive folder, or contact the author with the full output including the following error:\\n\",\n", " e,\n", " )"]}, {"cell_type": "markdown", "id": "94e83308", "metadata": {"papermill": {"duration": 0.035176, "end_time": "2021-09-16T12:16:55.229204", "exception": false, "start_time": "2021-09-16T12:16:55.194028", "status": "completed"}, "tags": []}, "source": ["## Few-shot classification\n", "\n", "We start our implementation by discussing the dataset setup.\n", "In this notebook, we will use CIFAR100 which we have already seen in Tutorial 6.\n", "CIFAR100 has 100 classes each with 600 images of size $32\\times 32$ pixels.\n", "Instead of splitting the training, validation and test set over examples, we will split them over classes: we will use 80 classes for training, and 10 for validation and 10 for testing.\n", "Our overall goal is to obtain a model that can distinguish between the 10 test classes with seeing very little examples.\n", "First, let's load the dataset and visualize some examples."]}, {"cell_type": "code", "execution_count": 4, "id": "fb2232d3", "metadata": {"execution": {"iopub.execute_input": "2021-09-16T12:16:55.305767Z", "iopub.status.busy": "2021-09-16T12:16:55.305294Z", "iopub.status.idle": "2021-09-16T12:16:56.915972Z", "shell.execute_reply": "2021-09-16T12:16:56.915529Z"}, "papermill": {"duration": 1.649455, "end_time": "2021-09-16T12:16:56.916090", "exception": false, "start_time": "2021-09-16T12:16:55.266635", "status": "completed"}, "tags": []}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["Files already downloaded and verified\n"]}, {"name": "stdout", "output_type": "stream", "text": ["Files already downloaded and verified\n"]}], "source": ["# Loading CIFAR100 dataset\n", "cifar_train_set = CIFAR100(root=DATASET_PATH, train=True, download=True, transform=transforms.ToTensor())\n", "cifar_test_set = CIFAR100(root=DATASET_PATH, train=False, download=True, transform=transforms.ToTensor())"]}, {"cell_type": "code", "execution_count": 5, "id": "5df823a6", "metadata": {"execution": {"iopub.execute_input": "2021-09-16T12:16:56.996394Z", "iopub.status.busy": "2021-09-16T12:16:56.993092Z", "iopub.status.idle": "2021-09-16T12:16:57.189374Z", "shell.execute_reply": "2021-09-16T12:16:57.189770Z"}, "papermill": {"duration": 0.236155, "end_time": "2021-09-16T12:16:57.189912", "exception": false, "start_time": "2021-09-16T12:16:56.953757", "status": "completed"}, "tags": []}, "outputs": [{"data": {"application/pdf": "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\n", "image/svg+xml": ["\n", "\n", "\n"], "text/plain": [""]}, "metadata": {"needs_background": "light"}, "output_type": "display_data"}], "source": ["# Visualize some examples\n", "NUM_IMAGES = 12\n", "cifar_images = [cifar_train_set[np.random.randint(len(cifar_train_set))][0] for idx in range(NUM_IMAGES)]\n", "cifar_images = torch.stack(cifar_images, dim=0)\n", "img_grid = torchvision.utils.make_grid(cifar_images, nrow=6, normalize=True, pad_value=0.9)\n", "img_grid = img_grid.permute(1, 2, 0)\n", "\n", "plt.figure(figsize=(8, 8))\n", "plt.title(\"Image examples of the CIFAR100 dataset\")\n", "plt.imshow(img_grid)\n", "plt.axis(\"off\")\n", "plt.show()\n", "plt.close()"]}, {"cell_type": "markdown", "id": "d2753a72", "metadata": {"papermill": {"duration": 0.045855, "end_time": "2021-09-16T12:16:57.277837", "exception": false, "start_time": "2021-09-16T12:16:57.231982", "status": "completed"}, "tags": []}, "source": ["### Data preprocessing\n", "\n", "Next, we need to prepare the dataset in the training, validation and test split as mentioned before.\n", "The torchvision package gives us the training and test set as two separate dataset objects.\n", "The next code cells will merge the original training and test set, and then create the new train-val-test split."]}, {"cell_type": "code", "execution_count": 6, "id": "c6003b74", "metadata": {"execution": {"iopub.execute_input": "2021-09-16T12:16:57.364070Z", "iopub.status.busy": "2021-09-16T12:16:57.363592Z", "iopub.status.idle": "2021-09-16T12:16:57.440072Z", "shell.execute_reply": "2021-09-16T12:16:57.440447Z"}, "papermill": {"duration": 0.120966, "end_time": "2021-09-16T12:16:57.440598", "exception": false, "start_time": "2021-09-16T12:16:57.319632", "status": "completed"}, "tags": []}, "outputs": [], "source": ["# Merging original training and test set\n", "cifar_all_images = np.concatenate([cifar_train_set.data, cifar_test_set.data], axis=0)\n", "cifar_all_targets = torch.LongTensor(cifar_train_set.targets + cifar_test_set.targets)"]}, {"cell_type": "markdown", "id": "7ba136f2", "metadata": {"lines_to_next_cell": 2, "papermill": {"duration": 0.042617, "end_time": "2021-09-16T12:16:57.525339", "exception": false, "start_time": "2021-09-16T12:16:57.482722", "status": "completed"}, "tags": []}, "source": ["To have an easier time handling the dataset, we define our own, simple dataset class below.\n", "It takes a set of images, labels/targets, and image transformations, and\n", "returns the corresponding images and labels element-wise."]}, {"cell_type": "code", "execution_count": 7, "id": "87d13a5c", "metadata": {"execution": {"iopub.execute_input": "2021-09-16T12:16:57.612626Z", "iopub.status.busy": "2021-09-16T12:16:57.612098Z", "iopub.status.idle": "2021-09-16T12:16:57.613747Z", "shell.execute_reply": "2021-09-16T12:16:57.614134Z"}, "papermill": {"duration": 0.048028, "end_time": "2021-09-16T12:16:57.614251", "exception": false, "start_time": "2021-09-16T12:16:57.566223", "status": "completed"}, "tags": []}, "outputs": [], "source": ["class ImageDataset(data.Dataset):\n", " def __init__(self, imgs, targets, img_transform=None):\n", " \"\"\"\n", " Inputs:\n", " imgs - Numpy array of shape [N,32,32,3] containing all images.\n", " targets - PyTorch array of shape [N] containing all labels.\n", " img_transform - A torchvision transformation that should be applied\n", " to the images before returning. If none, no transformation\n", " is applied.\n", " \"\"\"\n", " super().__init__()\n", " self.img_transform = img_transform\n", " self.imgs = imgs\n", " self.targets = targets\n", "\n", " def __getitem__(self, idx):\n", " img, target = self.imgs[idx], self.targets[idx]\n", " img = Image.fromarray(img)\n", "\n", " if self.img_transform is not None:\n", " img = self.img_transform(img)\n", "\n", " return img, target\n", "\n", " def __len__(self):\n", " return self.imgs.shape[0]"]}, {"cell_type": "markdown", "id": "70a2bde0", "metadata": {"papermill": {"duration": 0.042741, "end_time": "2021-09-16T12:16:57.698003", "exception": false, "start_time": "2021-09-16T12:16:57.655262", "status": "completed"}, "tags": []}, "source": ["Now, we can create the class splits.\n", "We will assign the classes randomly to training, validation and test, and use a 80%-10%-10% split."]}, {"cell_type": "code", "execution_count": 8, "id": "6c427a32", "metadata": {"execution": {"iopub.execute_input": "2021-09-16T12:16:57.783244Z", "iopub.status.busy": "2021-09-16T12:16:57.782764Z", "iopub.status.idle": "2021-09-16T12:16:57.786435Z", "shell.execute_reply": "2021-09-16T12:16:57.785965Z"}, "papermill": {"duration": 0.0482, "end_time": "2021-09-16T12:16:57.786535", "exception": false, "start_time": "2021-09-16T12:16:57.738335", "status": "completed"}, "tags": []}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["Global seed set to 0\n"]}], "source": ["pl.seed_everything(0) # Set seed for reproducibility\n", "classes = torch.randperm(100) # Returns random permutation of numbers 0 to 99\n", "train_classes, val_classes, test_classes = classes[:80], classes[80:90], classes[90:]"]}, {"cell_type": "markdown", "id": "b04354dc", "metadata": {"papermill": {"duration": 0.040797, "end_time": "2021-09-16T12:16:57.868158", "exception": false, "start_time": "2021-09-16T12:16:57.827361", "status": "completed"}, "tags": []}, "source": ["To get an intuition of the validation and test classes, we print the class names below:"]}, {"cell_type": "code", "execution_count": 9, "id": "382f56ef", "metadata": {"execution": {"iopub.execute_input": "2021-09-16T12:16:57.956230Z", "iopub.status.busy": "2021-09-16T12:16:57.955759Z", "iopub.status.idle": "2021-09-16T12:16:57.958957Z", "shell.execute_reply": "2021-09-16T12:16:57.958490Z"}, "papermill": {"duration": 0.049254, "end_time": "2021-09-16T12:16:57.959059", "exception": false, "start_time": "2021-09-16T12:16:57.909805", "status": "completed"}, "tags": []}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["Validation classes: ['caterpillar', 'castle', 'skunk', 'ray', 'bus', 'motorcycle', 'keyboard', 'chimpanzee', 'possum', 'tiger']\n", "Test classes: ['kangaroo', 'crocodile', 'butterfly', 'shark', 'forest', 'pickup_truck', 'telephone', 'lion', 'worm', 'mushroom']\n"]}], "source": ["# Printing validation and test classes\n", "idx_to_class = {val: key for key, val in cifar_train_set.class_to_idx.items()}\n", "print(\"Validation classes:\", [idx_to_class[c.item()] for c in val_classes])\n", "print(\"Test classes:\", [idx_to_class[c.item()] for c in test_classes])"]}, {"cell_type": "markdown", "id": "b3201c8c", "metadata": {"lines_to_next_cell": 2, "papermill": {"duration": 0.043076, "end_time": "2021-09-16T12:16:58.043389", "exception": false, "start_time": "2021-09-16T12:16:58.000313", "status": "completed"}, "tags": []}, "source": ["As we can see, the classes have quite some variety and some classes might be easier to distinguish than others.\n", "For instance, in the test classes, 'pickup_truck' is the only vehicle while the classes 'mushroom', 'worm' and 'forest' might be harder to keep apart.\n", "Remember that we want to learn the classification of those ten classes from 80 other classes in our training set, and few examples from the actual test classes.\n", "We will experiment with the number of examples per class.\n", "\n", "Finally, we can create the training, validation and test dataset according to our split above.\n", "For this, we create dataset objects of our previously defined class `ImageDataset`."]}, {"cell_type": "code", "execution_count": 10, "id": "90fac17b", "metadata": {"execution": {"iopub.execute_input": "2021-09-16T12:16:58.130688Z", "iopub.status.busy": "2021-09-16T12:16:58.130215Z", "iopub.status.idle": "2021-09-16T12:16:58.132283Z", "shell.execute_reply": "2021-09-16T12:16:58.131883Z"}, "papermill": {"duration": 0.047528, "end_time": "2021-09-16T12:16:58.132384", "exception": false, "start_time": "2021-09-16T12:16:58.084856", "status": "completed"}, "tags": []}, "outputs": [], "source": ["def dataset_from_labels(imgs, targets, class_set, **kwargs):\n", " class_mask = (targets[:, None] == class_set[None, :]).any(dim=-1)\n", " return ImageDataset(imgs=imgs[class_mask], targets=targets[class_mask], **kwargs)"]}, {"cell_type": "markdown", "id": "538f34d4", "metadata": {"papermill": {"duration": 0.041952, "end_time": "2021-09-16T12:16:58.219072", "exception": false, "start_time": "2021-09-16T12:16:58.177120", "status": "completed"}, "tags": []}, "source": ["As in our experiments before on CIFAR in Tutorial 5, 6 and 9, we normalize the dataset.\n", "Additionally, we use small augmentations during training to prevent overfitting."]}, {"cell_type": "code", "execution_count": 11, "id": "1150cc59", "metadata": {"execution": {"iopub.execute_input": "2021-09-16T12:16:58.310188Z", "iopub.status.busy": "2021-09-16T12:16:58.309710Z", "iopub.status.idle": "2021-09-16T12:17:00.575563Z", "shell.execute_reply": "2021-09-16T12:17:00.575102Z"}, "papermill": {"duration": 2.315272, "end_time": "2021-09-16T12:17:00.575679", "exception": false, "start_time": "2021-09-16T12:16:58.260407", "status": "completed"}, "tags": []}, "outputs": [], "source": ["DATA_MEANS = (cifar_train_set.data / 255.0).mean(axis=(0, 1, 2))\n", "DATA_STD = (cifar_train_set.data / 255.0).std(axis=(0, 1, 2))\n", "\n", "test_transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize(DATA_MEANS, DATA_STD)])\n", "# For training, we add some augmentation.\n", "train_transform = transforms.Compose(\n", " [\n", " transforms.RandomHorizontalFlip(),\n", " transforms.RandomResizedCrop((32, 32), scale=(0.8, 1.0), ratio=(0.9, 1.1)),\n", " transforms.ToTensor(),\n", " transforms.Normalize(DATA_MEANS, DATA_STD),\n", " ]\n", ")\n", "\n", "train_set = dataset_from_labels(cifar_all_images, cifar_all_targets, train_classes, img_transform=train_transform)\n", "val_set = dataset_from_labels(cifar_all_images, cifar_all_targets, val_classes, img_transform=test_transform)\n", "test_set = dataset_from_labels(cifar_all_images, cifar_all_targets, test_classes, img_transform=test_transform)"]}, {"cell_type": "markdown", "id": "a96f08ba", "metadata": {"lines_to_next_cell": 2, "papermill": {"duration": 0.041553, "end_time": "2021-09-16T12:17:00.662005", "exception": false, "start_time": "2021-09-16T12:17:00.620452", "status": "completed"}, "tags": []}, "source": ["### Data sampling\n", "\n", "The strategy of how to use the available training data for learning few-shot adaptation is crucial in meta-learning.\n", "All three algorithms that we discuss here have a similar idea: simulate few-shot learning during training.\n", "Specifically, at each training step, we randomly select a small number of classes, and sample a small number of examples for each class.\n", "This represents our few-shot training batch, which we also refer to as **support set**.\n", "Additionally, we sample a second set of examples from the same classes, and refer to this batch as **query set**.\n", "Our training objective is to classify the query set correctly from seeing the support set and its corresponding labels.\n", "The main difference between our three methods (ProtoNet, MAML, and Proto-MAML) is in how they use the support set to adapt to the training classes.\n", "\n", "This subsection summarizes the code that is needed to create such training batches.\n", "In PyTorch, we can specify the data sampling procedure by so-called `Sampler` ([documentation](https://pytorch.org/docs/stable/data.html#data-loading-order-and-sampler)).\n", "Samplers are iteratable objects that return indices in the order in which the data elements should be sampled.\n", "In our previous notebooks, we usually used the option `shuffle=True` in the `data.DataLoader` objects which creates a sampler returning the data indices in a random order.\n", "Here, we focus on samplers that return batches of indices that correspond to support and query set batches.\n", "Below, we implement such a sampler."]}, {"cell_type": "code", "execution_count": 12, "id": "854b16a5", "metadata": {"execution": {"iopub.execute_input": "2021-09-16T12:17:00.759300Z", "iopub.status.busy": "2021-09-16T12:17:00.755250Z", "iopub.status.idle": "2021-09-16T12:17:00.761236Z", "shell.execute_reply": "2021-09-16T12:17:00.760749Z"}, "papermill": {"duration": 0.055575, "end_time": "2021-09-16T12:17:00.761340", "exception": false, "start_time": "2021-09-16T12:17:00.705765", "status": "completed"}, "tags": []}, "outputs": [], "source": ["class FewShotBatchSampler:\n", " def __init__(self, dataset_targets, N_way, K_shot, include_query=False, shuffle=True, shuffle_once=False):\n", " \"\"\"\n", " Inputs:\n", " dataset_targets - PyTorch tensor of the labels of the data elements.\n", " N_way - Number of classes to sample per batch.\n", " K_shot - Number of examples to sample per class in the batch.\n", " include_query - If True, returns batch of size N_way*K_shot*2, which\n", " can be split into support and query set. Simplifies\n", " the implementation of sampling the same classes but\n", " distinct examples for support and query set.\n", " shuffle - If True, examples and classes are newly shuffled in each\n", " iteration (for training)\n", " shuffle_once - If True, examples and classes are shuffled once in\n", " the beginning, but kept constant across iterations\n", " (for validation)\n", " \"\"\"\n", " super().__init__()\n", " self.dataset_targets = dataset_targets\n", " self.N_way = N_way\n", " self.K_shot = K_shot\n", " self.shuffle = shuffle\n", " self.include_query = include_query\n", " if self.include_query:\n", " self.K_shot *= 2\n", " self.batch_size = self.N_way * self.K_shot # Number of overall images per batch\n", "\n", " # Organize examples by class\n", " self.classes = torch.unique(self.dataset_targets).tolist()\n", " self.num_classes = len(self.classes)\n", " self.indices_per_class = {}\n", " self.batches_per_class = {} # Number of K-shot batches that each class can provide\n", " for c in self.classes:\n", " self.indices_per_class[c] = torch.where(self.dataset_targets == c)[0]\n", " self.batches_per_class[c] = self.indices_per_class[c].shape[0] // self.K_shot\n", "\n", " # Create a list of classes from which we select the N classes per batch\n", " self.iterations = sum(self.batches_per_class.values()) // self.N_way\n", " self.class_list = [c for c in self.classes for _ in range(self.batches_per_class[c])]\n", " if shuffle_once or self.shuffle:\n", " self.shuffle_data()\n", " else:\n", " # For testing, we iterate over classes instead of shuffling them\n", " sort_idxs = [\n", " i + p * self.num_classes for i, c in enumerate(self.classes) for p in range(self.batches_per_class[c])\n", " ]\n", " self.class_list = np.array(self.class_list)[np.argsort(sort_idxs)].tolist()\n", "\n", " def shuffle_data(self):\n", " # Shuffle the examples per class\n", " for c in self.classes:\n", " perm = torch.randperm(self.indices_per_class[c].shape[0])\n", " self.indices_per_class[c] = self.indices_per_class[c][perm]\n", " # Shuffle the class list from which we sample. Note that this way of shuffling\n", " # does not prevent to choose the same class twice in a batch. However, for\n", " # training and validation, this is not a problem.\n", " random.shuffle(self.class_list)\n", "\n", " def __iter__(self):\n", " # Shuffle data\n", " if self.shuffle:\n", " self.shuffle_data()\n", "\n", " # Sample few-shot batches\n", " start_index = defaultdict(int)\n", " for it in range(self.iterations):\n", " class_batch = self.class_list[it * self.N_way : (it + 1) * self.N_way] # Select N classes for the batch\n", " index_batch = []\n", " for c in class_batch: # For each class, select the next K examples and add them to the batch\n", " index_batch.extend(self.indices_per_class[c][start_index[c] : start_index[c] + self.K_shot])\n", " start_index[c] += self.K_shot\n", " if self.include_query: # If we return support+query set, sort them so that they are easy to split\n", " index_batch = index_batch[::2] + index_batch[1::2]\n", " yield index_batch\n", "\n", " def __len__(self):\n", " return self.iterations"]}, {"cell_type": "markdown", "id": "06629cb0", "metadata": {"papermill": {"duration": 0.041795, "end_time": "2021-09-16T12:17:00.844077", "exception": false, "start_time": "2021-09-16T12:17:00.802282", "status": "completed"}, "tags": []}, "source": ["Now, we can create our intended data loaders by passing an object of `FewShotBatchSampler` as `batch_sampler=...` input to the PyTorch data loader object.\n", "For our experiments, we will use a 5-class 4-shot training setting.\n", "This means that each support set contains 5 classes with 4 examples each, i.e., 20 images overall.\n", "Usually, it is good to keep the number of shots equal to the number that you aim to test on.\n", "However, we will experiment later with different number of shots, and hence, we pick 4 as a compromise for now.\n", "To get the best performing model, it is recommended to consider the\n", "number of training shots as hyperparameter in a grid search."]}, {"cell_type": "code", "execution_count": 13, "id": "2391b323", "metadata": {"execution": {"iopub.execute_input": "2021-09-16T12:17:00.930337Z", "iopub.status.busy": "2021-09-16T12:17:00.929871Z", "iopub.status.idle": "2021-09-16T12:17:00.959337Z", "shell.execute_reply": "2021-09-16T12:17:00.958858Z"}, "papermill": {"duration": 0.074158, "end_time": "2021-09-16T12:17:00.959445", "exception": false, "start_time": "2021-09-16T12:17:00.885287", "status": "completed"}, "tags": []}, "outputs": [], "source": ["N_WAY = 5\n", "K_SHOT = 4\n", "train_data_loader = data.DataLoader(\n", " train_set,\n", " batch_sampler=FewShotBatchSampler(train_set.targets, include_query=True, N_way=N_WAY, K_shot=K_SHOT, shuffle=True),\n", " num_workers=4,\n", ")\n", "val_data_loader = data.DataLoader(\n", " val_set,\n", " batch_sampler=FewShotBatchSampler(\n", " val_set.targets, include_query=True, N_way=N_WAY, K_shot=K_SHOT, shuffle=False, shuffle_once=True\n", " ),\n", " num_workers=4,\n", ")"]}, {"cell_type": "markdown", "id": "b916416f", "metadata": {"lines_to_next_cell": 2, "papermill": {"duration": 0.042019, "end_time": "2021-09-16T12:17:01.042924", "exception": false, "start_time": "2021-09-16T12:17:01.000905", "status": "completed"}, "tags": []}, "source": ["For simplicity, we implemented the sampling of a support and query set as sampling a support set with twice the number of examples.\n", "After sampling a batch from the data loader, we need to split it into a support and query set.\n", "We can summarize this step in the following function:"]}, {"cell_type": "code", "execution_count": 14, "id": "f2af4f57", "metadata": {"execution": {"iopub.execute_input": "2021-09-16T12:17:01.130833Z", "iopub.status.busy": "2021-09-16T12:17:01.130367Z", "iopub.status.idle": "2021-09-16T12:17:01.132446Z", "shell.execute_reply": "2021-09-16T12:17:01.132049Z"}, "papermill": {"duration": 0.04868, "end_time": "2021-09-16T12:17:01.132545", "exception": false, "start_time": "2021-09-16T12:17:01.083865", "status": "completed"}, "tags": []}, "outputs": [], "source": ["def split_batch(imgs, targets):\n", " support_imgs, query_imgs = imgs.chunk(2, dim=0)\n", " support_targets, query_targets = targets.chunk(2, dim=0)\n", " return support_imgs, query_imgs, support_targets, query_targets"]}, {"cell_type": "markdown", "id": "da7f82f6", "metadata": {"papermill": {"duration": 0.041597, "end_time": "2021-09-16T12:17:01.215440", "exception": false, "start_time": "2021-09-16T12:17:01.173843", "status": "completed"}, "tags": []}, "source": ["Finally, to ensure that our implementation of the data sampling process is correct, we can sample a batch and visualize its support and query set.\n", "What we would like to see is that the support and query set have the same classes, but distinct examples."]}, {"cell_type": "code", "execution_count": 15, "id": "9b1b5af8", "metadata": {"execution": {"iopub.execute_input": "2021-09-16T12:17:01.306238Z", "iopub.status.busy": "2021-09-16T12:17:01.305760Z", "iopub.status.idle": "2021-09-16T12:17:01.582287Z", "shell.execute_reply": "2021-09-16T12:17:01.581851Z"}, "papermill": {"duration": 0.323266, "end_time": "2021-09-16T12:17:01.582404", "exception": false, "start_time": "2021-09-16T12:17:01.259138", "status": "completed"}, "tags": []}, "outputs": [], "source": ["imgs, targets = next(iter(val_data_loader)) # We use the validation set since it does not apply augmentations\n", "support_imgs, query_imgs, _, _ = split_batch(imgs, targets)\n", "support_grid = torchvision.utils.make_grid(support_imgs, nrow=K_SHOT, normalize=True, pad_value=0.9)\n", "support_grid = support_grid.permute(1, 2, 0)\n", "query_grid = torchvision.utils.make_grid(query_imgs, nrow=K_SHOT, normalize=True, pad_value=0.9)\n", "query_grid = query_grid.permute(1, 2, 0)\n", "\n", "fig, ax = plt.subplots(1, 2, figsize=(8, 5))\n", "ax[0].imshow(support_grid)\n", "ax[0].set_title(\"Support set\")\n", "ax[0].axis(\"off\")\n", "ax[1].imshow(query_grid)\n", "ax[1].set_title(\"Query set\")\n", "ax[1].axis(\"off\")\n", "fig.suptitle(\"Few Shot Batch\", weight=\"bold\")\n", "fig.show()\n", "plt.close(fig)"]}, {"cell_type": "markdown", "id": "63d0e470", "metadata": {"papermill": {"duration": 0.047618, "end_time": "2021-09-16T12:17:01.680502", "exception": false, "start_time": "2021-09-16T12:17:01.632884", "status": "completed"}, "tags": []}, "source": ["As we can see, the support and query set have the same five classes, but different examples.\n", "The models will be tasked to classify the examples in the query set by learning from the support set and its labels.\n", "With the data sampling in place, we can now start to implement our first meta-learning model: Prototypical Networks."]}, {"cell_type": "markdown", "id": "06af8576", "metadata": {"papermill": {"duration": 0.049184, "end_time": "2021-09-16T12:17:01.778920", "exception": false, "start_time": "2021-09-16T12:17:01.729736", "status": "completed"}, "tags": []}, "source": ["## Prototypical Networks"]}, {"cell_type": "markdown", "id": "118429e4", "metadata": {"papermill": {"duration": 0.051246, "end_time": "2021-09-16T12:17:01.882315", "exception": false, "start_time": "2021-09-16T12:17:01.831069", "status": "completed"}, "tags": []}, "source": ["The Prototypical Network, or ProtoNet for short, is a metric-based meta-learning algorithm which operates similar to a nearest neighbor classification.\n", "Metric-based meta-learning methods classify a new example $\\mathbf{x}$ based on some distance function $d_{\\varphi}$ between $x$ and all elements in the support set.\n", "ProtoNets implements this idea with the concept of prototypes in a learned feature space.\n", "First, ProtoNet uses an embedding function $f_{\\theta}$ to encode each input in the support set into a $L$-dimensional feature vector.\n", "Next, for each class $c$, we collect the feature vectors of all examples with label $c$, and average their feature vectors.\n", "Formally, we can define this as:\n", "\n", "$$\\mathbf{v}_c=\\frac{1}{|S_c|}\\sum_{(\\mathbf{x}_i,y_i)\\in S_c}f_{\\theta}(\\mathbf{x}_i)$$\n", "\n", "where $S_c$ is the part of the support set $S$ for which $y_i=c$, and $\\mathbf{v}_c$ represents the _prototype_ of class $c$.\n", "The prototype calculation is visualized below for a 2-dimensional feature space and 3 classes (Figure credit - [Snell et al.](https://arxiv.org/pdf/1703.05175.pdf)).\n", "The colored dots represent encoded support elements with color-corresponding class label, and the black dots next to the class label are the averaged prototypes.\n", "\n", "
\n", "\n", "Based on these prototypes, we want to classify a new example.\n", "Remember that since we want to learn the encoding function $f_{\\theta}$, this classification must be differentiable and hence, we need to define a probability distribution across classes.\n", "For this, we will make use of the distance function $d_{\\varphi}$: the closer a new example $\\mathbf{x}$ is to a prototype $\\mathbf{v}_c$, the higher the probability for $\\mathbf{x}$ belonging to class $c$.\n", "Formally, we can simply use a softmax over the distances of $\\mathbf{x}$ to all class prototypes:\n", "\n", "$$p(y=c\\vert\\mathbf{x})=\\text{softmax}(-d_{\\varphi}(f_{\\theta}(\\mathbf{x}), \\mathbf{v}_c))=\\frac{\\exp\\left(-d_{\\varphi}(f_{\\theta}(\\mathbf{x}), \\mathbf{v}_c)\\right)}{\\sum_{c'\\in \\mathcal{C}}\\exp\\left(-d_{\\varphi}(f_{\\theta}(\\mathbf{x}), \\mathbf{v}_{c'})\\right)}$$\n", "\n", "Note that the negative sign is necessary since we want to increase the probability for close-by vectors and have a low probability for distant vectors.\n", "We train the network $f_{\\theta}$ based on the cross entropy error of the training query set examples.\n", "Thereby, the gradient flows through both the prototypes $\\mathbf{v}_c$ and the query set encodings $f_{\\theta}(\\mathbf{x})$.\n", "For the distance function $d_{\\varphi}$, we can choose any function as long as it is differentiable with respect to both of its inputs.\n", "The most common function, which we also use here, is the squared\n", "euclidean distance, but there has been several works on different\n", "distance functions as well."]}, {"cell_type": "markdown", "id": "00b71a3a", "metadata": {"papermill": {"duration": 0.04147, "end_time": "2021-09-16T12:17:01.974706", "exception": false, "start_time": "2021-09-16T12:17:01.933236", "status": "completed"}, "tags": []}, "source": ["### ProtoNet implementation"]}, {"cell_type": "markdown", "id": "04b1893c", "metadata": {"lines_to_next_cell": 2, "papermill": {"duration": 0.041485, "end_time": "2021-09-16T12:17:02.058073", "exception": false, "start_time": "2021-09-16T12:17:02.016588", "status": "completed"}, "tags": []}, "source": ["Now that we know how a ProtoNet works in principle, let's look at how we can apply to our specific problem of few-shot image classification, and implement it below.\n", "First, we need to define the encoder function $f_{\\theta}$.\n", "Since we work with CIFAR images, we can take a look back at Tutorial 5 where we compared common Computer Vision architectures, and choose one of the best performing ones.\n", "Here, we go with a DenseNet since it is in general more parameter efficient than ResNet.\n", "Luckily, we do not need to implement DenseNet ourselves again and can rely on torchvision's model package instead.\n", "We use common hyperparameters of 64 initial feature channels, add 32 per block, and use a bottleneck size of 64 (i.e. 2 times the growth rate).\n", "We use 4 stages of 6 layers each, which results in overall about 1 million parameters.\n", "Note that the torchvision package assumes that the last layer is used for classification and hence calls its output size `num_classes`.\n", "However, we can instead just use it as the feature space of ProtoNet, and choose an arbitrary dimensionality.\n", "We will use the same network for other algorithms in this notebook to ensure a fair comparison."]}, {"cell_type": "code", "execution_count": 16, "id": "4541e273", "metadata": {"execution": {"iopub.execute_input": "2021-09-16T12:17:02.146559Z", "iopub.status.busy": "2021-09-16T12:17:02.146086Z", "iopub.status.idle": "2021-09-16T12:17:02.148149Z", "shell.execute_reply": "2021-09-16T12:17:02.147753Z"}, "lines_to_next_cell": 2, "papermill": {"duration": 0.047774, "end_time": "2021-09-16T12:17:02.148248", "exception": false, "start_time": "2021-09-16T12:17:02.100474", "status": "completed"}, "tags": []}, "outputs": [], "source": ["def get_convnet(output_size):\n", " convnet = torchvision.models.DenseNet(\n", " growth_rate=32,\n", " block_config=(6, 6, 6, 6),\n", " bn_size=2,\n", " num_init_features=64,\n", " num_classes=output_size, # Output dimensionality\n", " )\n", " return convnet"]}, {"cell_type": "markdown", "id": "083ac82c", "metadata": {"lines_to_next_cell": 2, "papermill": {"duration": 0.041445, "end_time": "2021-09-16T12:17:02.231461", "exception": false, "start_time": "2021-09-16T12:17:02.190016", "status": "completed"}, "tags": []}, "source": ["Next, we can look at implementing ProtoNet.\n", "We will define it as PyTorch Lightning module to use all functionalities of PyTorch Lightning.\n", "The first step during training is to encode all images in a batch with our network.\n", "Next, we calculate the class prototypes from the support set (function `calculate_prototypes`), and classify the query set examples according to the prototypes (function `classify_feats`).\n", "Keep in mind that we use the data sampling described before, such that the support and query set are stacked together in the batch.\n", "Thus, we use our previously defined function `split_batch` to split them apart.\n", "The full code can be found below."]}, {"cell_type": "code", "execution_count": 17, "id": "f386a814", "metadata": {"execution": {"iopub.execute_input": "2021-09-16T12:17:02.325211Z", "iopub.status.busy": "2021-09-16T12:17:02.317106Z", "iopub.status.idle": "2021-09-16T12:17:02.327317Z", "shell.execute_reply": "2021-09-16T12:17:02.326845Z"}, "lines_to_next_cell": 2, "papermill": {"duration": 0.053982, "end_time": "2021-09-16T12:17:02.327415", "exception": false, "start_time": "2021-09-16T12:17:02.273433", "status": "completed"}, "tags": []}, "outputs": [], "source": ["class ProtoNet(pl.LightningModule):\n", " def __init__(self, proto_dim, lr):\n", " \"\"\"Inputs.\n", "\n", " proto_dim - Dimensionality of prototype feature space\n", " lr - Learning rate of Adam optimizer\n", " \"\"\"\n", " super().__init__()\n", " self.save_hyperparameters()\n", " self.model = get_convnet(output_size=self.hparams.proto_dim)\n", "\n", " def configure_optimizers(self):\n", " optimizer = optim.AdamW(self.parameters(), lr=self.hparams.lr)\n", " scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=[140, 180], gamma=0.1)\n", " return [optimizer], [scheduler]\n", "\n", " @staticmethod\n", " def calculate_prototypes(features, targets):\n", " # Given a stack of features vectors and labels, return class prototypes\n", " # features - shape [N, proto_dim], targets - shape [N]\n", " classes, _ = torch.unique(targets).sort() # Determine which classes we have\n", " prototypes = []\n", " for c in classes:\n", " p = features[torch.where(targets == c)[0]].mean(dim=0) # Average class feature vectors\n", " prototypes.append(p)\n", " prototypes = torch.stack(prototypes, dim=0)\n", " # Return the 'classes' tensor to know which prototype belongs to which class\n", " return prototypes, classes\n", "\n", " def classify_feats(self, prototypes, classes, feats, targets):\n", " # Classify new examples with prototypes and return classification error\n", " dist = torch.pow(prototypes[None, :] - feats[:, None], 2).sum(dim=2) # Squared euclidean distance\n", " preds = F.log_softmax(-dist, dim=1)\n", " labels = (classes[None, :] == targets[:, None]).long().argmax(dim=-1)\n", " acc = (preds.argmax(dim=1) == labels).float().mean()\n", " return preds, labels, acc\n", "\n", " def calculate_loss(self, batch, mode):\n", " # Determine training loss for a given support and query set\n", " imgs, targets = batch\n", " features = self.model(imgs) # Encode all images of support and query set\n", " support_feats, query_feats, support_targets, query_targets = split_batch(features, targets)\n", " prototypes, classes = ProtoNet.calculate_prototypes(support_feats, support_targets)\n", " preds, labels, acc = self.classify_feats(prototypes, classes, query_feats, query_targets)\n", " loss = F.cross_entropy(preds, labels)\n", "\n", " self.log(\"%s_loss\" % mode, loss)\n", " self.log(\"%s_acc\" % mode, acc)\n", " return loss\n", "\n", " def training_step(self, batch, batch_idx):\n", " return self.calculate_loss(batch, mode=\"train\")\n", "\n", " def validation_step(self, batch, batch_idx):\n", " self.calculate_loss(batch, mode=\"val\")"]}, {"cell_type": "markdown", "id": "38f882ab", "metadata": {"papermill": {"duration": 0.041639, "end_time": "2021-09-16T12:17:02.410483", "exception": false, "start_time": "2021-09-16T12:17:02.368844", "status": "completed"}, "tags": []}, "source": ["For validation, we use the same principle as training and sample support and query sets from the hold-out 10 classes.\n", "However, this gives us noisy scores depending on which query sets are chosen to which support sets.\n", "This is why we will use a different strategy during testing.\n", "For validation, our training strategy is sufficient since it is much\n", "faster than testing, and gives a good estimate of the training\n", "generalization as long as we keep the support-query sets constant across\n", "validation iterations."]}, {"cell_type": "markdown", "id": "412dbc53", "metadata": {"lines_to_next_cell": 2, "papermill": {"duration": 0.041462, "end_time": "2021-09-16T12:17:02.493712", "exception": false, "start_time": "2021-09-16T12:17:02.452250", "status": "completed"}, "tags": []}, "source": ["### Training\n", "\n", "After implementing the model, we can already start training it.\n", "We use our common PyTorch Lightning training function, and train the model for 200 epochs.\n", "The training function takes `model_class` as input argument, i.e. the\n", "PyTorch Lightning module class that should be trained, since we will\n", "reuse this function for other algorithms as well."]}, {"cell_type": "code", "execution_count": 18, "id": "c8a72bca", "metadata": {"execution": {"iopub.execute_input": "2021-09-16T12:17:02.582441Z", "iopub.status.busy": "2021-09-16T12:17:02.581969Z", "iopub.status.idle": "2021-09-16T12:17:02.584137Z", "shell.execute_reply": "2021-09-16T12:17:02.583618Z"}, "papermill": {"duration": 0.049001, "end_time": "2021-09-16T12:17:02.584238", "exception": false, "start_time": "2021-09-16T12:17:02.535237", "status": "completed"}, "tags": []}, "outputs": [], "source": ["def train_model(model_class, train_loader, val_loader, **kwargs):\n", " trainer = pl.Trainer(\n", " default_root_dir=os.path.join(CHECKPOINT_PATH, model_class.__name__),\n", " gpus=1 if str(device) == \"cuda:0\" else 0,\n", " max_epochs=200,\n", " callbacks=[\n", " ModelCheckpoint(save_weights_only=True, mode=\"max\", monitor=\"val_acc\"),\n", " LearningRateMonitor(\"epoch\"),\n", " ],\n", " progress_bar_refresh_rate=0,\n", " )\n", " trainer.logger._default_hp_metric = None\n", "\n", " # Check whether pretrained model exists. If yes, load it and skip training\n", " pretrained_filename = os.path.join(CHECKPOINT_PATH, model_class.__name__ + \".ckpt\")\n", " if os.path.isfile(pretrained_filename):\n", " print(\"Found pretrained model at %s, loading...\" % pretrained_filename)\n", " # Automatically loads the model with the saved hyperparameters\n", " model = model_class.load_from_checkpoint(pretrained_filename)\n", " else:\n", " pl.seed_everything(42) # To be reproducable\n", " model = model_class(**kwargs)\n", " trainer.fit(model, train_loader, val_loader)\n", " model = model_class.load_from_checkpoint(\n", " trainer.checkpoint_callback.best_model_path\n", " ) # Load best checkpoint after training\n", "\n", " return model"]}, {"cell_type": "markdown", "id": "dbd42a3c", "metadata": {"papermill": {"duration": 0.041582, "end_time": "2021-09-16T12:17:02.668351", "exception": false, "start_time": "2021-09-16T12:17:02.626769", "status": "completed"}, "tags": []}, "source": ["Below is the training call for our ProtoNet.\n", "We use a 64-dimensional feature space.\n", "Larger feature spaces showed to give noisier results since the squared euclidean distance becomes proportionally larger in expectation, and smaller feature spaces might not allow for enough flexibility.\n", "We recommend to load the pre-trained model here at first, but feel free\n", "to play around with the hyperparameters yourself."]}, {"cell_type": "code", "execution_count": 19, "id": "f590bdb9", "metadata": {"execution": {"iopub.execute_input": "2021-09-16T12:17:02.757357Z", "iopub.status.busy": "2021-09-16T12:17:02.756875Z", "iopub.status.idle": "2021-09-16T12:17:02.818883Z", "shell.execute_reply": "2021-09-16T12:17:02.818418Z"}, "papermill": {"duration": 0.109115, "end_time": "2021-09-16T12:17:02.818985", "exception": false, "start_time": "2021-09-16T12:17:02.709870", "status": "completed"}, "tags": []}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["GPU available: True, used: True\n"]}, {"name": "stderr", "output_type": "stream", "text": ["TPU available: False, using: 0 TPU cores\n"]}, {"name": "stderr", "output_type": "stream", "text": ["IPU available: False, using: 0 IPUs\n"]}, {"name": "stdout", "output_type": "stream", "text": ["Found pretrained model at saved_models/MetaLearning/ProtoNet.ckpt, loading...\n"]}], "source": ["protonet_model = train_model(\n", " ProtoNet, proto_dim=64, lr=2e-4, train_loader=train_data_loader, val_loader=val_data_loader\n", ")"]}, {"cell_type": "markdown", "id": "a522c092", "metadata": {"papermill": {"duration": 0.043075, "end_time": "2021-09-16T12:17:02.905128", "exception": false, "start_time": "2021-09-16T12:17:02.862053", "status": "completed"}, "tags": []}, "source": ["We can also take a closer look at the TensorBoard below."]}, {"cell_type": "code", "execution_count": 20, "id": "09a6d207", "metadata": {"execution": {"iopub.execute_input": "2021-09-16T12:17:02.994383Z", "iopub.status.busy": "2021-09-16T12:17:02.993922Z", "iopub.status.idle": "2021-09-16T12:17:02.996018Z", "shell.execute_reply": "2021-09-16T12:17:02.995566Z"}, "papermill": {"duration": 0.047523, "end_time": "2021-09-16T12:17:02.996115", "exception": false, "start_time": "2021-09-16T12:17:02.948592", "status": "completed"}, "tags": []}, "outputs": [], "source": ["# Opens tensorboard in notebook. Adjust the path to your CHECKPOINT_PATH if needed\n", "# # %tensorboard --logdir ../saved_models/tutorial16/tensorboards/ProtoNet/"]}, {"cell_type": "markdown", "id": "2450edf4", "metadata": {"papermill": {"duration": 0.042925, "end_time": "2021-09-16T12:17:03.081932", "exception": false, "start_time": "2021-09-16T12:17:03.039007", "status": "completed"}, "tags": []}, "source": ["
\n", "\n", "In contrast to standard supervised learning, we see that ProtoNet does not overfit as much as we would expect.\n", "The validation accuracy is of course lower than the average training, but the training loss does not stick close to zero.\n", "This is because no training batch is as the other, and we also mix new examples in the support set and query set.\n", "This gives us slightly different prototypes in every iteration, and makes it harder for the network to fully overfit."]}, {"cell_type": "markdown", "id": "061f9ce7", "metadata": {"lines_to_next_cell": 2, "papermill": {"duration": 0.042575, "end_time": "2021-09-16T12:17:03.167627", "exception": false, "start_time": "2021-09-16T12:17:03.125052", "status": "completed"}, "tags": []}, "source": ["### Testing\n", "\n", "Our goal of meta-learning is to obtain a model that can quickly adapt to a new task, or in this case, new classes to distinguish between.\n", "To test this, we will use our trained ProtoNet and adapt it to the 10 test classes.\n", "Thereby, we pick $k$ examples per class from which we determine the prototypes, and test the classification accuracy on all other examples.\n", "This can be seen as using the $k$ examples per class as support set, and the rest of the dataset as a query set.\n", "We iterate through the dataset such that each example has been once included in a support set.\n", "The average performance over all support sets tells us how well we can expect ProtoNet to perform when seeing only $k$ examples per class.\n", "During training, we used $k=4$.\n", "In testing, we will experiment with $k=\\{2,4,8,16,32\\}$ to get a better sense of how $k$ influences the results.\n", "We would expect that we achieve higher accuracies the more examples we have in the support set, but we don't know how it scales.\n", "Hence, let's first implement a function that executes the testing procedure for a given $k$:"]}, {"cell_type": "code", "execution_count": 21, "id": "35fd8d5e", "metadata": {"execution": {"iopub.execute_input": "2021-09-16T12:17:03.264299Z", "iopub.status.busy": "2021-09-16T12:17:03.263816Z", "iopub.status.idle": "2021-09-16T12:17:03.265879Z", "shell.execute_reply": "2021-09-16T12:17:03.265483Z"}, "papermill": {"duration": 0.055389, "end_time": "2021-09-16T12:17:03.265979", "exception": false, "start_time": "2021-09-16T12:17:03.210590", "status": "completed"}, "tags": []}, "outputs": [], "source": ["@torch.no_grad()\n", "def test_proto_net(model, dataset, data_feats=None, k_shot=4):\n", " \"\"\"Inputs.\n", "\n", " model - Pretrained ProtoNet model\n", " dataset - The dataset on which the test should be performed.\n", " Should be instance of ImageDataset\n", " data_feats - The encoded features of all images in the dataset.\n", " If None, they will be newly calculated, and returned\n", " for later usage.\n", " k_shot - Number of examples per class in the support set.\n", " \"\"\"\n", " model = model.to(device)\n", " model.eval()\n", " num_classes = dataset.targets.unique().shape[0]\n", " exmps_per_class = dataset.targets.shape[0] // num_classes # We assume uniform example distribution here\n", "\n", " # The encoder network remains unchanged across k-shot settings. Hence, we only need\n", " # to extract the features for all images once.\n", " if data_feats is None:\n", " # Dataset preparation\n", " dataloader = data.DataLoader(dataset, batch_size=128, num_workers=4, shuffle=False, drop_last=False)\n", "\n", " img_features = []\n", " img_targets = []\n", " for imgs, targets in tqdm(dataloader, \"Extracting image features\", leave=False):\n", " imgs = imgs.to(device)\n", " feats = model.model(imgs)\n", " img_features.append(feats.detach().cpu())\n", " img_targets.append(targets)\n", " img_features = torch.cat(img_features, dim=0)\n", " img_targets = torch.cat(img_targets, dim=0)\n", " # Sort by classes, so that we obtain tensors of shape [num_classes, exmps_per_class, ...]\n", " # Makes it easier to process later\n", " img_targets, sort_idx = img_targets.sort()\n", " img_targets = img_targets.reshape(num_classes, exmps_per_class).transpose(0, 1)\n", " img_features = img_features[sort_idx].reshape(num_classes, exmps_per_class, -1).transpose(0, 1)\n", " else:\n", " img_features, img_targets = data_feats\n", "\n", " # We iterate through the full dataset in two manners. First, to select the k-shot batch.\n", " # Second, the evaluate the model on all other examples\n", " accuracies = []\n", " for k_idx in tqdm(range(0, img_features.shape[0], k_shot), \"Evaluating prototype classification\", leave=False):\n", " # Select support set and calculate prototypes\n", " k_img_feats = img_features[k_idx : k_idx + k_shot].flatten(0, 1)\n", " k_targets = img_targets[k_idx : k_idx + k_shot].flatten(0, 1)\n", " prototypes, proto_classes = model.calculate_prototypes(k_img_feats, k_targets)\n", " # Evaluate accuracy on the rest of the dataset\n", " batch_acc = 0\n", " for e_idx in range(0, img_features.shape[0], k_shot):\n", " if k_idx == e_idx: # Do not evaluate on the support set examples\n", " continue\n", " e_img_feats = img_features[e_idx : e_idx + k_shot].flatten(0, 1)\n", " e_targets = img_targets[e_idx : e_idx + k_shot].flatten(0, 1)\n", " _, _, acc = model.classify_feats(prototypes, proto_classes, e_img_feats, e_targets)\n", " batch_acc += acc.item()\n", " batch_acc /= img_features.shape[0] // k_shot - 1\n", " accuracies.append(batch_acc)\n", "\n", " return (mean(accuracies), stdev(accuracies)), (img_features, img_targets)"]}, {"cell_type": "markdown", "id": "05290272", "metadata": {"papermill": {"duration": 0.042707, "end_time": "2021-09-16T12:17:03.352459", "exception": false, "start_time": "2021-09-16T12:17:03.309752", "status": "completed"}, "tags": []}, "source": ["Testing ProtoNet is relatively quick if we have processed all images once. Hence, we can do in this notebook:"]}, {"cell_type": "code", "execution_count": 22, "id": "796136e5", "metadata": {"execution": {"iopub.execute_input": "2021-09-16T12:17:03.444650Z", "iopub.status.busy": "2021-09-16T12:17:03.444177Z", "iopub.status.idle": "2021-09-16T12:17:47.451057Z", "shell.execute_reply": "2021-09-16T12:17:47.450586Z"}, "papermill": {"duration": 44.055627, "end_time": "2021-09-16T12:17:47.451168", "exception": false, "start_time": "2021-09-16T12:17:03.395541", "status": "completed"}, "tags": []}, "outputs": [{"data": {"application/vnd.jupyter.widget-view+json": {"model_id": "4ee1a875c45c4bcabbc0a211132f80e9", "version_major": 2, "version_minor": 0}, "text/plain": ["Extracting image features: 0%| | 0/47 [00:00\n", "\n", "\n"], "text/plain": [""]}, "metadata": {}, "output_type": "display_data"}], "source": ["ax = plot_few_shot(protonet_accuracies, name=\"ProtoNet\", color=\"C1\")\n", "plt.show()\n", "plt.close()"]}, {"cell_type": "markdown", "id": "4618c0ad", "metadata": {"papermill": {"duration": 0.047539, "end_time": "2021-09-16T12:17:48.127526", "exception": false, "start_time": "2021-09-16T12:17:48.079987", "status": "completed"}, "tags": []}, "source": ["As we initially expected, the performance of ProtoNet indeed increases the more samples we have.\n", "However, even with just two samples per class, we classify almost half of the images correctly, which is well above random accuracy (10%).\n", "The curve shows an exponentially dampend trend, meaning that adding 2 extra examples to $k=2$ has a much higher impact than adding 2 extra samples if we already have $k=16$.\n", "Nonetheless, we can say that ProtoNet adapts fairly well to new classes."]}, {"cell_type": "markdown", "id": "4e1f3b11", "metadata": {"papermill": {"duration": 0.048108, "end_time": "2021-09-16T12:17:48.224066", "exception": false, "start_time": "2021-09-16T12:17:48.175958", "status": "completed"}, "tags": []}, "source": ["## MAML and ProtoMAML"]}, {"cell_type": "markdown", "id": "f33d10c6", "metadata": {"papermill": {"duration": 0.048018, "end_time": "2021-09-16T12:17:48.319782", "exception": false, "start_time": "2021-09-16T12:17:48.271764", "status": "completed"}, "tags": []}, "source": ["The second meta-learning algorithm we will look at is MAML, short for Model-Agnostic Meta-Learning.\n", "MAML is an optimization-based meta-learning algorithm, which means that it tries to adjust the standard optimization procedure to a few-shot setting.\n", "The idea of MAML is relatively simple: given a model, support and query set during training, we optimize the model for $m$ steps on the support set, and evaluate the gradients of the query loss with respect to the original model's parameters.\n", "For the same model, we do it for a few different support-query sets and accumulate the gradients.\n", "This results in learning a model that provides a good initialization for being quickly adapted to the training tasks.\n", "If we denote the model parameters with $\\theta$, we can visualize the procedure as follows (Figure credit - [Finn et al. ](http://proceedings.mlr.press/v70/finn17a.html)).\n", "\n", "
"]}, {"cell_type": "markdown", "id": "e5530458", "metadata": {"papermill": {"duration": 0.047818, "end_time": "2021-09-16T12:17:48.415998", "exception": false, "start_time": "2021-09-16T12:17:48.368180", "status": "completed"}, "tags": []}, "source": ["The full algorithm of MAML is therefore as follows.\n", "At each training step, we sample a batch of tasks, i.e., a batch of support-query set pairs.\n", "For each task $\\mathcal{T}_i$, we optimize a model $f_{\\theta}$ on the support set via SGD, and denote this model as $f_{\\theta_i'}$.\n", "We refer to this optimization as _inner loop_.\n", "Using this new model, we calculate the gradients of the original parameters, $\\theta$, with respect to the query loss on $f_{\\theta_i'}$.\n", "These gradients are accumulated over all tasks, and used to update $\\theta$.\n", "This is called _outer loop_ since we iterate over tasks.\n", "The full MAML algorithm is summarized below (Figure credit - [Finn et al. ](http://proceedings.mlr.press/v70/finn17a.html)).\n", "\n", "
"]}, {"cell_type": "markdown", "id": "e41d953b", "metadata": {"papermill": {"duration": 0.047596, "end_time": "2021-09-16T12:17:48.511380", "exception": false, "start_time": "2021-09-16T12:17:48.463784", "status": "completed"}, "tags": []}, "source": ["To obtain gradients for the initial parameters $\\theta$ from the optimized model $f_{\\theta_i'}$, we actually need second-order gradients, i.e. gradients of gradients, as the support set gradients depend on $\\theta$ as well.\n", "This makes MAML computationally expensive, especially when using mulitple inner loop steps.\n", "A simpler, yet almost equally well performing alternative is First-Order MAML (FOMAML) which only uses first-order gradients.\n", "This means that the second-order gradients are ignored, and we can calculate the outer loop gradients (line 10 in algorithm 2) simply by calculating the gradients with respect to $\\theta_i'$, and use those as update to $\\theta$.\n", "Hence, the new update rule becomes:\n", "$$\\theta\\leftarrow\\theta-\\beta\\sum_{\\mathcal{T}_i\\sim p(\\mathcal{T})}\\nabla_{\\theta_i'}\\mathcal{L}_{\\mathcal{T}_i}(f_{\\theta_i'})$$\n", "Note the change of $\\theta$ to $\\theta_i'$ for $\\nabla$."]}, {"cell_type": "markdown", "id": "0ae15319", "metadata": {"papermill": {"duration": 0.047717, "end_time": "2021-09-16T12:17:48.607150", "exception": false, "start_time": "2021-09-16T12:17:48.559433", "status": "completed"}, "tags": []}, "source": ["### ProtoMAML\n", "\n", "A problem of MAML is how to design the output classification layer.\n", "In case all tasks have different number of classes, we need to initialize the output layer with zeros or randomly in every iteration.\n", "Even if we always have the same number of classes, we just start from random predictions.\n", "This requires several inner loop steps to reach a reasonable classification result.\n", "To overcome this problem, Triantafillou et al.\n", "(2020) propose to combine the merits of Prototypical Networks and MAML.\n", "Specifically, we can use prototypes to initialize our output layer to have a strong initialization.\n", "Thereby, it can be shown that the softmax over euclidean distances can be reformulated as a linear layer with softmax.\n", "To see this, let's first write out the negative euclidean distance between a feature vector $f_{\\theta}(\\mathbf{x}^{*})$ of a new data point $\\mathbf{x}^{*}$ to a prototype $\\mathbf{v}_c$ of class $c$:\n", "$$\n", "-||f_{\\theta}(\\mathbf{x}^{*})-\\mathbf{v}_c||^2=-f_{\\theta}(\\mathbf{x}^{*})^Tf_{\\theta}(\\mathbf{x}^{*})+2\\mathbf{v}_c^{T}f_{\\theta}(\\mathbf{x}^{*})-\\mathbf{v}_c^T\\mathbf{v}_c\n", "$$\n", "\n", "We perform the classification across all classes $c\\in\\mathcal{C}$ and take a softmax on the distance.\n", "Hence, any term that is same for all classes can be removed without changing the output probabilities.\n", "In the equation above, this is true for $-f_{\\theta}(\\mathbf{x}^{*})^Tf_{\\theta}(\\mathbf{x}^{*})$ since it is independent of any class prototype.\n", "Thus, we can write:\n", "\n", "$$\n", "-||f_{\\theta}(\\mathbf{x}^{*})-\\mathbf{v}_c||^2=2\\mathbf{v}_c^{T}f_{\\theta}(\\mathbf{x}^{*})-||\\mathbf{v}_c||^2+\\text{constant}\n", "$$\n", "\n", "Taking a second look at the equation above, it looks a lot like a linear layer.\n", "For this, we use $\\mathbf{W}_{c,\\cdot}=2\\mathbf{v}_c$ and $b_c=-||\\mathbf{v}_c||^2$ which gives us the linear layer $\\mathbf{W}f_{\\theta}(\\mathbf{x}^{*})+\\mathbf{b}$.\n", "Hence, if we initialize the output weight with twice the prototypes, and the biases by the negative squared L2 norm of the prototypes, we start with a Prototypical Network.\n", "MAML allows us to adapt this layer and the rest of the network further.\n", "\n", "In the following, we will implement First-Order ProtoMAML for few-shot classification.\n", "The implementation of MAML would be the same except the output layer initialization."]}, {"cell_type": "markdown", "id": "25fd69c5", "metadata": {"lines_to_next_cell": 2, "papermill": {"duration": 0.048101, "end_time": "2021-09-16T12:17:48.703021", "exception": false, "start_time": "2021-09-16T12:17:48.654920", "status": "completed"}, "tags": []}, "source": ["### ProtoMAML implementation\n", "\n", "For implementing ProtoMAML, we can follow Algorithm 2 with minor modifications.\n", "At each training step, we first sample a batch of tasks, and a support and query set for each task.\n", "In our case of few-shot classification, this means that we simply sample multiple support-query set pairs from our sampler.\n", "For each task, we finetune our current model on the support set.\n", "However, since we need to remember the original parameters for the other tasks, the outer loop gradient update and future training steps, we need to create a copy of our model, and finetune only the copy.\n", "We can copy a model by using standard Python functions like `deepcopy`.\n", "The inner loop is implemented in the function `adapt_few_shot` in the PyTorch Lightning module below.\n", "\n", "After finetuning the model, we apply it on the query set and calculate the first-order gradients with respect to the original parameters $\\theta$.\n", "In contrast to simple MAML, we also have to consider the gradients with respect to the output layer initialization, i.e. the prototypes, since they directly rely on $\\theta$.\n", "To realize this efficiently, we take two steps.\n", "First, we calculate the prototypes by applying the original model, i.e. not the copied model, on the support elements.\n", "When initializing the output layer, we detach the prototypes to stop the gradients.\n", "This is because in the inner loop itself, we do not want to consider gradients through the prototypes back to the original model.\n", "However, after the inner loop is finished, we re-attach the computation graph of the prototypes by writing `output_weight = (output_weight - init_weight).detach() + init_weight`.\n", "While this line does not change the value of the variable `output_weight`, it adds its dependency on the prototype initialization `init_weight`.\n", "Thus, if we call `.backward` on `output_weight`, we will automatically calculate the first-order gradients with respect to the prototype initialization in the original model.\n", "\n", "After calculating all gradients and summing them together in the original model, we can take a standard optimizer step.\n", "PyTorch Lightning's method is however designed to return a loss-tensor on which we call `.backward` first.\n", "Since this is not possible here, we need to perform the optimization step ourselves.\n", "All details can be found in the code below.\n", "\n", "For implementing (Proto-)MAML with second-order gradients, it is recommended to use libraries such as [$\\nabla$higher](https://github.com/facebookresearch/higher) from Facebook AI Research.\n", "For simplicity, we stick with first-order methods here."]}, {"cell_type": "code", "execution_count": 25, "id": "a98b7a2a", "metadata": {"execution": {"iopub.execute_input": "2021-09-16T12:17:48.814495Z", "iopub.status.busy": "2021-09-16T12:17:48.811822Z", "iopub.status.idle": "2021-09-16T12:17:48.816545Z", "shell.execute_reply": "2021-09-16T12:17:48.816133Z"}, "lines_to_next_cell": 2, "papermill": {"duration": 0.065575, "end_time": "2021-09-16T12:17:48.816648", "exception": false, "start_time": "2021-09-16T12:17:48.751073", "status": "completed"}, "tags": []}, "outputs": [], "source": ["class ProtoMAML(pl.LightningModule):\n", " def __init__(self, proto_dim, lr, lr_inner, lr_output, num_inner_steps):\n", " \"\"\"Inputs.\n", "\n", " proto_dim - Dimensionality of prototype feature space\n", " lr - Learning rate of the outer loop Adam optimizer\n", " lr_inner - Learning rate of the inner loop SGD optimizer\n", " lr_output - Learning rate for the output layer in the inner loop\n", " num_inner_steps - Number of inner loop updates to perform\n", " \"\"\"\n", " super().__init__()\n", " self.save_hyperparameters()\n", " self.model = get_convnet(output_size=self.hparams.proto_dim)\n", "\n", " def configure_optimizers(self):\n", " optimizer = optim.AdamW(self.parameters(), lr=self.hparams.lr)\n", " scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=[140, 180], gamma=0.1)\n", " return [optimizer], [scheduler]\n", "\n", " def run_model(self, local_model, output_weight, output_bias, imgs, labels):\n", " # Execute a model with given output layer weights and inputs\n", " feats = local_model(imgs)\n", " preds = F.linear(feats, output_weight, output_bias)\n", " loss = F.cross_entropy(preds, labels)\n", " acc = (preds.argmax(dim=1) == labels).float()\n", " return loss, preds, acc\n", "\n", " def adapt_few_shot(self, support_imgs, support_targets):\n", " # Determine prototype initialization\n", " support_feats = self.model(support_imgs)\n", " prototypes, classes = ProtoNet.calculate_prototypes(support_feats, support_targets)\n", " support_labels = (classes[None, :] == support_targets[:, None]).long().argmax(dim=-1)\n", " # Create inner-loop model and optimizer\n", " local_model = deepcopy(self.model)\n", " local_model.train()\n", " local_optim = optim.SGD(local_model.parameters(), lr=self.hparams.lr_inner)\n", " local_optim.zero_grad()\n", " # Create output layer weights with prototype-based initialization\n", " init_weight = 2 * prototypes\n", " init_bias = -torch.norm(prototypes, dim=1) ** 2\n", " output_weight = init_weight.detach().requires_grad_()\n", " output_bias = init_bias.detach().requires_grad_()\n", "\n", " # Optimize inner loop model on support set\n", " for _ in range(self.hparams.num_inner_steps):\n", " # Determine loss on the support set\n", " loss, _, _ = self.run_model(local_model, output_weight, output_bias, support_imgs, support_labels)\n", " # Calculate gradients and perform inner loop update\n", " loss.backward()\n", " local_optim.step()\n", " # Update output layer via SGD\n", " output_weight.data -= self.hparams.lr_output * output_weight.grad\n", " output_bias.data -= self.hparams.lr_output * output_bias.grad\n", " # Reset gradients\n", " local_optim.zero_grad()\n", " output_weight.grad.fill_(0)\n", " output_bias.grad.fill_(0)\n", "\n", " # Re-attach computation graph of prototypes\n", " output_weight = (output_weight - init_weight).detach() + init_weight\n", " output_bias = (output_bias - init_bias).detach() + init_bias\n", "\n", " return local_model, output_weight, output_bias, classes\n", "\n", " def outer_loop(self, batch, mode=\"train\"):\n", " accuracies = []\n", " losses = []\n", " self.model.zero_grad()\n", "\n", " # Determine gradients for batch of tasks\n", " for task_batch in batch:\n", " imgs, targets = task_batch\n", " support_imgs, query_imgs, support_targets, query_targets = split_batch(imgs, targets)\n", " # Perform inner loop adaptation\n", " local_model, output_weight, output_bias, classes = self.adapt_few_shot(support_imgs, support_targets)\n", " # Determine loss of query set\n", " query_labels = (classes[None, :] == query_targets[:, None]).long().argmax(dim=-1)\n", " loss, preds, acc = self.run_model(local_model, output_weight, output_bias, query_imgs, query_labels)\n", " # Calculate gradients for query set loss\n", " if mode == \"train\":\n", " loss.backward()\n", "\n", " for p_global, p_local in zip(self.model.parameters(), local_model.parameters()):\n", " p_global.grad += p_local.grad # First-order approx. -> add gradients of finetuned and base model\n", "\n", " accuracies.append(acc.mean().detach())\n", " losses.append(loss.detach())\n", "\n", " # Perform update of base model\n", " if mode == \"train\":\n", " opt = self.optimizers()\n", " opt.step()\n", " opt.zero_grad()\n", "\n", " self.log(\"%s_loss\" % mode, sum(losses) / len(losses))\n", " self.log(\"%s_acc\" % mode, sum(accuracies) / len(accuracies))\n", "\n", " def training_step(self, batch, batch_idx):\n", " self.outer_loop(batch, mode=\"train\")\n", " return None # Returning None means we skip the default training optimizer steps by PyTorch Lightning\n", "\n", " def validation_step(self, batch, batch_idx):\n", " # Validation requires to finetune a model, hence we need to enable gradients\n", " torch.set_grad_enabled(True)\n", " self.outer_loop(batch, mode=\"val\")\n", " torch.set_grad_enabled(False)"]}, {"cell_type": "markdown", "id": "f54dbd9c", "metadata": {"lines_to_next_cell": 2, "papermill": {"duration": 0.0484, "end_time": "2021-09-16T12:17:48.913179", "exception": false, "start_time": "2021-09-16T12:17:48.864779", "status": "completed"}, "tags": []}, "source": ["### Training\n", "\n", "To train ProtoMAML, we need to change our sampling slightly.\n", "Instead of a single support-query set batch, we need to sample multiple.\n", "To implement this, we yet use another Sampler which combines multiple batches from a `FewShotBatchSampler`, and returns it afterwards.\n", "Additionally, we define a `collate_fn` for our data loader which takes the stack of support-query set images, and returns the tasks as a list.\n", "This makes it easier to process in our PyTorch Lightning module before.\n", "The implementation of the sampler can be found below."]}, {"cell_type": "code", "execution_count": 26, "id": "e72ad2ea", "metadata": {"execution": {"iopub.execute_input": "2021-09-16T12:17:49.021644Z", "iopub.status.busy": "2021-09-16T12:17:49.021158Z", "iopub.status.idle": "2021-09-16T12:17:49.023186Z", "shell.execute_reply": "2021-09-16T12:17:49.022724Z"}, "papermill": {"duration": 0.056968, "end_time": "2021-09-16T12:17:49.023285", "exception": false, "start_time": "2021-09-16T12:17:48.966317", "status": "completed"}, "tags": []}, "outputs": [], "source": ["class TaskBatchSampler:\n", " def __init__(self, dataset_targets, batch_size, N_way, K_shot, include_query=False, shuffle=True):\n", " \"\"\"\n", " Inputs:\n", " dataset_targets - PyTorch tensor of the labels of the data elements.\n", " batch_size - Number of tasks to aggregate in a batch\n", " N_way - Number of classes to sample per batch.\n", " K_shot - Number of examples to sample per class in the batch.\n", " include_query - If True, returns batch of size N_way*K_shot*2, which\n", " can be split into support and query set. Simplifies\n", " the implementation of sampling the same classes but\n", " distinct examples for support and query set.\n", " shuffle - If True, examples and classes are newly shuffled in each\n", " iteration (for training)\n", " \"\"\"\n", " super().__init__()\n", " self.batch_sampler = FewShotBatchSampler(dataset_targets, N_way, K_shot, include_query, shuffle)\n", " self.task_batch_size = batch_size\n", " self.local_batch_size = self.batch_sampler.batch_size\n", "\n", " def __iter__(self):\n", " # Aggregate multiple batches before returning the indices\n", " batch_list = []\n", " for batch_idx, batch in enumerate(self.batch_sampler):\n", " batch_list.extend(batch)\n", " if (batch_idx + 1) % self.task_batch_size == 0:\n", " yield batch_list\n", " batch_list = []\n", "\n", " def __len__(self):\n", " return len(self.batch_sampler) // self.task_batch_size\n", "\n", " def get_collate_fn(self):\n", " # Returns a collate function that converts one big tensor into a list of task-specific tensors\n", " def collate_fn(item_list):\n", " imgs = torch.stack([img for img, target in item_list], dim=0)\n", " targets = torch.stack([target for img, target in item_list], dim=0)\n", " imgs = imgs.chunk(self.task_batch_size, dim=0)\n", " targets = targets.chunk(self.task_batch_size, dim=0)\n", " return list(zip(imgs, targets))\n", "\n", " return collate_fn"]}, {"cell_type": "markdown", "id": "243b5162", "metadata": {"papermill": {"duration": 0.052467, "end_time": "2021-09-16T12:17:49.127410", "exception": false, "start_time": "2021-09-16T12:17:49.074943", "status": "completed"}, "tags": []}, "source": ["The creation of the data loaders is with this sampler straight-forward.\n", "Note that since many images need to loaded for a training batch, it is recommended to use less workers than usual."]}, {"cell_type": "code", "execution_count": 27, "id": "ba7e5519", "metadata": {"execution": {"iopub.execute_input": "2021-09-16T12:17:49.236316Z", "iopub.status.busy": "2021-09-16T12:17:49.235838Z", "iopub.status.idle": "2021-09-16T12:17:49.257937Z", "shell.execute_reply": "2021-09-16T12:17:49.258321Z"}, "papermill": {"duration": 0.078001, "end_time": "2021-09-16T12:17:49.258440", "exception": false, "start_time": "2021-09-16T12:17:49.180439", "status": "completed"}, "tags": []}, "outputs": [], "source": ["# Training constant (same as for ProtoNet)\n", "N_WAY = 5\n", "K_SHOT = 4\n", "\n", "# Training set\n", "train_protomaml_sampler = TaskBatchSampler(\n", " train_set.targets, include_query=True, N_way=N_WAY, K_shot=K_SHOT, batch_size=16\n", ")\n", "train_protomaml_loader = data.DataLoader(\n", " train_set, batch_sampler=train_protomaml_sampler, collate_fn=train_protomaml_sampler.get_collate_fn(), num_workers=2\n", ")\n", "\n", "# Validation set\n", "val_protomaml_sampler = TaskBatchSampler(\n", " val_set.targets,\n", " include_query=True,\n", " N_way=N_WAY,\n", " K_shot=K_SHOT,\n", " batch_size=1, # We do not update the parameters, hence the batch size is irrelevant here\n", " shuffle=False,\n", ")\n", "val_protomaml_loader = data.DataLoader(\n", " val_set, batch_sampler=val_protomaml_sampler, collate_fn=val_protomaml_sampler.get_collate_fn(), num_workers=2\n", ")"]}, {"cell_type": "markdown", "id": "91da1a26", "metadata": {"papermill": {"duration": 0.050178, "end_time": "2021-09-16T12:17:49.358560", "exception": false, "start_time": "2021-09-16T12:17:49.308382", "status": "completed"}, "tags": []}, "source": ["Now, we are ready to train our ProtoMAML.\n", "We use the same feature space size as for ProtoNet, but can use a higher learning rate since the outer loop gradients are accumulated over 16 batches.\n", "The inner loop learning rate is set to 0.1, which is much higher than the outer loop lr because we use SGD in the inner loop instead of Adam.\n", "Commonly, the learning rate for the output layer is higher than the base model is the base model is very deep or pre-trained.\n", "However, for our setup, we observed no noticable impact of using a different learning rate than the base model.\n", "The number of inner loop updates is another crucial hyperparmaeter, and depends on the similarity of our training tasks.\n", "Since all tasks are on images from the same dataset, we notice that a single inner loop update achieves similar performance as 3 or 5 while training considerably faster.\n", "However, especially in RL and NLP, larger number of inner loop steps are often needed."]}, {"cell_type": "code", "execution_count": 28, "id": "be7ce675", "metadata": {"execution": {"iopub.execute_input": "2021-09-16T12:17:49.464456Z", "iopub.status.busy": "2021-09-16T12:17:49.461887Z", "iopub.status.idle": "2021-09-16T12:17:49.533681Z", "shell.execute_reply": "2021-09-16T12:17:49.533246Z"}, "papermill": {"duration": 0.124824, "end_time": "2021-09-16T12:17:49.533850", "exception": false, "start_time": "2021-09-16T12:17:49.409026", "status": "completed"}, "tags": []}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["GPU available: True, used: True\n"]}, {"name": "stderr", "output_type": "stream", "text": ["TPU available: False, using: 0 TPU cores\n"]}, {"name": "stderr", "output_type": "stream", "text": ["IPU available: False, using: 0 IPUs\n"]}, {"name": "stdout", "output_type": "stream", "text": ["Found pretrained model at saved_models/MetaLearning/ProtoMAML.ckpt, loading...\n"]}], "source": ["protomaml_model = train_model(\n", " ProtoMAML,\n", " proto_dim=64,\n", " lr=1e-3,\n", " lr_inner=0.1,\n", " lr_output=0.1,\n", " num_inner_steps=1, # Often values between 1 and 10\n", " train_loader=train_protomaml_loader,\n", " val_loader=val_protomaml_loader,\n", ")"]}, {"cell_type": "markdown", "id": "9bbb768a", "metadata": {"papermill": {"duration": 0.050647, "end_time": "2021-09-16T12:17:49.634238", "exception": false, "start_time": "2021-09-16T12:17:49.583591", "status": "completed"}, "tags": []}, "source": ["Let's have a look at the training TensorBoard."]}, {"cell_type": "code", "execution_count": 29, "id": "5fad9e43", "metadata": {"execution": {"iopub.execute_input": "2021-09-16T12:17:49.740571Z", "iopub.status.busy": "2021-09-16T12:17:49.739973Z", "iopub.status.idle": "2021-09-16T12:17:49.747874Z", "shell.execute_reply": "2021-09-16T12:17:49.742382Z"}, "papermill": {"duration": 0.064603, "end_time": "2021-09-16T12:17:49.747986", "exception": false, "start_time": "2021-09-16T12:17:49.683383", "status": "completed"}, "tags": []}, "outputs": [], "source": ["# Opens tensorboard in notebook. Adjust the path to your CHECKPOINT_PATH if needed\n", "# # %tensorboard --logdir ../saved_models/tutorial16/tensorboards/ProtoMAML/"]}, {"cell_type": "markdown", "id": "75043944", "metadata": {"papermill": {"duration": 0.050469, "end_time": "2021-09-16T12:17:49.848822", "exception": false, "start_time": "2021-09-16T12:17:49.798353", "status": "completed"}, "tags": []}, "source": ["
![](\"https://github.com/PyTorchLightning/lightning-tutorials/raw/main/course_UvA-DL/12-meta-learning/few-shot-classification.png\")
![](\"https://github.com/PyTorchLightning/lightning-tutorials/raw/main/course_UvA-DL/12-meta-learning/protonet_classification.svg\")
![](\"https://github.com/PyTorchLightning/lightning-tutorials/raw/main/course_UvA-DL/12-meta-learning/tensorboard_screenshot_ProtoNet.png\")
![](\"https://github.com/PyTorchLightning/lightning-tutorials/raw/main/course_UvA-DL/12-meta-learning/MAML_figure.svg\")
![](\"https://github.com/PyTorchLightning/lightning-tutorials/raw/main/course_UvA-DL/12-meta-learning/MAML_algorithm.svg\")
![](\"https://github.com/PyTorchLightning/lightning-tutorials/raw/main/course_UvA-DL/12-meta-learning/tensorboard_screenshot_ProtoMAML.png\")