examples/unsupervised_hello_world.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Copyright 2021 The TensorFlow Similarity Authors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# @title Licensed under the Apache License, Version 2.0 (the \"License\");\n",
    "# you may not use this file except in compliance with the License.\n",
    "# You may obtain a copy of the License at\n",
    "#\n",
    "# https://www.apache.org/licenses/LICENSE-2.0\n",
    "#\n",
    "# Unless required by applicable law or agreed to in writing, software\n",
    "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
    "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
    "# See the License for the specific language governing permissions and\n",
    "# limitations under the License."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TensorFlow Similarity Self-Supervised Learning Hello World"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table class=\"tfo-notebook-buttons\" align=\"left\">\n",
    "  <td>\n",
    "    <a target=\"_blank\" href=\"https://colab.research.google.com/github/tensorflow/similarity/blob/master/examples/unsupervised_hello_world.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" />Run in Google Colab</a>\n",
    "  </td>\n",
    "  <td>\n",
    "    <a target=\"_blank\" href=\"https://github.com/tensorflow/similarity/blob/master/examples/unsupervised_hello_world.ipynb\"><img src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" />View source on GitHub</a>\n",
    "  </td>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[TensorFlow Similarity](https://github.com/tensorflow/similarity) is a python package focused on making similarity learning and self-supervised learning quick and easy.\n",
    "\n",
    "![self_supervised_overview.png](https://raw.githubusercontent.com/tensorflow/similarity/master/assets/images/self_supervised_overview.png)\n",
    "\n",
    "Self-supervised learning is an approach to pre-training models using unlabeled data. This approach drastically increases accuracy when you have very few labeled examples but a lot of unlabelled data. The key insight is that you can train a self-supervised model to learn data representations by contrasting multiple augmented views of the same example. These learned representations capture data invariants, e.g., object translation, color jitter, noise, etc. Training a simple linear classifier on top of the frozen representations is easier and requires fewer labels because the pre-trained model already produces meaningful and generally useful features. Overall, self-supervised pre-training learns representations which are more [generic](https://arxiv.org/abs/2110.00528) and [robust](https://arxiv.org/abs/1902.01889) than other approaches to augmented training and pre-training. \n",
    "\n",
    "Tensorflow Similarity provides a set of network architectures, losses, and data augmentations that are common across a number of self-supervised learning techniques. The Tensorflow Similarity package attempts to provide a consistent terminology across these techniques; however, this leads to slightly different naming conventions, as many papers use different terms to describe the same components. \n",
    "\n",
    "The main terms used by Tensorflow Similarity are:\n",
    "\n",
    "* **View**: A view represents an augmented example.\n",
    "\n",
    "* **Backbone**: Refers to the model that learns the **Representation** that we will use for downstream tasks.\n",
    "\n",
    "* **Projector**: Is an MLP model that projects the backbone representation of a view to an **Embedding** that is contrasted with other views using a specialized contrastive loss.\n",
    "\n",
    "* **Predictor**: Is an optional MLP model that is used, in conjunction with gradient stopping, in some recent architectures to further improve the representation quality.\n",
    "\n",
    "* **Stop Gradient**: Is used by some algorithms to ensure that we only propagate the update from the main view and not the contrasting view.\n",
    "\n",
    "\n",
    "![contrastive_model_terms.png](https://raw.githubusercontent.com/tensorflow/similarity/master/assets/images/contrastive_model_terms.png)\n",
    "\n",
    "\n",
    "### Notebook goal\n",
    "\n",
    "This notebook demonstrates how to use Tensorflow Similarity to boost classification accuracy by pre-training a ResNet18 model using contrastive learning on the cifar10 dataset. As you will see, the pre-trained model achieves about ~1.8x the accuracy of the model trained without pre-training. For example, **using SimSiam pre-training, you can achieve 87%-91% accuracy versus 50% accuracy when training the same architecture from scratch**.\n",
    "\n",
    "To do this, this notebook walks through how to:\n",
    "\n",
    "1. Create a `tf.data.Dataset` that will generate two augmented views for each example in a batch.\n",
    "\n",
    "2. Create basic versions of **Backbone**, **Projector**, and **Predictor** networks to construct the `ContrastiveModel()`\n",
    "\n",
    "3. Train a `ContrastiveModel()` using one of the following contrastive learning algorithms: [SimCLR](https://arxiv.org/abs/2002.05709), [SimSiam](https://arxiv.org/abs/2011.10566), and [Barlow Twins](https://arxiv.org/abs/2103.03230).\n",
    "\n",
    "4. Compare the classification performance of the pre-trained model versus a model trained from scratch.\n",
    "\n",
    "\n",
    "### Things to try\n",
    "\n",
    "You can explore the following things that will affect the model performance:\n",
    "- Try different self-supervised learning algorithms.\n",
    "- Pre-train on a different dataset, e.g., cifar100.\n",
    "- Restrict supervised training to use a subset of the data, e.g., 100 labels per class.\n",
    "- Use a larger embedding by increasing the size of the projection and predictor layers.\n",
    "- Try using different augmentation profiles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gc\n",
    "import os\n",
    "import random\n",
    "import time\n",
    "from pathlib import Path\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from tabulate import tabulate\n",
    "\n",
    "# INFO messages are not printed.\n",
    "# This must be run before loading other modules.\n",
    "os.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"1\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": []
    }
   ],
   "source": [
    "# install TF addons if needed\n",
    "try:\n",
    "    import tensorflow_addons as tfa  # main package\n",
    "except ModuleNotFoundError:\n",
    "    %pip install tensorflow-addons\n",
    "    import tensorflow_addons as tfa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# install TF similarity if needed\n",
    "try:\n",
    "    import tensorflow_similarity as tfsim  # main package\n",
    "except ModuleNotFoundError:\n",
    "    %pip install tensorflow_similarity\n",
    "    import tensorflow_similarity as tfsim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "import tensorflow_datasets as tfds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "tfsim.utils.tf_cap_memory()  # Avoid GPU memory blow up"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Clear out any old model state.\n",
    "gc.collect()\n",
    "tf.keras.backend.clear_session()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TensorFlow: 2.10.0\n",
      "TensorFlow Similarity 0.17.0.dev17\n"
     ]
    }
   ],
   "source": [
    "print(\"TensorFlow:\", tf.__version__)\n",
    "print(\"TensorFlow Similarity\", tfsim.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dataset Preperation\n",
    "\n",
    "The following section:\n",
    "* Loads the [CIFAR10](https://www.tensorflow.org/datasets/catalog/cifar10) data from tensorflow datasets.\n",
    "* Creates the train, val, test, and query/index splits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA_PATH = Path(\"tfsim_contrastive_model\")\n",
    "if not DATA_PATH.exists():\n",
    "    DATA_PATH.mkdir(parents=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Load The Raw Data\n",
    "\n",
    "We are going to load the [CIFAR10](https://www.tensorflow.org/datasets/catalog/cifar10) dataset. This dataset is often used in the self-supervised papers, enabling us to reproduce the published results. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "((x_raw_train, y_raw_train), (x_test, y_test)), ds_info = tfds.load(\n",
    "    \"cifar10\",\n",
    "    split=[\"train\", \"test\"],\n",
    "    batch_size=-1,\n",
    "    shuffle_files=True,\n",
    "    as_supervised=True,\n",
    "    with_info=True,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create Data Splits\n",
    "The TensorFlow Datasets' [CIFAR10](https://www.tensorflow.org/datasets/catalog/cifar10) dataset provides a test and train split. \n",
    "* **Train**: Used for self-supervised pre-training and for training the classifiers.\n",
    "* **Test**: Reserved for the classifier evaluation.\n",
    "\n",
    "However, we are going to partition the train data into the following additional splits:\n",
    "\n",
    "* **Validation**: Data used for validation metrics during the pre-training phase. \n",
    "* **Query and Index**: Data used to compute matching metrics. The query data is used to retrieve the nearest indexed examples.\n",
    "\n",
    "In particular, the Query and Index split allows us to track the matching classification performance during training. \n",
    "\n",
    "<div class=\"alert alert-block alert-info\"> <b>NOTE </b> An increasing match accuracy is a strong indication that the model is learning useful features, however, it does require that we have labeled data. If a dataset only has a small number of labeled examples, they can be passed as the query and index to help monitor the potential matching classification performance during training.</div> \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute the indicies for query, index, val, and train splits\n",
    "query_idxs, index_idxs, val_idxs, train_idxs = [], [], [], []\n",
    "for cid in range(ds_info.features[\"label\"].num_classes):\n",
    "    idxs = tf.random.shuffle(tf.where(y_raw_train == cid))\n",
    "    idxs = tf.reshape(idxs, (-1,))\n",
    "    query_idxs.extend(idxs[:200])  # 200 query examples per class\n",
    "    index_idxs.extend(idxs[200:400])  # 200 index examples per class\n",
    "    val_idxs.extend(idxs[400:500])  # 100 validation examples per class\n",
    "    train_idxs.extend(idxs[500:])  # The remaining are used for training\n",
    "\n",
    "random.shuffle(query_idxs)\n",
    "random.shuffle(index_idxs)\n",
    "random.shuffle(val_idxs)\n",
    "random.shuffle(train_idxs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_split(idxs: list) -> tuple:\n",
    "    x, y = [], []\n",
    "    for idx in idxs:\n",
    "        x.append(x_raw_train[int(idx)])\n",
    "        y.append(y_raw_train[int(idx)])\n",
    "    return tf.convert_to_tensor(np.array(x)), tf.convert_to_tensor(np.array(y))\n",
    "\n",
    "\n",
    "x_query, y_query = create_split(query_idxs)\n",
    "x_index, y_index = create_split(index_idxs)\n",
    "x_val, y_val = create_split(val_idxs)\n",
    "x_train, y_train = create_split(train_idxs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       Examples            Labels\n",
      "-----  ------------------  --------\n",
      "train  (45000, 32, 32, 3)  (45000,)\n",
      "val    (1000, 32, 32, 3)   (1000,)\n",
      "query  (2000, 32, 32, 3)   (2000,)\n",
      "index  (2000, 32, 32, 3)   (2000,)\n",
      "test   (10000, 32, 32, 3)  (10000,)\n"
     ]
    }
   ],
   "source": [
    "print(\n",
    "    tabulate(\n",
    "        [\n",
    "            [\"train\", x_train.shape, y_train.shape],\n",
    "            [\"val\", x_val.shape, y_val.shape],\n",
    "            [\"query\", x_query.shape, y_query.shape],\n",
    "            [\"index\", x_index.shape, y_index.shape],\n",
    "            [\"test\", x_test.shape, y_test.shape],\n",
    "        ],\n",
    "        headers=[\"Examples\", \"Labels\"],\n",
    "    )\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Self-Supervised Training Setup\n",
    "\n",
    "This following section:\n",
    "* Sets the training parameters used for building the different architectures.\n",
    "* Creates a train and test tf.data.Dataset.\n",
    "* Visualizes the pairs of augmented views from a single batch."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Self-Supervised Algorithm Selection\n",
    "[TensorFlow Similarity](https://github.com/tensorflow/similarity) currently supports three different self-supervised models.\n",
    "* [SimCLR](http://arxiv.org/abs/2002.05709): Only requires the Backbone and the projector and uses a contrastive cross-entropy loss.\n",
    "* [SimSiam](https://arxiv.org/abs/2011.10566): Requires the Backbone, projector, and predictor and only compares the cosine distance between augmented views from the same example.\n",
    "* [Barlow Twins](https://arxiv.org/abs/2103.03230): Only requires the Backbone and the projector and uses a loss that compares the feature covariance instead of contrasting the views.\n",
    "* [VicReg](https://arxiv.org/abs/2105.04906): Only requires the Backbone and projector and uses a loss that enforces the learned representations to be invariant to random augmentations while preserving the covariance and variance information.\n",
    "\n",
    "The `ALGORITHM` parameter is used throughout this notebook to set up the various architectures and the parameters defined below are set up to reproduce the results published in the papers. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "ALGORITHM = \"simsiam\"  # @param [\"barlow\", \"simsiam\", \"simclr\", \"vigreg\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training Parameter Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "CIFAR_IMG_SIZE = 32\n",
    "BATCH_SIZE = 512\n",
    "PRE_TRAIN_EPOCHS = 800\n",
    "PRE_TRAIN_STEPS_PER_EPOCH = len(x_train) // BATCH_SIZE\n",
    "VAL_STEPS_PER_EPOCH = 20\n",
    "WEIGHT_DECAY = 5e-4\n",
    "DIM = 2048  # The layer size for the projector and predictor models.\n",
    "WARMUP_LR = 0.0\n",
    "WARMUP_STEPS = 0\n",
    "TEMPERATURE = None\n",
    "\n",
    "if ALGORITHM == \"simsiam\":\n",
    "    INIT_LR = 3e-2 * int(BATCH_SIZE / 256)\n",
    "elif ALGORITHM == \"barlow\":\n",
    "    INIT_LR = 1e-3  # Initial LR for the learning rate schedule.\n",
    "    WARMUP_STEPS = 1000\n",
    "elif ALGORITHM == \"simclr\":\n",
    "    INIT_LR = 1e-3  # Initial LR for the learning rate schedule, see section B.1 in the paper.\n",
    "    TEMPERATURE = 0.5  # Tuned for CIFAR10, see section B.9 in the paper.\n",
    "elif ALGORITHM == \"vicreg\":\n",
    "    INIT_LR = 1e-3 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Augmented View Configuration\n",
    "\n",
    "Self-supervised networks require at least two augmented \"views\" of each example. This can be created using a DataSet and an augmentation function. The DataSet treats each example in the batch as its own class and then the augment function produces two separate views for each example. \n",
    "\n",
    "This means the resulting batch will yield tuples containing the two views, i.e., `Tuple[(BATCH_SIZE, 32, 32, 3), (BATCH_SIZE, 32, 32, 3)]`. TODO make this clearer, \"each example in the batch is of this type\"\n",
    "\n",
    "TensorFlow Similarity provides several random augmentation functions, and here we combine augmenters from the simCLR module to replicate the augmentations used in simsiam."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def img_scaling(img):\n",
    "    return tf.keras.applications.imagenet_utils.preprocess_input(\n",
    "        img, \n",
    "        data_format=None, \n",
    "        mode='torch')\n",
    "\n",
    "\n",
    "@tf.function\n",
    "def simsiam_augmenter(img, blur=True, area_range=(0.2, 1.0)):\n",
    "    \"\"\"SimSiam augmenter.\n",
    "\n",
    "    The SimSiam augmentations are based on the SimCLR augmentations, but have\n",
    "    some important differences.\n",
    "    * The crop area lower bound is 20% instead of 8%.\n",
    "    * The color jitter and grayscale are applied separately instead of together.\n",
    "    * The color jitter ranges are much smaller.\n",
    "    * Blur is not applied for the cifar10 dataset.\n",
    "\n",
    "    args:\n",
    "        img: Single image tensor of shape (H, W, C)\n",
    "        blur: If true, apply blur. Should be disabled for cifar10.\n",
    "        area_range: The upper and lower bound of the random crop percentage.\n",
    "\n",
    "    returns:\n",
    "        A single image tensor of shape (H, W, C) with values between 0.0 and 1.0.\n",
    "    \"\"\"\n",
    "    # random resize and crop. Increase the size before we crop.\n",
    "    img = tfsim.augmenters.augmentation_utils.cropping.crop_and_resize(\n",
    "        img, CIFAR_IMG_SIZE, CIFAR_IMG_SIZE, area_range=area_range\n",
    "    )\n",
    "    \n",
    "    # The following transforms expect the data to be [0, 1]\n",
    "    img /= 255.\n",
    "    \n",
    "    # random color jitter\n",
    "    def _jitter_transform(x):\n",
    "        return tfsim.augmenters.augmentation_utils.color_jitter.color_jitter_rand(\n",
    "            x,\n",
    "            np.random.uniform(0.0, 0.4),\n",
    "            np.random.uniform(0.0, 0.4),\n",
    "            np.random.uniform(0.0, 0.4),\n",
    "            np.random.uniform(0.0, 0.1),\n",
    "            \"multiplicative\",\n",
    "        )\n",
    "\n",
    "    img = tfsim.augmenters.augmentation_utils.random_apply.random_apply(_jitter_transform, p=0.8, x=img)\n",
    "\n",
    "    # # random grayscale\n",
    "    def _grascayle_transform(x):\n",
    "        return tfsim.augmenters.augmentation_utils.color_jitter.to_grayscale(x)\n",
    "\n",
    "    img = tfsim.augmenters.augmentation_utils.random_apply.random_apply(_grascayle_transform, p=0.2, x=img)\n",
    "\n",
    "    # optional random gaussian blur\n",
    "    if blur:\n",
    "        img = tfsim.augmenters.augmentation_utils.blur.random_blur(img, p=0.5)\n",
    "\n",
    "    # random horizontal flip\n",
    "    img = tf.image.random_flip_left_right(img)\n",
    "    \n",
    "    # scale the data back to [0, 255]\n",
    "    img = img * 255.\n",
    "    img = tf.clip_by_value(img, 0., 255.)\n",
    "\n",
    "    return img\n",
    "\n",
    "\n",
    "@tf.function()\n",
    "def process(img):\n",
    "    view1 = simsiam_augmenter(img, blur=False)\n",
    "    view1 = img_scaling(view1)\n",
    "    view2 = simsiam_augmenter(img, blur=False)\n",
    "    view2 = img_scaling(view2)\n",
    "    return (view1, view2)\n",
    "\n",
    "\n",
    "train_ds = tf.data.Dataset.from_tensor_slices(x_train)\n",
    "train_ds = train_ds.repeat()\n",
    "train_ds = train_ds.shuffle(1024)\n",
    "train_ds = train_ds.map(process, num_parallel_calls=tf.data.AUTOTUNE)\n",
    "train_ds = train_ds.batch(BATCH_SIZE)\n",
    "train_ds = train_ds.prefetch(tf.data.AUTOTUNE)\n",
    "\n",
    "val_ds = tf.data.Dataset.from_tensor_slices(x_val)\n",
    "val_ds = val_ds.repeat()\n",
    "val_ds = val_ds.shuffle(1024)\n",
    "val_ds = val_ds.map(process, num_parallel_calls=tf.data.AUTOTUNE)\n",
    "val_ds = val_ds.batch(BATCH_SIZE)\n",
    "val_ds = val_ds.prefetch(tf.data.AUTOTUNE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualize Augmentations\n",
    "\n",
    "The following cell plots the pairs of augmented views side by side. This can be a useful sanity check as many augmentation functions are set up for the larger ImageNet examples and can be overly aggressive for smaller images found in CIFAR."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2400x400 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display_imgs = next(train_ds.as_numpy_iterator())\n",
    "max_pixel = np.max([display_imgs[0].max(), display_imgs[1].max()])\n",
    "min_pixel = np.min([display_imgs[0].min(), display_imgs[1].min()])\n",
    "\n",
    "tfsim.visualization.visualize_views(\n",
    "    views=display_imgs,\n",
    "    num_imgs=16,\n",
    "    views_per_col=8,\n",
    "    max_pixel_value=max_pixel,\n",
    "    min_pixel_value=min_pixel,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Contrastive Model Setup\n",
    " \n",
    "The following section creates the sub-models used by the different algorithms. There are various architectures for building self-supervised models which may include some of the following:\n",
    "* **Backbone**: This is the base model and is typically an existing architecture like ResNet or EfficientNet.\n",
    "* **Projector**: This is a small multi-layer Neural Net and provides the embedding features at the end of training.\n",
    "* **Predictor**: This model is used by BYOL and SimSiam and provides an additional small multi-layer Neural Net.\n",
    " \n",
    "Typically, the projector and predictor networks are only 2 or 3 layers with batch normalization. While some [papers](https://arxiv.org/abs/2010.10241) claim that batch normalization is not required, the [SimSiam paper](https://arxiv.org/abs/2011.10566) shows empirically that the batch normalization is critical to prevent the model from collapsing to a degenerate solution.\n",
    " \n",
    "Additionally, many papers show a single `encoder` block, but this often contains both the `Backbone` and the `Projector` network.\n",
    " \n",
    "![contrastive_loss_functions.png](https://raw.githubusercontent.com/tensorflow/similarity/master/assets/images/contrastive_loss_functions.png)\n",
    " \n",
    "The diagram above shows three self-supervised architectures supported by TensorFlow Similarity. As you can see, they all share a common structure:\n",
    "* Processing multiple views of the same example.\n",
    "* Using a backbone model for learning the representation output. \n",
    "* Using a projector for the embedding output.\n",
    "* Additionally, note that the loss is symmetric, so we compute it twice during each step. First for view 1 and then a second time for view 2. These two losses are then summed up to compute the final aggregate loss.\n",
    " \n",
    "However, there are some key differences including:\n",
    " \n",
    "* The loss is different in each of the three architectures.\n",
    "    * SimCLR uses a contrastive cross-entropy loss where each example's pair of augmented views should be close to 1 and all other views should be close to zero. Including the negative examples in the loss is part of the reason that SimCLR benefits from larger batch sizes.\n",
    "    * SimSiam only compares the cosine distance between the pairs of augmented views. This means there are no negative examples in the loss, and consequently, the batch size can be much smaller.\n",
    "    * Barlow Twins attempts to learn the cross-correlation between the embedding features, where similar feature activations between two views will produce small values along the diagonal and a positive penalty is applied for positive or negative off-diagonal correlations. In this way the diagonal represents features that are invariant to augmented views, while the off-diagonal values encourage the features to be independent of each other.\n",
    "* The SimSiam architecture requires an additional Predictor network.\n",
    "* The SimSiam architecture also uses a stop-gradient to ensure that we only flow the gradient from the target view.\n",
    " \n",
    " \n",
    "TensorFlow Similarity offers a common set of modules to construct the common parts, and implement the parts which are specific to popular self-supervised algorithms on top of it. Attempting to offer flexibility to add your own algorithm or reuse proven architectures that the results we have reproduced. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Backbone Model\n",
    "\n",
    "The backbone uses a custom version of ResNet18 in order to reproduce the SimSiam CIFAR10 results.\n",
    " \n",
    "<div class=\"alert alert-block alert-info\"> <b>NOTE</b> The ResNet models provided in `tf.keras.applications` use larger `[(1x1), (3x3), (1x1)]` blocks that can't be used to reproduce the SimSiam CIFAR10 results. </div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"resnet18sim\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_1 (InputLayer)        [(None, 32, 32, 3)]       0         \n",
      "                                                                 \n",
      " resnet18 (Functional)       (None, 4, 4, 512)         11182784  \n",
      "                                                                 \n",
      " avg_pool (GlobalAveragePool  (None, 512)              0         \n",
      " ing2D)                                                          \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 11,182,784\n",
      "Trainable params: 11,173,056\n",
      "Non-trainable params: 9,728\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "def get_backbone(img_size, activation=\"relu\", preproc_mode=\"torch\"):\n",
    "    input_shape = (img_size, img_size, 3)\n",
    "\n",
    "    backbone = tfsim.architectures.ResNet18Sim(\n",
    "        input_shape,\n",
    "        include_top=False,  # Take the pooling layer as the output.\n",
    "        pooling=\"avg\",\n",
    "    )\n",
    "    return backbone\n",
    "\n",
    "\n",
    "backbone = get_backbone(CIFAR_IMG_SIZE)\n",
    "backbone.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Projector Model\n",
    " \n",
    "This MLP is common to all the self-supervised models and is typically a stack of 3 layers of the same size. However, SimSiam only uses 2 layers for the smaller CIFAR images. Having too much capacity in the models can make it difficult for the loss to stabilize and converge.\n",
    " \n",
    "Additionally, the SimSiam paper found that disabling the center and scale parameters can lead to a small boost in the final loss.\n",
    " \n",
    "<div class=\"alert alert-block alert-info\"> <b>NOTE</b> This is the model output that is returned by `ContrastiveModel.predict()` and represents the distance based embedding. This embedding can be used for the KNN lookups and matching classification metrics. However, when using the pre-train model for downstream tasks, only the `ContrastiveModel.backbone` is used. </div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "projector = None # Passing None will automatically build the default projector.\n",
    "\n",
    "# Uncomment to build a custom projector.\n",
    "# def get_projector(input_dim, dim, activation=\"relu\", num_layers: int = 3):\n",
    "#     inputs = tf.keras.layers.Input((input_dim,), name=\"projector_input\")\n",
    "#     x = inputs\n",
    "\n",
    "#     for i in range(num_layers - 1):\n",
    "#         x = tf.keras.layers.Dense(\n",
    "#             dim,\n",
    "#             use_bias=False,\n",
    "#             kernel_initializer=tf.keras.initializers.LecunUniform(),\n",
    "#             name=f\"projector_layer_{i}\",\n",
    "#         )(x)\n",
    "#         x = tf.keras.layers.BatchNormalization(epsilon=1.001e-5, name=f\"batch_normalization_{i}\")(x)\n",
    "#         x = tf.keras.layers.Activation(activation, name=f\"{activation}_activation_{i}\")(x)\n",
    "#     x = tf.keras.layers.Dense(\n",
    "#         dim,\n",
    "#         use_bias=False,\n",
    "#         kernel_initializer=tf.keras.initializers.LecunUniform(),\n",
    "#         name=\"projector_output\",\n",
    "#     )(x)\n",
    "#     x = tf.keras.layers.BatchNormalization(\n",
    "#         epsilon=1.001e-5,\n",
    "#         center=False,  # Page:5, Paragraph:2 of SimSiam paper\n",
    "#         scale=False,  # Page:5, Paragraph:2 of SimSiam paper\n",
    "#         name=f\"batch_normalization_ouput\",\n",
    "#     )(x)\n",
    "#     # Metric Logging layer. Monitors the std of the layer activations.\n",
    "#     # Degnerate solutions colapse to 0 while valid solutions will move\n",
    "#     # towards something like 0.0220. The actual number will depend on the layer size.\n",
    "#     o = tfsim.layers.ActivationStdLoggingLayer(name=\"proj_std\")(x)\n",
    "#     projector = tf.keras.Model(inputs, o, name=\"projector\")\n",
    "#     return projector\n",
    "\n",
    "# projector = get_projector(input_dim=backbone.output.shape[-1], dim=DIM, num_layers=2)\n",
    "# projector.summary()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predictor model\n",
    "\n",
    "The predictor model is used by [BYOL](https://arxiv.org/abs/2006.07733) and [SimSiam](https://arxiv.org/abs/2011.10566), and is an additional 2 layer MLP containing a bottleneck in the hidden layer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictor = None # Passing None will automatically build the default predictor.\n",
    "\n",
    "# Uncomment to build a custom predictor.\n",
    "# def get_predictor(input_dim, hidden_dim=512, activation=\"relu\"):\n",
    "#     inputs = tf.keras.layers.Input(shape=(input_dim,), name=\"predictor_input\")\n",
    "#     x = inputs\n",
    "\n",
    "#     x = tf.keras.layers.Dense(\n",
    "#         hidden_dim,\n",
    "#         use_bias=False,\n",
    "#         kernel_initializer=tf.keras.initializers.LecunUniform(),\n",
    "#         name=\"predictor_layer_0\",\n",
    "#     )(x)\n",
    "#     x = tf.keras.layers.BatchNormalization(epsilon=1.001e-5, name=\"batch_normalization_0\")(x)\n",
    "#     x = tf.keras.layers.Activation(activation, name=f\"{activation}_activation_0\")(x)\n",
    "\n",
    "#     x = tf.keras.layers.Dense(\n",
    "#         input_dim,\n",
    "#         kernel_initializer=tf.keras.initializers.LecunUniform(),\n",
    "#         name=\"predictor_output\",\n",
    "#     )(x)\n",
    "#     # Metric Logging layer. Monitors the std of the layer activations.\n",
    "#     # Degnerate solutions colapse to 0 while valid solutions will move\n",
    "#     # towards something like 0.0220. The actual number will depend on the layer size.\n",
    "#     o = tfsim.layers.ActivationStdLoggingLayer(name=\"pred_std\")(x)\n",
    "#     predictor = tf.keras.Model(inputs, o, name=\"predictor\")\n",
    "#     return predictor\n",
    "\n",
    "\n",
    "# predictor = get_predictor(input_dim=DIM, hidden_dim=512)\n",
    "# predictor.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Self-Supervised Algorithms\n",
    " \n",
    "The following section builds the `ContrastiveModel` based on the `ALGORITHM` set at the start of the Notebook.\n",
    " \n",
    "The model training is very sensitive to the learning rate decay and weight decay.\n",
    "* **SimSiam**: Requires using SGD with weight decay from TF Addons. Adding weight decay as a kernel_regularizer doesn't seem to be able to reproduce the published results in the paper.\n",
    "* **Barlow Twins**: We can use LAMB and avoid the need for the learning rate schedule. Lamb is similar to the LARS optimizer used in the Barlow paper, but includes the use of ADAM. Alternatively, we can use SGD but the optimizer requires a warm up period, otherwise the loss explodes.\n",
    "* **SimCLR**: We can also use LAMB as the original paper uses LARS. However, LAMB seems to require smaller learning rates than shown for LARS in the original paper."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "contrastive_model = tfsim.models.create_contrastive_model(\n",
    "    backbone=backbone,\n",
    "    projector=projector,\n",
    "    predictor=predictor,\n",
    "    algorithm=ALGORITHM,\n",
    "    name=ALGORITHM,\n",
    ")\n",
    "\n",
    "if ALGORITHM == \"simsiam\":\n",
    "    loss = tfsim.losses.SimSiamLoss(projection_type=\"cosine_distance\", name=ALGORITHM)\n",
    "    lr_decayed_fn = tf.keras.optimizers.schedules.CosineDecay(\n",
    "        initial_learning_rate=INIT_LR,\n",
    "        decay_steps=PRE_TRAIN_EPOCHS * PRE_TRAIN_STEPS_PER_EPOCH,\n",
    "    )\n",
    "    wd_decayed_fn = tf.keras.optimizers.schedules.CosineDecay(\n",
    "        initial_learning_rate=WEIGHT_DECAY,\n",
    "        decay_steps=PRE_TRAIN_EPOCHS * PRE_TRAIN_STEPS_PER_EPOCH,\n",
    "    )\n",
    "    optimizer = tfa.optimizers.SGDW(learning_rate=lr_decayed_fn, weight_decay=wd_decayed_fn, momentum=0.9)\n",
    "elif ALGORITHM == \"barlow\":\n",
    "    loss = tfsim.losses.Barlow(name=ALGORITHM)\n",
    "    optimizer = tfa.optimizers.LAMB(learning_rate=INIT_LR)\n",
    "elif ALGORITHM == \"simclr\":\n",
    "    loss = tfsim.losses.SimCLRLoss(name=ALGORITHM, temperature=TEMPERATURE)\n",
    "    optimizer = tfa.optimizers.LAMB(learning_rate=INIT_LR)\n",
    "elif ALGORITHM == \"vicreg\":\n",
    "    loss = tfsim.losses.VicReg(name=ALGORITHM)\n",
    "    optimizer = tfa.optimizers.LAMB(learning_rate=INIT_LR)\n",
    "else:\n",
    "    raise ValueError(f\"{ALGORITHM} is not supported.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Compile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "contrastive_model.compile(\n",
    "    optimizer=optimizer,\n",
    "    loss=loss,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Callbacks\n",
    "\n",
    "We track the training using several callbacks.\n",
    "\n",
    "* **EvalCallback** creates an index at the end of each epoch and provides a proxy for the nearest neighbor matching classification using `binary_accuracy`.\n",
    "* **TensordBoard** and **ModelCheckpoint** are provided for tracking the training progress."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TensorBoard logging enable in tfsim_contrastive_model/models/logs/simsiam_1676309803.0325284/index\n"
     ]
    }
   ],
   "source": [
    "log_dir = DATA_PATH / \"models\" / \"logs\" / f\"{loss.name}_{time.time()}\"\n",
    "chkpt_dir = DATA_PATH / \"models\" / \"checkpoints\" / f\"{loss.name}_{time.time()}\"\n",
    "\n",
    "\n",
    "evb = tfsim.callbacks.EvalCallback(\n",
    "    img_scaling(tf.cast(x_query, tf.float32)),\n",
    "    y_query,\n",
    "    img_scaling(tf.cast(x_index, tf.float32)),\n",
    "    y_index,\n",
    "    metrics=[\"binary_accuracy\"],\n",
    "    k=1,\n",
    "    tb_logdir=log_dir,\n",
    ")\n",
    "tbc = tf.keras.callbacks.TensorBoard(\n",
    "    log_dir=log_dir,\n",
    "    histogram_freq=1,\n",
    "    update_freq=100,\n",
    ")\n",
    "mcp = tf.keras.callbacks.ModelCheckpoint(\n",
    "    filepath=chkpt_dir,\n",
    "    monitor=\"val_loss\",\n",
    "    mode=\"min\",\n",
    "    save_best_only=True,\n",
    "    save_weights_only=True,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Model Training\n",
    " \n",
    "The model training provides a number of metrics.\n",
    "- **loss**: This represents the total loss over the contrastive batch. Separate contrastive and regularization losses will also be shown if there are trainable variables in the model layers.\n",
    "- **proj_std and pred_std**: These are added as metric logging layers in the model and show the std of the activations of the final layer in the projector or predictor models.\n",
    "- **binary_accuracy**: This is the nearest neighbor matching classification accuracy. A new index is built at the end of each epoch and the accuracy is computed using the query and index examples.\n",
    " \n",
    "**Notes: Move this to the evaluation section in the paper.**\n",
    "- SGDW or LAMB seems to be required to prevent the loss from becoming unstable.\n",
    "- Per layer kernel_regularization with weight decay doesn't work.\n",
    "- The kernel initialization seems very critical. Smaller, uniform initialization schemes like Lecunn seem to work best.\n",
    "- The projector is a more stable output for the KNN match metrics. The predictor output is typically worse and higher variance.\n",
    "- The LR and weight decay schedule seem important. The loss becomes unstable if the updates are too large later in training.\n",
    "- Too much capacity in the combined model and the training won't converge... same goes for too little capacity.\n",
    "- Augmentation is critical, but too much augmentation and the model won't converge."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/800\n",
      "87/87 [==============================] - 32s 249ms/step - loss: 0.4136 - projector_loss: 0.2068 - proj_std: 0.0320 - pred_std: 0.0210 - val_loss: 0.2078 - val_projector_loss: 0.1039 - val_proj_std: 0.0257 - val_pred_std: 0.0175 - binary_accuracy: 0.2195\n",
      "Epoch 2/800\n",
      "87/87 [==============================] - 20s 233ms/step - loss: 0.2064 - projector_loss: 0.1032 - proj_std: 0.0299 - pred_std: 0.0234 - val_loss: 0.0756 - val_projector_loss: 0.0378 - val_proj_std: 0.0167 - val_pred_std: 0.0117 - binary_accuracy: 0.2155\n",
      "Epoch 3/800\n",
      "87/87 [==============================] - 20s 231ms/step - loss: 0.2732 - projector_loss: 0.1366 - proj_std: 0.0355 - pred_std: 0.0315 - val_loss: 0.1203 - val_projector_loss: 0.0602 - val_proj_std: 0.0209 - val_pred_std: 0.0162 - binary_accuracy: 0.2375\n",
      "Epoch 4/800\n",
      "87/87 [==============================] - 20s 231ms/step - loss: 0.2465 - projector_loss: 0.1232 - proj_std: 0.0358 - pred_std: 0.0316 - val_loss: 0.1113 - val_projector_loss: 0.0556 - val_proj_std: 0.0232 - val_pred_std: 0.0188 - binary_accuracy: 0.2385\n",
      "Epoch 5/800\n",
      "87/87 [==============================] - 20s 230ms/step - loss: 0.2583 - projector_loss: 0.1292 - proj_std: 0.0377 - pred_std: 0.0343 - val_loss: 0.1178 - val_projector_loss: 0.0589 - val_proj_std: 0.0239 - val_pred_std: 0.0210 - binary_accuracy: 0.2430\n",
      "...\n",
      "Epoch 795/800\n",
      "87/87 [==============================] - 20s 231ms/step - loss: 0.0579 - projector_loss: 0.0289 - proj_std: 0.0435 - pred_std: 0.0435 - val_loss: 0.1363 - val_projector_loss: 0.0681 - val_proj_std: 0.0435 - val_pred_std: 0.0435 - binary_accuracy: 0.8595\n",
      "Epoch 796/800\n",
      "87/87 [==============================] - 20s 231ms/step - loss: 0.0589 - projector_loss: 0.0294 - proj_std: 0.0435 - pred_std: 0.0435 - val_loss: 0.1345 - val_projector_loss: 0.0673 - val_proj_std: 0.0435 - val_pred_std: 0.0435 - binary_accuracy: 0.8595\n",
      "Epoch 797/800\n",
      "87/87 [==============================] - 20s 231ms/step - loss: 0.0588 - projector_loss: 0.0294 - proj_std: 0.0435 - pred_std: 0.0435 - val_loss: 0.1355 - val_projector_loss: 0.0677 - val_proj_std: 0.0435 - val_pred_std: 0.0435 - binary_accuracy: 0.8595\n",
      "Epoch 798/800\n",
      "87/87 [==============================] - 20s 230ms/step - loss: 0.0583 - projector_loss: 0.0291 - proj_std: 0.0435 - pred_std: 0.0435 - val_loss: 0.1337 - val_projector_loss: 0.0668 - val_proj_std: 0.0435 - val_pred_std: 0.0435 - binary_accuracy: 0.8605\n",
      "Epoch 799/800\n",
      "87/87 [==============================] - 20s 231ms/step - loss: 0.0586 - projector_loss: 0.0293 - proj_std: 0.0435 - pred_std: 0.0435 - val_loss: 0.1315 - val_projector_loss: 0.0658 - val_proj_std: 0.0435 - val_pred_std: 0.0435 - binary_accuracy: 0.8595\n",
      "Epoch 800/800\n",
      "87/87 [==============================] - 20s 231ms/step - loss: 0.0582 - projector_loss: 0.0291 - proj_std: 0.0435 - pred_std: 0.0435 - val_loss: 0.1352 - val_projector_loss: 0.0676 - val_proj_std: 0.0435 - val_pred_std: 0.0435 - binary_accuracy: 0.8590\n"
     ]
    }
   ],
   "source": [
    "history = contrastive_model.fit(\n",
    "    train_ds,\n",
    "    epochs=PRE_TRAIN_EPOCHS,\n",
    "    steps_per_epoch=PRE_TRAIN_STEPS_PER_EPOCH,\n",
    "    validation_data=val_ds,\n",
    "    validation_steps=VAL_STEPS_PER_EPOCH,\n",
    "    callbacks=[evb, tbc, mcp],\n",
    "    verbose=1,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x400 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(15, 4))\n",
    "plt.subplot(1, 3, 1)\n",
    "plt.plot(history.history[\"loss\"])\n",
    "plt.grid()\n",
    "plt.title(f\"{loss.name} - loss\")\n",
    "\n",
    "plt.subplot(1, 3, 2)\n",
    "plt.plot(history.history[\"proj_std\"], label=\"proj\")\n",
    "if \"pred_std\" in history.history:\n",
    "    plt.plot(history.history[\"pred_std\"], label=\"pred\")\n",
    "plt.grid()\n",
    "plt.title(f\"{loss.name} - std metrics\")\n",
    "plt.legend()\n",
    "\n",
    "plt.subplot(1, 3, 3)\n",
    "plt.plot(history.history[\"binary_accuracy\"], label=\"acc\")\n",
    "plt.grid()\n",
    "plt.title(f\"{loss.name} - match metrics\")\n",
    "plt.legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Save and Reload\n",
    " \n",
    "The `ContrastiveModel` contains a set of sub-models and custom train and test steps. Consequently, the `ContrastiveModel` implements a custom save function that performs the following:\n",
    "* Saves each of the sub models, including the predictor if one exists.\n",
    "* A JSON file containing the serialized Loss, Metrics, and Optimizer.\n",
    "* The Optimizer weighs as a npy file.\n",
    " \n",
    "We also provide a custom `load_model()` function that restores the `ContrastiveModel` and supports continued training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can also load the trained weights from the model checkpoints\n",
    "# contrastive_model.load_weights(DATA_PATH / 'models' / 'checkpoints' / f\"{loss.name}_{CHECKPOINT_TIMESTAMP}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: tfsim_contrastive_model/models/trained_model/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: tfsim_contrastive_model/models/trained_model/assets\n"
     ]
    }
   ],
   "source": [
    "contrastive_model.save(DATA_PATH / \"models\" / \"trained_model\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "del contrastive_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "contrastive_model = tf.keras.models.load_model(\n",
    "    DATA_PATH / \"models\" / \"trained_model\",\n",
    "    custom_objects={\n",
    "        \"ContrastiveModel\": tfsim.models.ContrastiveModel,\n",
    "        \"ActivationStdLoggingLayer\": tfsim.layers.ActivationStdLoggingLayer,\n",
    "    },\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Evaluation\n",
    " \n",
    "This final section trains two different classifiers.\n",
    " \n",
    "1. **No Pre-training**: Uses a ResNet18 model and a simple linear layer.\n",
    " \n",
    "2. **Pre-trained** Uses the frozen pre-trained backbone from the ContrastiveModel and only trains the weights in the linear layer.\n",
    " \n",
    "The original train data is partitioned into eval_train and eval_val splits and a simplified augmentation is applied to the training data. \n",
    " \n",
    "The models are then trained for 10 epochs and the classification accuracy is evaluated on the held out test split."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "TEST_EPOCHS = 10\n",
    "TEST_STEPS_PER_EPOCH = len(x_train) // BATCH_SIZE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "@tf.function\n",
    "def eval_augmenter(img):\n",
    "    # random resize and crop. Increase the size before we crop.\n",
    "    img = tfsim.augmenters.augmentation_utils.cropping.crop_and_resize(\n",
    "        img, CIFAR_IMG_SIZE, CIFAR_IMG_SIZE, area_range=(0.2, 1.0)\n",
    "    )\n",
    "    # random horizontal flip\n",
    "    img = tf.image.random_flip_left_right(img)\n",
    "    img = tf.clip_by_value(img, 0., 255.)\n",
    "\n",
    "    return img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval_train_ds = tf.data.Dataset.from_tensor_slices((x_train, tf.keras.utils.to_categorical(y_train, 10)))\n",
    "eval_train_ds = eval_train_ds.repeat()\n",
    "eval_train_ds = eval_train_ds.shuffle(1024)\n",
    "eval_train_ds = eval_train_ds.map(lambda x, y: (eval_augmenter(x), y), tf.data.AUTOTUNE)\n",
    "eval_train_ds = eval_train_ds.map(lambda x, y: (img_scaling(x), y), tf.data.AUTOTUNE)\n",
    "eval_train_ds = eval_train_ds.batch(BATCH_SIZE)\n",
    "eval_train_ds = eval_train_ds.prefetch(tf.data.AUTOTUNE)\n",
    "\n",
    "eval_val_ds = tf.data.Dataset.from_tensor_slices((x_val, tf.keras.utils.to_categorical(y_val, 10)))\n",
    "eval_val_ds = eval_val_ds.repeat()\n",
    "eval_val_ds = eval_val_ds.shuffle(1024)\n",
    "eval_val_ds = eval_val_ds.map(lambda x, y: (img_scaling(tf.cast(x, dtype=tf.float32)), y), tf.data.AUTOTUNE)\n",
    "eval_val_ds = eval_val_ds.batch(BATCH_SIZE)\n",
    "eval_val_ds = eval_val_ds.prefetch(tf.data.AUTOTUNE)\n",
    "\n",
    "eval_test_ds = tf.data.Dataset.from_tensor_slices((x_test, tf.keras.utils.to_categorical(y_test, 10)))\n",
    "eval_test_ds = eval_test_ds.map(lambda x, y: (img_scaling(tf.cast(x, dtype=tf.float32)), y), tf.data.AUTOTUNE)\n",
    "eval_test_ds = eval_test_ds.batch(BATCH_SIZE)\n",
    "eval_test_ds = eval_test_ds.prefetch(tf.data.AUTOTUNE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_eval_model(img_size, backbone, total_steps, trainable=True, lr=1.8):\n",
    "    backbone.trainable = trainable\n",
    "    inputs = tf.keras.layers.Input((img_size, img_size, 3), name=\"eval_input\")\n",
    "    x = backbone(inputs, training=trainable)\n",
    "    o = tf.keras.layers.Dense(10, activation=\"softmax\")(x)\n",
    "    model = tf.keras.Model(inputs, o)\n",
    "    cosine_decayed_lr = tf.keras.experimental.CosineDecay(initial_learning_rate=lr, decay_steps=total_steps)\n",
    "    opt = tf.keras.optimizers.SGD(cosine_decayed_lr, momentum=0.9)\n",
    "    model.compile(optimizer=opt, loss=\"categorical_crossentropy\", metrics=[\"acc\"])\n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### No Pretrain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "87/87 [==============================] - 13s 112ms/step - loss: 2.0278 - acc: 0.2571 - val_loss: 1.7205 - val_acc: 0.3712\n",
      "Epoch 2/10\n",
      "87/87 [==============================] - 9s 104ms/step - loss: 1.7542 - acc: 0.3510 - val_loss: 1.5881 - val_acc: 0.4158\n",
      "Epoch 3/10\n",
      "87/87 [==============================] - 9s 104ms/step - loss: 1.6622 - acc: 0.3883 - val_loss: 1.5059 - val_acc: 0.4511\n",
      "Epoch 4/10\n",
      "87/87 [==============================] - 9s 104ms/step - loss: 1.6075 - acc: 0.4128 - val_loss: 1.4638 - val_acc: 0.4580\n",
      "Epoch 5/10\n",
      "87/87 [==============================] - 9s 104ms/step - loss: 1.5660 - acc: 0.4320 - val_loss: 1.4175 - val_acc: 0.4867\n",
      "Epoch 6/10\n",
      "87/87 [==============================] - 9s 104ms/step - loss: 1.5392 - acc: 0.4413 - val_loss: 1.3912 - val_acc: 0.4936\n",
      "Epoch 7/10\n",
      "87/87 [==============================] - 9s 104ms/step - loss: 1.5211 - acc: 0.4477 - val_loss: 1.3717 - val_acc: 0.4974\n",
      "Epoch 8/10\n",
      "87/87 [==============================] - 9s 104ms/step - loss: 1.5061 - acc: 0.4562 - val_loss: 1.3679 - val_acc: 0.4966\n",
      "Epoch 9/10\n",
      "87/87 [==============================] - 9s 104ms/step - loss: 1.4987 - acc: 0.4583 - val_loss: 1.3604 - val_acc: 0.5017\n",
      "Epoch 10/10\n",
      "87/87 [==============================] - 9s 104ms/step - loss: 1.4950 - acc: 0.4600 - val_loss: 1.3579 - val_acc: 0.5051\n"
     ]
    }
   ],
   "source": [
    "no_pt_eval_model = get_eval_model(\n",
    "    img_size=CIFAR_IMG_SIZE,\n",
    "    backbone=get_backbone(CIFAR_IMG_SIZE, DIM),\n",
    "    total_steps=TEST_EPOCHS * TEST_STEPS_PER_EPOCH,\n",
    "    trainable=True,\n",
    "    lr=1e-3,\n",
    ")\n",
    "no_pt_history = no_pt_eval_model.fit(\n",
    "    eval_train_ds,\n",
    "    batch_size=BATCH_SIZE,\n",
    "    epochs=TEST_EPOCHS,\n",
    "    steps_per_epoch=TEST_STEPS_PER_EPOCH,\n",
    "    validation_data=eval_val_ds,\n",
    "    validation_steps=VAL_STEPS_PER_EPOCH,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pretrained"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_1\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " eval_input (InputLayer)     [(None, 32, 32, 3)]       0         \n",
      "                                                                 \n",
      " resnet18sim (SimilarityMode  (None, 512)              11182784  \n",
      " l)                                                              \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 10)                5130      \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 11,187,914\n",
      "Trainable params: 5,130\n",
      "Non-trainable params: 11,182,784\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "pt_eval_model = get_eval_model(\n",
    "    img_size=CIFAR_IMG_SIZE,\n",
    "    backbone=contrastive_model.backbone,\n",
    "    total_steps=TEST_EPOCHS * TEST_STEPS_PER_EPOCH,\n",
    "    trainable=False,\n",
    "    lr=30.0,\n",
    ")\n",
    "pt_eval_model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "87/87 [==============================] - 4s 31ms/step - loss: 38.7522 - acc: 0.1102 - val_loss: 46.2305 - val_acc: 0.1637\n",
      "Epoch 2/10\n",
      "87/87 [==============================] - 2s 27ms/step - loss: 31.3384 - acc: 0.1285 - val_loss: 36.8347 - val_acc: 0.1855\n",
      "Epoch 3/10\n",
      "87/87 [==============================] - 2s 27ms/step - loss: 23.4059 - acc: 0.1644 - val_loss: 12.9000 - val_acc: 0.1475\n",
      "Epoch 4/10\n",
      "87/87 [==============================] - 2s 27ms/step - loss: 8.9611 - acc: 0.3288 - val_loss: 1.4494 - val_acc: 0.6218\n",
      "Epoch 5/10\n",
      "87/87 [==============================] - 2s 27ms/step - loss: 0.6391 - acc: 0.8302 - val_loss: 0.3483 - val_acc: 0.8980\n",
      "Epoch 6/10\n",
      "87/87 [==============================] - 2s 27ms/step - loss: 0.3687 - acc: 0.8847 - val_loss: 0.3437 - val_acc: 0.9045\n",
      "Epoch 7/10\n",
      "87/87 [==============================] - 2s 27ms/step - loss: 0.3625 - acc: 0.8877 - val_loss: 0.3471 - val_acc: 0.9006\n",
      "Epoch 8/10\n",
      "87/87 [==============================] - 2s 27ms/step - loss: 0.3618 - acc: 0.8883 - val_loss: 0.3405 - val_acc: 0.9055\n",
      "Epoch 9/10\n",
      "87/87 [==============================] - 2s 27ms/step - loss: 0.3552 - acc: 0.8891 - val_loss: 0.3352 - val_acc: 0.9073\n",
      "Epoch 10/10\n",
      "87/87 [==============================] - 2s 27ms/step - loss: 0.3527 - acc: 0.8909 - val_loss: 0.3376 - val_acc: 0.9057\n"
     ]
    }
   ],
   "source": [
    "pt_history = pt_eval_model.fit(\n",
    "    eval_train_ds,\n",
    "    batch_size=BATCH_SIZE,\n",
    "    epochs=TEST_EPOCHS,\n",
    "    steps_per_epoch=TEST_STEPS_PER_EPOCH,\n",
    "    validation_data=eval_val_ds,\n",
    "    validation_steps=VAL_STEPS_PER_EPOCH,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Comparison"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20/20 [==============================] - 1s 32ms/step - loss: 1.3865 - acc: 0.4956\n",
      "no pretrain [1.3864651918411255, 0.49559998512268066]\n",
      "20/20 [==============================] - 0s 21ms/step - loss: 0.3928 - acc: 0.8816\n",
      "pretrained [0.3927702009677887, 0.881600022315979]\n"
     ]
    }
   ],
   "source": [
    "print(\"no pretrain\", no_pt_eval_model.evaluate(eval_test_ds))\n",
    "print(\"pretrained\", pt_eval_model.evaluate(eval_test_ds))"
   ]
  }
 ],
 "metadata": {
  "environment": {
   "kernel": "python3",
   "name": "tf2-gpu.2-8.m91",
   "type": "gcloud",
   "uri": "gcr.io/deeplearning-platform-release/tf2-gpu.2-8:m91"
  },
  "kernelspec": {
   "display_name": ".env",
   "language": "python",
   "name": "python3"
  },
  "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"
  },
  "vscode": {
   "interpreter": {
    "hash": "c7b3389fe492617a9dd862ce9e69c0dfb3e62254a4be8ff5561f4f9b5c78139c"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}