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": 1,
   "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": 2,
   "metadata": {},
   "outputs": [],
   "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": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Your CPU supports instructions that this binary was not compiled to use: SSE3 SSE4.1 SSE4.2 AVX AVX2\n",
      "For maximum performance, you can install NMSLIB from sources \n",
      "pip install --no-binary :all: nmslib\n"
     ]
    }
   ],
   "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": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "import tensorflow_datasets as tfds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Physical devices cannot be modified after being initialized\n"
     ]
    }
   ],
   "source": [
    "tfsim.utils.tf_cap_memory()  # Avoid GPU memory blow up"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Clear out any old model state.\n",
    "gc.collect()\n",
    "tf.keras.backend.clear_session()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TensorFlow: 2.7.0\n",
      "TensorFlow Similarity 0.16.0.dev51\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": 8,
   "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": null,
   "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": 10,
   "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": 11,
   "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": 12,
   "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."
   ]
  },
  {
   "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",
    "\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": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "ALGORITHM = \"simsiam\"  # @param [\"barlow\", \"simsiam\", \"simclr\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training Parameter Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "CIFAR_IMG_SIZE = 32\n",
    "\n",
    "if ALGORITHM == \"simsiam\":\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",
    "    INIT_LR = 3e-2 * int(BATCH_SIZE / 256)\n",
    "    WARMUP_LR = 0.0\n",
    "    WARMUP_STEPS = 0\n",
    "    DIM = 2048  # The layer size for the projector and predictor models.\n",
    "elif ALGORITHM == \"barlow\":\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",
    "    INIT_LR = 1e-3  # Initial LR for the learning rate schedule.\n",
    "    WARMUP_LR = 0.0\n",
    "    WARMUP_STEPS = 1000\n",
    "    DIM = 2048  # The layer size for the projector and predictor models.\n",
    "elif ALGORITHM == \"simclr\":\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",
    "    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",
    "    DIM = 2048  # The layer size for the projector and predictor models."
   ]
  },
  {
   "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": 15,
   "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": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1728x288 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": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"projector\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " projector_input (InputLayer  [(None, 512)]            0         \n",
      " )                                                               \n",
      "                                                                 \n",
      " projector_layer_0 (Dense)   (None, 2048)              1048576   \n",
      "                                                                 \n",
      " batch_normalization_0 (Batc  (None, 2048)             8192      \n",
      " hNormalization)                                                 \n",
      "                                                                 \n",
      " relu_activation_0 (Activati  (None, 2048)             0         \n",
      " on)                                                             \n",
      "                                                                 \n",
      " projector_output (Dense)    (None, 2048)              4194304   \n",
      "                                                                 \n",
      " batch_normalization_ouput (  (None, 2048)             4096      \n",
      " BatchNormalization)                                             \n",
      "                                                                 \n",
      " proj_std (ActivationStdLogg  (None, 2048)             0         \n",
      " ingLayer)                                                       \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 5,255,168\n",
      "Trainable params: 5,246,976\n",
      "Non-trainable params: 8,192\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "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",
    "\n",
    "projector = get_projector(input_dim=backbone.output.shape[-1], dim=DIM, num_layers=2)\n",
    "projector.summary()"
   ]
  },
  {
   "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": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"predictor\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " predictor_input (InputLayer  [(None, 2048)]           0         \n",
      " )                                                               \n",
      "                                                                 \n",
      " predictor_layer_0 (Dense)   (None, 512)               1048576   \n",
      "                                                                 \n",
      " batch_normalization_0 (Batc  (None, 512)              2048      \n",
      " hNormalization)                                                 \n",
      "                                                                 \n",
      " relu_activation_0 (Activati  (None, 512)              0         \n",
      " on)                                                             \n",
      "                                                                 \n",
      " predictor_output (Dense)    (None, 2048)              1050624   \n",
      "                                                                 \n",
      " pred_std (ActivationStdLogg  (None, 2048)             0         \n",
      " ingLayer)                                                       \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 2,101,248\n",
      "Trainable params: 2,100,224\n",
      "Non-trainable params: 1,024\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "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": [
    "if ALGORITHM == \"simsiam\":\n",
    "    loss = tfsim.losses.SimSiamLoss(projection_type=\"cosine_distance\", name=ALGORITHM)\n",
    "\n",
    "    contrastive_model = tfsim.models.ContrastiveModel(\n",
    "        backbone=backbone,\n",
    "        projector=projector,\n",
    "        predictor=predictor,  # NOTE: simiam requires predictor model.\n",
    "        algorithm=ALGORITHM,\n",
    "        name=ALGORITHM,\n",
    "    )\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",
    "\n",
    "    contrastive_model = tfsim.models.ContrastiveModel(\n",
    "        backbone=backbone,\n",
    "        projector=projector,\n",
    "        algorithm=\"barlow\",\n",
    "    )\n",
    "    optimizer = tfa.optimizers.LAMB(learning_rate=INIT_LR)\n",
    "elif ALGORITHM == \"simclr\":\n",
    "    loss = tfsim.losses.SimCLRLoss(name=ALGORITHM, temperature=TEMPERATURE)\n",
    "\n",
    "    contrastive_model = tfsim.models.ContrastiveModel(\n",
    "        backbone=backbone,\n",
    "        projector=projector,\n",
    "        algorithm=ALGORITHM,\n",
    "    )\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_1648855712.954453/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": [
      "87/87 [==============================] - 45s 522ms/step - loss: 0.2315 - proj_std: 0.0148 - pred_std: 0.0116 - val_loss: 0.1490 - val_proj_std: 0.0120 - val_pred_std: 0.0093 - binary_accuracy: 0.2475\n",
      "Epoch 4/800\n",
      "87/87 [==============================] - 45s 522ms/step - loss: 0.2412 - proj_std: 0.0154 - pred_std: 0.0129 - val_loss: 0.1350 - val_proj_std: 0.0111 - val_pred_std: 0.0083 - binary_accuracy: 0.2275\n",
      "Epoch 5/800\n",
      "87/87 [==============================] - 45s 522ms/step - loss: 0.1969 - proj_std: 0.0146 - pred_std: 0.0121 - val_loss: 0.1484 - val_proj_std: 0.0126 - val_pred_std: 0.0103 - binary_accuracy: 0.2235\n",
      "Epoch 6/800\n",
      "87/87 [==============================] - 45s 522ms/step - loss: 0.2006 - proj_std: 0.0152 - pred_std: 0.0129 - val_loss: 0.1510 - val_proj_std: 0.0132 - val_pred_std: 0.0107 - binary_accuracy: 0.2290\n",
      "Epoch 7/800\n",
      "87/87 [==============================] - 45s 522ms/step - loss: 0.2338 - proj_std: 0.0161 - pred_std: 0.0140 - val_loss: 0.2381 - val_proj_std: 0.0129 - val_pred_std: 0.0123 - binary_accuracy: 0.2215\n",
      "Epoch 8/800\n",
      "87/87 [==============================] - 46s 531ms/step - loss: 0.1311 - proj_std: 0.0106 - pred_std: 0.0079 - val_loss: 0.0825 - val_proj_std: 0.0079 - val_pred_std: 0.0058 - binary_accuracy: 0.2465\n",
      "\n",
      "...\n",
      "\n",
      "Epoch 795/800\n",
      "87/87 [==============================] - 45s 520ms/step - loss: 0.0510 - proj_std: 0.0211 - pred_std: 0.0211 - val_loss: 0.0921 - val_proj_std: 0.0211 - val_pred_std: 0.0211 - binary_accuracy: 0.8400\n",
      "Epoch 796/800\n",
      "87/87 [==============================] - 45s 521ms/step - loss: 0.0501 - proj_std: 0.0211 - pred_std: 0.0211 - val_loss: 0.0905 - val_proj_std: 0.0211 - val_pred_std: 0.0211 - binary_accuracy: 0.8385\n",
      "Epoch 797/800\n",
      "87/87 [==============================] - 45s 520ms/step - loss: 0.0504 - proj_std: 0.0211 - pred_std: 0.0211 - val_loss: 0.0894 - val_proj_std: 0.0211 - val_pred_std: 0.0211 - binary_accuracy: 0.8400\n",
      "Epoch 798/800\n",
      "87/87 [==============================] - 45s 520ms/step - loss: 0.0507 - proj_std: 0.0211 - pred_std: 0.0211 - val_loss: 0.0917 - val_proj_std: 0.0211 - val_pred_std: 0.0211 - binary_accuracy: 0.8405\n",
      "Epoch 799/800\n",
      "87/87 [==============================] - 45s 521ms/step - loss: 0.0505 - proj_std: 0.0211 - pred_std: 0.0211 - val_loss: 0.0904 - val_proj_std: 0.0211 - val_pred_std: 0.0211 - binary_accuracy: 0.8380\n",
      "Epoch 800/800\n",
      "87/87 [==============================] - 45s 520ms/step - loss: 0.0508 - proj_std: 0.0211 - pred_std: 0.0211 - val_loss: 0.0931 - val_proj_std: 0.0211 - val_pred_std: 0.0211 - binary_accuracy: 0.8380\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",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "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": 26,
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "contrastive_model.save(DATA_PATH / \"models\" / f\"trained_model\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "del contrastive_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "contrastive_model = tfsim.models.contrastive_model.load_model(DATA_PATH / \"models\" / f\"trained_model\")"
   ]
  },
  {
   "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": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "TEST_EPOCHS = 10\n",
    "TEST_STEPS_PER_EPOCH = int(len(x_train) // BATCH_SIZE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "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": 31,
   "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": 32,
   "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": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "87/87 [==============================] - 23s 243ms/step - loss: 2.0172 - acc: 0.2489 - val_loss: 1.7746 - val_acc: 0.3575\n",
      "Epoch 2/10\n",
      "87/87 [==============================] - 21s 240ms/step - loss: 1.7701 - acc: 0.3436 - val_loss: 1.6403 - val_acc: 0.4103\n",
      "Epoch 3/10\n",
      "87/87 [==============================] - 21s 240ms/step - loss: 1.6876 - acc: 0.3810 - val_loss: 1.5606 - val_acc: 0.4524\n",
      "Epoch 4/10\n",
      "87/87 [==============================] - 21s 240ms/step - loss: 1.6282 - acc: 0.4041 - val_loss: 1.5015 - val_acc: 0.4822\n",
      "Epoch 5/10\n",
      "87/87 [==============================] - 21s 240ms/step - loss: 1.5949 - acc: 0.4160 - val_loss: 1.4811 - val_acc: 0.4837\n",
      "Epoch 6/10\n",
      "87/87 [==============================] - 21s 240ms/step - loss: 1.5587 - acc: 0.4312 - val_loss: 1.4530 - val_acc: 0.4939\n",
      "Epoch 7/10\n",
      "87/87 [==============================] - 21s 240ms/step - loss: 1.5467 - acc: 0.4392 - val_loss: 1.4394 - val_acc: 0.4990\n",
      "Epoch 8/10\n",
      "87/87 [==============================] - 21s 240ms/step - loss: 1.5332 - acc: 0.4422 - val_loss: 1.4325 - val_acc: 0.5049\n",
      "Epoch 9/10\n",
      "87/87 [==============================] - 21s 239ms/step - loss: 1.5244 - acc: 0.4492 - val_loss: 1.4230 - val_acc: 0.5032\n",
      "Epoch 10/10\n",
      "87/87 [==============================] - 21s 239ms/step - loss: 1.5225 - acc: 0.4477 - val_loss: 1.4310 - val_acc: 0.5011\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": 34,
   "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": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "87/87 [==============================] - 7s 73ms/step - loss: 25.6340 - acc: 0.1167 - val_loss: 45.2397 - val_acc: 0.1006\n",
      "Epoch 2/10\n",
      "87/87 [==============================] - 6s 70ms/step - loss: 28.9244 - acc: 0.1400 - val_loss: 17.0148 - val_acc: 0.2383\n",
      "Epoch 3/10\n",
      "87/87 [==============================] - 6s 70ms/step - loss: 23.7029 - acc: 0.1814 - val_loss: 8.9316 - val_acc: 0.4129\n",
      "Epoch 4/10\n",
      "87/87 [==============================] - 6s 70ms/step - loss: 2.9793 - acc: 0.6001 - val_loss: 0.4309 - val_acc: 0.8693\n",
      "Epoch 5/10\n",
      "87/87 [==============================] - 6s 70ms/step - loss: 0.3985 - acc: 0.8709 - val_loss: 0.3780 - val_acc: 0.8748\n",
      "Epoch 6/10\n",
      "87/87 [==============================] - 6s 70ms/step - loss: 0.3886 - acc: 0.8745 - val_loss: 0.3781 - val_acc: 0.8800\n",
      "Epoch 7/10\n",
      "87/87 [==============================] - 6s 70ms/step - loss: 0.3763 - acc: 0.8768 - val_loss: 0.3719 - val_acc: 0.8820\n",
      "Epoch 8/10\n",
      "87/87 [==============================] - 6s 70ms/step - loss: 0.3698 - acc: 0.8814 - val_loss: 0.3714 - val_acc: 0.8688\n",
      "Epoch 9/10\n",
      "87/87 [==============================] - 6s 70ms/step - loss: 0.3667 - acc: 0.8815 - val_loss: 0.3688 - val_acc: 0.8827\n",
      "Epoch 10/10\n",
      "87/87 [==============================] - 6s 70ms/step - loss: 0.3626 - acc: 0.8817 - val_loss: 0.3683 - val_acc: 0.8831\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": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20/20 [==============================] - 2s 75ms/step - loss: 1.3837 - acc: 0.4973\n",
      "no pretrain [1.383693814277649, 0.49729999899864197]\n",
      "20/20 [==============================] - 1s 56ms/step - loss: 0.3843 - acc: 0.8721\n",
      "pretrained [0.38433709740638733, 0.8720999956130981]\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"
  },
  "interpreter": {
   "hash": "cada0c3e68bbe3038c05f3f13c34d05fb5411cc128b62a4a529880c33c3268c3"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}