{"cells": [{"cell_type": "markdown", "id": "eeb0607e", "metadata": {"papermill": {"duration": 0.006215, "end_time": "2023-10-11T16:48:23.514437", "exception": false, "start_time": "2023-10-11T16:48:23.508222", "status": "completed"}, "tags": []}, "source": ["\n", "# Tutorial 11: Vision Transformers\n", "\n", "* **Author:** Phillip Lippe\n", "* **License:** CC BY-SA\n", "* **Generated:** 2023-10-11T16:46:16.362239\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/Lightning-AI/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": "c1728e3f", "metadata": {"papermill": {"duration": 0.005237, "end_time": "2023-10-11T16:48:23.525178", "exception": false, "start_time": "2023-10-11T16:48:23.519941", "status": "completed"}, "tags": []}, "source": ["## Setup\n", "This notebook requires some packages besides pytorch-lightning."]}, {"cell_type": "code", "execution_count": 1, "id": "d2bedfbc", "metadata": {"colab": {}, "colab_type": "code", "execution": {"iopub.execute_input": "2023-10-11T16:48:23.537626Z", "iopub.status.busy": "2023-10-11T16:48:23.536968Z", "iopub.status.idle": "2023-10-11T16:49:56.146882Z", "shell.execute_reply": "2023-10-11T16:49:56.145589Z"}, "id": "LfrJLKPFyhsK", "lines_to_next_cell": 0, "papermill": {"duration": 92.618353, "end_time": "2023-10-11T16:49:56.148949", "exception": false, "start_time": "2023-10-11T16:48:23.530596", "status": "completed"}, "tags": []}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\r\n", "\u001b[0m"]}], "source": ["! pip install --quiet \"ipython[notebook]>=8.0.0, <8.17.0\" \"setuptools>=68.0.0, <68.3.0\" \"tensorboard\" \"lightning>=2.0.0\" \"urllib3\" \"torch>=1.8.1, <2.1.0\" \"matplotlib\" \"pytorch-lightning>=1.4, <2.1.0\" \"seaborn\" \"torchvision\" \"torchmetrics>=0.7, <1.3\" \"matplotlib>=3.0.0, <3.9.0\""]}, {"cell_type": "markdown", "id": "fc77b35e", "metadata": {"papermill": {"duration": 0.00551, "end_time": "2023-10-11T16:49:56.160131", "exception": false, "start_time": "2023-10-11T16:49:56.154621", "status": "completed"}, "tags": []}, "source": ["
\n", "Let's start with importing our standard set of libraries."]}, {"cell_type": "code", "execution_count": 2, "id": "50922f13", "metadata": {"execution": {"iopub.execute_input": "2023-10-11T16:49:56.172985Z", "iopub.status.busy": "2023-10-11T16:49:56.172615Z", "iopub.status.idle": "2023-10-11T16:49:59.980676Z", "shell.execute_reply": "2023-10-11T16:49:59.979713Z"}, "papermill": {"duration": 3.817581, "end_time": "2023-10-11T16:49:59.983216", "exception": false, "start_time": "2023-10-11T16:49:56.165635", "status": "completed"}, "tags": []}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["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 lightning as L\n", "import matplotlib\n", "import matplotlib.pyplot as plt\n", "import matplotlib_inline.backend_inline\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 lightning.pytorch.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", "matplotlib_inline.backend_inline.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", "L.seed_everything(42)\n", "\n", "# Ensure that all operations are deterministic on GPU (if used) for reproducibility\n", "torch.backends.cudnn.deterministic = 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": "602a93e6", "metadata": {"papermill": {"duration": 0.009096, "end_time": "2023-10-11T16:50:00.002063", "exception": false, "start_time": "2023-10-11T16:49:59.992967", "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": "27596d37", "metadata": {"execution": {"iopub.execute_input": "2023-10-11T16:50:00.022441Z", "iopub.status.busy": "2023-10-11T16:50:00.021661Z", "iopub.status.idle": "2023-10-11T16:50:01.032554Z", "shell.execute_reply": "2023-10-11T16:50:01.031404Z"}, "papermill": {"duration": 1.023518, "end_time": "2023-10-11T16:50:01.034574", "exception": false, "start_time": "2023-10-11T16:50:00.011056", "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": "8be381c1", "metadata": {"papermill": {"duration": 0.005873, "end_time": "2023-10-11T16:50:01.046626", "exception": false, "start_time": "2023-10-11T16:50:01.040753", "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": "0b38ed9f", "metadata": {"execution": {"iopub.execute_input": "2023-10-11T16:50:01.060548Z", "iopub.status.busy": "2023-10-11T16:50:01.060165Z", "iopub.status.idle": "2023-10-11T16:50:09.154891Z", "shell.execute_reply": "2023-10-11T16:50:09.154223Z"}, "papermill": {"duration": 8.10378, "end_time": "2023-10-11T16:50:09.156597", "exception": false, "start_time": "2023-10-11T16:50:01.052817", "status": "completed"}, "tags": []}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to /__w/13/s/.datasets/cifar-10-python.tar.gz\n"]}, {"name": "stderr", "output_type": "stream", "text": ["\r", " 0%| | 0/170498071 [00:00\n", "\n", "\n"], "text/plain": [""]}, "metadata": {}, "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", "L.seed_everything(42)\n", "train_set, _ = torch.utils.data.random_split(train_dataset, [45000, 5000])\n", "L.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": "42b9a82b", "metadata": {"lines_to_next_cell": 2, "papermill": {"duration": 0.007534, "end_time": "2023-10-11T16:50:09.172842", "exception": false, "start_time": "2023-10-11T16:50:09.165308", "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": "0e3c688d", "metadata": {"execution": {"iopub.execute_input": "2023-10-11T16:50:09.189034Z", "iopub.status.busy": "2023-10-11T16:50:09.188813Z", "iopub.status.idle": "2023-10-11T16:50:09.193435Z", "shell.execute_reply": "2023-10-11T16:50:09.192940Z"}, "papermill": {"duration": 0.014257, "end_time": "2023-10-11T16:50:09.194617", "exception": false, "start_time": "2023-10-11T16:50:09.180360", "status": "completed"}, "tags": []}, "outputs": [], "source": ["def img_to_patch(x, patch_size, flatten_channels=True):\n", " \"\"\"\n", " Args:\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": "8d560b31", "metadata": {"papermill": {"duration": 0.007673, "end_time": "2023-10-11T16:50:09.209899", "exception": false, "start_time": "2023-10-11T16:50:09.202226", "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": "42cc2515", "metadata": {"execution": {"iopub.execute_input": "2023-10-11T16:50:09.225751Z", "iopub.status.busy": "2023-10-11T16:50:09.225539Z", "iopub.status.idle": "2023-10-11T16:50:09.385274Z", "shell.execute_reply": "2023-10-11T16:50:09.384635Z"}, "papermill": {"duration": 0.170414, "end_time": "2023-10-11T16:50:09.387841", "exception": false, "start_time": "2023-10-11T16:50:09.217427", "status": "completed"}, "tags": []}, "outputs": [{"data": {"application/pdf": "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", "image/svg+xml": ["\n", "\n", "\n"], "text/plain": [""]}, "metadata": {}, "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": "fce03264", "metadata": {"lines_to_next_cell": 2, "papermill": {"duration": 0.011124, "end_time": "2023-10-11T16:50:09.411257", "exception": false, "start_time": "2023-10-11T16:50:09.400133", "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": "b3e96682", "metadata": {"execution": {"iopub.execute_input": "2023-10-11T16:50:09.434681Z", "iopub.status.busy": "2023-10-11T16:50:09.434404Z", "iopub.status.idle": "2023-10-11T16:50:09.441612Z", "shell.execute_reply": "2023-10-11T16:50:09.440899Z"}, "lines_to_next_cell": 2, "papermill": {"duration": 0.020464, "end_time": "2023-10-11T16:50:09.442831", "exception": false, "start_time": "2023-10-11T16:50:09.422367", "status": "completed"}, "tags": []}, "outputs": [], "source": ["class AttentionBlock(nn.Module):\n", " def __init__(self, embed_dim, hidden_dim, num_heads, dropout=0.0):\n", " \"\"\"Attention Block.\n", "\n", " Args:\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": "389c288f", "metadata": {"lines_to_next_cell": 2, "papermill": {"duration": 0.011039, "end_time": "2023-10-11T16:50:09.464960", "exception": false, "start_time": "2023-10-11T16:50:09.453921", "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": "d8000482", "metadata": {"execution": {"iopub.execute_input": "2023-10-11T16:50:09.488518Z", "iopub.status.busy": "2023-10-11T16:50:09.488085Z", "iopub.status.idle": "2023-10-11T16:50:09.497693Z", "shell.execute_reply": "2023-10-11T16:50:09.497152Z"}, "lines_to_next_cell": 2, "papermill": {"duration": 0.022778, "end_time": "2023-10-11T16:50:09.498866", "exception": false, "start_time": "2023-10-11T16:50:09.476088", "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", " \"\"\"Vision Transformer.\n", "\n", " Args:\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": "bbbbec8f", "metadata": {"lines_to_next_cell": 2, "papermill": {"duration": 0.01115, "end_time": "2023-10-11T16:50:09.521246", "exception": false, "start_time": "2023-10-11T16:50:09.510096", "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": "c23f32f8", "metadata": {"execution": {"iopub.execute_input": "2023-10-11T16:50:09.547231Z", "iopub.status.busy": "2023-10-11T16:50:09.546699Z", "iopub.status.idle": "2023-10-11T16:50:09.558648Z", "shell.execute_reply": "2023-10-11T16:50:09.557958Z"}, "lines_to_next_cell": 2, "papermill": {"duration": 0.027538, "end_time": "2023-10-11T16:50:09.559836", "exception": false, "start_time": "2023-10-11T16:50:09.532298", "status": "completed"}, "tags": []}, "outputs": [], "source": ["class ViT(L.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": "d6db3bc8", "metadata": {"lines_to_next_cell": 2, "papermill": {"duration": 0.011049, "end_time": "2023-10-11T16:50:09.582211", "exception": false, "start_time": "2023-10-11T16:50:09.571162", "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": "c340d778", "metadata": {"execution": {"iopub.execute_input": "2023-10-11T16:50:09.639607Z", "iopub.status.busy": "2023-10-11T16:50:09.639152Z", "iopub.status.idle": "2023-10-11T16:50:09.646206Z", "shell.execute_reply": "2023-10-11T16:50:09.645571Z"}, "papermill": {"duration": 0.054221, "end_time": "2023-10-11T16:50:09.647472", "exception": false, "start_time": "2023-10-11T16:50:09.593251", "status": "completed"}, "tags": []}, "outputs": [], "source": ["def train_model(**kwargs):\n", " trainer = L.Trainer(\n", " default_root_dir=os.path.join(CHECKPOINT_PATH, \"ViT\"),\n", " accelerator=\"auto\",\n", " devices=1,\n", " max_epochs=180,\n", " callbacks=[\n", " ModelCheckpoint(save_weights_only=True, mode=\"max\", monitor=\"val_acc\"),\n", " LearningRateMonitor(\"epoch\"),\n", " ],\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", " L.seed_everything(42) # To be reproducible\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": "d8950685", "metadata": {"papermill": {"duration": 0.011171, "end_time": "2023-10-11T16:50:09.670245", "exception": false, "start_time": "2023-10-11T16:50:09.659074", "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": "4bdd2011", "metadata": {"execution": {"iopub.execute_input": "2023-10-11T16:50:09.693708Z", "iopub.status.busy": "2023-10-11T16:50:09.693241Z", "iopub.status.idle": "2023-10-11T16:50:14.235512Z", "shell.execute_reply": "2023-10-11T16:50:14.234884Z"}, "papermill": {"duration": 4.555732, "end_time": "2023-10-11T16:50:14.237177", "exception": false, "start_time": "2023-10-11T16:50:09.681445", "status": "completed"}, "tags": []}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["GPU available: True (cuda), 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": ["Lightning automatically upgraded your loaded checkpoint from v1.6.4 to v2.0.9.post0. To apply the upgrade to your files permanently, run `python -m lightning.pytorch.utilities.upgrade_checkpoint --file saved_models/VisionTransformers/ViT.ckpt`\n"]}, {"name": "stderr", "output_type": "stream", "text": ["You are using a CUDA device ('NVIDIA GeForce RTX 3090') that has Tensor Cores. To properly utilize them, you should set `torch.set_float32_matmul_precision('medium' | 'high')` which will trade-off precision for performance. For more details, read https://pytorch.org/docs/stable/generated/torch.set_float32_matmul_precision.html#torch.set_float32_matmul_precision\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: [6,7]\n"]}, {"data": {"application/vnd.jupyter.widget-view+json": {"model_id": "07213871d777412bbdd751397b4b2ae2", "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: [6,7]\n"]}, {"data": {"application/vnd.jupyter.widget-view+json": {"model_id": "ba4380f790d342218f4586de3b26bd3a", "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.7713000178337097, 'val': 0.7781999707221985}\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": "0209f85a", "metadata": {"papermill": {"duration": 0.0121, "end_time": "2023-10-11T16:50:14.262011", "exception": false, "start_time": "2023-10-11T16:50:14.249911", "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": "a883635e", "metadata": {"execution": {"iopub.execute_input": "2023-10-11T16:50:14.287852Z", "iopub.status.busy": "2023-10-11T16:50:14.287203Z", "iopub.status.idle": "2023-10-11T16:50:15.299485Z", "shell.execute_reply": "2023-10-11T16:50:15.298399Z"}, "papermill": {"duration": 1.027256, "end_time": "2023-10-11T16:50:15.301321", "exception": false, "start_time": "2023-10-11T16:50:14.274065", "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": "39f40ab3", "metadata": {"papermill": {"duration": 0.012167, "end_time": "2023-10-11T16:50:15.325727", "exception": false, "start_time": "2023-10-11T16:50:15.313560", "status": "completed"}, "tags": []}, "source": ["
"]}, {"cell_type": "markdown", "id": "1c17d2d1", "metadata": {"papermill": {"duration": 0.012059, "end_time": "2023-10-11T16:50:15.350065", "exception": false, "start_time": "2023-10-11T16:50:15.338006", "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": "7465d825", "metadata": {"papermill": {"duration": 0.012063, "end_time": "2023-10-11T16:50:15.374300", "exception": false, "start_time": "2023-10-11T16:50:15.362237", "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 hierarchy (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": "1bb8b4c5", "metadata": {"papermill": {"duration": 0.012065, "end_time": "2023-10-11T16:50:15.398548", "exception": false, "start_time": "2023-10-11T16:50:15.386483", "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/Lightning-AI/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/Lightning-AI/lightning) or [Bolt](https://github.com/Lightning-AI/lightning-bolts)\n", "GitHub Issues page and filter for \"good first issue\".\n", "\n", "* [Lightning good first issue](https://github.com/Lightning-AI/lightning/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22)\n", "* [Bolt good first issue](https://github.com/Lightning-AI/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": "id,colab,colab_type,-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.10.12"}, "papermill": {"default_parameters": {}, "duration": 115.589197, "end_time": "2023-10-11T16:50:18.231450", "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": "2023-10-11T16:48:22.642253", "version": "2.4.0"}, "widgets": {"application/vnd.jupyter.widget-state+json": {"state": {"060eb30fed1c49f79b7990838253aa6a": {"model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", "state": {"_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "ProgressView", "bar_style": "success", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_487a13dec4a9483d936ef007b4f07410", "max": 79.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_7e8e880bb69b427b9630a0b3a4477960", "tabbable": null, "tooltip": null, "value": 79.0}}, "07213871d777412bbdd751397b4b2ae2": {"model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", "state": {"_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HBoxView", "box_style": "", "children": ["IPY_MODEL_1fef22589dee4f149eac02ed2cd7365a", "IPY_MODEL_c61ace69bc144a41b538f0e0514d5308", "IPY_MODEL_d823dd197dfc476191e1f2e6cd31ff6d"], "layout": "IPY_MODEL_7ae6c93b5cf54a9b86a0cdcc7f8a8bd7", "tabbable": null, "tooltip": null}}, "0a9ab78248684a5886b81c21825d90cc": {"model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": {"_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HTMLView", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_c75a3d2cd19e4fe49b7a21bb7904aa5d", "placeholder": "\u200b", "style": "IPY_MODEL_fcb2290c9ee4473dbf8b44d5c927f877", "tabbable": null, "tooltip": null, "value": "Testing DataLoader 0: 100%"}}, "1fef22589dee4f149eac02ed2cd7365a": {"model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": {"_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HTMLView", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_c4c60f1a88f94534921892740d567db6", "placeholder": "\u200b", "style": "IPY_MODEL_e6524f46ac0b4f86a79a98e976593266", "tabbable": null, "tooltip": null, "value": "Testing DataLoader 0: 100%"}}, "3846494b9cfe4e59a57016c44a1e334d": {"model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": {"_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": 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, "padding": null, "right": null, "top": null, "visibility": null, "width": null}}, "487a13dec4a9483d936ef007b4f07410": {"model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": {"_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": 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, "padding": null, "right": null, "top": null, "visibility": null, "width": null}}, "4bbb2ae0ac6a4fed9cac4294a91ec215": {"model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": {"_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": 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, "padding": null, "right": null, "top": null, "visibility": null, "width": null}}, "6e514ad7197945b29a0ed48c421f00bc": {"model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": {"_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": 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, "padding": null, "right": null, "top": null, "visibility": null, "width": "100%"}}, "71a77047f27f4cbb9a3b3280d4a3c2b4": {"model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", "state": {"_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "bar_color": null, "description_width": ""}}, "7ae6c93b5cf54a9b86a0cdcc7f8a8bd7": {"model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": {"_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": 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, "padding": null, "right": null, "top": null, "visibility": null, "width": "100%"}}, "7e8e880bb69b427b9630a0b3a4477960": {"model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", "state": {"_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "bar_color": null, "description_width": ""}}, "8b8c4c63537b4bd29186bcdd4d5d0f91": {"model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": {"_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HTMLView", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_b0ee2d181b0d4b9f8af378c0a94536e2", "placeholder": "\u200b", "style": "IPY_MODEL_91c75fbacba340839d3ca1e37c475958", "tabbable": null, "tooltip": null, "value": " 79/79 [00:00<00:00, 116.91it/s]"}}, "91c75fbacba340839d3ca1e37c475958": {"model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", "state": {"_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "background": null, "description_width": "", "font_size": null, "text_color": null}}, "b0ee2d181b0d4b9f8af378c0a94536e2": {"model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": {"_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": 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, "padding": null, "right": null, "top": null, "visibility": null, "width": null}}, "ba4380f790d342218f4586de3b26bd3a": {"model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", "state": {"_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HBoxView", "box_style": "", "children": ["IPY_MODEL_0a9ab78248684a5886b81c21825d90cc", "IPY_MODEL_060eb30fed1c49f79b7990838253aa6a", "IPY_MODEL_8b8c4c63537b4bd29186bcdd4d5d0f91"], "layout": "IPY_MODEL_6e514ad7197945b29a0ed48c421f00bc", "tabbable": null, "tooltip": null}}, "c4c60f1a88f94534921892740d567db6": {"model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": {"_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": 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, "padding": null, "right": null, "top": null, "visibility": null, "width": null}}, "c61ace69bc144a41b538f0e0514d5308": {"model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", "state": {"_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "ProgressView", "bar_style": "success", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_4bbb2ae0ac6a4fed9cac4294a91ec215", "max": 40.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_71a77047f27f4cbb9a3b3280d4a3c2b4", "tabbable": null, "tooltip": null, "value": 40.0}}, "c75a3d2cd19e4fe49b7a21bb7904aa5d": {"model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": {"_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": 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, "padding": null, "right": null, "top": null, "visibility": null, "width": null}}, "c87eb70416ac41e891eeb16c6d402ab8": {"model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", "state": {"_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "background": null, "description_width": "", "font_size": null, "text_color": null}}, "d823dd197dfc476191e1f2e6cd31ff6d": {"model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": {"_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HTMLView", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_3846494b9cfe4e59a57016c44a1e334d", "placeholder": "\u200b", "style": "IPY_MODEL_c87eb70416ac41e891eeb16c6d402ab8", "tabbable": null, "tooltip": null, "value": " 40/40 [00:00<00:00, 118.63it/s]"}}, "e6524f46ac0b4f86a79a98e976593266": {"model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", "state": {"_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "background": null, "description_width": "", "font_size": null, "text_color": null}}, "fcb2290c9ee4473dbf8b44d5c927f877": {"model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", "state": {"_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "background": null, "description_width": "", "font_size": null, "text_color": null}}}, "version_major": 2, "version_minor": 0}}}, "nbformat": 4, "nbformat_minor": 5}
![](\"https://github.com/Lightning-AI/lightning-tutorials/raw/main/course_UvA-DL/11-vision-transformer/vit_architecture.png\")
![](\"https://github.com/Lightning-AI/lightning-tutorials/raw/main/course_UvA-DL/11-vision-transformer/pre_layer_norm.svg\")
![](\"https://github.com/Lightning-AI/lightning-tutorials/raw/main/course_UvA-DL/11-vision-transformer/tensorboard_screenshot.png\")