{"cells": [{"cell_type": "markdown", "id": "9b0d3dbf", "metadata": {"papermill": {"duration": 0.012709, "end_time": "2021-10-25T20:00:43.480755", "exception": false, "start_time": "2021-10-25T20:00:43.468046", "status": "completed"}, "tags": []}, "source": ["\n", "# Barlow Twins Tutorial\n", "\n", "* **Author:** Ananya Harsh Jha (ananya@pytorchlightning.ai)\n", "* **License:** CC BY-SA\n", "* **Generated:** 2021-10-25T22:00:34.269471\n", "\n", "This notebook describes the self-supervised learning method Barlow Twins.\n", "Barlow Twins differs from other recently proposed algorithms as it doesn't\n", "fall under the category of either contrastive learning, or methods like knowledge\n", "distillation or clustering. The simplicity of the loss function and its effectiveness\n", "in comparison to the current state of the art makes Barlow Twins an interesting\n", "case study.\n", "\n", "\n", "---\n", "Open in [![Open In Colab](data:image/png;base64,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){height=\"20px\" width=\"117px\"}](https://colab.research.google.com/github/PytorchLightning/lightning-tutorials/blob/publication/.notebooks/lightning_examples/barlow-twins.ipynb)\n", "\n", "Give us a \u2b50 [on Github](https://www.github.com/PytorchLightning/pytorch-lightning/)\n", "| Check out [the documentation](https://pytorch-lightning.readthedocs.io/en/latest/)\n", "| Join us [on Slack](https://join.slack.com/t/pytorch-lightning/shared_invite/zt-pw5v393p-qRaDgEk24~EjiZNBpSQFgQ)"]}, {"cell_type": "markdown", "id": "a0f8a9cf", "metadata": {"papermill": {"duration": 0.011144, "end_time": "2021-10-25T20:00:43.503475", "exception": false, "start_time": "2021-10-25T20:00:43.492331", "status": "completed"}, "tags": []}, "source": ["## Setup\n", "This notebook requires some packages besides pytorch-lightning."]}, {"cell_type": "code", "execution_count": 1, "id": "9ba1fb3e", "metadata": {"colab": {}, "colab_type": "code", "execution": {"iopub.execute_input": "2021-10-25T20:00:43.529599Z", "iopub.status.busy": "2021-10-25T20:00:43.529097Z", "iopub.status.idle": "2021-10-25T20:00:43.531815Z", "shell.execute_reply": "2021-10-25T20:00:43.531280Z"}, "id": "LfrJLKPFyhsK", "lines_to_next_cell": 0, "papermill": {"duration": 0.017035, "end_time": "2021-10-25T20:00:43.531927", "exception": false, "start_time": "2021-10-25T20:00:43.514892", "status": "completed"}, "tags": []}, "outputs": [], "source": ["# ! pip install --quiet \"torch>=1.6, <1.9\" \"torchmetrics>=0.3\" \"torchvision\" \"matplotlib\" \"pytorch-lightning>=1.3\""]}, {"cell_type": "markdown", "id": "23d70cf8", "metadata": {"papermill": {"duration": 0.011167, "end_time": "2021-10-25T20:00:43.554606", "exception": false, "start_time": "2021-10-25T20:00:43.543439", "status": "completed"}, "tags": []}, "source": ["## Barlow Twins\n", "\n", "Barlow Twins finds itself in unique place amongst the current state-of-the-art self-supervised learning methods. It does not fall under the existing categories of contrastive learning, knowledge distillation or clustering based methods. Instead, it creates its own category of redundancy reductionand achieves competitive performance with a simple yet effective loss function. In this tutorial, we look at coding up a small version of Barlow Twins algorithm using PyTorch Lightning."]}, {"cell_type": "code", "execution_count": 2, "id": "29341bf4", "metadata": {"execution": {"iopub.execute_input": "2021-10-25T20:00:43.584461Z", "iopub.status.busy": "2021-10-25T20:00:43.583974Z", "iopub.status.idle": "2021-10-25T20:00:44.983203Z", "shell.execute_reply": "2021-10-25T20:00:44.982750Z"}, "papermill": {"duration": 1.417567, "end_time": "2021-10-25T20:00:44.983322", "exception": false, "start_time": "2021-10-25T20:00:43.565755", "status": "completed"}, "tags": []}, "outputs": [], "source": ["from functools import partial\n", "from typing import Sequence, Tuple, Union\n", "\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import pytorch_lightning as pl\n", "import torch\n", "import torch.nn as nn\n", "import torch.nn.functional as F\n", "import torchvision.transforms as transforms\n", "import torchvision.transforms.functional as VisionF\n", "from pytorch_lightning import Callback, LightningModule, Trainer\n", "from pytorch_lightning.callbacks import ModelCheckpoint\n", "from pytorch_lightning.metrics.functional import accuracy\n", "from torch.utils.data import DataLoader\n", "from torchvision.datasets import CIFAR10\n", "from torchvision.models.resnet import resnet18\n", "from torchvision.utils import make_grid\n", "\n", "batch_size = 32\n", "num_workers = 0  # to run notebook on CPU\n", "max_epochs = 200\n", "z_dim = 128"]}, {"cell_type": "markdown", "id": "721a96db", "metadata": {"papermill": {"duration": 0.011192, "end_time": "2021-10-25T20:00:45.006236", "exception": false, "start_time": "2021-10-25T20:00:44.995044", "status": "completed"}, "tags": []}, "source": ["### Transforms\n", "\n", "We first define the data augmentation pipeline used in Barlow Twins. Here, we use pipeline proposed in SimCLR, which generates two copies/views of an input image by applying the following transformations in a sequence.\n", "\n", "First it takes a random crop of the image and resizes it to a fixed pre-specified size. Then, it applies a left-to-right random flip with a probability of 0.5. This step is followed by a composition of color jitter, conversion to grayscale with a probability of 0.2 and the application of a Gaussian blur filter. Finally, we normalize the image and convert it to a tensor.\n", "\n", "Within this transform, we add a third view for our online finetuner, which we explain later on. But, to explain things quickly here, we add a another transform to perform perform test our encoder on a downstream classification task."]}, {"cell_type": "code", "execution_count": 3, "id": "6cb8b894", "metadata": {"execution": {"iopub.execute_input": "2021-10-25T20:00:45.037011Z", "iopub.status.busy": "2021-10-25T20:00:45.030646Z", "iopub.status.idle": "2021-10-25T20:00:45.038691Z", "shell.execute_reply": "2021-10-25T20:00:45.039079Z"}, "papermill": {"duration": 0.021697, "end_time": "2021-10-25T20:00:45.039192", "exception": false, "start_time": "2021-10-25T20:00:45.017495", "status": "completed"}, "tags": []}, "outputs": [], "source": ["class BarlowTwinsTransform:\n", "    def __init__(self, train=True, input_height=224, gaussian_blur=True, jitter_strength=1.0, normalize=None):\n", "\n", "        self.input_height = input_height\n", "        self.gaussian_blur = gaussian_blur\n", "        self.jitter_strength = jitter_strength\n", "        self.normalize = normalize\n", "        self.train = train\n", "\n", "        color_jitter = transforms.ColorJitter(\n", "            0.8 * self.jitter_strength,\n", "            0.8 * self.jitter_strength,\n", "            0.8 * self.jitter_strength,\n", "            0.2 * self.jitter_strength,\n", "        )\n", "\n", "        color_transform = [transforms.RandomApply([color_jitter], p=0.8), transforms.RandomGrayscale(p=0.2)]\n", "\n", "        if self.gaussian_blur:\n", "            kernel_size = int(0.1 * self.input_height)\n", "            if kernel_size % 2 == 0:\n", "                kernel_size += 1\n", "\n", "            color_transform.append(transforms.RandomApply([transforms.GaussianBlur(kernel_size=kernel_size)], p=0.5))\n", "\n", "        self.color_transform = transforms.Compose(color_transform)\n", "\n", "        if normalize is None:\n", "            self.final_transform = transforms.ToTensor()\n", "        else:\n", "            self.final_transform = transforms.Compose([transforms.ToTensor(), normalize])\n", "\n", "        self.transform = transforms.Compose(\n", "            [\n", "                transforms.RandomResizedCrop(self.input_height),\n", "                transforms.RandomHorizontalFlip(p=0.5),\n", "                self.color_transform,\n", "                self.final_transform,\n", "            ]\n", "        )\n", "\n", "        self.finetune_transform = None\n", "        if self.train:\n", "            self.finetune_transform = transforms.Compose(\n", "                [\n", "                    transforms.RandomCrop(32, padding=4, padding_mode=\"reflect\"),\n", "                    transforms.RandomHorizontalFlip(),\n", "                    transforms.ToTensor(),\n", "                ]\n", "            )\n", "        else:\n", "            self.finetune_transform = transforms.ToTensor()\n", "\n", "    def __call__(self, sample):\n", "        return self.transform(sample), self.transform(sample), self.finetune_transform(sample)"]}, {"cell_type": "markdown", "id": "69b57f48", "metadata": {"papermill": {"duration": 0.011342, "end_time": "2021-10-25T20:00:45.061887", "exception": false, "start_time": "2021-10-25T20:00:45.050545", "status": "completed"}, "tags": []}, "source": ["### Dataset\n", "\n", "We select CIFAR10 as the dataset to demonstrate the pre-training process for Barlow Twins. CIFAR10 images are 32x32 in size and we do not apply a Gaussian blur transformation on them. In this step, we create the training and validation dataloaders for CIFAR10."]}, {"cell_type": "code", "execution_count": 4, "id": "273da819", "metadata": {"execution": {"iopub.execute_input": "2021-10-25T20:00:45.091605Z", "iopub.status.busy": "2021-10-25T20:00:45.086769Z", "iopub.status.idle": "2021-10-25T20:00:49.752232Z", "shell.execute_reply": "2021-10-25T20:00:49.751801Z"}, "papermill": {"duration": 4.679129, "end_time": "2021-10-25T20:00:49.752355", "exception": false, "start_time": "2021-10-25T20:00:45.073226", "status": "completed"}, "tags": []}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./cifar-10-python.tar.gz\n"]}, {"data": {"application/vnd.jupyter.widget-view+json": {"model_id": "b13dfae7160c4c8586c5780f597cd8e4", "version_major": 2, "version_minor": 0}, "text/plain": ["  0%|          | 0/170498071 [00:00<?, ?it/s]"]}, "metadata": {}, "output_type": "display_data"}, {"name": "stdout", "output_type": "stream", "text": ["Extracting ./cifar-10-python.tar.gz to .\n"]}, {"name": "stdout", "output_type": "stream", "text": ["Files already downloaded and verified\n"]}], "source": ["def cifar10_normalization():\n", "    normalize = transforms.Normalize(\n", "        mean=[x / 255.0 for x in [125.3, 123.0, 113.9]], std=[x / 255.0 for x in [63.0, 62.1, 66.7]]\n", "    )\n", "    return normalize\n", "\n", "\n", "train_transform = BarlowTwinsTransform(\n", "    train=True, input_height=32, gaussian_blur=False, jitter_strength=0.5, normalize=cifar10_normalization()\n", ")\n", "train_dataset = CIFAR10(root=\".\", train=True, download=True, transform=train_transform)\n", "\n", "val_transform = BarlowTwinsTransform(\n", "    train=False, input_height=32, gaussian_blur=False, jitter_strength=0.5, normalize=cifar10_normalization()\n", ")\n", "val_dataset = CIFAR10(root=\".\", train=False, download=True, transform=train_transform)\n", "\n", "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=num_workers, drop_last=True)\n", "val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False, num_workers=num_workers, drop_last=True)"]}, {"cell_type": "markdown", "id": "c119f82e", "metadata": {"papermill": {"duration": 0.012485, "end_time": "2021-10-25T20:00:49.778137", "exception": false, "start_time": "2021-10-25T20:00:49.765652", "status": "completed"}, "tags": []}, "source": ["### Plot images\n", "\n", "To see how the CIFAR10 images look after the data augmentation pipeline, we load a few images from the dataloader and plot them here."]}, {"cell_type": "code", "execution_count": 5, "id": "22f7ae3b", "metadata": {"execution": {"iopub.execute_input": "2021-10-25T20:00:49.807780Z", "iopub.status.busy": "2021-10-25T20:00:49.804798Z", "iopub.status.idle": "2021-10-25T20:00:49.997053Z", "shell.execute_reply": "2021-10-25T20:00:49.997465Z"}, "papermill": {"duration": 0.207019, "end_time": "2021-10-25T20:00:49.997613", "exception": false, "start_time": "2021-10-25T20:00:49.790594", "status": "completed"}, "tags": []}, "outputs": [{"data": {"image/png": "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\n", "text/plain": ["<Figure size 432x288 with 1 Axes>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["for batch in val_loader:\n", "    (img1, img2, _), label = batch\n", "    break\n", "\n", "img_grid = make_grid(img1, normalize=True)\n", "\n", "\n", "def show(imgs):\n", "    if not isinstance(imgs, list):\n", "        imgs = [imgs]\n", "    fix, axs = plt.subplots(ncols=len(imgs), squeeze=False)\n", "    for i, img in enumerate(imgs):\n", "        img = img.detach()\n", "        img = VisionF.to_pil_image(img)\n", "        axs[0, i].imshow(np.asarray(img))\n", "        axs[0, i].set(xticklabels=[], yticklabels=[], xticks=[], yticks=[])\n", "\n", "\n", "show(img_grid)"]}, {"cell_type": "markdown", "id": "a0233366", "metadata": {"papermill": {"duration": 0.018776, "end_time": "2021-10-25T20:00:50.033993", "exception": false, "start_time": "2021-10-25T20:00:50.015217", "status": "completed"}, "tags": []}, "source": ["### Barlow Twins Loss\n", "\n", "Here we define the loss function for Barlow Twins. It first normalizes the D dimensinonal vectors from the projection head and then computes the DxD cross-correlation matrix between the normalized vectors of the 2 views of each image.\n", "\n", "Then it splits this cross-correlation matrix into two parts. The first part, the diagonal of this matrix is brought closer to 1, which pushes up the cosine similarity between the latent vectors of two views of each image, thus making the backbone invariant to the transformations applied to the views. The second part of the loss pushes the non-diagonal elements of the cross-corrlelation matrix closes to 0. This reduces the redundancy between the different dimensions of the latent vector."]}, {"cell_type": "code", "execution_count": 6, "id": "7f3f6369", "metadata": {"execution": {"iopub.execute_input": "2021-10-25T20:00:50.069422Z", "iopub.status.busy": "2021-10-25T20:00:50.068917Z", "iopub.status.idle": "2021-10-25T20:00:50.071108Z", "shell.execute_reply": "2021-10-25T20:00:50.070701Z"}, "papermill": {"duration": 0.02278, "end_time": "2021-10-25T20:00:50.071208", "exception": false, "start_time": "2021-10-25T20:00:50.048428", "status": "completed"}, "tags": []}, "outputs": [], "source": ["class BarlowTwinsLoss(nn.Module):\n", "    def __init__(self, batch_size, lambda_coeff=5e-3, z_dim=128):\n", "        super().__init__()\n", "\n", "        self.z_dim = z_dim\n", "        self.batch_size = batch_size\n", "        self.lambda_coeff = lambda_coeff\n", "\n", "    def off_diagonal_ele(self, x):\n", "        # taken from: https://github.com/facebookresearch/barlowtwins/blob/main/main.py\n", "        # return a flattened view of the off-diagonal elements of a square matrix\n", "        n, m = x.shape\n", "        assert n == m\n", "        return x.flatten()[:-1].view(n - 1, n + 1)[:, 1:].flatten()\n", "\n", "    def forward(self, z1, z2):\n", "        # N x D, where N is the batch size and D is output dim of projection head\n", "        z1_norm = (z1 - torch.mean(z1, dim=0)) / torch.std(z1, dim=0)\n", "        z2_norm = (z2 - torch.mean(z2, dim=0)) / torch.std(z2, dim=0)\n", "\n", "        cross_corr = torch.matmul(z1_norm.T, z2_norm) / self.batch_size\n", "\n", "        on_diag = torch.diagonal(cross_corr).add_(-1).pow_(2).sum()\n", "        off_diag = self.off_diagonal_ele(cross_corr).pow_(2).sum()\n", "\n", "        return on_diag + self.lambda_coeff * off_diag"]}, {"cell_type": "markdown", "id": "050c8b3c", "metadata": {"papermill": {"duration": 0.014594, "end_time": "2021-10-25T20:00:50.101352", "exception": false, "start_time": "2021-10-25T20:00:50.086758", "status": "completed"}, "tags": []}, "source": ["### Backbone\n", "\n", "This is a standard Resnet backbone that we pre-train using the Barlow Twins method. To accommodate the 32x32 CIFAR10 images, we replace the first 7x7 convolution of the Resnet backbone by a 3x3 filter. We also remove the first Maxpool layer from the network for CIFAR10 images."]}, {"cell_type": "code", "execution_count": 7, "id": "a1df9ad9", "metadata": {"execution": {"iopub.execute_input": "2021-10-25T20:00:50.134356Z", "iopub.status.busy": "2021-10-25T20:00:50.133886Z", "iopub.status.idle": "2021-10-25T20:00:50.315984Z", "shell.execute_reply": "2021-10-25T20:00:50.315481Z"}, "papermill": {"duration": 0.200049, "end_time": "2021-10-25T20:00:50.316105", "exception": false, "start_time": "2021-10-25T20:00:50.116056", "status": "completed"}, "tags": []}, "outputs": [], "source": ["encoder = resnet18()\n", "\n", "# for CIFAR10, replace the first 7x7 conv with smaller 3x3 conv and remove the first maxpool\n", "encoder.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False)\n", "encoder.maxpool = nn.MaxPool2d(kernel_size=1, stride=1)\n", "\n", "# replace classification fc layer of Resnet to obtain representations from the backbone\n", "encoder.fc = nn.Identity()"]}, {"cell_type": "markdown", "id": "c85b1d8a", "metadata": {"papermill": {"duration": 0.014604, "end_time": "2021-10-25T20:00:50.345738", "exception": false, "start_time": "2021-10-25T20:00:50.331134", "status": "completed"}, "tags": []}, "source": ["### Projection head\n", "\n", "Unlike SimCLR and BYOL, the downstream performance of Barlow Twins greatly benefits from having a larger projection head after the backbone network. The paper utilizes a 3 layer MLP with 8192 hidden dimensions and 8192 as the output dimenion of the projection head. For the purposes of the tutorial, we use a smaller projection head. But, it is imperative to mention here that in practice, Barlow Twins needs to be trained using a bigger projection head as it is highly sensitive to its architecture and output dimensionality."]}, {"cell_type": "code", "execution_count": 8, "id": "62392e1c", "metadata": {"execution": {"iopub.execute_input": "2021-10-25T20:00:50.379426Z", "iopub.status.busy": "2021-10-25T20:00:50.378950Z", "iopub.status.idle": "2021-10-25T20:00:50.380731Z", "shell.execute_reply": "2021-10-25T20:00:50.381114Z"}, "papermill": {"duration": 0.020782, "end_time": "2021-10-25T20:00:50.381232", "exception": false, "start_time": "2021-10-25T20:00:50.360450", "status": "completed"}, "tags": []}, "outputs": [], "source": ["class ProjectionHead(nn.Module):\n", "    def __init__(self, input_dim=2048, hidden_dim=2048, output_dim=128):\n", "        super().__init__()\n", "\n", "        self.projection_head = nn.Sequential(\n", "            nn.Linear(input_dim, hidden_dim, bias=True),\n", "            nn.BatchNorm1d(hidden_dim),\n", "            nn.ReLU(),\n", "            nn.Linear(hidden_dim, output_dim, bias=False),\n", "        )\n", "\n", "    def forward(self, x):\n", "        return self.projection_head(x)"]}, {"cell_type": "markdown", "id": "3b69afcd", "metadata": {"papermill": {"duration": 0.014461, "end_time": "2021-10-25T20:00:50.410233", "exception": false, "start_time": "2021-10-25T20:00:50.395772", "status": "completed"}, "tags": []}, "source": ["### Learning rate warmup\n", "\n", "For the purposes of this tutorial, we keep things simple and use a linear warmup schedule with Adam optimizer. In our previous experiments we have found that linear warmup part is much more important for the final performance of a model than the cosine decay component of the schedule."]}, {"cell_type": "code", "execution_count": 9, "id": "1df8bf31", "metadata": {"execution": {"iopub.execute_input": "2021-10-25T20:00:50.442982Z", "iopub.status.busy": "2021-10-25T20:00:50.442512Z", "iopub.status.idle": "2021-10-25T20:00:50.444620Z", "shell.execute_reply": "2021-10-25T20:00:50.444217Z"}, "papermill": {"duration": 0.019933, "end_time": "2021-10-25T20:00:50.444716", "exception": false, "start_time": "2021-10-25T20:00:50.424783", "status": "completed"}, "tags": []}, "outputs": [], "source": ["def fn(warmup_steps, step):\n", "    if step < warmup_steps:\n", "        return float(step) / float(max(1, warmup_steps))\n", "    else:\n", "        return 1.0\n", "\n", "\n", "def linear_warmup_decay(warmup_steps):\n", "    return partial(fn, warmup_steps)"]}, {"cell_type": "markdown", "id": "0f165fdf", "metadata": {"papermill": {"duration": 0.014653, "end_time": "2021-10-25T20:00:50.473995", "exception": false, "start_time": "2021-10-25T20:00:50.459342", "status": "completed"}, "tags": []}, "source": ["### Barlow Twins Lightning Module\n", "\n", "We keep the LightningModule for Barlow Twins neat and simple. It takes in an backbone encoder and initializes the projection head and the loss function. We configure the optimizer and the learning rate scheduler in the ``configure_optimizers`` method."]}, {"cell_type": "code", "execution_count": 10, "id": "ad94b021", "metadata": {"execution": {"iopub.execute_input": "2021-10-25T20:00:50.511807Z", "iopub.status.busy": "2021-10-25T20:00:50.511324Z", "iopub.status.idle": "2021-10-25T20:00:50.513468Z", "shell.execute_reply": "2021-10-25T20:00:50.512978Z"}, "papermill": {"duration": 0.024798, "end_time": "2021-10-25T20:00:50.513565", "exception": false, "start_time": "2021-10-25T20:00:50.488767", "status": "completed"}, "tags": []}, "outputs": [], "source": ["class BarlowTwins(LightningModule):\n", "    def __init__(\n", "        self,\n", "        encoder,\n", "        encoder_out_dim,\n", "        num_training_samples,\n", "        batch_size,\n", "        lambda_coeff=5e-3,\n", "        z_dim=128,\n", "        learning_rate=1e-4,\n", "        warmup_epochs=10,\n", "        max_epochs=200,\n", "    ):\n", "        super().__init__()\n", "\n", "        self.encoder = encoder\n", "        self.projection_head = ProjectionHead(input_dim=encoder_out_dim, hidden_dim=encoder_out_dim, output_dim=z_dim)\n", "        self.loss_fn = BarlowTwinsLoss(batch_size=batch_size, lambda_coeff=lambda_coeff, z_dim=z_dim)\n", "\n", "        self.learning_rate = learning_rate\n", "        self.warmup_epochs = warmup_epochs\n", "        self.max_epochs = max_epochs\n", "\n", "        self.train_iters_per_epoch = num_training_samples // batch_size\n", "\n", "    def forward(self, x):\n", "        return self.encoder(x)\n", "\n", "    def shared_step(self, batch):\n", "        (x1, x2, _), _ = batch\n", "\n", "        z1 = self.projection_head(self.encoder(x1))\n", "        z2 = self.projection_head(self.encoder(x2))\n", "\n", "        return self.loss_fn(z1, z2)\n", "\n", "    def training_step(self, batch, batch_idx):\n", "        loss = self.shared_step(batch)\n", "\n", "        self.log(\"train_loss\", loss.item(), on_step=True, on_epoch=False)\n", "        return loss\n", "\n", "    def validation_step(self, batch, batch_idx):\n", "        loss = self.shared_step(batch)\n", "\n", "        self.log(\"val_loss\", loss, on_step=False, on_epoch=True)\n", "        return loss\n", "\n", "    def configure_optimizers(self):\n", "        optimizer = torch.optim.Adam(self.parameters(), lr=self.learning_rate)\n", "\n", "        warmup_steps = self.train_iters_per_epoch * self.warmup_epochs\n", "\n", "        scheduler = {\n", "            \"scheduler\": torch.optim.lr_scheduler.LambdaLR(\n", "                optimizer,\n", "                linear_warmup_decay(warmup_steps),\n", "            ),\n", "            \"interval\": \"step\",\n", "            \"frequency\": 1,\n", "        }\n", "\n", "        return [optimizer], [scheduler]"]}, {"cell_type": "markdown", "id": "5ec4d0aa", "metadata": {"papermill": {"duration": 0.014734, "end_time": "2021-10-25T20:00:50.543024", "exception": false, "start_time": "2021-10-25T20:00:50.528290", "status": "completed"}, "tags": []}, "source": ["### Evaluation\n", "\n", "We define a callback which appends a linear layer on top of the encoder and trains the classification evaluation head in an online manner. We make sure not to backpropagate the gradients back to the encoder while tuning the linear layer. This technique was used in SimCLR as well and they showed that the final downstream classification peformance is pretty much similar to the results on online finetuning as the training progresses."]}, {"cell_type": "code", "execution_count": 11, "id": "f271c5a3", "metadata": {"execution": {"iopub.execute_input": "2021-10-25T20:00:50.582976Z", "iopub.status.busy": "2021-10-25T20:00:50.574339Z", "iopub.status.idle": "2021-10-25T20:00:50.585053Z", "shell.execute_reply": "2021-10-25T20:00:50.584582Z"}, "papermill": {"duration": 0.027403, "end_time": "2021-10-25T20:00:50.585148", "exception": false, "start_time": "2021-10-25T20:00:50.557745", "status": "completed"}, "tags": []}, "outputs": [], "source": ["class OnlineFineTuner(Callback):\n", "    def __init__(\n", "        self,\n", "        encoder_output_dim: int,\n", "        num_classes: int,\n", "    ) -> None:\n", "        super().__init__()\n", "\n", "        self.optimizer: torch.optim.Optimizer\n", "\n", "        self.encoder_output_dim = encoder_output_dim\n", "        self.num_classes = num_classes\n", "\n", "    def on_pretrain_routine_start(self, trainer: pl.Trainer, pl_module: pl.LightningModule) -> None:\n", "\n", "        # add linear_eval layer and optimizer\n", "        pl_module.online_finetuner = nn.Linear(self.encoder_output_dim, self.num_classes).to(pl_module.device)\n", "        self.optimizer = torch.optim.Adam(pl_module.online_finetuner.parameters(), lr=1e-4)\n", "\n", "    def extract_online_finetuning_view(\n", "        self, batch: Sequence, device: Union[str, torch.device]\n", "    ) -> Tuple[torch.Tensor, torch.Tensor]:\n", "        (_, _, finetune_view), y = batch\n", "        finetune_view = finetune_view.to(device)\n", "        y = y.to(device)\n", "\n", "        return finetune_view, y\n", "\n", "    def on_train_batch_end(\n", "        self,\n", "        trainer: pl.Trainer,\n", "        pl_module: pl.LightningModule,\n", "        outputs: Sequence,\n", "        batch: Sequence,\n", "        batch_idx: int,\n", "        dataloader_idx: int,\n", "    ) -> None:\n", "        x, y = self.extract_online_finetuning_view(batch, pl_module.device)\n", "\n", "        with torch.no_grad():\n", "            feats = pl_module(x)\n", "\n", "        feats = feats.detach()\n", "        preds = pl_module.online_finetuner(feats)\n", "        loss = F.cross_entropy(preds, y)\n", "\n", "        loss.backward()\n", "        self.optimizer.step()\n", "        self.optimizer.zero_grad()\n", "\n", "        acc = accuracy(F.softmax(preds, dim=1), y)\n", "        pl_module.log(\"online_train_acc\", acc, on_step=True, on_epoch=False)\n", "        pl_module.log(\"online_train_loss\", loss, on_step=True, on_epoch=False)\n", "\n", "    def on_validation_batch_end(\n", "        self,\n", "        trainer: pl.Trainer,\n", "        pl_module: pl.LightningModule,\n", "        outputs: Sequence,\n", "        batch: Sequence,\n", "        batch_idx: int,\n", "        dataloader_idx: int,\n", "    ) -> None:\n", "        x, y = self.extract_online_finetuning_view(batch, pl_module.device)\n", "\n", "        with torch.no_grad():\n", "            feats = pl_module(x)\n", "\n", "        feats = feats.detach()\n", "        preds = pl_module.online_finetuner(feats)\n", "        loss = F.cross_entropy(preds, y)\n", "\n", "        acc = accuracy(F.softmax(preds, dim=1), y)\n", "        pl_module.log(\"online_val_acc\", acc, on_step=False, on_epoch=True, sync_dist=True)\n", "        pl_module.log(\"online_val_loss\", loss, on_step=False, on_epoch=True, sync_dist=True)"]}, {"cell_type": "markdown", "id": "c7f6bb76", "metadata": {"papermill": {"duration": 0.014775, "end_time": "2021-10-25T20:00:50.614884", "exception": false, "start_time": "2021-10-25T20:00:50.600109", "status": "completed"}, "tags": []}, "source": ["Finally, we define the trainer for training the model. We pass in the ``train_loader`` and ``val_loader`` we had initialized earlier to the ``fit`` function."]}, {"cell_type": "code", "execution_count": 12, "id": "21965f37", "metadata": {"execution": {"iopub.execute_input": "2021-10-25T20:00:50.649228Z", "iopub.status.busy": "2021-10-25T20:00:50.648753Z", "iopub.status.idle": "2021-10-25T20:00:50.731321Z", "shell.execute_reply": "2021-10-25T20:00:50.730897Z"}, "papermill": {"duration": 0.101688, "end_time": "2021-10-25T20:00:50.731435", "exception": false, "start_time": "2021-10-25T20:00:50.629747", "status": "completed"}, "tags": []}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["/home/AzDevOps_azpcontainer/.local/lib/python3.9/site-packages/pytorch_lightning/callbacks/model_checkpoint.py:240: LightningDeprecationWarning: `ModelCheckpoint(every_n_val_epochs)` is deprecated in v1.4 and will be removed in v1.6. Please use `every_n_epochs` instead.\n", "  rank_zero_deprecation(\n", "/home/AzDevOps_azpcontainer/.local/lib/python3.9/site-packages/pytorch_lightning/callbacks/model_checkpoint.py:432: UserWarning: ModelCheckpoint(save_last=True, save_top_k=None, monitor=None) is a redundant configuration. You can save the last checkpoint with ModelCheckpoint(save_top_k=None, monitor=None).\n", "  rank_zero_warn(\n", "ModelCheckpoint(save_last=True, save_top_k=-1, monitor=None) will duplicate the last checkpoint saved.\n"]}, {"name": "stderr", "output_type": "stream", "text": ["/home/AzDevOps_azpcontainer/.local/lib/python3.9/site-packages/pytorch_lightning/trainer/connectors/accelerator_connector.py:746: UserWarning: You requested multiple GPUs but did not specify a backend, e.g. `Trainer(accelerator=\"dp\"|\"ddp\"|\"ddp2\")`. Setting `accelerator=\"ddp_spawn\"` for you.\n", "  rank_zero_warn(\n", "Using native 16bit precision.\n"]}, {"name": "stderr", "output_type": "stream", "text": ["GPU available: True, used: True\n"]}, {"name": "stderr", "output_type": "stream", "text": ["TPU available: False, using: 0 TPU cores\n"]}, {"name": "stderr", "output_type": "stream", "text": ["IPU available: False, using: 0 IPUs\n"]}], "source": ["encoder_out_dim = 512\n", "\n", "model = BarlowTwins(\n", "    encoder=encoder,\n", "    encoder_out_dim=encoder_out_dim,\n", "    num_training_samples=len(train_dataset),\n", "    batch_size=batch_size,\n", "    z_dim=z_dim,\n", ")\n", "\n", "online_finetuner = OnlineFineTuner(encoder_output_dim=encoder_out_dim, num_classes=10)\n", "checkpoint_callback = ModelCheckpoint(every_n_val_epochs=100, save_top_k=-1, save_last=True)\n", "\n", "trainer = Trainer(\n", "    max_epochs=max_epochs,\n", "    gpus=torch.cuda.device_count(),\n", "    precision=16 if torch.cuda.device_count() > 0 else 32,\n", "    callbacks=[online_finetuner, checkpoint_callback],\n", ")\n", "\n", "# uncomment this to train the model\n", "# this is done for the tutorial so that the notebook compiles\n", "# trainer.fit(model, train_loader, val_loader)"]}, {"cell_type": "markdown", "id": "9cb9b57c", "metadata": {"papermill": {"duration": 0.016005, "end_time": "2021-10-25T20:00:50.763854", "exception": false, "start_time": "2021-10-25T20:00:50.747849", "status": "completed"}, "tags": []}, "source": ["### Using the trained encoder for downstream tasks\n", "\n", "Once the encoder is pretrained on CIFAR10, we can use it to get image embeddings and use them further downstream on tasks like classification, detection, segmentation etc.\n", "\n", "In this tutorial, we did not completely train our encoder for 100s of epochs using the Barlow Twins pretraining method. So, we will load the pretrained encoder weights from a checkpoint and show the image embeddings obtained from that.\n", "\n", "To create this checkpoint, the encoder was pretrained for 200 epochs, and obtained a online finetune accuracy of x% on CIFAR-10."]}, {"cell_type": "code", "execution_count": 13, "id": "bc2dfce3", "metadata": {"execution": {"iopub.execute_input": "2021-10-25T20:00:50.800041Z", "iopub.status.busy": "2021-10-25T20:00:50.799564Z", "iopub.status.idle": "2021-10-25T20:00:51.171031Z", "shell.execute_reply": "2021-10-25T20:00:51.170535Z"}, "papermill": {"duration": 0.391254, "end_time": "2021-10-25T20:00:51.171147", "exception": false, "start_time": "2021-10-25T20:00:50.779893", "status": "completed"}, "tags": []}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["torch.Size([4, 512])\n"]}], "source": ["# ckpt_model = torch.load('')  # upload checkpoint to aws\n", "# encoder = ckpt_model.encoder\n", "encoder = model.encoder\n", "\n", "downstream_dataset = CIFAR10(root=\".\", train=False, transform=transforms.ToTensor())\n", "dataloader = DataLoader(downstream_dataset, batch_size=4, shuffle=False)\n", "\n", "for batch in dataloader:\n", "    img, label = batch\n", "    print(encoder(img).shape)\n", "    break"]}, {"cell_type": "markdown", "id": "68078df0", "metadata": {"papermill": {"duration": 0.01633, "end_time": "2021-10-25T20:00:51.204343", "exception": false, "start_time": "2021-10-25T20:00:51.188013", "status": "completed"}, "tags": []}, "source": ["## Congratulations - Time to Join the Community!\n", "\n", "Congratulations on completing this notebook tutorial! If you enjoyed this and would like to join the Lightning\n", "movement, you can do so in the following ways!\n", "\n", "### Star [Lightning](https://github.com/PyTorchLightning/pytorch-lightning) on GitHub\n", "The easiest way to help our community is just by starring the GitHub repos! This helps raise awareness of the cool\n", "tools we're building.\n", "\n", "### Join our [Slack](https://join.slack.com/t/pytorch-lightning/shared_invite/zt-pw5v393p-qRaDgEk24~EjiZNBpSQFgQ)!\n", "The best way to keep up to date on the latest advancements is to join our community! Make sure to introduce yourself\n", "and share your interests in `#general` channel\n", "\n", "\n", "### Contributions !\n", "The best way to contribute to our community is to become a code contributor! At any time you can go to\n", "[Lightning](https://github.com/PyTorchLightning/pytorch-lightning) or [Bolt](https://github.com/PyTorchLightning/lightning-bolts)\n", "GitHub Issues page and filter for \"good first issue\".\n", "\n", "* [Lightning good first issue](https://github.com/PyTorchLightning/pytorch-lightning/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22)\n", "* [Bolt good first issue](https://github.com/PyTorchLightning/lightning-bolts/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22)\n", "* You can also contribute your own notebooks with useful examples !\n", "\n", "### Great thanks from the entire Pytorch Lightning Team for your interest !\n", "\n", "![Pytorch Lightning](data:image/png;base64,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){height=\"60px\" width=\"240px\"}"]}, {"cell_type": "raw", "metadata": {"raw_mimetype": "text/restructuredtext"}, "source": [".. customcarditem::\n", "   :header: Barlow Twins Tutorial\n", "   :card_description: This notebook describes the self-supervised learning method Barlow Twins. Barlow Twins differs from other recently proposed algorithms as it doesn't fall under the category of...\n", "   :tags: Image,Self-Supervised,GPU/TPU,Lightning-Examples"]}], "metadata": {"jupytext": {"cell_metadata_filter": "colab_type,id,colab,-all", "formats": "ipynb,py:percent", "main_language": "python"}, "language_info": {"codemirror_mode": {"name": "ipython", "version": 3}, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.7"}, "papermill": {"default_parameters": {}, "duration": 9.405997, "end_time": "2021-10-25T20:00:51.627704", "environment_variables": {}, "exception": null, "input_path": "lightning_examples/barlow-twins/barlow_twins.ipynb", "output_path": ".notebooks/lightning_examples/barlow-twins.ipynb", "parameters": {}, "start_time": "2021-10-25T20:00:42.221707", "version": "2.3.3"}, "widgets": {"application/vnd.jupyter.widget-state+json": {"state": {"3365e6cc23b14f7480580fbdbd5bc019": {"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}}, "3882c1fab7874567af01f5ca5b6b5529": {"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}}, "431aeabf10b2446bb97010d31753e44e": {"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}}, "4bb27c7671944b6e97113a02c0341e2c": {"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": ""}}, "7ddd35cbfb3845b1a206ac0fcbdbfc85": {"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_3365e6cc23b14f7480580fbdbd5bc019", "placeholder": "\u200b", "style": "IPY_MODEL_4bb27c7671944b6e97113a02c0341e2c", "value": ""}}, "7f3c22706f004367af15c8839b531c8a": {"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": ""}}, "a75cd1c0f8504f44a015affaa4e54a48": {"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_431aeabf10b2446bb97010d31753e44e", "placeholder": "\u200b", "style": "IPY_MODEL_d8f730207f83419cb86c5c93f4f7584e", "value": " 170499072/? [00:01&lt;00:00, 116151155.58it/s]"}}, "b13dfae7160c4c8586c5780f597cd8e4": {"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_7ddd35cbfb3845b1a206ac0fcbdbfc85", "IPY_MODEL_eca693d1c480402d8c204656916344ad", "IPY_MODEL_a75cd1c0f8504f44a015affaa4e54a48"], "layout": "IPY_MODEL_3882c1fab7874567af01f5ca5b6b5529"}}, "bd170e01fdeb46d4aff4afb77af815fd": {"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}}, "d8f730207f83419cb86c5c93f4f7584e": {"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": ""}}, "eca693d1c480402d8c204656916344ad": {"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_bd170e01fdeb46d4aff4afb77af815fd", "max": 170498071.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_7f3c22706f004367af15c8839b531c8a", "value": 170498071.0}}}, "version_major": 2, "version_minor": 0}}}, "nbformat": 4, "nbformat_minor": 5}