{"cells": [{"cell_type": "markdown", "id": "aa14bc73", "metadata": {"papermill": {"duration": 0.013536, "end_time": "2021-10-10T16:36:01.853136", "exception": false, "start_time": "2021-10-10T16:36:01.839600", "status": "completed"}, "tags": []}, "source": ["\n", "# Tutorial 11: Vision Transformers\n", "\n", "* **Author:** Phillip Lippe\n", "* **License:** CC BY-SA\n", "* **Generated:** 2021-10-10T18:35:49.064490\n", "\n", "In this tutorial, we will take a closer look at a recent new trend: Transformers for Computer Vision.\n", "Since [Alexey Dosovitskiy et al.](https://openreview.net/pdf?id=YicbFdNTTy) successfully applied a Transformer on a variety of image recognition benchmarks, there have been an incredible amount of follow-up works showing that CNNs might not be optimal architecture for Computer Vision anymore.\n", "But how do Vision Transformers work exactly, and what benefits and drawbacks do they offer in contrast to CNNs?\n", "We will answer these questions by implementing a Vision Transformer ourselves, and train it on the popular, small dataset CIFAR10.\n", "We will compare these results to popular convolutional architectures such as Inception, ResNet and DenseNet.\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/11-vision-transformer.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": "9f2931ec", "metadata": {"papermill": {"duration": 0.011652, "end_time": "2021-10-10T16:36:01.876879", "exception": false, "start_time": "2021-10-10T16:36:01.865227", "status": "completed"}, "tags": []}, "source": ["## Setup\n", "This notebook requires some packages besides pytorch-lightning."]}, {"cell_type": "code", "execution_count": 1, "id": "1d59c918", "metadata": {"colab": {}, "colab_type": "code", "execution": {"iopub.execute_input": "2021-10-10T16:36:01.905223Z", "iopub.status.busy": "2021-10-10T16:36:01.904752Z", "iopub.status.idle": "2021-10-10T16:36:01.907322Z", "shell.execute_reply": "2021-10-10T16:36:01.906861Z"}, "id": "LfrJLKPFyhsK", "lines_to_next_cell": 0, "papermill": {"duration": 0.018985, "end_time": "2021-10-10T16:36:01.907434", "exception": false, "start_time": "2021-10-10T16:36:01.888449", "status": "completed"}, "tags": []}, "outputs": [], "source": ["# ! pip install --quiet \"torchmetrics>=0.3\" \"matplotlib\" \"torch>=1.6, <1.9\" \"pytorch-lightning>=1.3\" \"torchvision\" \"seaborn\""]}, {"cell_type": "markdown", "id": "cef420ac", "metadata": {"papermill": {"duration": 0.0116, "end_time": "2021-10-10T16:36:01.931606", "exception": false, "start_time": "2021-10-10T16:36:01.920006", "status": "completed"}, "tags": []}, "source": ["
\n", "Let's start with importing our standard set of libraries."]}, {"cell_type": "code", "execution_count": 2, "id": "d1953eb9", "metadata": {"execution": {"iopub.execute_input": "2021-10-10T16:36:01.963459Z", "iopub.status.busy": "2021-10-10T16:36:01.962980Z", "iopub.status.idle": "2021-10-10T16:36:03.909605Z", "shell.execute_reply": "2021-10-10T16:36:03.909182Z"}, "papermill": {"duration": 1.966591, "end_time": "2021-10-10T16:36:03.909720", "exception": false, "start_time": "2021-10-10T16:36:01.943129", "status": "completed"}, "tags": []}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["/tmp/ipykernel_493/3416006740.py:22: 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 os\n", "import urllib.request\n", "from urllib.error import HTTPError\n", "\n", "import matplotlib\n", "import matplotlib.pyplot as plt\n", "import pytorch_lightning as pl\n", "import seaborn as sns\n", "import torch\n", "import torch.nn as nn\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 pytorch_lightning.callbacks import LearningRateMonitor, ModelCheckpoint\n", "from torchvision import transforms\n", "from torchvision.datasets import CIFAR10\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", "# %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/VisionTransformers/\")\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": "7b4c9cda", "metadata": {"papermill": {"duration": 0.012503, "end_time": "2021-10-10T16:36:03.935539", "exception": false, "start_time": "2021-10-10T16:36:03.923036", "status": "completed"}, "tags": []}, "source": ["We provide a pre-trained Vision Transformer which we download in the next cell.\n", "However, Vision Transformers can be relatively quickly trained on CIFAR10 with an overall training time of less than an hour on an NVIDIA TitanRTX.\n", "Feel free to experiment with training your own Transformer once you went through the whole notebook."]}, {"cell_type": "code", "execution_count": 3, "id": "6284d05a", "metadata": {"execution": {"iopub.execute_input": "2021-10-10T16:36:03.966290Z", "iopub.status.busy": "2021-10-10T16:36:03.965811Z", "iopub.status.idle": "2021-10-10T16:36:04.460168Z", "shell.execute_reply": "2021-10-10T16:36:04.460557Z"}, "papermill": {"duration": 0.512509, "end_time": "2021-10-10T16:36:04.460702", "exception": false, "start_time": "2021-10-10T16:36:03.948193", "status": "completed"}, "tags": []}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["Downloading https://raw.githubusercontent.com/phlippe/saved_models/main/tutorial15/ViT.ckpt...\n"]}, {"name": "stdout", "output_type": "stream", "text": ["Downloading https://raw.githubusercontent.com/phlippe/saved_models/main/tutorial15/tensorboards/ViT/events.out.tfevents.ViT...\n", "Downloading https://raw.githubusercontent.com/phlippe/saved_models/main/tutorial5/tensorboards/ResNet/events.out.tfevents.resnet...\n"]}], "source": ["# Github URL where saved models are stored for this tutorial\n", "base_url = \"https://raw.githubusercontent.com/phlippe/saved_models/main/\"\n", "# Files to download\n", "pretrained_files = [\n", " \"tutorial15/ViT.ckpt\",\n", " \"tutorial15/tensorboards/ViT/events.out.tfevents.ViT\",\n", " \"tutorial5/tensorboards/ResNet/events.out.tfevents.resnet\",\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.split(\"/\", 1)[1])\n", " if \"/\" in file_name.split(\"/\", 1)[1]:\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": "c96b3099", "metadata": {"papermill": {"duration": 0.012919, "end_time": "2021-10-10T16:36:04.487227", "exception": false, "start_time": "2021-10-10T16:36:04.474308", "status": "completed"}, "tags": []}, "source": ["We load the CIFAR10 dataset below.\n", "We use the same setup of the datasets and data augmentations as for the CNNs in Tutorial 5 to keep a fair comparison.\n", "The constants in the `transforms.Normalize` correspond to the values\n", "that scale and shift the data to a zero mean and standard deviation of\n", "one."]}, {"cell_type": "code", "execution_count": 4, "id": "bb8b01bd", "metadata": {"execution": {"iopub.execute_input": "2021-10-10T16:36:04.522789Z", "iopub.status.busy": "2021-10-10T16:36:04.522299Z", "iopub.status.idle": "2021-10-10T16:36:06.982772Z", "shell.execute_reply": "2021-10-10T16:36:06.983222Z"}, "papermill": {"duration": 2.483202, "end_time": "2021-10-10T16:36:06.983367", "exception": false, "start_time": "2021-10-10T16:36:04.500165", "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"]}, {"name": "stderr", "output_type": "stream", "text": ["Global seed set to 42\n"]}, {"name": "stderr", "output_type": "stream", "text": ["Global seed set to 42\n"]}, {"name": "stdout", "output_type": "stream", "text": ["Files already downloaded and verified\n"]}, {"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": ["test_transform = transforms.Compose(\n", " [\n", " transforms.ToTensor(),\n", " transforms.Normalize([0.49139968, 0.48215841, 0.44653091], [0.24703223, 0.24348513, 0.26158784]),\n", " ]\n", ")\n", "# For training, we add some augmentation. Networks are too powerful and would overfit.\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([0.49139968, 0.48215841, 0.44653091], [0.24703223, 0.24348513, 0.26158784]),\n", " ]\n", ")\n", "# Loading the training dataset. We need to split it into a training and validation part\n", "# We need to do a little trick because the validation set should not use the augmentation.\n", "train_dataset = CIFAR10(root=DATASET_PATH, train=True, transform=train_transform, download=True)\n", "val_dataset = CIFAR10(root=DATASET_PATH, train=True, transform=test_transform, download=True)\n", "pl.seed_everything(42)\n", "train_set, _ = torch.utils.data.random_split(train_dataset, [45000, 5000])\n", "pl.seed_everything(42)\n", "_, val_set = torch.utils.data.random_split(val_dataset, [45000, 5000])\n", "\n", "# Loading the test set\n", "test_set = CIFAR10(root=DATASET_PATH, train=False, transform=test_transform, download=True)\n", "\n", "# We define a set of data loaders that we can use for various purposes later.\n", "train_loader = data.DataLoader(train_set, batch_size=128, shuffle=True, drop_last=True, pin_memory=True, num_workers=4)\n", "val_loader = data.DataLoader(val_set, batch_size=128, shuffle=False, drop_last=False, num_workers=4)\n", "test_loader = data.DataLoader(test_set, batch_size=128, shuffle=False, drop_last=False, num_workers=4)\n", "\n", "# Visualize some examples\n", "NUM_IMAGES = 4\n", "CIFAR_images = torch.stack([val_set[idx][0] for idx in range(NUM_IMAGES)], dim=0)\n", "img_grid = torchvision.utils.make_grid(CIFAR_images, nrow=4, 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 CIFAR10 dataset\")\n", "plt.imshow(img_grid)\n", "plt.axis(\"off\")\n", "plt.show()\n", "plt.close()"]}, {"cell_type": "markdown", "id": "de31824d", "metadata": {"lines_to_next_cell": 2, "papermill": {"duration": 0.01573, "end_time": "2021-10-10T16:36:07.015490", "exception": false, "start_time": "2021-10-10T16:36:06.999760", "status": "completed"}, "tags": []}, "source": ["## Transformers for image classification\n", "\n", "Transformers have been originally proposed to process sets since it is a permutation-equivariant architecture, i.e., producing the same output permuted if the input is permuted.\n", "To apply Transformers to sequences, we have simply added a positional encoding to the input feature vectors, and the model learned by itself what to do with it.\n", "So, why not do the same thing on images?\n", "This is exactly what [Alexey Dosovitskiy et al. ](https://openreview.net/pdf?id=YicbFdNTTy) proposed in their paper \"An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale\".\n", "Specifically, the Vision Transformer is a model for image classification that views images as sequences of smaller patches.\n", "As a preprocessing step, we split an image of, for example, $48\\times 48$ pixels into 9 $16\\times 16$ patches.\n", "Each of those patches is considered to be a \"word\"/\"token\", and projected to a feature space.\n", "With adding positional encodings and a token for classification on top, we can apply a Transformer as usual to this sequence and start training it for our task.\n", "A nice GIF visualization of the architecture is shown below (figure credit - [Phil Wang](https://github.com/lucidrains/vit-pytorch/blob/main/images/vit.gif)):\n", "\n", "
\n", "\n", "We will walk step by step through the Vision Transformer, and implement all parts by ourselves.\n", "First, let's implement the image preprocessing: an image of size $N\\times N$ has to be split into $(N/M)^2$ patches of size $M\\times M$.\n", "These represent the input words to the Transformer."]}, {"cell_type": "code", "execution_count": 5, "id": "ae492f17", "metadata": {"execution": {"iopub.execute_input": "2021-10-10T16:36:07.050794Z", "iopub.status.busy": "2021-10-10T16:36:07.048305Z", "iopub.status.idle": "2021-10-10T16:36:07.053076Z", "shell.execute_reply": "2021-10-10T16:36:07.052610Z"}, "papermill": {"duration": 0.022148, "end_time": "2021-10-10T16:36:07.053172", "exception": false, "start_time": "2021-10-10T16:36:07.031024", "status": "completed"}, "tags": []}, "outputs": [], "source": ["def img_to_patch(x, patch_size, flatten_channels=True):\n", " \"\"\"\n", " Inputs:\n", " x - torch.Tensor representing the image of shape [B, C, H, W]\n", " patch_size - Number of pixels per dimension of the patches (integer)\n", " flatten_channels - If True, the patches will be returned in a flattened format\n", " as a feature vector instead of a image grid.\n", " \"\"\"\n", " B, C, H, W = x.shape\n", " x = x.reshape(B, C, H // patch_size, patch_size, W // patch_size, patch_size)\n", " x = x.permute(0, 2, 4, 1, 3, 5) # [B, H', W', C, p_H, p_W]\n", " x = x.flatten(1, 2) # [B, H'*W', C, p_H, p_W]\n", " if flatten_channels:\n", " x = x.flatten(2, 4) # [B, H'*W', C*p_H*p_W]\n", " return x"]}, {"cell_type": "markdown", "id": "1577af41", "metadata": {"papermill": {"duration": 0.016461, "end_time": "2021-10-10T16:36:07.085363", "exception": false, "start_time": "2021-10-10T16:36:07.068902", "status": "completed"}, "tags": []}, "source": ["Let's take a look at how that works for our CIFAR examples above.\n", "For our images of size $32\\times 32$, we choose a patch size of 4.\n", "Hence, we obtain sequences of 64 patches of size $4\\times 4$.\n", "We visualize them below:"]}, {"cell_type": "code", "execution_count": 6, "id": "bc8f2072", "metadata": {"execution": {"iopub.execute_input": "2021-10-10T16:36:07.121184Z", "iopub.status.busy": "2021-10-10T16:36:07.120716Z", "iopub.status.idle": "2021-10-10T16:36:07.353313Z", "shell.execute_reply": "2021-10-10T16:36:07.353705Z"}, "papermill": {"duration": 0.252758, "end_time": "2021-10-10T16:36:07.353849", "exception": false, "start_time": "2021-10-10T16:36:07.101091", "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": ["img_patches = img_to_patch(CIFAR_images, patch_size=4, flatten_channels=False)\n", "\n", "fig, ax = plt.subplots(CIFAR_images.shape[0], 1, figsize=(14, 3))\n", "fig.suptitle(\"Images as input sequences of patches\")\n", "for i in range(CIFAR_images.shape[0]):\n", " img_grid = torchvision.utils.make_grid(img_patches[i], nrow=64, normalize=True, pad_value=0.9)\n", " img_grid = img_grid.permute(1, 2, 0)\n", " ax[i].imshow(img_grid)\n", " ax[i].axis(\"off\")\n", "plt.show()\n", "plt.close()"]}, {"cell_type": "markdown", "id": "cce53f7d", "metadata": {"lines_to_next_cell": 2, "papermill": {"duration": 0.018572, "end_time": "2021-10-10T16:36:07.393026", "exception": false, "start_time": "2021-10-10T16:36:07.374454", "status": "completed"}, "tags": []}, "source": ["Compared to the original images, it is much harder to recognize the objects from those patch lists now.\n", "Still, this is the input we provide to the Transformer for classifying the images.\n", "The model has to learn itself how it has to combine the patches to recognize the objects.\n", "The inductive bias in CNNs that an image is grid of pixels, is lost in this input format.\n", "\n", "After we have looked at the preprocessing, we can now start building the Transformer model.\n", "Since we have discussed the fundamentals of Multi-Head Attention in [Tutorial 6](https://uvadlc-notebooks.readthedocs.io/en/latest/tutorial_notebooks/tutorial6/Transformers_and_MHAttention.html), we will use the PyTorch module `nn.MultiheadAttention` ([docs](https://pytorch.org/docs/stable/generated/torch.nn.MultiheadAttention.html?highlight=multihead#torch.nn.MultiheadAttention)) here.\n", "Further, we use the Pre-Layer Normalization version of the Transformer blocks proposed by [Ruibin Xiong et al. ](http://proceedings.mlr.press/v119/xiong20b/xiong20b.pdf) in 2020.\n", "The idea is to apply Layer Normalization not in between residual blocks, but instead as a first layer in the residual blocks.\n", "This reorganization of the layers supports better gradient flow and removes the necessity of a warm-up stage.\n", "A visualization of the difference between the standard Post-LN and the Pre-LN version is shown below.\n", "\n", "
\n", "\n", "The implementation of the Pre-LN attention block looks as follows:"]}, {"cell_type": "code", "execution_count": 7, "id": "0f69e05b", "metadata": {"execution": {"iopub.execute_input": "2021-10-10T16:36:07.437581Z", "iopub.status.busy": "2021-10-10T16:36:07.437105Z", "iopub.status.idle": "2021-10-10T16:36:07.439187Z", "shell.execute_reply": "2021-10-10T16:36:07.438722Z"}, "lines_to_next_cell": 2, "papermill": {"duration": 0.027401, "end_time": "2021-10-10T16:36:07.439284", "exception": false, "start_time": "2021-10-10T16:36:07.411883", "status": "completed"}, "tags": []}, "outputs": [], "source": ["class AttentionBlock(nn.Module):\n", " def __init__(self, embed_dim, hidden_dim, num_heads, dropout=0.0):\n", " \"\"\"\n", " Inputs:\n", " embed_dim - Dimensionality of input and attention feature vectors\n", " hidden_dim - Dimensionality of hidden layer in feed-forward network\n", " (usually 2-4x larger than embed_dim)\n", " num_heads - Number of heads to use in the Multi-Head Attention block\n", " dropout - Amount of dropout to apply in the feed-forward network\n", " \"\"\"\n", " super().__init__()\n", "\n", " self.layer_norm_1 = nn.LayerNorm(embed_dim)\n", " self.attn = nn.MultiheadAttention(embed_dim, num_heads)\n", " self.layer_norm_2 = nn.LayerNorm(embed_dim)\n", " self.linear = nn.Sequential(\n", " nn.Linear(embed_dim, hidden_dim),\n", " nn.GELU(),\n", " nn.Dropout(dropout),\n", " nn.Linear(hidden_dim, embed_dim),\n", " nn.Dropout(dropout),\n", " )\n", "\n", " def forward(self, x):\n", " inp_x = self.layer_norm_1(x)\n", " x = x + self.attn(inp_x, inp_x, inp_x)[0]\n", " x = x + self.linear(self.layer_norm_2(x))\n", " return x"]}, {"cell_type": "markdown", "id": "b5f96bdf", "metadata": {"lines_to_next_cell": 2, "papermill": {"duration": 0.0187, "end_time": "2021-10-10T16:36:07.476786", "exception": false, "start_time": "2021-10-10T16:36:07.458086", "status": "completed"}, "tags": []}, "source": ["Now we have all modules ready to build our own Vision Transformer.\n", "Besides the Transformer encoder, we need the following modules:\n", "\n", "* A **linear projection** layer that maps the input patches to a feature vector of larger size.\n", "It is implemented by a simple linear layer that takes each $M\\times M$ patch independently as input.\n", "* A **classification token** that is added to the input sequence.\n", "We will use the output feature vector of the classification token (CLS token in short) for determining the classification prediction.\n", "* Learnable **positional encodings** that are added to the tokens before being processed by the Transformer.\n", "Those are needed to learn position-dependent information, and convert the set to a sequence.\n", "Since we usually work with a fixed resolution, we can learn the positional encodings instead of having the pattern of sine and cosine functions.\n", "* A **MLP head** that takes the output feature vector of the CLS token, and maps it to a classification prediction.\n", "This is usually implemented by a small feed-forward network or even a single linear layer.\n", "\n", "With those components in mind, let's implement the full Vision Transformer below:"]}, {"cell_type": "code", "execution_count": 8, "id": "0228d483", "metadata": {"execution": {"iopub.execute_input": "2021-10-10T16:36:07.522084Z", "iopub.status.busy": "2021-10-10T16:36:07.521601Z", "iopub.status.idle": "2021-10-10T16:36:07.523699Z", "shell.execute_reply": "2021-10-10T16:36:07.523301Z"}, "lines_to_next_cell": 2, "papermill": {"duration": 0.02827, "end_time": "2021-10-10T16:36:07.523823", "exception": false, "start_time": "2021-10-10T16:36:07.495553", "status": "completed"}, "tags": []}, "outputs": [], "source": ["class VisionTransformer(nn.Module):\n", " def __init__(\n", " self,\n", " embed_dim,\n", " hidden_dim,\n", " num_channels,\n", " num_heads,\n", " num_layers,\n", " num_classes,\n", " patch_size,\n", " num_patches,\n", " dropout=0.0,\n", " ):\n", " \"\"\"\n", " Inputs:\n", " embed_dim - Dimensionality of the input feature vectors to the Transformer\n", " hidden_dim - Dimensionality of the hidden layer in the feed-forward networks\n", " within the Transformer\n", " num_channels - Number of channels of the input (3 for RGB)\n", " num_heads - Number of heads to use in the Multi-Head Attention block\n", " num_layers - Number of layers to use in the Transformer\n", " num_classes - Number of classes to predict\n", " patch_size - Number of pixels that the patches have per dimension\n", " num_patches - Maximum number of patches an image can have\n", " dropout - Amount of dropout to apply in the feed-forward network and\n", " on the input encoding\n", " \"\"\"\n", " super().__init__()\n", "\n", " self.patch_size = patch_size\n", "\n", " # Layers/Networks\n", " self.input_layer = nn.Linear(num_channels * (patch_size ** 2), embed_dim)\n", " self.transformer = nn.Sequential(\n", " *(AttentionBlock(embed_dim, hidden_dim, num_heads, dropout=dropout) for _ in range(num_layers))\n", " )\n", " self.mlp_head = nn.Sequential(nn.LayerNorm(embed_dim), nn.Linear(embed_dim, num_classes))\n", " self.dropout = nn.Dropout(dropout)\n", "\n", " # Parameters/Embeddings\n", " self.cls_token = nn.Parameter(torch.randn(1, 1, embed_dim))\n", " self.pos_embedding = nn.Parameter(torch.randn(1, 1 + num_patches, embed_dim))\n", "\n", " def forward(self, x):\n", " # Preprocess input\n", " x = img_to_patch(x, self.patch_size)\n", " B, T, _ = x.shape\n", " x = self.input_layer(x)\n", "\n", " # Add CLS token and positional encoding\n", " cls_token = self.cls_token.repeat(B, 1, 1)\n", " x = torch.cat([cls_token, x], dim=1)\n", " x = x + self.pos_embedding[:, : T + 1]\n", "\n", " # Apply Transforrmer\n", " x = self.dropout(x)\n", " x = x.transpose(0, 1)\n", " x = self.transformer(x)\n", "\n", " # Perform classification prediction\n", " cls = x[0]\n", " out = self.mlp_head(cls)\n", " return out"]}, {"cell_type": "markdown", "id": "0fde39b8", "metadata": {"lines_to_next_cell": 2, "papermill": {"duration": 0.018994, "end_time": "2021-10-10T16:36:07.561842", "exception": false, "start_time": "2021-10-10T16:36:07.542848", "status": "completed"}, "tags": []}, "source": ["Finally, we can put everything into a PyTorch Lightning Module as usual.\n", "We use `torch.optim.AdamW` as the optimizer, which is Adam with a corrected weight decay implementation.\n", "Since we use the Pre-LN Transformer version, we do not need to use a learning rate warmup stage anymore.\n", "Instead, we use the same learning rate scheduler as the CNNs in our previous tutorial on image classification."]}, {"cell_type": "code", "execution_count": 9, "id": "99bcb238", "metadata": {"execution": {"iopub.execute_input": "2021-10-10T16:36:07.606617Z", "iopub.status.busy": "2021-10-10T16:36:07.606128Z", "iopub.status.idle": "2021-10-10T16:36:07.608256Z", "shell.execute_reply": "2021-10-10T16:36:07.607820Z"}, "lines_to_next_cell": 2, "papermill": {"duration": 0.027621, "end_time": "2021-10-10T16:36:07.608351", "exception": false, "start_time": "2021-10-10T16:36:07.580730", "status": "completed"}, "tags": []}, "outputs": [], "source": ["class ViT(pl.LightningModule):\n", " def __init__(self, model_kwargs, lr):\n", " super().__init__()\n", " self.save_hyperparameters()\n", " self.model = VisionTransformer(**model_kwargs)\n", " self.example_input_array = next(iter(train_loader))[0]\n", "\n", " def forward(self, x):\n", " return self.model(x)\n", "\n", " def configure_optimizers(self):\n", " optimizer = optim.AdamW(self.parameters(), lr=self.hparams.lr)\n", " lr_scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=[100, 150], gamma=0.1)\n", " return [optimizer], [lr_scheduler]\n", "\n", " def _calculate_loss(self, batch, mode=\"train\"):\n", " imgs, labels = batch\n", " preds = self.model(imgs)\n", " loss = F.cross_entropy(preds, labels)\n", " acc = (preds.argmax(dim=-1) == labels).float().mean()\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", " loss = self._calculate_loss(batch, mode=\"train\")\n", " return loss\n", "\n", " def validation_step(self, batch, batch_idx):\n", " self._calculate_loss(batch, mode=\"val\")\n", "\n", " def test_step(self, batch, batch_idx):\n", " self._calculate_loss(batch, mode=\"test\")"]}, {"cell_type": "markdown", "id": "db79a63a", "metadata": {"lines_to_next_cell": 2, "papermill": {"duration": 0.018896, "end_time": "2021-10-10T16:36:07.646134", "exception": false, "start_time": "2021-10-10T16:36:07.627238", "status": "completed"}, "tags": []}, "source": ["## Experiments\n", "\n", "Commonly, Vision Transformers are applied to large-scale image classification benchmarks such as ImageNet to leverage their full potential.\n", "However, here we take a step back and ask: can Vision Transformer also succeed on classical, small benchmarks such as CIFAR10?\n", "To find this out, we train a Vision Transformer from scratch on the CIFAR10 dataset.\n", "Let's first create a training function for our PyTorch Lightning module\n", "which also loads the pre-trained model if you have downloaded it above."]}, {"cell_type": "code", "execution_count": 10, "id": "8c1f2286", "metadata": {"execution": {"iopub.execute_input": "2021-10-10T16:36:07.692103Z", "iopub.status.busy": "2021-10-10T16:36:07.691595Z", "iopub.status.idle": "2021-10-10T16:36:07.693685Z", "shell.execute_reply": "2021-10-10T16:36:07.693221Z"}, "papermill": {"duration": 0.028441, "end_time": "2021-10-10T16:36:07.693783", "exception": false, "start_time": "2021-10-10T16:36:07.665342", "status": "completed"}, "tags": []}, "outputs": [], "source": ["def train_model(**kwargs):\n", " trainer = pl.Trainer(\n", " default_root_dir=os.path.join(CHECKPOINT_PATH, \"ViT\"),\n", " gpus=1 if str(device) == \"cuda:0\" else 0,\n", " max_epochs=180,\n", " callbacks=[\n", " ModelCheckpoint(save_weights_only=True, mode=\"max\", monitor=\"val_acc\"),\n", " LearningRateMonitor(\"epoch\"),\n", " ],\n", " progress_bar_refresh_rate=1,\n", " )\n", " trainer.logger._log_graph = True # If True, we plot the computation graph in tensorboard\n", " trainer.logger._default_hp_metric = None # Optional logging argument that we don't need\n", "\n", " # Check whether pretrained model exists. If yes, load it and skip training\n", " pretrained_filename = os.path.join(CHECKPOINT_PATH, \"ViT.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 = ViT.load_from_checkpoint(pretrained_filename)\n", " else:\n", " pl.seed_everything(42) # To be reproducable\n", " model = ViT(**kwargs)\n", " trainer.fit(model, train_loader, val_loader)\n", " # Load best checkpoint after training\n", " model = ViT.load_from_checkpoint(trainer.checkpoint_callback.best_model_path)\n", "\n", " # Test best model on validation and test set\n", " val_result = trainer.test(model, test_dataloaders=val_loader, verbose=False)\n", " test_result = trainer.test(model, test_dataloaders=test_loader, verbose=False)\n", " result = {\"test\": test_result[0][\"test_acc\"], \"val\": val_result[0][\"test_acc\"]}\n", "\n", " return model, result"]}, {"cell_type": "markdown", "id": "e359c353", "metadata": {"papermill": {"duration": 0.019033, "end_time": "2021-10-10T16:36:07.732020", "exception": false, "start_time": "2021-10-10T16:36:07.712987", "status": "completed"}, "tags": []}, "source": ["Now, we can already start training our model.\n", "As seen in our implementation, we have couple of hyperparameter that we have to choose.\n", "When creating this notebook, we have performed a small grid search over hyperparameters and listed the best hyperparameters in the cell below.\n", "Nevertheless, it is worth to discuss the influence that each hyperparameter has, and what intuition we have for choosing its value.\n", "\n", "First, let's consider the patch size.\n", "The smaller we make the patches, the longer the input sequences to the Transformer become.\n", "While in general, this allows the Transformer to model more complex functions, it requires a longer computation time due to its quadratic memory usage in the attention layer.\n", "Furthermore, small patches can make the task more difficult since the Transformer has to learn which patches are close-by, and which are far away.\n", "We experimented with patch sizes of 2, 4 and 8 which gives us the input sequence lengths of 256, 64, and 16 respectively.\n", "We found 4 to result in the best performance, and hence pick it below.\n", "\n", "Next, the embedding and hidden dimensionality have a similar impact to a Transformer as to an MLP.\n", "The larger the sizes, the more complex the model becomes, and the longer it takes to train.\n", "In Transformer however, we have one more aspect to consider: the query-key sizes in the Multi-Head Attention layers.\n", "Each key has the feature dimensionality of `embed_dim/num_heads`.\n", "Considering that we have an input sequence length of 64, a minimum reasonable size for the key vectors is 16 or 32.\n", "Lower dimensionalities can restrain the possible attention maps too much.\n", "We observed that more than 8 heads are not necessary for the Transformer, and therefore pick a embedding dimensionality of `256`.\n", "The hidden dimensionality in the feed-forward networks is usually 2-4x larger than the embedding dimensionality, and thus we pick `512`.\n", "\n", "Finally, the learning rate for Transformers is usually relatively small, and in papers, a common value to use is 3e-5.\n", "However, since we work with a smaller dataset and have a potentially easier task, we found that we are able to increase the learning rate to 3e-4 without any problems.\n", "To reduce overfitting, we use a dropout value of 0.2.\n", "Remember that we also use small image augmentations as regularization during training.\n", "\n", "Feel free to explore the hyperparameters yourself by changing the values below.\n", "In general, the Vision Transformer did not show to be too sensitive to\n", "the hyperparameter choices on the CIFAR10 dataset."]}, {"cell_type": "code", "execution_count": 11, "id": "8aacc01b", "metadata": {"execution": {"iopub.execute_input": "2021-10-10T16:36:07.775505Z", "iopub.status.busy": "2021-10-10T16:36:07.775020Z", "iopub.status.idle": "2021-10-10T16:36:15.614815Z", "shell.execute_reply": "2021-10-10T16:36:15.615209Z"}, "papermill": {"duration": 7.864306, "end_time": "2021-10-10T16:36:15.615357", "exception": false, "start_time": "2021-10-10T16:36:07.751051", "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/VisionTransformers/ViT.ckpt, loading...\n"]}, {"name": "stderr", "output_type": "stream", "text": ["/home/AzDevOps_azpcontainer/.local/lib/python3.9/site-packages/pytorch_lightning/trainer/trainer.py:678: LightningDeprecationWarning: `trainer.test(test_dataloaders)` is deprecated in v1.4 and will be removed in v1.6. Use `trainer.test(dataloaders)` instead.\n", " rank_zero_deprecation(\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n"]}, {"name": "stderr", "output_type": "stream", "text": ["/usr/local/lib/python3.9/dist-packages/torch/_jit_internal.py:603: LightningDeprecationWarning: The `LightningModule.datamodule` property is deprecated in v1.3 and will be removed in v1.5. Access the datamodule through using `self.trainer.datamodule` instead.\n", " if hasattr(mod, name):\n", "/usr/local/lib/python3.9/dist-packages/torch/_jit_internal.py:603: LightningDeprecationWarning: The `LightningModule.loaded_optimizer_states_dict` property is deprecated in v1.4 and will be removed in v1.6.\n", " if hasattr(mod, name):\n"]}, {"data": {"application/vnd.jupyter.widget-view+json": {"model_id": "2824556005cc42f79c31cbebe248b150", "version_major": 2, "version_minor": 0}, "text/plain": ["Testing: 0it [00:00, ?it/s]"]}, "metadata": {}, "output_type": "display_data"}, {"name": "stderr", "output_type": "stream", "text": ["LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n"]}, {"data": {"application/vnd.jupyter.widget-view+json": {"model_id": "06ecaa193abb4c6599f94a9a7e64de8f", "version_major": 2, "version_minor": 0}, "text/plain": ["Testing: 0it [00:00, ?it/s]"]}, "metadata": {}, "output_type": "display_data"}, {"name": "stdout", "output_type": "stream", "text": ["ViT results {'test': 0.7559000253677368, 'val': 0.7563999891281128}\n"]}], "source": ["model, results = train_model(\n", " model_kwargs={\n", " \"embed_dim\": 256,\n", " \"hidden_dim\": 512,\n", " \"num_heads\": 8,\n", " \"num_layers\": 6,\n", " \"patch_size\": 4,\n", " \"num_channels\": 3,\n", " \"num_patches\": 64,\n", " \"num_classes\": 10,\n", " \"dropout\": 0.2,\n", " },\n", " lr=3e-4,\n", ")\n", "print(\"ViT results\", results)"]}, {"cell_type": "markdown", "id": "c305d6d0", "metadata": {"papermill": {"duration": 0.327633, "end_time": "2021-10-10T16:36:16.015814", "exception": false, "start_time": "2021-10-10T16:36:15.688181", "status": "completed"}, "tags": []}, "source": ["The Vision Transformer achieves a validation and test performance of about 75%.\n", "In comparison, almost all CNN architectures that we have tested in [Tutorial 5](https://uvadlc-notebooks.readthedocs.io/en/latest/tutorial_notebooks/tutorial5/Inception_ResNet_DenseNet.html) obtained a classification performance of around 90%.\n", "This is a considerable gap and shows that although Vision Transformers perform strongly on ImageNet with potential pretraining, they cannot come close to simple CNNs on CIFAR10 when being trained from scratch.\n", "The differences between a CNN and Transformer can be well observed in the training curves.\n", "Let's look at them in a tensorboard below:"]}, {"cell_type": "code", "execution_count": 12, "id": "88cc38e7", "metadata": {"execution": {"iopub.execute_input": "2021-10-10T16:36:16.703879Z", "iopub.status.busy": "2021-10-10T16:36:16.703404Z", "iopub.status.idle": "2021-10-10T16:36:16.705449Z", "shell.execute_reply": "2021-10-10T16:36:16.705045Z"}, "papermill": {"duration": 0.027779, "end_time": "2021-10-10T16:36:16.705553", "exception": false, "start_time": "2021-10-10T16:36:16.677774", "status": "completed"}, "tags": []}, "outputs": [], "source": ["# Opens tensorboard in notebook. Adjust the path to your CHECKPOINT_PATH!\n", "# %tensorboard --logdir ../saved_models/tutorial15/tensorboards/"]}, {"cell_type": "markdown", "id": "1b7c6344", "metadata": {"papermill": {"duration": 0.021202, "end_time": "2021-10-10T16:36:16.748363", "exception": false, "start_time": "2021-10-10T16:36:16.727161", "status": "completed"}, "tags": []}, "source": ["
"]}, {"cell_type": "markdown", "id": "26c6ac67", "metadata": {"papermill": {"duration": 0.02121, "end_time": "2021-10-10T16:36:16.790843", "exception": false, "start_time": "2021-10-10T16:36:16.769633", "status": "completed"}, "tags": []}, "source": ["The tensorboard compares the Vision Transformer to a ResNet trained on CIFAR10.\n", "When looking at the training losses, we see that the ResNet learns much more quickly in the first iterations.\n", "While the learning rate might have an influence on the initial learning speed, we see the same trend in the validation accuracy.\n", "The ResNet achieves the best performance of the Vision Transformer after just 5 epochs (2000 iterations).\n", "Further, while the ResNet training loss and validation accuracy have a similar trend, the validation performance of the Vision Transformers only marginally changes after 10k iterations while the training loss has almost just started going down.\n", "Yet, the Vision Transformer is also able to achieve a close-to 100% accuracy on the training set.\n", "\n", "All those observed phenomenons can be explained with a concept that we have visited before: inductive biases.\n", "Convolutional Neural Networks have been designed with the assumption that images are translation invariant.\n", "Hence, we apply convolutions with shared filters across the image.\n", "Furthermore, a CNN architecture integrates the concept of distance in an image: two pixels that are close to each other are more related than two distant pixels.\n", "Local patterns are combined into larger patterns, until we perform our classification prediction.\n", "All those aspects are inductive biases of a CNN.\n", "In contrast, a Vision Transformer does not know which two pixels are close to each other, and which are far apart.\n", "It has to learn this information solely from the sparse learning signal of the classification task.\n", "This is a huge disadvantage when we have a small dataset since such information is crucial for generalizing to an unseen test dataset.\n", "With large enough datasets and/or good pre-training, a Transformer can learn this information without the need of inductive biases, and instead is more flexible than a CNN.\n", "Especially long-distance relations between local patterns can be difficult to process in CNNs, while in Transformers, all patches have the distance of one.\n", "This is why Vision Transformers are so strong on large-scale datasets\n", "such as ImageNet, but underperform a lot when being applied to a small\n", "dataset such as CIFAR10."]}, {"cell_type": "markdown", "id": "5df010c9", "metadata": {"papermill": {"duration": 0.021723, "end_time": "2021-10-10T16:36:16.834866", "exception": false, "start_time": "2021-10-10T16:36:16.813143", "status": "completed"}, "tags": []}, "source": ["## Conclusion\n", "\n", "In this tutorial, we have implemented our own Vision Transformer from scratch and applied it on the task of image classification.\n", "Vision Transformers work by splitting an image into a sequence of smaller patches, use those as input to a standard Transformer encoder.\n", "While Vision Transformers achieved outstanding results on large-scale image recognition benchmarks such as ImageNet, they considerably underperform when being trained from scratch on small-scale datasets like CIFAR10.\n", "The reason is that in contrast to CNNs, Transformers do not have the inductive biases of translation invariance and the feature hierachy (i.e. larger patterns consist of many smaller patterns).\n", "However, these aspects can be learned when enough data is provided, or the model has been pre-trained on other large-scale tasks.\n", "Considering that Vision Transformers have just been proposed end of 2020, there is likely a lot more to come on Transformers for Computer Vision.\n", "\n", "\n", "### References\n", "\n", "Dosovitskiy, Alexey, et al.\n", "\"An image is worth 16x16 words: Transformers for image recognition at scale.\"\n", "International Conference on Representation Learning (2021).\n", "[link](https://arxiv.org/pdf/2010.11929.pdf)\n", "\n", "Chen, Xiangning, et al.\n", "\"When Vision Transformers Outperform ResNets without Pretraining or Strong Data Augmentations.\"\n", "arXiv preprint arXiv:2106.01548 (2021).\n", "[link](https://arxiv.org/abs/2106.01548)\n", "\n", "Tolstikhin, Ilya, et al.\n", "\"MLP-mixer: An all-MLP Architecture for Vision.\"\n", "arXiv preprint arXiv:2105.01601 (2021).\n", "[link](https://arxiv.org/abs/2105.01601)\n", "\n", "Xiong, Ruibin, et al.\n", "\"On layer normalization in the transformer architecture.\"\n", "International Conference on Machine Learning.\n", "PMLR, 2020.\n", "[link](http://proceedings.mlr.press/v119/xiong20b/xiong20b.pdf)"]}, {"cell_type": "markdown", "id": "18e70eed", "metadata": {"papermill": {"duration": 0.021621, "end_time": "2021-10-10T16:36:16.878164", "exception": false, "start_time": "2021-10-10T16:36:16.856543", "status": "completed"}, "tags": []}, "source": ["## Congratulations - Time to Join the Community!\n", "\n", "Congratulations on completing this notebook tutorial! If you enjoyed this and would like to join the Lightning\n", "movement, you can do so in the following ways!\n", "\n", "### Star [Lightning](https://github.com/PyTorchLightning/pytorch-lightning) on GitHub\n", "The easiest way to help our community is just by starring the GitHub repos! This helps raise awareness of the cool\n", "tools we're building.\n", "\n", "### Join our [Slack](https://join.slack.com/t/pytorch-lightning/shared_invite/zt-pw5v393p-qRaDgEk24~EjiZNBpSQFgQ)!\n", "The best way to keep up to date on the latest advancements is to join our community! Make sure to introduce yourself\n", "and share your interests in `#general` channel\n", "\n", "\n", "### Contributions !\n", "The best way to contribute to our community is to become a code contributor! At any time you can go to\n", "[Lightning](https://github.com/PyTorchLightning/pytorch-lightning) or [Bolt](https://github.com/PyTorchLightning/lightning-bolts)\n", "GitHub Issues page and filter for \"good first issue\".\n", "\n", "* [Lightning good first issue](https://github.com/PyTorchLightning/pytorch-lightning/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22)\n", "* [Bolt good first issue](https://github.com/PyTorchLightning/lightning-bolts/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22)\n", "* You can also contribute your own notebooks with useful examples !\n", "\n", "### Great thanks from the entire Pytorch Lightning Team for your interest !\n", "\n", "{height=\"60px\" width=\"240px\"}"]}, {"cell_type": "raw", "metadata": {"raw_mimetype": "text/restructuredtext"}, "source": [".. customcarditem::\n", " :header: Tutorial 11: Vision Transformers\n", " :card_description: In this tutorial, we will take a closer look at a recent new trend: Transformers for Computer Vision. Since [Alexey Dosovitskiy et...\n", " :tags: Image,GPU/TPU,UvA-DL-Course\n", " :image: _static/images/course_UvA-DL/11-vision-transformer.jpg"]}], "metadata": {"jupytext": {"cell_metadata_filter": "colab,colab_type,id,-all", "formats": "ipynb,py:percent", "main_language": "python"}, "language_info": {"codemirror_mode": {"name": "ipython", "version": 3}, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.7"}, "papermill": {"default_parameters": {}, "duration": 17.019243, "end_time": "2021-10-10T16:36:17.607886", "environment_variables": {}, "exception": null, "input_path": "course_UvA-DL/11-vision-transformer/Vision_Transformer.ipynb", "output_path": ".notebooks/course_UvA-DL/11-vision-transformer.ipynb", "parameters": {}, "start_time": "2021-10-10T16:36:00.588643", "version": "2.3.3"}, "widgets": {"application/vnd.jupyter.widget-state+json": {"state": {"06ecaa193abb4c6599f94a9a7e64de8f": {"model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HBoxModel", "state": {"_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HBoxView", "box_style": "", "children": ["IPY_MODEL_262db12adb4a4eb8a01537b1fbbac6a7", "IPY_MODEL_de04ee4e69b34edbb4623993191f18ff", "IPY_MODEL_34d1be73a2424261976f78e8ebd2f3b9"], "layout": "IPY_MODEL_3cf6ceecdcc04e9ea8214064fe78c0cc"}}, "07ce532be9e048b4a36844396612f0d6": {"model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "DescriptionStyleModel", "state": {"_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "description_width": ""}}, "112f161d8d5e4d6892247a723f5c42d7": {"model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HTMLModel", "state": {"_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HTMLView", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_88a70622b99e4603992ebe4a8310647a", "placeholder": "\u200b", "style": "IPY_MODEL_07ce532be9e048b4a36844396612f0d6", "value": "Testing: 100%"}}, "21c8daba50c54686b687787528812f0a": {"model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "DescriptionStyleModel", "state": {"_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "description_width": ""}}, "24c3fc2871254a43a96cb796a4246134": {"model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HTMLModel", "state": {"_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HTMLView", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_be78b541f4774bcba63ff910d8f1ce22", "placeholder": "\u200b", "style": "IPY_MODEL_21c8daba50c54686b687787528812f0a", "value": " 40/40 [00:00<00:00, 47.98it/s]"}}, "262db12adb4a4eb8a01537b1fbbac6a7": {"model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HTMLModel", "state": {"_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HTMLView", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_d1ce9a66c073476d9c101cd69731611d", "placeholder": "\u200b", "style": "IPY_MODEL_654debaf094149e09b6c3423310b596c", "value": "Testing: 100%"}}, "2824556005cc42f79c31cbebe248b150": {"model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HBoxModel", "state": {"_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HBoxView", "box_style": "", "children": ["IPY_MODEL_112f161d8d5e4d6892247a723f5c42d7", "IPY_MODEL_b29fce5508ba479589e3f4b0d0c593ae", "IPY_MODEL_24c3fc2871254a43a96cb796a4246134"], "layout": "IPY_MODEL_d1dd5a2d9d904ef3949b431c81e9f5ad"}}, "34d1be73a2424261976f78e8ebd2f3b9": {"model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HTMLModel", "state": {"_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HTMLView", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_8511d9a6c88540a893dd44dd16362e6b", "placeholder": "\u200b", "style": "IPY_MODEL_ce9b4471f190492182eb11d93560a81b", "value": " 79/79 [00:01<00:00, 49.85it/s]"}}, "3cf6ceecdcc04e9ea8214064fe78c0cc": {"model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": {"_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": "inline-flex", "flex": null, "flex_flow": "row wrap", "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": "100%"}}, "654debaf094149e09b6c3423310b596c": {"model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "DescriptionStyleModel", "state": {"_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "description_width": ""}}, "688aa138fc5148bf85f1c48377198169": {"model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": {"_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": "2", "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null}}, "8511d9a6c88540a893dd44dd16362e6b": {"model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": {"_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null}}, "88a70622b99e4603992ebe4a8310647a": {"model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": {"_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null}}, "a5c301fa41b34ea29fc9e3745f950ce2": {"model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": {"_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": "2", "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null}}, "b29fce5508ba479589e3f4b0d0c593ae": {"model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "FloatProgressModel", "state": {"_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "ProgressView", "bar_style": "success", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_a5c301fa41b34ea29fc9e3745f950ce2", "max": 1.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_d1bd9770a9c04cc687a41b9da1507b7c", "value": 1.0}}, "b4d671d57ae7430b9f8b46f5dd95be19": {"model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "ProgressStyleModel", "state": {"_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "bar_color": null, "description_width": ""}}, "be78b541f4774bcba63ff910d8f1ce22": {"model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": {"_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null}}, "ce9b4471f190492182eb11d93560a81b": {"model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "DescriptionStyleModel", "state": {"_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "description_width": ""}}, "d1bd9770a9c04cc687a41b9da1507b7c": {"model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "ProgressStyleModel", "state": {"_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "bar_color": null, "description_width": ""}}, "d1ce9a66c073476d9c101cd69731611d": {"model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": {"_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null}}, "d1dd5a2d9d904ef3949b431c81e9f5ad": {"model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": {"_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": "inline-flex", "flex": null, "flex_flow": "row wrap", "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": "100%"}}, "de04ee4e69b34edbb4623993191f18ff": {"model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "FloatProgressModel", "state": {"_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "ProgressView", "bar_style": "success", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_688aa138fc5148bf85f1c48377198169", "max": 1.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_b4d671d57ae7430b9f8b46f5dd95be19", "value": 1.0}}}, "version_major": 2, "version_minor": 0}}}, "nbformat": 4, "nbformat_minor": 5}
![](\"https://github.com/PyTorchLightning/lightning-tutorials/raw/main/course_UvA-DL/11-vision-transformer/vit_architecture.png\")
![](\"https://github.com/PyTorchLightning/lightning-tutorials/raw/main/course_UvA-DL/11-vision-transformer/pre_layer_norm.svg\")
![](\"https://github.com/PyTorchLightning/lightning-tutorials/raw/main/course_UvA-DL/11-vision-transformer/tensorboard_screenshot.png\")