{"cells": [{"cell_type": "markdown", "id": "48a2fe14", "metadata": {"papermill": {"duration": 0.005641, "end_time": "2022-05-03T01:20:56.252312", "exception": false, "start_time": "2022-05-03T01:20:56.246671", "status": "completed"}, "tags": []}, "source": ["\n", "# Barlow Twins Tutorial\n", "\n", "* **Author:** Ananya Harsh Jha (ananya@pytorchlightning.ai)\n", "* **License:** CC BY-SA\n", "* **Generated:** 2022-05-03T02:43:23.580918\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/stable/)\n", "| Join us [on Slack](https://www.pytorchlightning.ai/community)"]}, {"cell_type": "markdown", "id": "dab2d7b1", "metadata": {"papermill": {"duration": 0.003838, "end_time": "2022-05-03T01:20:56.260406", "exception": false, "start_time": "2022-05-03T01:20:56.256568", "status": "completed"}, "tags": []}, "source": ["## Setup\n", "This notebook requires some packages besides pytorch-lightning."]}, {"cell_type": "code", "execution_count": 1, "id": "3bcc2dc2", "metadata": {"colab": {}, "colab_type": "code", "execution": {"iopub.execute_input": "2022-05-03T01:20:56.269677Z", "iopub.status.busy": "2022-05-03T01:20:56.269140Z", "iopub.status.idle": "2022-05-03T01:20:59.914616Z", "shell.execute_reply": "2022-05-03T01:20:59.913702Z"}, "id": "LfrJLKPFyhsK", "lines_to_next_cell": 0, "papermill": {"duration": 3.652597, "end_time": "2022-05-03T01:20:59.916987", "exception": false, "start_time": "2022-05-03T01:20:56.264390", "status": "completed"}, "tags": []}, "outputs": [], "source": ["! pip install --quiet \"matplotlib\" \"ipython[notebook]\" \"torchvision\" \"setuptools==59.5.0\" \"torch>=1.8\" \"torchmetrics>=0.7\" \"pytorch-lightning>=1.4\""]}, {"cell_type": "markdown", "id": "cefe847c", "metadata": {"papermill": {"duration": 0.004031, "end_time": "2022-05-03T01:20:59.925670", "exception": false, "start_time": "2022-05-03T01:20:59.921639", "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": "4addcae1", "metadata": {"execution": {"iopub.execute_input": "2022-05-03T01:20:59.935004Z", "iopub.status.busy": "2022-05-03T01:20:59.934714Z", "iopub.status.idle": "2022-05-03T01:21:02.711834Z", "shell.execute_reply": "2022-05-03T01:21:02.711143Z"}, "papermill": {"duration": 2.784679, "end_time": "2022-05-03T01:21:02.714368", "exception": false, "start_time": "2022-05-03T01:20:59.929689", "status": "completed"}, "tags": []}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["/usr/lib/python3.8/site-packages/apex/pyprof/__init__.py:5: FutureWarning: pyprof will be removed by the end of June, 2022\n", "  warnings.warn(\"pyprof will be removed by the end of June, 2022\", FutureWarning)\n"]}, {"name": "stderr", "output_type": "stream", "text": ["WARNING:root:Bagua cannot detect bundled NCCL library, Bagua will try to use system NCCL instead. If you encounter any error, please run `import bagua_core; bagua_core.install_deps()` or the `bagua_install_deps.py` script to install bundled libraries.\n"]}], "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 torch import Tensor\n", "from torch.utils.data import DataLoader\n", "from torchmetrics.functional import accuracy\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": "acfe4f07", "metadata": {"papermill": {"duration": 0.004083, "end_time": "2022-05-03T01:21:02.723379", "exception": false, "start_time": "2022-05-03T01:21:02.719296", "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": "0268ff9d", "metadata": {"execution": {"iopub.execute_input": "2022-05-03T01:21:02.733060Z", "iopub.status.busy": "2022-05-03T01:21:02.732590Z", "iopub.status.idle": "2022-05-03T01:21:02.741112Z", "shell.execute_reply": "2022-05-03T01:21:02.740567Z"}, "papermill": {"duration": 0.015061, "end_time": "2022-05-03T01:21:02.742486", "exception": false, "start_time": "2022-05-03T01:21:02.727425", "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": "9ff849b7", "metadata": {"papermill": {"duration": 0.004046, "end_time": "2022-05-03T01:21:02.750613", "exception": false, "start_time": "2022-05-03T01:21:02.746567", "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": "e3468fce", "metadata": {"execution": {"iopub.execute_input": "2022-05-03T01:21:02.761326Z", "iopub.status.busy": "2022-05-03T01:21:02.760849Z", "iopub.status.idle": "2022-05-03T01:21:07.845668Z", "shell.execute_reply": "2022-05-03T01:21:07.844979Z"}, "papermill": {"duration": 5.091829, "end_time": "2022-05-03T01:21:07.847911", "exception": false, "start_time": "2022-05-03T01:21:02.756082", "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": "0d637445d6d8411297c8497dd704eb7f", "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": "e5d20bb9", "metadata": {"papermill": {"duration": 0.00442, "end_time": "2022-05-03T01:21:07.858214", "exception": false, "start_time": "2022-05-03T01:21:07.853794", "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": "ffdbfa81", "metadata": {"execution": {"iopub.execute_input": "2022-05-03T01:21:07.868614Z", "iopub.status.busy": "2022-05-03T01:21:07.868328Z", "iopub.status.idle": "2022-05-03T01:21:08.053638Z", "shell.execute_reply": "2022-05-03T01:21:08.052975Z"}, "papermill": {"duration": 0.19286, "end_time": "2022-05-03T01:21:08.055804", "exception": false, "start_time": "2022-05-03T01:21:07.862944", "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": "1ebdbd2b", "metadata": {"papermill": {"duration": 0.005454, "end_time": "2022-05-03T01:21:08.067902", "exception": false, "start_time": "2022-05-03T01:21:08.062448", "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": "06e4e4c0", "metadata": {"execution": {"iopub.execute_input": "2022-05-03T01:21:08.080401Z", "iopub.status.busy": "2022-05-03T01:21:08.080118Z", "iopub.status.idle": "2022-05-03T01:21:08.087147Z", "shell.execute_reply": "2022-05-03T01:21:08.086522Z"}, "papermill": {"duration": 0.015233, "end_time": "2022-05-03T01:21:08.088681", "exception": false, "start_time": "2022-05-03T01:21:08.073448", "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": "af086bbe", "metadata": {"papermill": {"duration": 0.005637, "end_time": "2022-05-03T01:21:08.100125", "exception": false, "start_time": "2022-05-03T01:21:08.094488", "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": "123382f1", "metadata": {"execution": {"iopub.execute_input": "2022-05-03T01:21:08.113314Z", "iopub.status.busy": "2022-05-03T01:21:08.112701Z", "iopub.status.idle": "2022-05-03T01:21:08.268899Z", "shell.execute_reply": "2022-05-03T01:21:08.268104Z"}, "papermill": {"duration": 0.16539, "end_time": "2022-05-03T01:21:08.271128", "exception": false, "start_time": "2022-05-03T01:21:08.105738", "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": "f440f360", "metadata": {"papermill": {"duration": 0.005551, "end_time": "2022-05-03T01:21:08.283411", "exception": false, "start_time": "2022-05-03T01:21:08.277860", "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": "2975b668", "metadata": {"execution": {"iopub.execute_input": "2022-05-03T01:21:08.296007Z", "iopub.status.busy": "2022-05-03T01:21:08.295469Z", "iopub.status.idle": "2022-05-03T01:21:08.300257Z", "shell.execute_reply": "2022-05-03T01:21:08.299653Z"}, "papermill": {"duration": 0.012837, "end_time": "2022-05-03T01:21:08.301778", "exception": false, "start_time": "2022-05-03T01:21:08.288941", "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": "86a6d540", "metadata": {"papermill": {"duration": 0.005677, "end_time": "2022-05-03T01:21:08.313096", "exception": false, "start_time": "2022-05-03T01:21:08.307419", "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": "56a7b0b7", "metadata": {"execution": {"iopub.execute_input": "2022-05-03T01:21:08.325323Z", "iopub.status.busy": "2022-05-03T01:21:08.324922Z", "iopub.status.idle": "2022-05-03T01:21:08.328636Z", "shell.execute_reply": "2022-05-03T01:21:08.328021Z"}, "papermill": {"duration": 0.011487, "end_time": "2022-05-03T01:21:08.330091", "exception": false, "start_time": "2022-05-03T01:21:08.318604", "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": "f2c9250b", "metadata": {"papermill": {"duration": 0.005561, "end_time": "2022-05-03T01:21:08.341357", "exception": false, "start_time": "2022-05-03T01:21:08.335796", "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": "cab91fad", "metadata": {"execution": {"iopub.execute_input": "2022-05-03T01:21:08.354107Z", "iopub.status.busy": "2022-05-03T01:21:08.353556Z", "iopub.status.idle": "2022-05-03T01:21:08.362090Z", "shell.execute_reply": "2022-05-03T01:21:08.361493Z"}, "papermill": {"duration": 0.016575, "end_time": "2022-05-03T01:21:08.363538", "exception": false, "start_time": "2022-05-03T01:21:08.346963", "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", "        self.log(\"train_loss\", loss, 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", "        self.log(\"val_loss\", loss, on_step=False, on_epoch=True)\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": "c3035885", "metadata": {"papermill": {"duration": 0.005617, "end_time": "2022-05-03T01:21:08.374836", "exception": false, "start_time": "2022-05-03T01:21:08.369219", "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": "e1321f73", "metadata": {"execution": {"iopub.execute_input": "2022-05-03T01:21:08.387481Z", "iopub.status.busy": "2022-05-03T01:21:08.387178Z", "iopub.status.idle": "2022-05-03T01:21:08.397504Z", "shell.execute_reply": "2022-05-03T01:21:08.396907Z"}, "papermill": {"duration": 0.018391, "end_time": "2022-05-03T01:21:08.398964", "exception": false, "start_time": "2022-05-03T01:21:08.380573", "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_fit_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[Tensor, 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": "f6325fed", "metadata": {"papermill": {"duration": 0.005584, "end_time": "2022-05-03T01:21:08.410318", "exception": false, "start_time": "2022-05-03T01:21:08.404734", "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": "3d172029", "metadata": {"execution": {"iopub.execute_input": "2022-05-03T01:21:08.422975Z", "iopub.status.busy": "2022-05-03T01:21:08.422470Z", "iopub.status.idle": "2022-05-03T01:21:08.657523Z", "shell.execute_reply": "2022-05-03T01:21:08.656922Z"}, "papermill": {"duration": 0.243001, "end_time": "2022-05-03T01:21:08.659057", "exception": false, "start_time": "2022-05-03T01:21:08.416056", "status": "completed"}, "tags": []}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["ModelCheckpoint(save_last=True, save_top_k=-1, monitor=None) will duplicate the last checkpoint saved.\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"]}, {"name": "stderr", "output_type": "stream", "text": ["HPU available: False, using: 0 HPUs\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_epochs=100, save_top_k=-1, save_last=True)\n", "\n", "trainer = Trainer(\n", "    max_epochs=max_epochs,\n", "    accelerator=\"auto\",\n", "    devices=1 if torch.cuda.is_available() else None,  # limiting got iPython runs\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": "8bd09d4d", "metadata": {"papermill": {"duration": 0.005851, "end_time": "2022-05-03T01:21:08.671789", "exception": false, "start_time": "2022-05-03T01:21:08.665938", "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": "f2877d1f", "metadata": {"execution": {"iopub.execute_input": "2022-05-03T01:21:08.685209Z", "iopub.status.busy": "2022-05-03T01:21:08.684742Z", "iopub.status.idle": "2022-05-03T01:21:09.080222Z", "shell.execute_reply": "2022-05-03T01:21:09.079567Z"}, "papermill": {"duration": 0.404237, "end_time": "2022-05-03T01:21:09.081976", "exception": false, "start_time": "2022-05-03T01:21:08.677739", "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": "d35cf819", "metadata": {"papermill": {"duration": 0.005993, "end_time": "2022-05-03T01:21:09.094796", "exception": false, "start_time": "2022-05-03T01:21:09.088803", "status": "completed"}, "tags": []}, "source": ["## Congratulations - Time to Join the Community!\n", "\n", "Congratulations on completing this notebook tutorial! If you enjoyed this and would like to join the Lightning\n", "movement, you can do so in the following ways!\n", "\n", "### Star [Lightning](https://github.com/PyTorchLightning/pytorch-lightning) on GitHub\n", "The easiest way to help our community is just by starring the GitHub repos! This helps raise awareness of the cool\n", "tools we're building.\n", "\n", "### Join our [Slack](https://www.pytorchlightning.ai/community)!\n", "The best way to keep up to date on the latest advancements is to join our community! Make sure to introduce yourself\n", "and share your interests in `#general` channel\n", "\n", "\n", "### Contributions !\n", "The best way to contribute to our community is to become a code contributor! At any time you can go to\n", "[Lightning](https://github.com/PyTorchLightning/pytorch-lightning) or [Bolt](https://github.com/PyTorchLightning/lightning-bolts)\n", "GitHub Issues page and filter for \"good first issue\".\n", "\n", "* [Lightning good first issue](https://github.com/PyTorchLightning/pytorch-lightning/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22)\n", "* [Bolt good first issue](https://github.com/PyTorchLightning/lightning-bolts/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22)\n", "* You can also contribute your own notebooks with useful examples !\n", "\n", "### Great thanks from the entire Pytorch Lightning Team for your interest !\n", "\n", "[![Pytorch Lightning](data:image/png;base64,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){height=\"60px\" width=\"240px\"}](https://pytorchlightning.ai)"]}, {"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.8.10"}, "papermill": {"default_parameters": {}, "duration": 15.139577, "end_time": "2022-05-03T01:21:09.919938", "environment_variables": {}, "exception": null, "input_path": "lightning_examples/barlow-twins/barlow_twins.ipynb", "output_path": ".notebooks/lightning_examples/barlow-twins.ipynb", "parameters": {}, "start_time": "2022-05-03T01:20:54.780361", "version": "2.3.4"}, "widgets": {"application/vnd.jupyter.widget-state+json": {"state": {"0d637445d6d8411297c8497dd704eb7f": {"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_dd30a8ab063447708f22b4847426cf80", "IPY_MODEL_d49d112ca0ac4352af35bb4ad446cca1", "IPY_MODEL_c8e5e7fd020941f889a28247ba77f3f6"], "layout": "IPY_MODEL_fb2becc997ff43098ee238f48c6216d5"}}, "579c0a2f47ea40eca302d66d457e869d": {"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}}, "57e0ec6141f84b6f898aa10e4062a6c7": {"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}}, "587932cf61a747b3900695e6bb3b35d9": {"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}}, "73d30dde3bc04b06b0e18d4a24601b20": {"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": ""}}, "78828cc33b144d349ad8cacbd45fc6c8": {"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": ""}}, "7fc4fbf0e8924419975a975195a47674": {"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": ""}}, "c8e5e7fd020941f889a28247ba77f3f6": {"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_579c0a2f47ea40eca302d66d457e869d", "placeholder": "\u200b", "style": "IPY_MODEL_73d30dde3bc04b06b0e18d4a24601b20", "value": " 170499072/? [00:01&lt;00:00, 114866769.73it/s]"}}, "d49d112ca0ac4352af35bb4ad446cca1": {"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_587932cf61a747b3900695e6bb3b35d9", "max": 170498071.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_7fc4fbf0e8924419975a975195a47674", "value": 170498071.0}}, "dd30a8ab063447708f22b4847426cf80": {"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_57e0ec6141f84b6f898aa10e4062a6c7", "placeholder": "\u200b", "style": "IPY_MODEL_78828cc33b144d349ad8cacbd45fc6c8", "value": ""}}, "fb2becc997ff43098ee238f48c6216d5": {"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}}}, "version_major": 2, "version_minor": 0}}}, "nbformat": 4, "nbformat_minor": 5}