cutmix.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "cutmix.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S2qg_vxs91NV"
      },
      "source": [
        "# CutMix data augmentation for image classification\n",
        "\n",
        "**Author:** [Sayan Nath](https://twitter.com/SayanNa20204009)<br>\n",
        "**Date created:** 2021/03/25<br>\n",
        "**Last modified:** 2021/03/25<br>\n",
        "**Description:** Data augmentation with CutMix for image classification on CIFAR-10."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d8o5dvT7-KeP"
      },
      "source": [
        "## Introduction"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KtUhqR0fZ1mI"
      },
      "source": [
        "_CutMix_ is a data augmentation technique that addresses the issue of\n",
        "information loss and inefficiency present in regional dropout strategies. \n",
        "Instead of removing pixels and filling them with black or grey pixels or\n",
        "Gaussian noise, you replace the removed regions with a patch from another image,\n",
        "while the ground truth labels are mixed proportionally to the number of pixels\n",
        "of combined images. CutMix was proposed in\n",
        "[CutMix: Regularization Strategy to Train Strong Classifiers with Localizable Features](https://arxiv.org/pdf/1905.04899.pdf)\n",
        "(Yun et al., 2019)\n",
        "\n",
        "It's implemented with the following formulas:\n",
        "\n",
        "![](https://i.imgur.com/cGvd13V.png)\n",
        "\n",
        "where M is the binary mask which indicates the cutout and the fill-in regions from the two randomly drawn images and λ is drawn from [Beta(α,α) distribution](https://en.wikipedia.org/wiki/Beta_distribution) and `λ ∈ [0, 1]`\n",
        "\n",
        "\n",
        "The coordinates of bounding boxes are ![](https://i.imgur.com/eNisep4.png) which indicates the cutout and fill-in regions in case of the images.\n",
        "\n",
        "The bounding box sampling is represented by:\n",
        "\n",
        "![](https://i.imgur.com/Snph9aj.png)\n",
        "\n",
        "where `rx,ry` are randomly drawn from a uniform distribution with upper bound\n",
        "\n",
        "This example requires TensorFlow 2.4 or higher."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RdHktOHMxN_t"
      },
      "source": [
        "## Import the necessary packages"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jF9JLzG7AT3C"
      },
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "from tensorflow.keras import mixed_precision\n",
        "\n",
        "np.random.seed(42)\n",
        "tf.random.set_seed(42)"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OsyqMVujxa92"
      },
      "source": [
        "## Load the CIFAR-10 dataset\n",
        "\n",
        "In this example, we will use the\n",
        "[CIFAR- 10 dataset](https://www.cs.toronto.edu/~kriz/cifar.html)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kLjqzw95AoOV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5022589e-6548-4ceb-cbfc-b56c191b2f37"
      },
      "source": [
        "(x_train, y_train), (x_test, y_test) = tf.keras.datasets.cifar10.load_data()\n",
        "\n",
        "\n",
        "y_train = tf.keras.utils.to_categorical(y_train, num_classes=10)\n",
        "y_test = tf.keras.utils.to_categorical(y_test, num_classes=10)"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Downloading data from https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz\n",
            "170500096/170498071 [==============================] - 4s 0us/step\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-3KX99WjTODk",
        "outputId": "d6a98b9b-8ad5-4e72-c9bd-b8f5a93da8bf"
      },
      "source": [
        "print(x_train.shape)\n",
        "print(y_train.shape)\n",
        "\n",
        "print(x_test.shape)\n",
        "print(y_test.shape)"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(50000, 32, 32, 3)\n",
            "(50000, 10)\n",
            "(10000, 32, 32, 3)\n",
            "(10000, 10)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_TiyAbozDfB3"
      },
      "source": [
        "class_names = [\"Airplane\", \"Automobile\", \"Bird\", \"Cat\", \"Deer\", \"Dog\", \"Frog\", \"Horse\", \"Ship\", \"Truck\"]"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GSglnCojx5nt"
      },
      "source": [
        "## Define hyperparameters"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zXbNlfHKA3q2"
      },
      "source": [
        "AUTO = tf.data.experimental.AUTOTUNE\n",
        "BATCH_SIZE = 32\n",
        "IMG_SHAPE = 32"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_z9SarG-ypVM"
      },
      "source": [
        "## Define the image preprocessing function"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "buntzLP9A6-U"
      },
      "source": [
        "def preprocess_image(image, label):\n",
        "  image = tf.image.resize(image, (IMG_SHAPE, IMG_SHAPE))\n",
        "  image = tf.image.convert_image_dtype(image, tf.float32) / 255.\n",
        "  return image, label"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PZQ1k__B2KC3"
      },
      "source": [
        "## Convert the data into TensorFlow `Dataset` objects"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "doU1_wf81j59"
      },
      "source": [
        "train_ds_one = tf.data.Dataset.from_tensor_slices((x_train, y_train)).shuffle(1024).map(preprocess_image, num_parallel_calls=AUTO)\n",
        "train_ds_two = tf.data.Dataset.from_tensor_slices((x_train, y_train)).shuffle(1024).map(preprocess_image, num_parallel_calls=AUTO)\n",
        "\n",
        "train_ds_simple = tf.data.Dataset.from_tensor_slices((x_train, y_train))\n",
        "\n",
        "test_ds = tf.data.Dataset.from_tensor_slices((x_test, y_test))\n",
        "\n",
        "train_ds_simple = (train_ds_simple.map(preprocess_image, num_parallel_calls=AUTO).batch(BATCH_SIZE).prefetch(AUTO))\n",
        "\n",
        "# Combine two shuffled datasets from the same training data.\n",
        "train_ds = tf.data.Dataset.zip((train_ds_one, train_ds_two))\n",
        "\n",
        "test_ds = (test_ds.map(preprocess_image, num_parallel_calls=AUTO).batch(BATCH_SIZE).prefetch(AUTO))"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rL-pV1kiyu6w"
      },
      "source": [
        "## Define the CutMix data augmentation function\n",
        "\n",
        "The CutMix function takes two `image` and `label` pairs to perform the\n",
        "augmentation. It samples `λ(l)` from the\n",
        "[Beta distribution](https://en.wikipedia.org/wiki/Beta_distribution) and returns\n",
        "a bounding box from `get_box` function. We then crop the second image (`image2`)\n",
        "and pad this image in the final padded image at the same location."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L1qrlrjvBBKb"
      },
      "source": [
        "def sample_beta_distribution(size, concentration_0=0.2, concentration_1=0.2):\n",
        "    gamma_1_sample = tf.random.gamma(shape=[size], alpha=concentration_1)\n",
        "    gamma_2_sample = tf.random.gamma(shape=[size], alpha=concentration_0)\n",
        "    return gamma_1_sample / (gamma_1_sample + gamma_2_sample)\n",
        "\n",
        "@tf.function\n",
        "def get_box(lambda_value):\n",
        "    cut_rat = tf.math.sqrt(1.0 - lambda_value)\n",
        "\n",
        "    cut_w = IMG_SHAPE * cut_rat  # rw\n",
        "    cut_w = tf.cast(cut_w, tf.int32)\n",
        "\n",
        "    cut_h = IMG_SHAPE * cut_rat  # rh\n",
        "    cut_h = tf.cast(cut_h, tf.int32)\n",
        "\n",
        "    cut_x = tf.random.uniform((1,), minval=0, maxval=IMG_SHAPE, dtype=tf.int32)  # rx\n",
        "    cut_y = tf.random.uniform((1,), minval=0, maxval=IMG_SHAPE, dtype=tf.int32)  # ry\n",
        "\n",
        "    boundaryx1 = tf.clip_by_value(cut_x[0] - cut_w // 2, 0, IMG_SHAPE)\n",
        "    boundaryy1 = tf.clip_by_value(cut_y[0] - cut_h // 2, 0, IMG_SHAPE)\n",
        "    bbx2 = tf.clip_by_value(cut_x[0] + cut_w // 2, 0, IMG_SHAPE)\n",
        "    bby2 = tf.clip_by_value(cut_y[0] + cut_h // 2, 0, IMG_SHAPE)\n",
        "\n",
        "    target_h = bby2 - boundaryy1\n",
        "    if target_h == 0:\n",
        "        target_h += 1\n",
        "\n",
        "    target_w = bbx2 - boundaryx1\n",
        "    if target_w == 0:\n",
        "        target_w += 1\n",
        "\n",
        "    return boundaryx1, boundaryy1, target_h, target_w\n",
        "\n",
        "\n",
        "@tf.function\n",
        "def cutmix(train_ds_one, train_ds_two):\n",
        "\n",
        "    (image1, label1), (image2, label2) = train_ds_one, train_ds_two\n",
        "\n",
        "    alpha = [0.25]\n",
        "    beta = [0.25]\n",
        "\n",
        "    # Get a sample from the Beta distribution\n",
        "    lambda_value = sample_beta_distribution(1, alpha, beta)\n",
        " \n",
        "    # Define Lambda\n",
        "    lambda_value = lambda_value[0][0]\n",
        "  \n",
        "    # Get the bounding box offsets, heights and widths\n",
        "    boundaryx1, boundaryy1, target_h, target_w = get_box(lambda_value)\n",
        "\n",
        "    # Get a patch from the second image (`image2`)\n",
        "    crop2 = tf.image.crop_to_bounding_box(image2, boundaryy1, boundaryx1, target_h, target_w)\n",
        "    # Pad the `image2` patch (`crop2`) with the same offset\n",
        "    image2 = tf.image.pad_to_bounding_box(crop2, boundaryy1, boundaryx1, IMG_SHAPE, IMG_SHAPE)\n",
        "    # Get a patch from the first image (`image1`)\n",
        "    crop1 = tf.image.crop_to_bounding_box(image1, boundaryy1, boundaryx1, target_h, target_w)\n",
        "    # Pad the `image1` patch (`crop1`) with the same offset\n",
        "    img1 = tf.image.pad_to_bounding_box(crop1, boundaryy1, boundaryx1, IMG_SHAPE, IMG_SHAPE)\n",
        "\n",
        "    # Modify the first image by subtracting the patch from `image1`\n",
        "    # (before applying the `image2` patch)\n",
        "    image1 = image1 - img1\n",
        "    # Add the modified `image1` and `image2`  together to get the CutMix image\n",
        "    image = image1 + image2\n",
        "\n",
        "    # Adjust Lambda in accordance to the pixel ration\n",
        "    lambda_value = 1 - (target_w * target_h) / (IMG_SHAPE * IMG_SHAPE)\n",
        "    lambda_value = tf.cast(lambda_value, tf.float32)\n",
        "\n",
        "    # Combine the labels of both images\n",
        "    label = lambda_value * label1 + (1 - lambda_value) * label2\n",
        "\n",
        "    return image, label"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8nqeRs783Qg7"
      },
      "source": [
        "**Note**: we are combining two images to create a single one."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fiAPfghC3BsO"
      },
      "source": [
        "## Visualize the new dataset after applying the CutMix augmentation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HxJbIiDxBEhd",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 591
        },
        "outputId": "8ed17112-e080-4b71-868d-924b6f65bb2b"
      },
      "source": [
        "# Create the new dataset using our `cutmix` utility\n",
        "train_ds_cmu = (train_ds.shuffle(1024).map(cutmix, num_parallel_calls=AUTO).batch(BATCH_SIZE).prefetch(AUTO))\n",
        "\n",
        "# Let's preview 9 samples from the dataset\n",
        "image_batch, label_batch = next(iter(train_ds_cmu))\n",
        "plt.figure(figsize=(10,10))\n",
        "for i in range(9):\n",
        "    ax = plt.subplot(3 ,3 ,i + 1)\n",
        "    plt.title(class_names[np.argmax(label_batch[i])])\n",
        "    plt.imshow(image_batch[i])\n",
        "    plt.axis('off')"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x720 with 9 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VTh8Z7Q87AWi"
      },
      "source": [
        "## Define the model using ResNet-20"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_gTDvUH7EPjW"
      },
      "source": [
        "def resnet_layer(inputs,\n",
        "                 num_filters=16,\n",
        "                 kernel_size=3,\n",
        "                 strides=1,\n",
        "                 activation='relu',\n",
        "                 batch_normalization=True,\n",
        "                 conv_first=True):\n",
        "\n",
        "    conv = keras.layers.Conv2D(num_filters,\n",
        "                  kernel_size=kernel_size,\n",
        "                  strides=strides,\n",
        "                  padding='same',\n",
        "                  kernel_initializer='he_normal',\n",
        "                  kernel_regularizer=keras.regularizers.l2(1e-4))\n",
        "\n",
        "    x = inputs\n",
        "    if conv_first:\n",
        "        x = conv(x)\n",
        "        if batch_normalization:\n",
        "            x = keras.layers.BatchNormalization()(x)\n",
        "        if activation is not None:\n",
        "            x = keras.layers.Activation(activation)(x)\n",
        "    else:\n",
        "        if batch_normalization:\n",
        "            x = keras.layers.BatchNormalization()(x)\n",
        "        if activation is not None:\n",
        "            x = keras.layers.Activation(activation)(x)\n",
        "        x = conv(x)\n",
        "    return x\n",
        "\n",
        "def resnet_v20(input_shape, depth, num_classes=10):\n",
        "\n",
        "    if (depth - 2) % 6 != 0:\n",
        "        raise ValueError('depth should be 6n+2 (eg 20, 32, 44 in [a])')\n",
        "    # Start model definition.\n",
        "    num_filters = 16\n",
        "    num_res_blocks = int((depth - 2) / 6)\n",
        "\n",
        "    inputs = keras.layers.Input(shape=input_shape)\n",
        "    x = resnet_layer(inputs=inputs)\n",
        "    # Instantiate the stack of residual units\n",
        "    for stack in range(3):\n",
        "        for res_block in range(num_res_blocks):\n",
        "            strides = 1\n",
        "            if stack > 0 and res_block == 0:  # first layer but not first stack\n",
        "                strides = 2  # downsample\n",
        "            y = resnet_layer(inputs=x,\n",
        "                             num_filters=num_filters,\n",
        "                             strides=strides)\n",
        "            y = resnet_layer(inputs=y,\n",
        "                             num_filters=num_filters,\n",
        "                             activation=None)\n",
        "            if stack > 0 and res_block == 0:  # first layer but not first stack\n",
        "                # linear projection residual shortcut connection to match\n",
        "                # changed dims\n",
        "                x = resnet_layer(inputs=x,\n",
        "                                 num_filters=num_filters,\n",
        "                                 kernel_size=1,\n",
        "                                 strides=strides,\n",
        "                                 activation=None,\n",
        "                                 batch_normalization=False)\n",
        "            x = keras.layers.add([x, y])\n",
        "            x = keras.layers.Activation('relu')(x)\n",
        "        num_filters *= 2\n",
        "\n",
        "    # Add classifier on top.\n",
        "    # v1 does not use BN after last shortcut connection-ReLU\n",
        "    x = keras.layers.AveragePooling2D(pool_size=8)(x)\n",
        "    y = keras.layers.Flatten()(x)\n",
        "    outputs = keras.layers.Dense(num_classes,\n",
        "                    activation='softmax',\n",
        "                    kernel_initializer='he_normal')(y)\n",
        "\n",
        "    # Instantiate model.\n",
        "    model = keras.models.Model(inputs=inputs, outputs=outputs)\n",
        "    return model"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AGEudC60AywA"
      },
      "source": [
        "def training_model():\n",
        "  return resnet_v20((32,32,3), 20) "
      ],
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6IveCOANBMbl"
      },
      "source": [
        "initial_model = training_model()\n",
        "initial_model.save_weights(\"initial_weights.h5\")"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XD2A1dTA7NgE"
      },
      "source": [
        "## 1. Train the model with the dataset augmented by CutMix"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0AOi1K7FCRML",
        "outputId": "97f89b22-a5bf-4cf4-d9f6-40c408809baa"
      },
      "source": [
        "model = training_model()\n",
        "model.load_weights(\"initial_weights.h5\")\n",
        "\n",
        "model.compile(loss=\"categorical_crossentropy\", optimizer=\"adam\", metrics=[\"accuracy\"])\n",
        "model.fit(train_ds_cmu,validation_data=test_ds, epochs=15)\n",
        "\n",
        "test_loss, test_accuracy = model.evaluate(test_ds)\n",
        "print(\"Test accuracy: {:.2f}%\".format(test_accuracy * 100))"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/15\n",
            "1563/1563 [==============================] - 68s 22ms/step - loss: 1.9125 - accuracy: 0.4114 - val_loss: 1.5080 - val_accuracy: 0.5131\n",
            "Epoch 2/15\n",
            "1563/1563 [==============================] - 34s 21ms/step - loss: 1.6632 - accuracy: 0.5339 - val_loss: 1.2390 - val_accuracy: 0.6141\n",
            "Epoch 3/15\n",
            "1563/1563 [==============================] - 34s 21ms/step - loss: 1.5568 - accuracy: 0.5842 - val_loss: 1.1439 - val_accuracy: 0.6634\n",
            "Epoch 4/15\n",
            "1563/1563 [==============================] - 34s 21ms/step - loss: 1.4982 - accuracy: 0.6079 - val_loss: 1.0863 - val_accuracy: 0.6815\n",
            "Epoch 5/15\n",
            "1563/1563 [==============================] - 34s 22ms/step - loss: 1.4524 - accuracy: 0.6305 - val_loss: 1.0434 - val_accuracy: 0.6899\n",
            "Epoch 6/15\n",
            "1563/1563 [==============================] - 34s 22ms/step - loss: 1.4176 - accuracy: 0.6519 - val_loss: 0.9067 - val_accuracy: 0.7507\n",
            "Epoch 7/15\n",
            "1563/1563 [==============================] - 34s 22ms/step - loss: 1.3980 - accuracy: 0.6569 - val_loss: 1.0845 - val_accuracy: 0.6593\n",
            "Epoch 8/15\n",
            "1563/1563 [==============================] - 34s 22ms/step - loss: 1.3722 - accuracy: 0.6715 - val_loss: 0.9353 - val_accuracy: 0.7364\n",
            "Epoch 9/15\n",
            "1563/1563 [==============================] - 34s 22ms/step - loss: 1.3548 - accuracy: 0.6827 - val_loss: 0.8301 - val_accuracy: 0.7797\n",
            "Epoch 10/15\n",
            "1563/1563 [==============================] - 34s 21ms/step - loss: 1.3415 - accuracy: 0.6865 - val_loss: 0.7855 - val_accuracy: 0.7998\n",
            "Epoch 11/15\n",
            "1563/1563 [==============================] - 34s 21ms/step - loss: 1.3294 - accuracy: 0.6927 - val_loss: 0.8768 - val_accuracy: 0.7660\n",
            "Epoch 12/15\n",
            "1563/1563 [==============================] - 34s 22ms/step - loss: 1.3181 - accuracy: 0.6994 - val_loss: 0.8326 - val_accuracy: 0.7760\n",
            "Epoch 13/15\n",
            "1563/1563 [==============================] - 33s 21ms/step - loss: 1.3064 - accuracy: 0.7031 - val_loss: 0.8176 - val_accuracy: 0.7813\n",
            "Epoch 14/15\n",
            "1563/1563 [==============================] - 36s 23ms/step - loss: 1.3012 - accuracy: 0.7068 - val_loss: 0.8991 - val_accuracy: 0.7538\n",
            "Epoch 15/15\n",
            "1563/1563 [==============================] - 34s 22ms/step - loss: 1.2944 - accuracy: 0.7104 - val_loss: 0.8397 - val_accuracy: 0.7830\n",
            "313/313 [==============================] - 2s 6ms/step - loss: 0.8397 - accuracy: 0.7830\n",
            "Test accuracy: 78.30%\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Lv4du43A8NN1"
      },
      "source": [
        "## 2. Train the model using the original non-augmented dataset"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "woYIoIKKCqov",
        "outputId": "69ffe972-a514-40b4-fa3a-5f14e91eab69"
      },
      "source": [
        "model = training_model()\n",
        "model.load_weights(\"initial_weights.h5\")\n",
        "model.compile(loss=\"categorical_crossentropy\", optimizer=\"adam\", metrics=[\"accuracy\"])\n",
        "model.fit(train_ds_simple,validation_data=test_ds, epochs=15)\n",
        "\n",
        "test_loss, test_accuracy = model.evaluate(test_ds)\n",
        "print(\"Test accuracy: {:.2f}%\".format(test_accuracy * 100))"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/15\n",
            "1563/1563 [==============================] - 25s 14ms/step - loss: 1.4777 - accuracy: 0.5220 - val_loss: 1.4840 - val_accuracy: 0.5344\n",
            "Epoch 2/15\n",
            "1563/1563 [==============================] - 22s 14ms/step - loss: 1.0746 - accuracy: 0.6744 - val_loss: 1.1067 - val_accuracy: 0.6664\n",
            "Epoch 3/15\n",
            "1563/1563 [==============================] - 22s 14ms/step - loss: 0.9015 - accuracy: 0.7408 - val_loss: 1.0764 - val_accuracy: 0.6794\n",
            "Epoch 4/15\n",
            "1563/1563 [==============================] - 22s 14ms/step - loss: 0.7967 - accuracy: 0.7823 - val_loss: 0.9531 - val_accuracy: 0.7261\n",
            "Epoch 5/15\n",
            "1563/1563 [==============================] - 22s 14ms/step - loss: 0.7183 - accuracy: 0.8147 - val_loss: 1.1002 - val_accuracy: 0.6946\n",
            "Epoch 6/15\n",
            "1563/1563 [==============================] - 22s 14ms/step - loss: 0.6622 - accuracy: 0.8381 - val_loss: 1.3530 - val_accuracy: 0.6557\n",
            "Epoch 7/15\n",
            "1563/1563 [==============================] - 22s 14ms/step - loss: 0.6136 - accuracy: 0.8584 - val_loss: 1.2183 - val_accuracy: 0.6815\n",
            "Epoch 8/15\n",
            "1563/1563 [==============================] - 22s 14ms/step - loss: 0.5790 - accuracy: 0.8719 - val_loss: 1.5116 - val_accuracy: 0.6585\n",
            "Epoch 9/15\n",
            "1563/1563 [==============================] - 22s 14ms/step - loss: 0.5511 - accuracy: 0.8864 - val_loss: 1.6412 - val_accuracy: 0.6475\n",
            "Epoch 10/15\n",
            "1563/1563 [==============================] - 22s 14ms/step - loss: 0.5299 - accuracy: 0.8960 - val_loss: 1.2417 - val_accuracy: 0.7274\n",
            "Epoch 11/15\n",
            "1563/1563 [==============================] - 22s 14ms/step - loss: 0.5100 - accuracy: 0.9046 - val_loss: 1.2850 - val_accuracy: 0.7310\n",
            "Epoch 12/15\n",
            "1563/1563 [==============================] - 22s 14ms/step - loss: 0.4979 - accuracy: 0.9126 - val_loss: 1.4046 - val_accuracy: 0.7135\n",
            "Epoch 13/15\n",
            "1563/1563 [==============================] - 22s 14ms/step - loss: 0.4906 - accuracy: 0.9177 - val_loss: 1.4842 - val_accuracy: 0.7170\n",
            "Epoch 14/15\n",
            "1563/1563 [==============================] - 22s 14ms/step - loss: 0.4862 - accuracy: 0.9215 - val_loss: 1.2598 - val_accuracy: 0.7441\n",
            "Epoch 15/15\n",
            "1563/1563 [==============================] - 22s 14ms/step - loss: 0.4749 - accuracy: 0.9291 - val_loss: 1.9676 - val_accuracy: 0.6645\n",
            "313/313 [==============================] - 2s 6ms/step - loss: 1.9676 - accuracy: 0.6645\n",
            "Test accuracy: 66.45%\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UL5P-p069ug8"
      },
      "source": [
        "## Notes\n",
        "In this example, we trained our model for 15 epochs. In our experiment, the\n",
        "model with CutMix achieves a better accuracy on the CIFAR-10 dataset (80.36% in\n",
        "our experiment) compared to the model that doesn't use the augmentation\n",
        "(72.70%).\n",
        "\n",
        "You may notice it takes less time to train the model with the CutMix augmentation.\n",
        "\n",
        "You can experiment further with the CutMix technique by following the\n",
        "[original paper](https://arxiv.org/pdf/1905.04899.pdf)."
      ]
    }
  ]
}