Implementation_DAUA_MNIST-MNISTM.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Implementation_DAUA.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/vvekraman/Missing-Class-Robust-Domain-Adaptation-by-Unilateral-Alignment/blob/main/Implementation_DAUA.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Zkfy6RqdEC3k"
      },
      "source": [
        "import tensorflow as tf\n",
        "import matplotlib.pyplot as plt\n",
        "from tensorflow.keras.models import Sequential, Model\n",
        "from tensorflow.keras.layers import Dense, Conv2D, Dropout, Flatten, MaxPooling2D, Input, BatchNormalization\n",
        "import numpy as np\n",
        "import pickle as pkl\n",
        "from tensorflow.keras import backend as K\n",
        "import gzip\n",
        "from numpy import array\n",
        "from numpy import argmax\n",
        "from tensorflow.keras.utils import to_categorical\n",
        "\n",
        "!mkdir -p checkpoints"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "13v7VzhVHZKu",
        "outputId": "e9b1bfb5-71a9-4d22-8af8-384b2b18ec79"
      },
      "source": [
        "# setting dev to GPU\n",
        "sess = tf.compat.v1.Session(config=tf.compat.v1.ConfigProto(log_device_placement=True))"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Device mapping:\n",
            "/job:localhost/replica:0/task:0/device:GPU:0 -> device: 0, name: Tesla K80, pci bus id: 0000:00:04.0, compute capability: 3.7\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H9st2Nq7EG3-"
      },
      "source": [
        "# loading MNIST dataset\n",
        "(x_train_MNIST, y_train_MNIST), (x_test_MNIST, y_test_MNIST) = tf.keras.datasets.mnist.load_data()\n",
        "\n",
        "# loading MNIST-M dataset\n",
        "!wget https://github.com/VanushVaswani/keras_mnistm/releases/download/1.0/keras_mnistm.pkl.gz\n",
        "with gzip.open('/content/keras_mnistm.pkl.gz', 'rb') as f:\n",
        "  u = pkl._Unpickler(f)\n",
        "  u.encoding = 'latin1'\n",
        "  mnistm = u.load()\n",
        "\n",
        "# data to train and test\n",
        "x_train_MNISTM, x_test_MNISTM = mnistm[\"train\"], mnistm[\"test\"]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 299
        },
        "id": "3ZlGE_RhEb8c",
        "outputId": "3f88cd99-b7c1-4547-ceb4-b6b228ddba5a"
      },
      "source": [
        "# MNIST plot\n",
        "img_index = 2\n",
        "print(\"The num is: \", y_train_MNIST[img_index])\n",
        "plt.imshow(x_train_MNIST[img_index], cmap='Greys')"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The num is:  4\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7f94c070d690>"
            ]
          },
          "metadata": {},
          "execution_count": 4
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 282
        },
        "id": "FfA0wr5X79Wr",
        "outputId": "30d70016-1056-4710-8c26-c32b38a4dfed"
      },
      "source": [
        "# MNIST-M plot\n",
        "plt.imshow(mnistm[\"train\"][2], cmap='Greys')"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7f94c01ea750>"
            ]
          },
          "metadata": {},
          "execution_count": 5
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "l4IBnl6AEK0D"
      },
      "source": [
        "# reshaping the array to 4-dims so that it can work with the Keras API\n",
        "x_train_MNIST = x_train_MNIST.reshape(x_train_MNIST.shape[0], 28, 28, 1)\n",
        "x_test_MNIST = x_test_MNIST.reshape(x_test_MNIST.shape[0], 28, 28, 1)\n",
        "x_train_MNISTM = x_train_MNISTM.reshape(x_train_MNISTM.shape[0], 28, 28, 3)\n",
        "x_test_MNISTM = x_test_MNISTM.reshape(x_test_MNISTM.shape[0], 28, 28, 3)\n",
        "\n",
        "# making sure that the values are float so that we can get decimal points after division\n",
        "x_train_MNIST = x_train_MNIST.astype('float32')\n",
        "x_test_MNIST = x_test_MNIST.astype('float32')\n",
        "x_train_MNISTM = x_train_MNISTM.astype('float32')\n",
        "x_test_MNISTM = x_test_MNISTM.astype('float32')\n",
        "\n",
        "# normalizing the RGB codes by dividing it to the max RGB value.\n",
        "x_train_MNIST /= 255\n",
        "x_test_MNIST /= 255\n",
        "x_train_MNISTM /= 255\n",
        "x_test_MNISTM /= 255\n",
        "\n",
        "print('x_train_MNIST shape:', x_train_MNIST.shape)\n",
        "print('Number of images in x_train_MNIST', x_train_MNIST.shape[0])\n",
        "print('Number of images in x_test_MNIST', x_test_MNIST.shape[0])\n",
        "\n",
        "print('x_train_MNISTM shape:', x_train_MNISTM.shape)\n",
        "print('Number of images in x_train_MNISTM', x_train_MNISTM.shape[0])\n",
        "print('Number of images in x_test_MNISTM', x_test_MNISTM.shape[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zw3SWvwjMts4"
      },
      "source": [
        "# changing MNIST 1 ch to 3 ch\n",
        "x_train_MNIST = tf.image.grayscale_to_rgb(tf.expand_dims(x_train_MNIST, axis=0)[0]).numpy()\n",
        "x_test_MNIST = tf.image.grayscale_to_rgb(tf.expand_dims(x_test_MNIST, axis=0)[0]).numpy()"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lwTFSpk2wZtT"
      },
      "source": [
        "# removing classes of MNIST-M\n",
        "def remove_class(class_no, x1, y):\n",
        "  img_indx = []\n",
        "\n",
        "  for indx, l in enumerate(y):\n",
        "    if l in class_no:\n",
        "      img_indx.append(indx)\n",
        "\n",
        "  y = np.delete(y, img_indx)\n",
        "  x1 = np.delete(x1, img_indx, axis=0)\n",
        "  return y, x1\n",
        "\n",
        "# removing classes specified in list class_no\n",
        "#_, x_train_MNISTM = remove_class(class_no=[8,9], x1=x_train_MNISTM, y=y_train_MNIST)  # 2 missing classes - (2/10)\n",
        "#_, x_train_MNISTM = remove_class(class_no=[2,3,4,5,6,7,8,9], x1=x_train_MNISTM, y=y_train_MNIST) # 8 missing classes - (8/10)\n",
        "\n",
        "print(\"length of y_train_MNIST:\", len(y_train_MNIST), \"\\nlength of x_train_MNIST:\", len(x_train_MNIST), \"\\nlength of x_train_MNISTM:\", len(x_train_MNISTM))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TvmsDIWq_xSQ"
      },
      "source": [
        "# def input shape\n",
        "input_shape = (28, 28, 3)"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u5zfadLr-6tq"
      },
      "source": [
        "#model s1\n",
        "def net_s1():\n",
        "  seq = Sequential()\n",
        "  seq.add(Conv2D(28, kernel_size=(3,3),name='conv_1', input_shape= input_shape))\n",
        "  seq.add(MaxPooling2D(pool_size=(2, 2)))\n",
        "\n",
        "  seq.add(Flatten())\n",
        "  \n",
        "  seq.add(Dense(128, activation=tf.nn.relu))\n",
        "  seq.add(Dropout(0.2))\n",
        "  seq.add(Dense(10,activation=tf.nn.softmax))\n",
        "  return seq"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IqZ4DvpGADwR"
      },
      "source": [
        "# compiling and fitting the s1 model\n",
        "model_s1 = net_s1()\n",
        "model_s1.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])\n",
        "model_s1.fit(x=x_train_MNIST,y=y_train_MNIST, epochs=10)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8xzC_ASxG41E"
      },
      "source": [
        "# # Testing the model\n",
        "model_s1.evaluate(x_test_MNIST, y_test_MNIST)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4RdVo_8FHJ8g"
      },
      "source": [
        "# Predicting\n",
        "img_index = 4422\n",
        "plt.imshow(x_test_MNIST[img_index],cmap='Greys')\n",
        "pred = model_s1.predict(tf.reshape(x_test_MNIST[img_index], [1,28,28,3]))\n",
        "print(pred.argmax())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qF8h5w4LfCn4"
      },
      "source": [
        "**STAGE 2**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Gvy8iSfIADl_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cd5cd995-5fa2-4fd5-f038-12358b54adea"
      },
      "source": [
        "# pre-trained model with classifier removed\n",
        "model_s1_FExt = Model(model_s1.input, model_s1.layers[-4].output)\n",
        "model_s1_FExt.summary()"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"model\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "conv_1_input (InputLayer)    [(None, 28, 28, 3)]       0         \n",
            "_________________________________________________________________\n",
            "conv_1 (Conv2D)              (None, 26, 26, 28)        784       \n",
            "_________________________________________________________________\n",
            "max_pooling2d (MaxPooling2D) (None, 13, 13, 28)        0         \n",
            "_________________________________________________________________\n",
            "flatten (Flatten)            (None, 4732)              0         \n",
            "=================================================================\n",
            "Total params: 784\n",
            "Trainable params: 784\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q52wlfWlhc87"
      },
      "source": [
        "# defining a custom gradient\n",
        "@tf.custom_gradient\n",
        "def grad_reverse(x):\n",
        "  y = tf.identity(x)\n",
        "  def custom_grad(dy):\n",
        "    return -dy\n",
        "  return y, custom_grad"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XKGdBZ9HgoiL"
      },
      "source": [
        "# GRL\n",
        "class GradReverse(tf.keras.layers.Layer):\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "\n",
        "    def call(self, x):\n",
        "        return grad_reverse(x)\n",
        "\n",
        "flip_grad = GradReverse()"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ytg0uGioADZ4"
      },
      "source": [
        "# STAGE 2\n",
        "\n",
        "def net_s2(input_shape):\n",
        "\n",
        "  inp = Input(input_shape)\n",
        "  x = Conv2D(28, kernel_size=(3,3),name='conv_1')(inp)\n",
        "  x = MaxPooling2D(pool_size=(2, 2))(x)\n",
        "\n",
        "  features_s2 = Flatten()(x)\n",
        "\n",
        "  # classifier\n",
        "  out = Dense(128, activation=tf.nn.relu)(features_s2)\n",
        "  out = Dropout(0.2)(out)\n",
        "  out_classf = Dense(10)(out)\n",
        "\n",
        "  # discriminator\n",
        "  flipg = flip_grad(features_s2)\n",
        "  dom = Dense(500, activation=tf.nn.relu)(flipg)  #flip_gradient(features_s2)\n",
        "  dom = Dropout(0.2)(dom)\n",
        "  out_disc = Dense(2)(dom)\n",
        "\n",
        "  model_s2 = Model(inp, [out_classf, out_disc])\n",
        "\n",
        "  return model_s2"
      ],
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cX9DwGZEbjtI",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 865
        },
        "outputId": "10f2354a-945a-4345-8f1a-57cd1c4cbdd2"
      },
      "source": [
        "# STAGE 2 model\n",
        "model_s2 = net_s2(input_shape)\n",
        "optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)\n",
        "#optimizer = tf.keras.optimizers.SGD(learning_rate=0.001, momentum=0.9)\n",
        "\n",
        "# plot model\n",
        "from keras.utils.vis_utils import plot_model\n",
        "plot_model(model_s2, to_file='model.png', show_shapes=True, show_layer_names=True, rankdir='TB', expand_nested=True, dpi=96)"
      ],
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {},
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XpkMKXo80_wv"
      },
      "source": [
        "# batch generator\n",
        "def shuffle_aligned_list(data):\n",
        "    num = data[0].shape[0]\n",
        "    p = np.random.permutation(num)\n",
        "    return [d[p] for d in data]\n",
        "\n",
        "\n",
        "def batch_generator(data, batch_size, shuffle=True):\n",
        "    if shuffle:\n",
        "        data = shuffle_aligned_list(data)\n",
        "\n",
        "    batch_count = 0\n",
        "    while True:\n",
        "        if batch_count * batch_size + batch_size >= len(data[0]):\n",
        "            batch_count = 0\n",
        "\n",
        "            if shuffle:\n",
        "                data = shuffle_aligned_list(data)\n",
        "\n",
        "        start = batch_count * batch_size\n",
        "        end = start + batch_size\n",
        "        batch_count += 1\n",
        "        yield [d[start:end] for d in data]"
      ],
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yITNaGEP2V1B"
      },
      "source": [
        "# one hot encoding\n",
        "dat_tr = array(y_train_MNIST)\n",
        "y_train_MNIST_enco = to_categorical(dat_tr)\n",
        "\n",
        "dat_test = array(y_test_MNIST)\n",
        "y_test_MNIST_enco = to_categorical(dat_test)\n",
        "\n",
        "\n",
        "# batch generators\n",
        "batch_size = 64\n",
        "\n",
        "mnist_full = batch_generator([x_train_MNIST, y_train_MNIST_enco], batch_size=batch_size)\n",
        "\n",
        "mnist_half = batch_generator([x_train_MNIST, y_train_MNIST_enco], batch_size=batch_size // 2)\n",
        "mnistm_half = batch_generator([x_train_MNISTM, y_train_MNIST_enco], batch_size=batch_size // 2)\n",
        "\n",
        "mnistm_test = batch_generator([x_test_MNISTM, y_test_MNIST_enco], batch_size=1, shuffle=False)"
      ],
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4yYGpj0IC0e9"
      },
      "source": [
        "# training Loop\n",
        "val_loss = []\n",
        "old_val_acc = 0\n",
        "\n",
        "plot_val_loss = []\n",
        "plot_tr_loss = []\n",
        "\n",
        "cat_tr_acc = tf.metrics.CategoricalAccuracy()\n",
        "cat_val_acc = tf.metrics.CategoricalAccuracy()\n",
        "\n",
        "progbar = tf.keras.utils.Progbar(len(x_train_MNIST)//batch_size+1)\n",
        "\n",
        "epochs = 50\n",
        "\n",
        "for epoch in range(epochs):\n",
        "  # training performance metrics init\n",
        "  tr_accu =[]\n",
        "  tr_loss = [] \n",
        "\n",
        "  print(\"\\nStart of epoch %d\" % (epoch+1,))\n",
        "\n",
        "  # iterate over the batches of the dataset.\n",
        "  for step, ((img_mnist_f, label_mnist_f), (img_mnist_h,_), (img_mnistm_h,_)) in enumerate(zip(mnist_full, mnist_half, mnistm_half)):\n",
        "    with tf.GradientTape() as tape:\n",
        "\n",
        "      out_classf,_ = model_s2(img_mnist_f, training=True)\n",
        "      loss_clf = tf.nn.softmax_cross_entropy_with_logits(labels=label_mnist_f, logits=out_classf)\n",
        "    \n",
        "      model_s2_FExt = Model(model_s2.input, model_s2.layers[3].output)\n",
        "      feat_s2 = model_s2_FExt(img_mnist_f, training=False)\n",
        "      feat_s1 = model_s1_FExt(img_mnist_f, training=False)\n",
        "      loss_cons = np.sum(np.abs((feat_s1-feat_s2)), axis=1)/len(feat_s1[0])\n",
        "\n",
        "      img_pair = tf.concat([[img_mnist_h],[img_mnistm_h]], 1)[0]\n",
        "      dom_lbl = np.vstack(([[1.,0.]]*(batch_size//2), [[0.,1.]]*(batch_size//2)))\n",
        "      _,out_disc = model_s2(img_pair, training=True)\n",
        "      loss_d = tf.nn.softmax_cross_entropy_with_logits(labels=dom_lbl, logits=out_disc)\n",
        "\n",
        "      l = 1 #lambda (regularisation term for the consistency loss)\n",
        "      loss_value = loss_clf + loss_d + l*loss_cons  # total loss\n",
        "\n",
        "    grads = tape.gradient(loss_value, model_s2.trainable_weights)\n",
        "    optimizer.apply_gradients(zip(grads, model_s2.trainable_weights))\n",
        "\n",
        "    # update training metric.\n",
        "    tr_accu.append(cat_tr_acc(label_mnist_f, tf.nn.softmax(out_classf)))\n",
        "\n",
        "    # update training loss\n",
        "    tr_loss.append(np.average(loss_value))\n",
        "\n",
        "    progbar.update(step+1)  #updates prog bar\n",
        "\n",
        "    # breaks loop after all the batches pass\n",
        "    if step == (60000//batch_size):\n",
        "      break\n",
        "\n",
        "  # validation\n",
        "  val_lbls=[]\n",
        "  val_output=[]\n",
        "  val_loss=[]\n",
        "  for i, (imgs, labels) in enumerate(mnistm_test):\n",
        "    # index (0->1999) taken for validation on the run\n",
        "    if i==2000:\n",
        "      break\n",
        "    out,_ = model_s2(imgs, training=False)\n",
        "    val_loss.append(tf.nn.softmax_cross_entropy_with_logits(labels=labels, logits=out))\n",
        "    val_lbls.append(tf.constant(labels)[0])\n",
        "    val_output.append(out[0])\n",
        "  val_accu = cat_val_acc(val_lbls, tf.nn.softmax(val_output))\n",
        "\n",
        "  # saving the best checkpoint\n",
        "  if val_accu.numpy() > old_val_acc:\n",
        "    model_s2.save_weights(\"/content/checkpoints/checkpoint-\" + str(epoch) + \".ckpt\")\n",
        "    old_val_acc = val_accu.numpy()\n",
        "    print(\"Checkpoint saved!\")\n",
        "\n",
        "  # Display metrics at the end of each epoch.\n",
        "  print(\"\\nStats:\", \n",
        "        \"\\nTraining accuracy:\", np.average(tr_accu), \n",
        "        \"\\nTraining loss:\", np.average(tr_loss),\n",
        "        \"\\nValidation accuracy:\",val_accu.numpy() ,\n",
        "        \"\\nValidation loss:\", np.average(val_loss))\n",
        "\n",
        "  # saving val & tr loss for plotting\n",
        "  plot_val_loss.append(np.average(val_loss))\n",
        "  plot_tr_loss.append(np.average(tr_loss))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FTxNbNpR4_gm"
      },
      "source": [
        "#loading saved models\n",
        "#model_s2 = net_s2(input_shape)\n",
        "#model_s2.load_weights(\"/content/checkpoints/checkpoint-40.ckpt\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ezBad0NECDau"
      },
      "source": [
        "# testing\n",
        "val_lbls=[]\n",
        "val_output=[]\n",
        "\n",
        "for i, (imgs, labels) in enumerate(mnistm_test):\n",
        "  if i==10000:\n",
        "    break\n",
        "  out,_ = model_s2(imgs, training=False)\n",
        "  val_lbls.append(tf.constant(labels)[0])\n",
        "  val_output.append(tf.nn.softmax(out[0]))    \n",
        "\n",
        "# test accuracy\n",
        "cat_acc_test = tf.metrics.CategoricalAccuracy()\n",
        "val_accu = cat_acc_test(val_lbls, val_output)\n",
        "\n",
        "print(\"Test accuracy:\", val_accu.numpy())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HbcfyD-ZMq18"
      },
      "source": [
        "# plot\n",
        "plt.plot(np.arange(1, len(plot_val_loss)+1),plot_val_loss, label=\"val_loss\")\n",
        "plt.plot(np.arange(1, len(plot_tr_loss)+1),plot_tr_loss, label=\"tr_loss\")\n",
        "plt.xlabel('epochs')\n",
        "plt.ylabel('loss')\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}