{"cells": [{"cell_type": "markdown", "id": "eebbf6fc", "metadata": {"papermill": {"duration": 0.005954, "end_time": "2022-05-03T01:17:20.213242", "exception": false, "start_time": "2022-05-03T01:17:20.207288", "status": "completed"}, "tags": []}, "source": ["\n", "# Tutorial 11: Vision Transformers\n", "\n", "* **Author:** Phillip Lippe\n", "* **License:** CC BY-SA\n", "* **Generated:** 2022-05-03T02:43:19.157102\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/stable/)\n", "| Join us [on Slack](https://www.pytorchlightning.ai/community)"]}, {"cell_type": "markdown", "id": "ae377bba", "metadata": {"papermill": {"duration": 0.004156, "end_time": "2022-05-03T01:17:20.222145", "exception": false, "start_time": "2022-05-03T01:17:20.217989", "status": "completed"}, "tags": []}, "source": ["## Setup\n", "This notebook requires some packages besides pytorch-lightning."]}, {"cell_type": "code", "execution_count": 1, "id": "cdb9a52b", "metadata": {"colab": {}, "colab_type": "code", "execution": {"iopub.execute_input": "2022-05-03T01:17:20.232412Z", "iopub.status.busy": "2022-05-03T01:17:20.231987Z", "iopub.status.idle": "2022-05-03T01:17:23.952555Z", "shell.execute_reply": "2022-05-03T01:17:23.951656Z"}, "id": "LfrJLKPFyhsK", "lines_to_next_cell": 0, "papermill": {"duration": 3.728566, "end_time": "2022-05-03T01:17:23.954910", "exception": false, "start_time": "2022-05-03T01:17:20.226344", "status": "completed"}, "tags": []}, "outputs": [], "source": ["! pip install --quiet \"setuptools==59.5.0\" \"pytorch-lightning>=1.4\" \"matplotlib\" \"torch>=1.8\" \"ipython[notebook]\" \"torchmetrics>=0.7\" \"torchvision\" \"seaborn\""]}, {"cell_type": "markdown", "id": "5fd97ab1", "metadata": {"papermill": {"duration": 0.004396, "end_time": "2022-05-03T01:17:23.964380", "exception": false, "start_time": "2022-05-03T01:17:23.959984", "status": "completed"}, "tags": []}, "source": ["
\n", "Let's start with importing our standard set of libraries."]}, {"cell_type": "code", "execution_count": 2, "id": "1531e42e", "metadata": {"execution": {"iopub.execute_input": "2022-05-03T01:17:23.974262Z", "iopub.status.busy": "2022-05-03T01:17:23.973981Z", "iopub.status.idle": "2022-05-03T01:17:27.209603Z", "shell.execute_reply": "2022-05-03T01:17:27.208919Z"}, "papermill": {"duration": 3.242624, "end_time": "2022-05-03T01:17:27.211198", "exception": false, "start_time": "2022-05-03T01:17:23.968574", "status": "completed"}, "tags": []}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["/usr/lib/python3.8/site-packages/apex/pyprof/__init__.py:5: FutureWarning: pyprof will be removed by the end of June, 2022\n", " warnings.warn(\"pyprof will be removed by the end of June, 2022\", FutureWarning)\n"]}, {"name": "stderr", "output_type": "stream", "text": ["WARNING:root:Bagua cannot detect bundled NCCL library, Bagua will try to use system NCCL instead. If you encounter any error, please run `import bagua_core; bagua_core.install_deps()` or the `bagua_install_deps.py` script to install bundled libraries.\n"]}, {"name": "stderr", "output_type": "stream", "text": ["/tmp/ipykernel_4348/214601731.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"]}], "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": "f9691117", "metadata": {"papermill": {"duration": 0.004669, "end_time": "2022-05-03T01:17:27.223303", "exception": false, "start_time": "2022-05-03T01:17:27.218634", "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": "dd8e211c", "metadata": {"execution": {"iopub.execute_input": "2022-05-03T01:17:27.233909Z", "iopub.status.busy": "2022-05-03T01:17:27.233491Z", "iopub.status.idle": "2022-05-03T01:17:27.715993Z", "shell.execute_reply": "2022-05-03T01:17:27.715318Z"}, "papermill": {"duration": 0.489852, "end_time": "2022-05-03T01:17:27.717637", "exception": false, "start_time": "2022-05-03T01:17:27.227785", "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": "1669f726", "metadata": {"papermill": {"duration": 0.004567, "end_time": "2022-05-03T01:17:27.727610", "exception": false, "start_time": "2022-05-03T01:17:27.723043", "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": "4595be96", "metadata": {"execution": {"iopub.execute_input": "2022-05-03T01:17:27.739906Z", "iopub.status.busy": "2022-05-03T01:17:27.739471Z", "iopub.status.idle": "2022-05-03T01:17:30.572558Z", "shell.execute_reply": "2022-05-03T01:17:30.571888Z"}, "papermill": {"duration": 2.840934, "end_time": "2022-05-03T01:17:30.574652", "exception": false, "start_time": "2022-05-03T01:17:27.733718", "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": "625eb0e2", "metadata": {"lines_to_next_cell": 2, "papermill": {"duration": 0.005677, "end_time": "2022-05-03T01:17:30.587013", "exception": false, "start_time": "2022-05-03T01:17:30.581336", "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": "e48e863d", "metadata": {"execution": {"iopub.execute_input": "2022-05-03T01:17:30.600115Z", "iopub.status.busy": "2022-05-03T01:17:30.599744Z", "iopub.status.idle": "2022-05-03T01:17:30.605187Z", "shell.execute_reply": "2022-05-03T01:17:30.604558Z"}, "papermill": {"duration": 0.014006, "end_time": "2022-05-03T01:17:30.606655", "exception": false, "start_time": "2022-05-03T01:17:30.592649", "status": "completed"}, "tags": []}, "outputs": [], "source": ["def img_to_patch(x, patch_size, flatten_channels=True):\n", " \"\"\"\n", " Inputs:\n", " x - 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": "d5d337e1", "metadata": {"papermill": {"duration": 0.005635, "end_time": "2022-05-03T01:17:30.618252", "exception": false, "start_time": "2022-05-03T01:17:30.612617", "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": "0447a46b", "metadata": {"execution": {"iopub.execute_input": "2022-05-03T01:17:30.630855Z", "iopub.status.busy": "2022-05-03T01:17:30.630323Z", "iopub.status.idle": "2022-05-03T01:17:30.874554Z", "shell.execute_reply": "2022-05-03T01:17:30.873888Z"}, "papermill": {"duration": 0.253495, "end_time": "2022-05-03T01:17:30.877328", "exception": false, "start_time": "2022-05-03T01:17:30.623833", "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": "7e117c18", "metadata": {"lines_to_next_cell": 2, "papermill": {"duration": 0.007619, "end_time": "2022-05-03T01:17:30.893902", "exception": false, "start_time": "2022-05-03T01:17:30.886283", "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": "2fe262a4", "metadata": {"execution": {"iopub.execute_input": "2022-05-03T01:17:30.910484Z", "iopub.status.busy": "2022-05-03T01:17:30.910003Z", "iopub.status.idle": "2022-05-03T01:17:30.915929Z", "shell.execute_reply": "2022-05-03T01:17:30.915333Z"}, "lines_to_next_cell": 2, "papermill": {"duration": 0.015829, "end_time": "2022-05-03T01:17:30.917380", "exception": false, "start_time": "2022-05-03T01:17:30.901551", "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": "d7042630", "metadata": {"lines_to_next_cell": 2, "papermill": {"duration": 0.008273, "end_time": "2022-05-03T01:17:30.933342", "exception": false, "start_time": "2022-05-03T01:17:30.925069", "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": "ad860bbe", "metadata": {"execution": {"iopub.execute_input": "2022-05-03T01:17:30.949682Z", "iopub.status.busy": "2022-05-03T01:17:30.949344Z", "iopub.status.idle": "2022-05-03T01:17:30.957129Z", "shell.execute_reply": "2022-05-03T01:17:30.956565Z"}, "lines_to_next_cell": 2, "papermill": {"duration": 0.017667, "end_time": "2022-05-03T01:17:30.958621", "exception": false, "start_time": "2022-05-03T01:17:30.940954", "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": "c28d8458", "metadata": {"lines_to_next_cell": 2, "papermill": {"duration": 0.01049, "end_time": "2022-05-03T01:17:30.980304", "exception": false, "start_time": "2022-05-03T01:17:30.969814", "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": "dac2e6e6", "metadata": {"execution": {"iopub.execute_input": "2022-05-03T01:17:31.000835Z", "iopub.status.busy": "2022-05-03T01:17:31.000310Z", "iopub.status.idle": "2022-05-03T01:17:31.008003Z", "shell.execute_reply": "2022-05-03T01:17:31.007407Z"}, "lines_to_next_cell": 2, "papermill": {"duration": 0.018102, "end_time": "2022-05-03T01:17:31.009519", "exception": false, "start_time": "2022-05-03T01:17:30.991417", "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": "3182334c", "metadata": {"lines_to_next_cell": 2, "papermill": {"duration": 0.007653, "end_time": "2022-05-03T01:17:31.024755", "exception": false, "start_time": "2022-05-03T01:17:31.017102", "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": "d3a2fae6", "metadata": {"execution": {"iopub.execute_input": "2022-05-03T01:17:31.041214Z", "iopub.status.busy": "2022-05-03T01:17:31.040813Z", "iopub.status.idle": "2022-05-03T01:17:31.047057Z", "shell.execute_reply": "2022-05-03T01:17:31.046467Z"}, "papermill": {"duration": 0.016244, "end_time": "2022-05-03T01:17:31.048572", "exception": false, "start_time": "2022-05-03T01:17:31.032328", "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, dataloaders=val_loader, verbose=False)\n", " test_result = trainer.test(model, 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": "9e70fa11", "metadata": {"papermill": {"duration": 0.007771, "end_time": "2022-05-03T01:17:31.063969", "exception": false, "start_time": "2022-05-03T01:17:31.056198", "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": "1f1be119", "metadata": {"execution": {"iopub.execute_input": "2022-05-03T01:17:31.080364Z", "iopub.status.busy": "2022-05-03T01:17:31.079966Z", "iopub.status.idle": "2022-05-03T01:17:38.675086Z", "shell.execute_reply": "2022-05-03T01:17:38.674392Z"}, "papermill": {"duration": 7.605082, "end_time": "2022-05-03T01:17:38.676696", "exception": false, "start_time": "2022-05-03T01:17:31.071614", "status": "completed"}, "tags": []}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["/home/AzDevOps_azpcontainer/.local/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/callback_connector.py:96: LightningDeprecationWarning: Setting `Trainer(progress_bar_refresh_rate=1)` is deprecated in v1.5 and will be removed in v1.7. Please pass `pytorch_lightning.callbacks.progress.TQDMProgressBar` with `refresh_rate` directly to the Trainer's `callbacks` argument instead. Or, to disable the progress bar pass `enable_progress_bar = False` to the Trainer.\n", " rank_zero_deprecation(\n", "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": "stderr", "output_type": "stream", "text": ["HPU available: False, using: 0 HPUs\n"]}, {"name": "stdout", "output_type": "stream", "text": ["Found pretrained model at saved_models/VisionTransformers/ViT.ckpt, loading...\n"]}, {"name": "stderr", "output_type": "stream", "text": ["Missing logger folder: saved_models/VisionTransformers/ViT/lightning_logs\n"]}, {"name": "stderr", "output_type": "stream", "text": ["LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n"]}, {"name": "stderr", "output_type": "stream", "text": ["/usr/local/lib/python3.8/dist-packages/torch/_tensor.py:575: UserWarning: floor_divide is deprecated, and will be removed in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values.\n", "To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor'). (Triggered internally at ../aten/src/ATen/native/BinaryOps.cpp:467.)\n", " return torch.floor_divide(self, other)\n"]}, {"data": {"application/vnd.jupyter.widget-view+json": {"model_id": "d2abe95bdab440069d9d2fc1aa99c8c8", "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": "02bf08b6012046d09f5c99638d19d052", "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": "fd727522", "metadata": {"papermill": {"duration": 0.008258, "end_time": "2022-05-03T01:17:38.694449", "exception": false, "start_time": "2022-05-03T01:17:38.686191", "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": "692021b1", "metadata": {"execution": {"iopub.execute_input": "2022-05-03T01:17:38.712378Z", "iopub.status.busy": "2022-05-03T01:17:38.712074Z", "iopub.status.idle": "2022-05-03T01:17:40.282410Z", "shell.execute_reply": "2022-05-03T01:17:40.281657Z"}, "papermill": {"duration": 1.581353, "end_time": "2022-05-03T01:17:40.284034", "exception": false, "start_time": "2022-05-03T01:17:38.702681", "status": "completed"}, "tags": []}, "outputs": [{"data": {"text/html": ["\n", " \n", " \n", " "], "text/plain": [""]}, "metadata": {}, "output_type": "display_data"}], "source": ["# Opens tensorboard in notebook. Adjust the path to your CHECKPOINT_PATH!\n", "%tensorboard --logdir ../saved_models/tutorial15/tensorboards/"]}, {"cell_type": "markdown", "id": "560426e2", "metadata": {"papermill": {"duration": 0.00826, "end_time": "2022-05-03T01:17:40.301798", "exception": false, "start_time": "2022-05-03T01:17:40.293538", "status": "completed"}, "tags": []}, "source": ["
"]}, {"cell_type": "markdown", "id": "207eb77d", "metadata": {"papermill": {"duration": 0.008522, "end_time": "2022-05-03T01:17:40.318602", "exception": false, "start_time": "2022-05-03T01:17:40.310080", "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": "962f994a", "metadata": {"papermill": {"duration": 0.008373, "end_time": "2022-05-03T01:17:40.335261", "exception": false, "start_time": "2022-05-03T01:17:40.326888", "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": "d8f4c6ea", "metadata": {"papermill": {"duration": 0.008363, "end_time": "2022-05-03T01:17:40.352069", "exception": false, "start_time": "2022-05-03T01:17:40.343706", "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://www.pytorchlightning.ai/community)!\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\"}](https://pytorchlightning.ai)"]}, {"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.8.10"}, "papermill": {"default_parameters": {}, "duration": 24.542489, "end_time": "2022-05-03T01:17:43.180500", "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": "2022-05-03T01:17:18.638011", "version": "2.3.4"}, "widgets": {"application/vnd.jupyter.widget-state+json": {"state": {"00f7b46d24594d49ae7293427dc19bea": {"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}}, "02bf08b6012046d09f5c99638d19d052": {"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_e54b3ffa9fc240dc93fa1aa70523643e", "IPY_MODEL_a6bcc3b8b4244605953f18de3efc8a4d", "IPY_MODEL_3f4a97dc31e246f980f50a8c4cab07c6"], "layout": "IPY_MODEL_12c4051743024f90b9114d29625aadcb"}}, "0428e543801d44a7aad4104f8abb69b0": {"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%"}}, "12c4051743024f90b9114d29625aadcb": {"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%"}}, "13a00a1dab71483d94b79ac610f95041": {"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": ""}}, "3002d0353bdc4f1fb74eddee1d5a7848": {"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": ""}}, "3f4a97dc31e246f980f50a8c4cab07c6": {"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_89e192d1314041bc979153567168529e", "placeholder": "\u200b", "style": "IPY_MODEL_a05eebbc06a945dfbabf45edb8f2ac2f", "value": " 79/79 [00:01<00:00, 77.22it/s]"}}, "574968baca404662bd31c1923f932620": {"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_620d75f5159c4be69779556e711c7da9", "max": 1.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_13a00a1dab71483d94b79ac610f95041", "value": 1.0}}, "620d75f5159c4be69779556e711c7da9": {"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}}, "842758efc7d04ffd9c718c666d9d382a": {"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}}, "89e192d1314041bc979153567168529e": {"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}}, "8fdd4e4e2eba4c15a50690a6d524eb8c": {"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": ""}}, "97e6b008666643ae9f75b23533112e0f": {"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_00f7b46d24594d49ae7293427dc19bea", "placeholder": "\u200b", "style": "IPY_MODEL_3002d0353bdc4f1fb74eddee1d5a7848", "value": "Testing DataLoader 0: 100%"}}, "a05eebbc06a945dfbabf45edb8f2ac2f": {"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": ""}}, "a6bcc3b8b4244605953f18de3efc8a4d": {"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_f2e505d8fa414183afa002934aadfbcc", "max": 1.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_8fdd4e4e2eba4c15a50690a6d524eb8c", "value": 1.0}}, "d2abe95bdab440069d9d2fc1aa99c8c8": {"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_97e6b008666643ae9f75b23533112e0f", "IPY_MODEL_574968baca404662bd31c1923f932620", "IPY_MODEL_f1f43e14cae747148cd21c222a6c4cb1"], "layout": "IPY_MODEL_0428e543801d44a7aad4104f8abb69b0"}}, "e54b3ffa9fc240dc93fa1aa70523643e": {"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_efdaa4b35e5540329034886d166a4497", "placeholder": "\u200b", "style": "IPY_MODEL_e9a01a39d8d143008f4f6fa44299fd91", "value": "Testing DataLoader 0: 100%"}}, "e9a01a39d8d143008f4f6fa44299fd91": {"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": ""}}, "eb1ddfc9f3604f93973c82fef4aaa435": {"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": ""}}, "efdaa4b35e5540329034886d166a4497": {"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}}, "f1f43e14cae747148cd21c222a6c4cb1": {"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_842758efc7d04ffd9c718c666d9d382a", "placeholder": "\u200b", "style": "IPY_MODEL_eb1ddfc9f3604f93973c82fef4aaa435", "value": " 40/40 [00:00<00:00, 61.66it/s]"}}, "f2e505d8fa414183afa002934aadfbcc": {"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}}}, "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\")