notebooks/train_tpu.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "TPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "### Use RETVec on TPU\n",
        "\n",
        "You can run this notebook in Google Colab, where you can request a TPU.\n",
        "\n",
        "RETVec requires a slightly different setup on TPU, because TPUs do not support string tensors. Thus, we will split the default RETVecTokenizer layer into two parts -- one that converts strings into an integer representation which runs on CPU, and the remaining components of RETVec including the word embedding model which runs on TPU (as well as the rest of the model).\n",
        "\n",
        "We will use the same example as in the `train_retvec_model_tf.ipynb` notebook, where we train an emotion classifier."
      ],
      "metadata": {
        "id": "KCdhdgLc-xCP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# installing needed dependencies\n",
        "try:\n",
        "    import retvec\n",
        "except ImportError:\n",
        "    !pip install retvec  # is retvec installed?\n",
        "\n",
        "try:\n",
        "    import datasets\n",
        "except ImportError:\n",
        "    !pip install datasets  # used to get the dataset\n",
        "\n",
        "try:\n",
        "    import matplotlib\n",
        "except ImportError:\n",
        "    !pip install matplotlib\n",
        "\n",
        "try:\n",
        "    import tensorflow_text\n",
        "except ImportError:\n",
        "    !pip install tensorflow_text"
      ],
      "metadata": {
        "id": "niDxQ-1x-mx9"
      },
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '1'  # silence TF INFO messages\n",
        "import tensorflow as tf\n",
        "import numpy as np\n",
        "from tensorflow.keras import layers\n",
        "import tensorflow_text as text\n",
        "from datasets import load_dataset\n",
        "from matplotlib import pyplot as plt"
      ],
      "metadata": {
        "id": "2Ovv0fvB-psR"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Import RETVec layers we need for TPU\n",
        "\n",
        "Note that we do not import the RETVecTokenizer layer for TPU here, since TPUs do not support tf.string inputs."
      ],
      "metadata": {
        "id": "6oLggdAk_a2B"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from retvec.tf.layers import RETVecEmbedding, RETVecIntToBinary, RETVecIntegerizer"
      ],
      "metadata": {
        "id": "fWwzCVs7-rgT"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Initialize TPU and TPU Strategy"
      ],
      "metadata": {
        "id": "pRdgWcpXrliX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "resolver = tf.distribute.cluster_resolver.TPUClusterResolver(tpu='')\n",
        "tf.config.experimental_connect_to_cluster(resolver)\n",
        "# This is the TPU initialization code that has to be at the beginning.\n",
        "tf.tpu.experimental.initialize_tpu_system(resolver)\n",
        "print(\"All devices: \", tf.config.list_logical_devices('TPU'))\n",
        "\n",
        "strategy = tf.distribute.TPUStrategy(resolver)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Jrf9ViW6rkmE",
        "outputId": "42c04ce9-b4de-47ae-d4d2-26c66cda78c5"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "All devices:  [LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:0', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:1', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:2', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:3', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:4', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:5', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:6', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:7', device_type='TPU')]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Create dataset\n",
        "\n",
        "We are going to use the [Go Emotion](https://huggingface.co/datasets/go_emotions) dataset to create a mulit-class emotion classifier. https://ai.googleblog.com/2021/10/goemotions-dataset-for-fine-grained.html"
      ],
      "metadata": {
        "id": "F9Rvip4S_wCO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# downloading dataset\n",
        "dataset = load_dataset('go_emotions')"
      ],
      "metadata": {
        "id": "jxYGjVIR_6S6"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# get class name mapping and number of class\n",
        "CLASSES = dataset['train'].features['labels'].feature.names\n",
        "NUM_CLASSES = len(CLASSES)\n",
        "print(f\"num classes {NUM_CLASSES}\")\n",
        "print(CLASSES)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CJDELoVj_6WE",
        "outputId": "0d027bb4-398a-49be-b891-a43167650e52"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "num classes 28\n",
            "['admiration', 'amusement', 'anger', 'annoyance', 'approval', 'caring', 'confusion', 'curiosity', 'desire', 'disappointment', 'disapproval', 'disgust', 'embarrassment', 'excitement', 'fear', 'gratitude', 'grief', 'joy', 'love', 'nervousness', 'optimism', 'pride', 'realization', 'relief', 'remorse', 'sadness', 'surprise', 'neutral']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# preparing data\n",
        "x_train = tf.constant(dataset['train']['text'], dtype=tf.string)\n",
        "\n",
        "# the one-hot requires a little more due to the multi-class nature of the dataset.\n",
        "y_train = np.zeros((len(x_train),NUM_CLASSES))\n",
        "for idx, ex in enumerate(dataset['train']['labels']):\n",
        "    for val in ex:\n",
        "        y_train[idx][val] = 1\n",
        "\n",
        "# test data\n",
        "x_test = tf.constant(dataset['test']['text'], dtype=tf.string)\n",
        "y_test = np.zeros((len(x_test),NUM_CLASSES))\n",
        "for idx, ex in enumerate(dataset['test']['labels']):\n",
        "    for val in ex:\n",
        "        y_test[idx][val] = 1"
      ],
      "metadata": {
        "id": "UDAQ-jsy_6YZ"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Pre-process dataset on CPU\n",
        "\n",
        "We use the `RETVecIntegerizer` class to convert the tf.strings input into integer tensors (on CPU). By default, the layer converts each word into it's UTF-8 codepoints (with max 16 characters per word).\n",
        "\n",
        "The `RETVecIntegerizer` has a method `integerize` which will encode a string tensor into its integer representation."
      ],
      "metadata": {
        "id": "a7CZv1PUAIPg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sequence_length = 128  # number of words per text, inputs will be padded or truncated to this length\n",
        "word_length = 16  # max characters per word\n",
        "\n",
        "# initialize whitespace tokenizer\n",
        "whitespace_tokenizer = text.WhitespaceTokenizer()\n",
        "\n",
        "# initialize RETVec integerizer\n",
        "integerizer = RETVecIntegerizer()"
      ],
      "metadata": {
        "id": "0lUZoLh1AV0Y"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# split text in dataset into words\n",
        "x_train = whitespace_tokenizer.tokenize(x_train)\n",
        "x_test = whitespace_tokenizer.tokenize(x_test)\n",
        "\n",
        "# convert from ragged tensor to tensor with pad/truncation to sequence_length\n",
        "x_train = x_train.to_tensor(default_value=\"\", shape=(x_train.shape[0], sequence_length))\n",
        "x_test = x_test.to_tensor(default_value=\"\", shape=(x_test.shape[0], sequence_length))\n",
        "\n",
        "# encode each word into their integer representation\n",
        "x_train = integerizer.integerize(x_train)\n",
        "x_test = integerizer.integerize(x_test)"
      ],
      "metadata": {
        "id": "p4lhTH4vrhYC"
      },
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print('train input shape:', x_train.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gw7QEnPKA0ZL",
        "outputId": "b87bf75b-61f6-4d7b-afd8-1697b8873453"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "train input shape: (43410, 128, 16)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Create Model\n",
        "\n",
        "Now, we can create the model with RETVec which will run on TPU. To do this, we use the layers `RETVecIntToBinary` which will binarize the UTF-8 codepoints, and `RETVecEmbedding` which will call the embedding model and produce 256-dim float embeddings for each word. Then, we can build the rest of the model like usual and train."
      ],
      "metadata": {
        "id": "EnAfdnUb__pt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "retvec_model_dir = 'gs://tensorflow/keras-applications/retvec-v1/' # currently colab TPU only supports gcs paths\n",
        "batch_size = 256\n",
        "epochs = 25\n",
        "\n",
        "# use TPU\n",
        "with strategy.scope():\n",
        "  # input is int32 tensor with shape (sequence_length, word_length)\n",
        "  inputs = tf.keras.layers.Input(shape=(sequence_length, word_length), dtype=tf.int32)\n",
        "  x = RETVecIntToBinary(sequence_length=sequence_length, word_length=word_length)(inputs)\n",
        "  x = RETVecEmbedding(model=retvec_model_dir)(x)\n",
        "\n",
        "  # build the rest of the model\n",
        "  x = layers.Bidirectional(layers.LSTM(64, return_sequences=True))(x)\n",
        "  x = layers.Bidirectional(layers.LSTM(64))(x)\n",
        "  outputs = layers.Dense(NUM_CLASSES, activation='sigmoid')(x)\n",
        "  model = tf.keras.Model(inputs, outputs)\n",
        "  model.summary()\n",
        "\n",
        "  model.compile('adam', 'binary_crossentropy', ['acc'])\n",
        "  history = model.fit(x_train, y_train, epochs=epochs, batch_size=batch_size,\n",
        "                      validation_data=(x_test, y_test))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LUzjZXZ--e5H",
        "outputId": "0e19b6e4-b88a-40d9-8444-3adf5cecaa6b"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:tensorflow:No training configuration found in save file, so the model was *not* compiled. Compile it manually.\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"model_1\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " input_2 (InputLayer)        [(None, 128, 16)]         0         \n",
            "                                                                 \n",
            " ret_vec_int_to_binary_1 (R  (None, 128, 16, 24)       0         \n",
            " ETVecIntToBinary)                                               \n",
            "                                                                 \n",
            " ret_vec_embedding_1 (RETVe  (None, 128, 256)          230144    \n",
            " cEmbedding)                                                     \n",
            "                                                                 \n",
            " bidirectional_2 (Bidirecti  (None, 128, 128)          164352    \n",
            " onal)                                                           \n",
            "                                                                 \n",
            " bidirectional_3 (Bidirecti  (None, 128)               98816     \n",
            " onal)                                                           \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 28)                3612      \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 496924 (1.90 MB)\n",
            "Trainable params: 266780 (1.02 MB)\n",
            "Non-trainable params: 230144 (899.00 KB)\n",
            "_________________________________________________________________\n",
            "Epoch 1/25\n",
            "170/170 [==============================] - 42s 121ms/step - loss: 0.1708 - acc: 0.2827 - val_loss: 0.1474 - val_acc: 0.2959\n",
            "Epoch 2/25\n",
            "170/170 [==============================] - 11s 64ms/step - loss: 0.1478 - acc: 0.2955 - val_loss: 0.1443 - val_acc: 0.2959\n",
            "Epoch 3/25\n",
            "170/170 [==============================] - 11s 68ms/step - loss: 0.1420 - acc: 0.3297 - val_loss: 0.1360 - val_acc: 0.3575\n",
            "Epoch 4/25\n",
            "170/170 [==============================] - 11s 62ms/step - loss: 0.1354 - acc: 0.3607 - val_loss: 0.1314 - val_acc: 0.3717\n",
            "Epoch 5/25\n",
            "170/170 [==============================] - 11s 63ms/step - loss: 0.1315 - acc: 0.3757 - val_loss: 0.1273 - val_acc: 0.3893\n",
            "Epoch 6/25\n",
            "170/170 [==============================] - 11s 67ms/step - loss: 0.1277 - acc: 0.3958 - val_loss: 0.1245 - val_acc: 0.4024\n",
            "Epoch 7/25\n",
            "170/170 [==============================] - 11s 62ms/step - loss: 0.1243 - acc: 0.4169 - val_loss: 0.1205 - val_acc: 0.4315\n",
            "Epoch 8/25\n",
            "170/170 [==============================] - 11s 63ms/step - loss: 0.1206 - acc: 0.4334 - val_loss: 0.1178 - val_acc: 0.4468\n",
            "Epoch 9/25\n",
            "170/170 [==============================] - 11s 64ms/step - loss: 0.1179 - acc: 0.4447 - val_loss: 0.1156 - val_acc: 0.4516\n",
            "Epoch 10/25\n",
            "170/170 [==============================] - 11s 64ms/step - loss: 0.1157 - acc: 0.4528 - val_loss: 0.1136 - val_acc: 0.4655\n",
            "Epoch 11/25\n",
            "170/170 [==============================] - 11s 63ms/step - loss: 0.1138 - acc: 0.4591 - val_loss: 0.1126 - val_acc: 0.4608\n",
            "Epoch 12/25\n",
            "170/170 [==============================] - 12s 73ms/step - loss: 0.1115 - acc: 0.4691 - val_loss: 0.1102 - val_acc: 0.4691\n",
            "Epoch 13/25\n",
            "170/170 [==============================] - 11s 64ms/step - loss: 0.1097 - acc: 0.4768 - val_loss: 0.1098 - val_acc: 0.4728\n",
            "Epoch 14/25\n",
            "170/170 [==============================] - 11s 63ms/step - loss: 0.1081 - acc: 0.4831 - val_loss: 0.1085 - val_acc: 0.4806\n",
            "Epoch 15/25\n",
            "170/170 [==============================] - 11s 65ms/step - loss: 0.1064 - acc: 0.4896 - val_loss: 0.1068 - val_acc: 0.4854\n",
            "Epoch 16/25\n",
            "170/170 [==============================] - 11s 63ms/step - loss: 0.1052 - acc: 0.4951 - val_loss: 0.1067 - val_acc: 0.4824\n",
            "Epoch 17/25\n",
            "170/170 [==============================] - 11s 64ms/step - loss: 0.1037 - acc: 0.4998 - val_loss: 0.1065 - val_acc: 0.4822\n",
            "Epoch 18/25\n",
            "170/170 [==============================] - 11s 65ms/step - loss: 0.1022 - acc: 0.5053 - val_loss: 0.1046 - val_acc: 0.4918\n",
            "Epoch 19/25\n",
            "170/170 [==============================] - 11s 63ms/step - loss: 0.1010 - acc: 0.5102 - val_loss: 0.1047 - val_acc: 0.4911\n",
            "Epoch 20/25\n",
            "170/170 [==============================] - 11s 66ms/step - loss: 0.0997 - acc: 0.5140 - val_loss: 0.1033 - val_acc: 0.4973\n",
            "Epoch 21/25\n",
            "170/170 [==============================] - 11s 65ms/step - loss: 0.0987 - acc: 0.5198 - val_loss: 0.1051 - val_acc: 0.4924\n",
            "Epoch 22/25\n",
            "170/170 [==============================] - 11s 62ms/step - loss: 0.0978 - acc: 0.5210 - val_loss: 0.1030 - val_acc: 0.5027\n",
            "Epoch 23/25\n",
            "170/170 [==============================] - 12s 69ms/step - loss: 0.0968 - acc: 0.5266 - val_loss: 0.1023 - val_acc: 0.5001\n",
            "Epoch 24/25\n",
            "170/170 [==============================] - 11s 67ms/step - loss: 0.0954 - acc: 0.5309 - val_loss: 0.1021 - val_acc: 0.5045\n",
            "Epoch 25/25\n",
            "170/170 [==============================] - 11s 62ms/step - loss: 0.0948 - acc: 0.5334 - val_loss: 0.1025 - val_acc: 0.5025\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# visualize the training curves\n",
        "plt.plot(history.history['acc'])\n",
        "plt.plot(history.history['val_acc'])\n",
        "plt.legend(['acc', 'val_acc'])\n",
        "plt.title(f'Accuracy')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 452
        },
        "id": "fLYBe3Yvsdqq",
        "outputId": "9199edc4-7c8e-464b-9a6c-7a8e0610930e"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Test Model\n",
        "\n",
        "Let's test our model on some examples, noting that we have to preprocess our inputs before feeding them to the model."
      ],
      "metadata": {
        "id": "qRnwfkjatMOV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def preprocess_text(text):\n",
        "    # we need to tokenize our inputs and convert them into integer codepoints\n",
        "    # before passing them to the model\n",
        "    text = tf.constant([txt])\n",
        "    text = whitespace_tokenizer.tokenize(text)\n",
        "    text = text.to_tensor(default_value=\"\", shape=(text.shape[0], sequence_length))\n",
        "    text = integerizer.integerize(text)\n",
        "    return text\n",
        "\n",
        "def predict_emotions(txt, threshold=0.5):\n",
        "    # recall it is multi-class so we need to get all prediction above a threshold (0.5)\n",
        "    preds = model(preprocess_text(text))[0]\n",
        "    out = 0\n",
        "    for i in range(NUM_CLASSES):\n",
        "        if preds[i] > threshold:\n",
        "            emotion_name = CLASSES[i]\n",
        "            emotion_prob = round(float(preds[i]) * 100, 1)\n",
        "            print(f\"{emotion_name} ({emotion_prob})%\")\n",
        "            out += 1\n",
        "    if not out:\n",
        "        print(\"neutral\")"
      ],
      "metadata": {
        "id": "So39n-nKrd_K"
      },
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "txt = \"I enjoy having a good icecream.\"\n",
        "predict_emotions(txt)"
      ],
      "metadata": {
        "id": "isWJPbWf-h4R",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d7fe825c-0ee1-412f-9919-64f35ef9c718"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "joy (84.5)%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# the model works even with typos, substitutions, and emojis!\n",
        "txt = \"I enjoy hving a g00d ic3cream!!! 🍦\"\n",
        "predict_emotions(txt)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "twyBz-_lvGyb",
        "outputId": "e79754c3-e414-425d-be6b-7d68b2eaadb2"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "joy (85.9)%\n"
          ]
        }
      ]
    }
  ]
}