clip_roco.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyMvs05Yfa0dOR+hwWKIh8ki"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Contrastive Language Image Pre-Training (CLIP) on Radiology Objects in COntext (ROCO)"
      ],
      "metadata": {
        "id": "lGtgnSaFPORr"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Import libraries and data\n",
        "Before starting executing the notebook, do the following steps:\n",
        "- Go to \"Runtime\" > \"Change type of runtime\" and select a GPU-based runtime;\n",
        "- Load the `resized_train.zip`, `caption_prediction_train.csv`, `concept_detection_train.csv`  files in the File folder."
      ],
      "metadata": {
        "id": "XbTjR7azPWUi"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7QRfnMo0PMnC"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import tensorflow as tf\n",
        "from PIL import Image\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "tfk = tf.keras\n",
        "tfkl = tfk.layers"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Set the random seed for reproducibility:"
      ],
      "metadata": {
        "id": "u-GUnZwNarmc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "seed = 24948989491\n",
        "\n",
        "rng = np.random.default_rng(seed)\n",
        "tf.random.set_seed(seed)\n",
        "tfk.utils.set_random_seed(812)"
      ],
      "metadata": {
        "id": "FNGjCsktauhq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Extract the images from `resized_train.zip`:"
      ],
      "metadata": {
        "id": "iiuBdadSXatO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!unzip resized_train.zip"
      ],
      "metadata": {
        "id": "tpt7w_QBZEis"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Load textual data:"
      ],
      "metadata": {
        "id": "FcAwDGgbb_yo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Load the captions\n",
        "captions = pd.read_csv(\"caption_prediction_train.csv\",sep=\"\\t\", index_col=\"ID\")\n",
        "\n",
        "# Load the labels\n",
        "labels = pd.read_csv(\"concept_detection_train.csv\",sep=\"\\t\",index_col=\"ID\")\n",
        "# Each label string contains multiple labels separated by a semicolumn.\n",
        "# Transform the strings in lists of labels.\n",
        "labels[\"cuis\"] = labels[\"cuis\"].str.split(pat=\";\")"
      ],
      "metadata": {
        "id": "VvlLdp2XbsKw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We explore the images to check if they are all 128x128 pixel and how many channels they have:"
      ],
      "metadata": {
        "id": "KfsCqAbAmLlv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "max_channels = 1\n",
        "for i in labels.index:\n",
        "  image_name = \"resized_train/\"+i+\".jpg\"\n",
        "  img = Image.open(image_name)\n",
        "  img = np.array(img)\n",
        "  if img.ndim==3 and img.shape[2] > max_channels:\n",
        "    max_channels = img.shape[2]\n",
        "  # Check if the image has the expected resolution of 128x128\n",
        "  if img.shape[0]!=128 or img.shape[1]!=128:\n",
        "    print(f\"Error in {image_name}: its resolution is \" +\n",
        "      f\"{img.shape[0]}x{img.shape[1]}, while it should be 128x128\")\n",
        "\n",
        "print(f\"The maximum number of channels is {max_channels}.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gvV_jUVokiPh",
        "outputId": "81353e0e-3fb0-433c-9ce7-6c23001bcd08"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The maximum number of channels is 3.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We import all the images, we shuffle them and we split them in training and test sets:"
      ],
      "metadata": {
        "id": "yVU4R6F3mTSE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "images = np.zeros((labels.shape[0],128,128,3),dtype=\"uint8\")\n",
        "count = 0\n",
        "for i in labels.index:\n",
        "  image_name = \"resized_train/\"+i+\".jpg\"\n",
        "  img = tf.io.read_file(image_name)\n",
        "  images[count]= tf.io.decode_image(img, channels=3)\n",
        "  count = count + 1"
      ],
      "metadata": {
        "id": "vS2pyxPnOwju"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_idx = rng.choice(range(labels.shape[0]),\n",
        "                               size=int(0.8*labels.shape[0]), replace=False)\n",
        "test_idx = np.delete(range(labels.shape[0]), train_idx)\n",
        "\n",
        "images_train = images[train_idx]\n",
        "images_test = images[test_idx]\n",
        "# Delete the variable to free a lot of space in the RAM\n",
        "images=None"
      ],
      "metadata": {
        "id": "UQW6m7LlPxRy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Following the division of the images, we split also the labels and the captions in training and test sets."
      ],
      "metadata": {
        "id": "ZedmmRO66o2V"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "captions_train = captions.iloc[train_idx]\n",
        "captions_test = captions.iloc[test_idx]\n",
        "labels_train = labels.iloc[train_idx]\n",
        "labels_test = labels.iloc[test_idx]"
      ],
      "metadata": {
        "id": "W0dZ5ftm8let"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Build the CLIP model"
      ],
      "metadata": {
        "id": "SUzdpCGjbK0n"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Set the constants for the CLIP model."
      ],
      "metadata": {
        "id": "Rg4svRWmyaHt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# The size of the images in input.\n",
        "input_shape = (128,128,3)\n",
        "# The vocabulary size for the words in the captions.\n",
        "vocab_size = 20000\n",
        "# The maximum number of words in a caption. Captions with a smaller number of\n",
        "# words are padded in the TextVectorization layer.\n",
        "sequence_length = 400\n",
        "# Dimension of the vectors representing each caption after the embedding.\n",
        "embed_dim = 128\n",
        "# Number of attention heads in each attention block.\n",
        "num_heads = 4\n",
        "# Dimension of the central layer of the feed forward NN.\n",
        "latent_dim = 1024\n",
        "# The final embedding dimensions for both texts and images\n",
        "final_embed_dim = 128"
      ],
      "metadata": {
        "id": "BJLzIE-ZoAlG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Define the CNN"
      ],
      "metadata": {
        "id": "_iXoxq0hesIe"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "We define the convolutional block, which will be the base block for the CNN."
      ],
      "metadata": {
        "id": "h4O0ayBYoOGe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def convolutional_block(x, filters, kernel):\n",
        "  '''\n",
        "  A function building a convolutional block in a neural network, composed of a\n",
        "  convolutional layer and a max pooling layer. It takes as parameters the number\n",
        "  of filters for the convolutional operation and the size of the convolutional\n",
        "  kernel.\n",
        "\n",
        "  Input shape: (None, h, w, channels)\n",
        "  Output shape: (None, h/2, w/2, filters)\n",
        "  '''\n",
        "  # Apply convolution operation to the input x\n",
        "  x = tfkl.Conv2D(\n",
        "      filters,\n",
        "      kernel,\n",
        "      strides=1,\n",
        "      padding='same',\n",
        "      activation='relu'\n",
        "  )(x)\n",
        "  # Apply max pooling operation to the convolution output\n",
        "  x = tfkl.MaxPooling2D()(x)\n",
        "\n",
        "  return x"
      ],
      "metadata": {
        "id": "kwMLtYYUnJGO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We define the convolutional neural network, which is composed of a series of convolutional blocks and a flatten block."
      ],
      "metadata": {
        "id": "WBVToquMqrD1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def get_convolutional_neural_network(blocks, filters, kernel):\n",
        "  '''\n",
        "  A function generating a Keras Model of a Convolutional Neural Network (CNN)\n",
        "  with the specified number of convolutional blocks, number of filters for each\n",
        "  convolutional block and kernel size.\n",
        "\n",
        "  Input shape: (None, h, w, channels)\n",
        "  Output shape: (None, h/(2^blocks)*w/(2^blocks)*filters*blocks)\n",
        "  '''\n",
        "  inputs = tfkl.Input(shape=input_shape, name='CNN_input')\n",
        "  x = tfkl.Normalization(name=\"CNN_normalization\")(inputs)\n",
        "  # Extract features via convolution and pooling operations\n",
        "  for b in range(blocks):\n",
        "    x = convolutional_block(x, filters*(b+1), kernel)\n",
        "  x = tfkl.Flatten(name=\"CNN_flatten\")(x)\n",
        "  # Create the Keras model\n",
        "  model = tfk.Model(inputs=inputs, outputs=x, name=\"Convolutional NN\")\n",
        "  return model"
      ],
      "metadata": {
        "id": "EESmkOCuqq43"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Define the Text Transformer"
      ],
      "metadata": {
        "id": "ZTPknBaqyJTI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class TokenAndPositionEmbedding(tfkl.Layer):\n",
        "  '''\n",
        "  A custom Keras Layer implementing the token and position embedding block.\n",
        "  It consists of two embedding layers, one for the tokens and one for the\n",
        "  position of the token.\n",
        "  '''\n",
        "  def __init__(self, maxlen, vocab_size, embed_dim, **kwargs):\n",
        "    super().__init__(**kwargs)\n",
        "    # Embedding layer for the token\n",
        "    self.token_emb = tfkl.Embedding(\n",
        "        input_dim=vocab_size, output_dim=embed_dim)\n",
        "    # Embedding layer for the position\n",
        "    self.pos_emb = tfkl.Embedding(input_dim=maxlen, output_dim=embed_dim)\n",
        "    self.maxlen = maxlen\n",
        "\n",
        "  def call(self, x):\n",
        "    '''\n",
        "    Input shape: (None, sequence_length)\n",
        "    Output shape: (None, sequence_length, embed_dim)\n",
        "    '''\n",
        "    # Create a tensor with positions from 0 to maxlen-1\n",
        "    positions = tf.range(start=0, limit=self.maxlen, delta=1)\n",
        "    # Embed the positions\n",
        "    positions = self.pos_emb(positions)\n",
        "    # Embed the tokens\n",
        "    x = self.token_emb(x)\n",
        "    # Add the token and position embeddings\n",
        "    return x + positions"
      ],
      "metadata": {
        "id": "RPhv5-8s2Dym"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class TransformerEncoderBlock(tfkl.Layer):\n",
        "  '''\n",
        "  A custom Keras Layer implementing a block in the Transformer encoder\n",
        "  architecture.\n",
        "  It consists of:\n",
        "  - Multi-head self-attention layer\n",
        "  - Feed-forward network with two dense layers and ReLU activation\n",
        "  - Two normalization layers\n",
        "  - Two dropout layers\n",
        "  '''\n",
        "  def __init__(self, embed_dim, num_heads, ff_dim, rate=0.1, **kwargs):\n",
        "    super().__init__(**kwargs)\n",
        "    self.att =tfkl.MultiHeadAttention(num_heads=num_heads,key_dim=embed_dim)\n",
        "    self.ffn = tfk.Sequential(\n",
        "        [\n",
        "            tfkl.Dense(ff_dim, activation=\"relu\"),\n",
        "            tfkl.Dense(embed_dim)\n",
        "        ]\n",
        "    )\n",
        "    self.layernorm1 = tfkl.LayerNormalization(epsilon=1e-6)\n",
        "    self.layernorm2 = tfkl.LayerNormalization(epsilon=1e-6)\n",
        "    self.dropout1 = tfkl.Dropout(rate)\n",
        "    self.dropout2 = tfkl.Dropout(rate)\n",
        "\n",
        "  def call(self, inputs, training):\n",
        "    '''\n",
        "    Input shape: (None, sequence_length, embed_dim)\n",
        "    Output shape: (None, sequence_length, embed_dim)\n",
        "    '''\n",
        "    # Self-attention\n",
        "    attn_output = self.att(inputs, inputs)\n",
        "    # Apply dropout to the attention output\n",
        "    attn_output = self.dropout1(attn_output, training=training)\n",
        "    # Add the attention output to the input and normalize\n",
        "    out1 = self.layernorm1(inputs + attn_output)\n",
        "    # Feed-forward\n",
        "    ffn_output = self.ffn(out1)\n",
        "    # Apply dropout to the feed-forward output\n",
        "    ffn_output = self.dropout2(ffn_output, training=training)\n",
        "    # Add the feed-forward output to the previous output and normalize\n",
        "    return self.layernorm2(out1 + ffn_output)"
      ],
      "metadata": {
        "id": "F6yzyQzl2WAM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def get_transformer_neural_network(blocks):\n",
        "  '''\n",
        "  A function generating a Keras Model of a transfomer encoder with a specified\n",
        "  number of blocks.\n",
        "\n",
        "  Input shape: (None, sequence_length)\n",
        "  Output shape: (None, embed_dim)\n",
        "  '''\n",
        "  inputs = tfkl.Input(shape=(sequence_length), name='transformer_input')\n",
        "  x = TokenAndPositionEmbedding(sequence_length, vocab_size, embed_dim,\n",
        "                                name=\"token_position_embedding\")(inputs)\n",
        "  for i in range(blocks):\n",
        "    x = TransformerEncoderBlock(embed_dim, num_heads, latent_dim,\n",
        "                                name=\"transformer_encoder_block\"+str(i+1))(x)\n",
        "  x = tfkl.GlobalAveragePooling1D(name=\"transformer_global_average_pooling\")(x)\n",
        "  model = tfk.Model(inputs=inputs, outputs=x, name=\"Transformer\")\n",
        "  return model"
      ],
      "metadata": {
        "id": "XM55P87q3H6C"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Define the CLIP Model"
      ],
      "metadata": {
        "id": "Zcpf44ijOon4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class CLIPConnector(tfkl.Layer):\n",
        "  '''\n",
        "  A custom Keras Layer for connecting the outputs of a CNN and a Transformer\n",
        "  model using the CLIP similarity computation.\n",
        "  '''\n",
        "  def __init__(self, **kwargs):\n",
        "        super().__init__(**kwargs)\n",
        "        self.t = self.add_weight(name=\"temperature\", trainable=True)\n",
        "        self.CNN_dense = tfkl.Dense(final_embed_dim, activation=None,\n",
        "                                    name=\"CNN_dense\")\n",
        "        self.transformer_dense = tfkl.Dense(final_embed_dim, activation=None,\n",
        "                                            name=\"transformer_dense\")\n",
        "\n",
        "  def call(self, CNN_output, transformer_output):\n",
        "    '''\n",
        "    Input shape:\n",
        "    - CNN_output: (None, CNN_output_size)\n",
        "    - transformer_output: (None, embed_dim)\n",
        "    Output shape: (None, None)\n",
        "    '''\n",
        "    # Use Dense layers to obtain the same embedding dimensions for the CNN and\n",
        "    # transformer encodings.\n",
        "    CNN_output_final_embed = self.CNN_dense(CNN_output)\n",
        "    transformer_output_final_embed = self.transformer_dense(transformer_output)\n",
        "\n",
        "    # l2 normalization of both embeddings.\n",
        "    CNN_output_final_embed_norm = tf.math.l2_normalize(\n",
        "        CNN_output_final_embed, axis=-1)\n",
        "    transformer_output_final_embed_norm = tf.math.l2_normalize(\n",
        "        transformer_output_final_embed, axis=-1)\n",
        "\n",
        "    # Computation of the cosine distance between the embeddings and\n",
        "    # multiplication for a trainable temperature parameter.\n",
        "    similarity_matrix = tf.linalg.matmul(transformer_output_final_embed_norm,\n",
        "                                         CNN_output_final_embed_norm,\n",
        "                                         transpose_a=False,\n",
        "                                         transpose_b=True)*tf.math.exp(self.t)\n",
        "\n",
        "    return similarity_matrix"
      ],
      "metadata": {
        "id": "oD70AQNdxnwe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "CNN_blocks = 4\n",
        "transformer_blocks = 4\n",
        "\n",
        "CNN = get_convolutional_neural_network(blocks=CNN_blocks, filters=64, kernel=5)\n",
        "transformer = get_transformer_neural_network(blocks=transformer_blocks)\n",
        "\n",
        "similarity_matrix = CLIPConnector(name=\"CLIP_connector\")(\n",
        "    CNN.output, transformer.output)\n",
        "\n",
        "CLIP=tfk.Model(inputs=[CNN.input, transformer.input], outputs=similarity_matrix,\n",
        "                 name=\"CLIP\")\n",
        "CLIP.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Dv7QKbccOxPW",
        "outputId": "bd07ea02-4dad-4cdc-f7f2-d52b55726375"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"CLIP\"\n",
            "__________________________________________________________________________________________________\n",
            " Layer (type)                   Output Shape         Param #     Connected to                     \n",
            "==================================================================================================\n",
            " CNN_input (InputLayer)         [(None, 128, 128, 3  0           []                               \n",
            "                                )]                                                                \n",
            "                                                                                                  \n",
            " CNN_normalization (Normalizati  (None, 128, 128, 3)  7          ['CNN_input[0][0]']              \n",
            " on)                                                                                              \n",
            "                                                                                                  \n",
            " conv2d (Conv2D)                (None, 128, 128, 64  4864        ['CNN_normalization[0][0]']      \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " transformer_input (InputLayer)  [(None, 400)]       0           []                               \n",
            "                                                                                                  \n",
            " max_pooling2d (MaxPooling2D)   (None, 64, 64, 64)   0           ['conv2d[0][0]']                 \n",
            "                                                                                                  \n",
            " token_position_embedding (Toke  (None, 400, 128)    2611200     ['transformer_input[0][0]']      \n",
            " nAndPositionEmbedding)                                                                           \n",
            "                                                                                                  \n",
            " conv2d_1 (Conv2D)              (None, 64, 64, 128)  204928      ['max_pooling2d[0][0]']          \n",
            "                                                                                                  \n",
            " transformer_encoder_block1 (Tr  (None, 400, 128)    527616      ['token_position_embedding[0][0]'\n",
            " ansformerEncoderBlock)                                          ]                                \n",
            "                                                                                                  \n",
            " max_pooling2d_1 (MaxPooling2D)  (None, 32, 32, 128)  0          ['conv2d_1[0][0]']               \n",
            "                                                                                                  \n",
            " transformer_encoder_block2 (Tr  (None, 400, 128)    527616      ['transformer_encoder_block1[0][0\n",
            " ansformerEncoderBlock)                                          ]']                              \n",
            "                                                                                                  \n",
            " CNN_flatten (Flatten)          (None, 131072)       0           ['max_pooling2d_1[0][0]']        \n",
            "                                                                                                  \n",
            " transformer_global_average_poo  (None, 128)         0           ['transformer_encoder_block2[0][0\n",
            " ling (GlobalAveragePooling1D)                                   ]']                              \n",
            "                                                                                                  \n",
            " CLIP_connector (CLIPConnector)  (None, None)        16793857    ['CNN_flatten[0][0]',            \n",
            "                                                                  'transformer_global_average_pool\n",
            "                                                                 ing[0][0]']                      \n",
            "                                                                                                  \n",
            "==================================================================================================\n",
            "Total params: 20,670,088\n",
            "Trainable params: 20,670,081\n",
            "Non-trainable params: 7\n",
            "__________________________________________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tfk.utils.plot_model(CLIP)"
      ],
      "metadata": {
        "id": "WqWq_MpMoLwP",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "b0ca5b21-3e91-446d-9e79-371be045e0ae"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {},
          "execution_count": 350
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Training and validation"
      ],
      "metadata": {
        "id": "NPxUHE63REdH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "learning_rate = 5e-5\n",
        "optimizer = tfk.optimizers.Adam(learning_rate)\n",
        "EPOCHS = 25\n",
        "BATCH_SIZE = 64"
      ],
      "metadata": {
        "id": "SrC9ZuY0H55g"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Define the custom loss function"
      ],
      "metadata": {
        "id": "JXwbjplrRGzC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def CLIP_loss_fn(y_true, y_pred):\n",
        "  '''\n",
        "  Custom loss function for the CLIP model. It computes the similarity between\n",
        "  the output matrix of CLIP and the identity matrix. To do this, it exploits the\n",
        "  cross-entropy loss function on both axes of the output matrix and then\n",
        "  averages the two results.\n",
        "  '''\n",
        "  labels = tf.range(tf.shape(y_true)[0])\n",
        "  loss_function = tfk.losses.SparseCategoricalCrossentropy(\n",
        "      from_logits=True, reduction=tfk.losses.Reduction.SUM_OVER_BATCH_SIZE)\n",
        "  loss_1 = loss_function(labels, y_pred)\n",
        "  loss_2 = loss_function(labels, tf.transpose(y_pred))\n",
        "  return (loss_1+loss_2)/2"
      ],
      "metadata": {
        "id": "IX_HfJNkRI4-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Train the model"
      ],
      "metadata": {
        "id": "HorzfjTqpYcE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "This code is performing text vectorization in TensorFlow's Keras library\n",
        "(tf.keras or tfk). It defines a TextVectorization layer with a vocabulary\n",
        "size of vocab_size, meaning it will only consider the top vocab_size most common\n",
        "tokens in the input text data. The layer has an output mode of \"int\",\n",
        "meaning it will return the vectorized representation of the text as integer\n",
        "token indices. The output sequence length is set to sequence_length, meaning\n",
        "each input text will be padded or truncated to sequence_length tokens.\n",
        "The adapt method is called on the training captions, allowing the vectorization\n",
        "layer to learn and update the tokenization and vocabulary mapping.\n",
        "'''\n",
        "vectorization = tfkl.TextVectorization(max_tokens=vocab_size, output_mode=\"int\",\n",
        "                                       output_sequence_length=sequence_length)\n",
        "vectorization.adapt(captions)\n",
        "captions_train_vect = vectorization(captions_train)\n",
        "captions_test_vect = vectorization(captions_test)"
      ],
      "metadata": {
        "id": "gs6MgAk7_TUZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "CLIP.compile(optimizer=optimizer, loss=CLIP_loss_fn)\n",
        "\n",
        "history = CLIP.fit(\n",
        "    x=[images_train, captions_train_vect],\n",
        "    y=tf.zeros(len(train_idx),2),\n",
        "    batch_size=BATCH_SIZE,\n",
        "    epochs=EPOCHS,\n",
        "    callbacks = [\n",
        "        tfk.callbacks.EarlyStopping(patience=2, monitor=\"val_loss\", restore_best_weights=True)\n",
        "    ],\n",
        "    validation_split = 0.2,\n",
        "    shuffle=False\n",
        ")"
      ],
      "metadata": {
        "id": "zjrl1WOxpaJk",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "377932d1-9db6-4d39-f95d-40afb64fd135"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/10\n",
            "833/833 [==============================] - 245s 268ms/step - loss: 4.0560 - val_loss: 4.1190\n",
            "Epoch 2/10\n",
            "833/833 [==============================] - 470s 565ms/step - loss: 3.8114 - val_loss: 4.0660\n",
            "Epoch 3/10\n",
            "833/833 [==============================] - 204s 244ms/step - loss: 3.7043 - val_loss: 4.0252\n",
            "Epoch 4/10\n",
            "833/833 [==============================] - 202s 242ms/step - loss: 3.6376 - val_loss: 3.9980\n",
            "Epoch 5/10\n",
            "833/833 [==============================] - 200s 241ms/step - loss: 3.5900 - val_loss: 3.9868\n",
            "Epoch 6/10\n",
            "833/833 [==============================] - 201s 241ms/step - loss: 3.5533 - val_loss: 3.9781\n",
            "Epoch 7/10\n",
            "833/833 [==============================] - 201s 241ms/step - loss: 3.5188 - val_loss: 3.9665\n",
            "Epoch 8/10\n",
            "833/833 [==============================] - 206s 247ms/step - loss: 3.4878 - val_loss: 3.9594\n",
            "Epoch 9/10\n",
            "833/833 [==============================] - 200s 241ms/step - loss: 3.4600 - val_loss: 3.9554\n",
            "Epoch 10/10\n",
            "833/833 [==============================] - 200s 241ms/step - loss: 3.4334 - val_loss: 3.9473\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.figure(figsize=(16,16))\n",
        "plt.plot(history.history[\"loss\"])\n",
        "plt.plot(history.history[\"val_loss\"], '--')\n",
        "plt.ylabel('loss')\n",
        "plt.xlabel('epoch')\n",
        "plt.legend(['train', 'validation'], loc='lower left')\n",
        "plt.ylim(bottom=0, top=4.5)\n",
        "plt.grid(visible=True)\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "7iBjDRFH63Mz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "CLIP.save(\"CLIP_\"+str(CNN_blocks)+\"_\"+str(transformer_blocks)+\".keras\")"
      ],
      "metadata": {
        "id": "o1wT4HsrAvpJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "In the following cell we execute the garbage collector because sometimes there is some garbage resulting from the training that occupies precious RAM memory."
      ],
      "metadata": {
        "id": "uCpFHYZt06k4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import gc\n",
        "gc.collect()"
      ],
      "metadata": {
        "id": "4UljyfpJqEoZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Analyze the captions"
      ],
      "metadata": {
        "id": "tV70NM_zNkkt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "m_tokenizer = tfk.preprocessing.text.Tokenizer(num_words=20000)\n",
        "m_tokenizer.fit_on_texts(captions[\"caption\"])"
      ],
      "metadata": {
        "id": "weWON7yPNqVV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "words_freq = m_tokenizer.word_counts\n",
        "words_freq = pd.DataFrame(words_freq.items(), columns=[\"word\", \"frequency\"])\n",
        "words_freq.set_index(\"word\", inplace=True)\n",
        "\n",
        "stopwords = [\"the\", \"of\", \"show\", \"and\", \"a\", \"in\", \"with\", \"be\", \"arrow\",\n",
        "             \"right\",\"left\",\"image\",\"to\", \"at\", \"on\", \"view\", \"demonstrate\",\n",
        "             \"after\", \"leave\", \"an\", \"from\", \"patient\", \"by\", \"large\",\n",
        "             \"compute\",\"computed\",\"reveal\",\"anterior\",\"low\",\"contrast\",\"as\",\n",
        "             \"no\",\"see\",\"area\",\"for\",\"cm\",\"that\", \"normal\", \"month\",\"level\",\n",
        "             \"line\",\"note\",\"into\",\"black\", \"enhance\",\"red\",\"small\",\"case\",\n",
        "             \"white\",\"both\",\"between\",\"arrowhead\",\"which\",\"there\",\"indicate\",\n",
        "             \"or\",\"indicate\",\"day\",\"year\",\"without\",\"present\",\"extend\",\"two\",\n",
        "             \"multiple\",\"region\",\"side\",\"within\",\"have\",\"mm\",\"also\",\"space\",\n",
        "             \"through\",\"b\",\"this\",\"not\",\"involve\",\"plain\",\"diameter\",\"perform\",\n",
        "             \"follow\",\"common\",\"point\",\"middle\",\"initial\",\"complete\",\"change\",\n",
        "             \"long\",\"first\",\"mr\",\"well\",\"adjacent\",\"high\",\"surround\",\"during\",\n",
        "             \"part\"]\n",
        "words_freq.drop(stopwords, inplace=True)\n",
        "\n",
        "words_freq.sort_values(by=\"frequency\", ascending=False, inplace=True)\n",
        "words_freq.head(100)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 455
        },
        "id": "TtzgrM5zRqYQ",
        "outputId": "c2f45c35-0252-4be9-e3b4-2600a8958416"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "            frequency\n",
              "word                 \n",
              "ct              14553\n",
              "scan            10738\n",
              "tomography       9695\n",
              "chest            8860\n",
              "mass             8598\n",
              "...               ...\n",
              "position         1246\n",
              "followup         1242\n",
              "stent            1230\n",
              "use              1223\n",
              "node             1217\n",
              "\n",
              "[100 rows x 1 columns]"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-b5c2a6b0-eadd-4c94-b62c-37d922cb1181\" class=\"colab-df-container\">\n",
              "    <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>frequency</th>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>word</th>\n",
              "      <th></th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>ct</th>\n",
              "      <td>14553</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>scan</th>\n",
              "      <td>10738</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>tomography</th>\n",
              "      <td>9695</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>chest</th>\n",
              "      <td>8860</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>mass</th>\n",
              "      <td>8598</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>...</th>\n",
              "      <td>...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>position</th>\n",
              "      <td>1246</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>followup</th>\n",
              "      <td>1242</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>stent</th>\n",
              "      <td>1230</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>use</th>\n",
              "      <td>1223</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>node</th>\n",
              "      <td>1217</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "<p>100 rows × 1 columns</p>\n",
              "</div>\n",
              "    <div class=\"colab-df-buttons\">\n",
              "\n",
              "  <div class=\"colab-df-container\">\n",
              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-b5c2a6b0-eadd-4c94-b62c-37d922cb1181')\"\n",
              "            title=\"Convert this dataframe to an interactive table.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
              "  </svg>\n",
              "    </button>\n",
              "\n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    .colab-df-buttons div {\n",
              "      margin-bottom: 4px;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "    <script>\n",
              "      const buttonEl =\n",
              "        document.querySelector('#df-b5c2a6b0-eadd-4c94-b62c-37d922cb1181 button.colab-df-convert');\n",
              "      buttonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "      async function convertToInteractive(key) {\n",
              "        const element = document.querySelector('#df-b5c2a6b0-eadd-4c94-b62c-37d922cb1181');\n",
              "        const dataTable =\n",
              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                    [key], {});\n",
              "        if (!dataTable) return;\n",
              "\n",
              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "          + ' to learn more about interactive tables.';\n",
              "        element.innerHTML = '';\n",
              "        dataTable['output_type'] = 'display_data';\n",
              "        await google.colab.output.renderOutput(dataTable, element);\n",
              "        const docLink = document.createElement('div');\n",
              "        docLink.innerHTML = docLinkHtml;\n",
              "        element.appendChild(docLink);\n",
              "      }\n",
              "    </script>\n",
              "  </div>\n",
              "\n",
              "\n",
              "<div id=\"df-06e3a105-d1c6-4101-bc5c-4c0f1c413354\">\n",
              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-06e3a105-d1c6-4101-bc5c-4c0f1c413354')\"\n",
              "            title=\"Suggest charts.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "     width=\"24px\">\n",
              "    <g>\n",
              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
              "    </g>\n",
              "</svg>\n",
              "  </button>\n",
              "\n",
              "<style>\n",
              "  .colab-df-quickchart {\n",
              "      --bg-color: #E8F0FE;\n",
              "      --fill-color: #1967D2;\n",
              "      --hover-bg-color: #E2EBFA;\n",
              "      --hover-fill-color: #174EA6;\n",
              "      --disabled-fill-color: #AAA;\n",
              "      --disabled-bg-color: #DDD;\n",
              "  }\n",
              "\n",
              "  [theme=dark] .colab-df-quickchart {\n",
              "      --bg-color: #3B4455;\n",
              "      --fill-color: #D2E3FC;\n",
              "      --hover-bg-color: #434B5C;\n",
              "      --hover-fill-color: #FFFFFF;\n",
              "      --disabled-bg-color: #3B4455;\n",
              "      --disabled-fill-color: #666;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart {\n",
              "    background-color: var(--bg-color);\n",
              "    border: none;\n",
              "    border-radius: 50%;\n",
              "    cursor: pointer;\n",
              "    display: none;\n",
              "    fill: var(--fill-color);\n",
              "    height: 32px;\n",
              "    padding: 0;\n",
              "    width: 32px;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart:hover {\n",
              "    background-color: var(--hover-bg-color);\n",
              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "    fill: var(--button-hover-fill-color);\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart-complete:disabled,\n",
              "  .colab-df-quickchart-complete:disabled:hover {\n",
              "    background-color: var(--disabled-bg-color);\n",
              "    fill: var(--disabled-fill-color);\n",
              "    box-shadow: none;\n",
              "  }\n",
              "\n",
              "  .colab-df-spinner {\n",
              "    border: 2px solid var(--fill-color);\n",
              "    border-color: transparent;\n",
              "    border-bottom-color: var(--fill-color);\n",
              "    animation:\n",
              "      spin 1s steps(1) infinite;\n",
              "  }\n",
              "\n",
              "  @keyframes spin {\n",
              "    0% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "      border-left-color: var(--fill-color);\n",
              "    }\n",
              "    20% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    30% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    40% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    60% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    80% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "    90% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "  }\n",
              "</style>\n",
              "\n",
              "  <script>\n",
              "    async function quickchart(key) {\n",
              "      const quickchartButtonEl =\n",
              "        document.querySelector('#' + key + ' button');\n",
              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
              "      try {\n",
              "        const charts = await google.colab.kernel.invokeFunction(\n",
              "            'suggestCharts', [key], {});\n",
              "      } catch (error) {\n",
              "        console.error('Error during call to suggestCharts:', error);\n",
              "      }\n",
              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
              "    }\n",
              "    (() => {\n",
              "      let quickchartButtonEl =\n",
              "        document.querySelector('#df-06e3a105-d1c6-4101-bc5c-4c0f1c413354 button');\n",
              "      quickchartButtonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "    })();\n",
              "  </script>\n",
              "</div>\n",
              "    </div>\n",
              "  </div>\n"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Import trained model"
      ],
      "metadata": {
        "id": "7pURW-OiL78J"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "CLIP = tfk.models.load_model(\"./CLIP_5_5_2.59.keras\",\n",
        "  custom_objects={\"TokenAndPositionEmbedding\":TokenAndPositionEmbedding,\n",
        "                  \"TransformerEncoderBlock\":TransformerEncoderBlock,\n",
        "                  \"CLIPConnector\":CLIPConnector,\n",
        "                  \"CLIP_loss_fn\":CLIP_loss_fn})"
      ],
      "metadata": {
        "id": "r23IIgMuL7ou"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "seed = 42342323423\n",
        "\n",
        "rng = np.random.default_rng(seed)\n",
        "tf.random.set_seed(seed)"
      ],
      "metadata": {
        "id": "flC6PIicMAZ9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "n = images_test.shape[0]\n",
        "idx = list(rng.choice(range(n), size=32, replace = False))\n",
        "predictions =CLIP.predict([images_test[idx], tf.gather(captions_test_vect,idx)])\n",
        "caption_vs_image = tf.nn.softmax(predictions, axis=1)\n",
        "image_vs_caption = tf.transpose(tf.nn.softmax(predictions, axis=0))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NIhQOv_soVFv",
        "outputId": "1e5153ad-4185-4368-cd9f-bf8cfa7a5d67"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1/1 [==============================] - 15s 15s/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "`caption_vs_image` is a matrix such that each row corresponds to a caption and each row corresponds to an image. If we take row `i`, its values are the probabilities that caption `i` is associate with the image in that column. Therefore, the sum of each row is equal to 1.\n",
        "`image_vs_caption` is the viceversa: each row corresponds to an image and each column corresponds to a caption."
      ],
      "metadata": {
        "id": "ZoPFfkLV00tD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plt.imshow(caption_vs_image)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 447
        },
        "id": "haJ0q5tj0ANJ",
        "outputId": "a440b8c9-8b52-410b-bfb7-5c55f58c01aa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7872bcd6ed10>"
            ]
          },
          "metadata": {},
          "execution_count": 22
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "selected_text = 23\n",
        "fig, ax = plt.subplots(nrows=2, ncols=8, figsize=(20,8))\n",
        "\n",
        "fig.suptitle(captions_test.iloc[idx[selected_text]][\"caption\"])\n",
        "\n",
        "i = 0\n",
        "\n",
        "top_perc = np.argsort(-caption_vs_image[selected_text].numpy())\n",
        "\n",
        "for i in range(8):\n",
        "  bars=ax[0][i].bar(0,caption_vs_image[selected_text][top_perc[i]].numpy(),\n",
        "                    color=\"r\")\n",
        "  ax[0][i].set_ylim(0,1)\n",
        "  if top_perc[i] == selected_text:\n",
        "    bars[0].set_color('g')\n",
        "  ax[1][i].imshow(images_test[idx[top_perc[i]]])\n",
        "  ax[1][i].set_title(f\"{caption_vs_image[selected_text][top_perc[i]].numpy():.2%}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 516
        },
        "id": "FUYMm8nd2byt",
        "outputId": "957b99ea-28ee-4609-e0e5-17c5aae734d7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 2000x800 with 16 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.imshow(image_vs_caption)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 447
        },
        "id": "Jcq71V_16iAX",
        "outputId": "be41a026-41fe-4025-be1c-9a01e25cc7f3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7872bcea9f90>"
            ]
          },
          "metadata": {},
          "execution_count": 24
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "selected_image = 23\n",
        "plt.imshow(images_test[idx[selected_image]])\n",
        "\n",
        "top_perc = np.argsort(-image_vs_caption[selected_image].numpy())\n",
        "\n",
        "for i in range(8):\n",
        "  if top_perc[i] == selected_image:\n",
        "    print(f\"\\033[92m {image_vs_caption[selected_image][top_perc[i]].numpy():.2%}  {captions_test['caption'][idx[top_perc[i]]]}\")\n",
        "  else:\n",
        "    print(f\"\\033[91m {image_vs_caption[selected_image][top_perc[i]].numpy():.2%}  {captions_test['caption'][idx[top_perc[i]]]}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 593
        },
        "id": "EuVVeYi06fDm",
        "outputId": "d9173d6d-39f2-404c-8bf7-7161139e5769"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[92m 43.16%  case  image of insertion of the sheath into the leave common carotid artery a  sheath be show insert through the skin into the proximal leave common carotid artery\n",
            "\u001b[91m 12.51%  angiogram show significant stenosis of the right coronary artery\n",
            "\u001b[91m 9.64%  the balloon mount pd stent short arrow release follow the inflation of balloon whilst long arrow identify the biliary stent\n",
            "\u001b[91m 6.81%  the right side of  vertebral body demonstrate abnormal marrow signal and enhancement consistent with osteomyelitis on cervical spine mri short tau inversion recovery\n",
            "\u001b[91m 5.93%  ct angiography diffuse alveolar haemorrhage\n",
            "\u001b[91m 5.29%  midline sagittal  image capture on december   show localized thickening of the subparietal galea aponeurotica with homogeneously slightly high signal intensity as indicate by the white arrow\n",
            "\u001b[91m 2.73%  cardiac mri  hyperintense image of the mass red arrow with evidence of metastasis white arrow\n",
            "\u001b[91m 2.63%  cervical magnetic resonance imaging reveal herniate nucleus pulposus in  and\n"
          ]
        },
        {
          "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": [
        "## Classification"
      ],
      "metadata": {
        "id": "0ECiiWPk3P36"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "We see that only one image is related to the mammography, therefore we ignore that class."
      ],
      "metadata": {
        "id": "KIWSnmm2mRR4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mammography_array = np.char.find(np.array(captions_test[\"caption\"], dtype=\"str\"),\"mammography\")>0\n",
        "sum(mammography_array)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YnDcH06QMbAX",
        "outputId": "ecb60afc-6c8c-42c6-a119-143646a80e24"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 143
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Following from the analysis of the most frequent word, we isolated 6 types of radiography images. We select, in our test set, only the images that have in their caption only one of names of the classes."
      ],
      "metadata": {
        "id": "q7f0nl7imaeG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "classes = [\" ct\",\"mri\",\"ultrasound\",\"fluoroscopy\",\"xray\",\"angiography\"]\n",
        "idx_classification = np.zeros(captions_test[\"caption\"].shape[0],dtype=\"int\")\n",
        "for cl in classes:\n",
        "  idx_classification+=np.char.find(np.array(captions_test[\"caption\"], dtype=\"str\"),cl)>0\n",
        "idx_classification = idx_classification==1"
      ],
      "metadata": {
        "id": "lkw4Xe_nG82t"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "images_test_class = images_test[idx_classification]\n",
        "captions_test_class = np.array(captions_test[\"caption\"], dtype=\"str\")\\\n",
        "   [idx_classification]"
      ],
      "metadata": {
        "id": "CD4egwUQSYTF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "type_rad = np.empty(sum(idx_classification),dtype='int')\n",
        "count = 0\n",
        "for cl in classes:\n",
        "  type_rad[np.char.find(captions_test_class,cl)>0]=count\n",
        "  count = count+1"
      ],
      "metadata": {
        "id": "EonZuh-COtbm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "prompts = [\"ct scan\", \"mri\",\"ultrasound\",\"fluoroscopy\",\"xray\",\"angiography\"]"
      ],
      "metadata": {
        "id": "Ho_idR6WflYa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We repeat the last data point so that it's possible to divide exactly the dataset in batches of 6 elements."
      ],
      "metadata": {
        "id": "VOhKFhdkRlv5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "images_test_class = np.append(images_test_class, images_test_class[images_test_class.shape[0]-1:images_test_class.shape[0]],\n",
        "                              axis=0)\n",
        "type_rad = np.append(type_rad, type_rad[type_rad.shape[0]-1:type_rad.shape[0]])"
      ],
      "metadata": {
        "id": "9WgaCgJbTFKN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "images_test_class.shape[0]/6"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "F4qxxLuVUNkp",
        "outputId": "796e40b0-6e3e-4c35-a3ba-51b08264474d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "699.0"
            ]
          },
          "metadata": {},
          "execution_count": 296
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The resulting `(6,6)` matrices are concatenated one under the other.\n",
        "We move to concatenate them along the columns, in order to have a final shape of `(6,n_images)`."
      ],
      "metadata": {
        "id": "upB3hpd8Xk9n"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "n_batches = 6"
      ],
      "metadata": {
        "id": "sPOWZCdvidWt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "predictions = CLIP.predict([images_test_class[0:n_batches*6],vectorization(np.tile(prompts,n_batches))],batch_size=6)\n",
        "predictions = np.concatenate(np.split(predictions,range(6,predictions.shape[0],6)),axis=1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TJPnxhJ9Uw-k",
        "outputId": "4e056672-f4af-4775-b616-501ad55d3bc2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "6/6 [==============================] - 6s 1s/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Compute the accuracy:"
      ],
      "metadata": {
        "id": "eF06GV0ejZ61"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sum(np.argmax(predictions, axis=0)==type_rad[0:6*n_batches])/(6*n_batches)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "juSKFGdzdu5e",
        "outputId": "f80e2144-fb41-4b4f-9b8d-40415cc32daf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.8055555555555556"
            ]
          },
          "metadata": {},
          "execution_count": 323
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Prompt ensemble\n",
        "We try to improve our performance using an ensemble of prompts. The resulting prediction matrices for each prompt are summed together."
      ],
      "metadata": {
        "id": "IqDhORgKissQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "prompts = np.array([[\"ct scan\", \"mri\",\"ultrasound\",\"fluoroscopy\",\"xray\",\"angiography\"],\n",
        "                    [\"tomography\", \"magnetic resonance imaging\",\"ultrasound\",\"fluoroscopy\",\"xray\",\"angiography\"],\n",
        "                    [\"ct\", \"mri\",\"ultrasound\",\"fluoroscopy\",\"xray\",\"ct angiography\"],\n",
        "                   [\"computed tomography\", \"mri\",\"ultrasound\",\"fluoroscopy\",\"chest xray\",\"coronal angiography\"],\n",
        "                   [\"ct\", \"mri\",\"abdominal ultrasound\",\"fluoroscopy\",\" xray\",\"angiography\"]])"
      ],
      "metadata": {
        "id": "kc6P5Ngpizm7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "n_batches = 6"
      ],
      "metadata": {
        "id": "3xC4kLhZjA9k"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "predictions = np.zeros((6,6*n_batches))\n",
        "for i in range(prompts.shape[0]):\n",
        "  temp = CLIP.predict([images_test_class[0:n_batches*6],vectorization(np.tile(prompts[i],n_batches))],batch_size=6)\n",
        "  temp = np.concatenate(np.split(temp,range(6,temp.shape[0],6)),axis=1)\n",
        "  predictions+=temp"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IT7aBLMLhx2D",
        "outputId": "b55220da-bcea-4e82-fdc5-e8333f0acdb8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "6/6 [==============================] - 9s 2s/step\n",
            "6/6 [==============================] - 7s 1s/step\n",
            "6/6 [==============================] - 8s 1s/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "np.sum(np.argmax(predictions, axis=0)==type_rad[0:6*n_batches])/(6*n_batches)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Xue5nBZGjYwI",
        "outputId": "5ad18984-88a9-4954-812a-f410a56a36a2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.75"
            ]
          },
          "metadata": {},
          "execution_count": 349
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Analysis of pneumonia images\n",
        "We exploit our model on the [Chest X-Ray dataset](https://www.kaggle.com/datasets/paultimothymooney/chest-xray-pneumonia/)."
      ],
      "metadata": {
        "id": "FRrSlBDq74X1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "print(f'Train set:{len(os.listdir(\"/chest-xray-pneumonia/chest_xray/test/NORMAL/\"))} normal xrays')\n",
        "print(f'Train set:{len(os.listdir(\"/chest-xray-pneumonia/chest_xray/test/PNEUMONIA/\"))} pneumonia xrays')"
      ],
      "metadata": {
        "id": "Ij5GuXP875Mh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "images_pneu = np.zeros((624,128,128,3),dtype=\"uint8\")\n",
        "count = 0\n",
        "for i in os.listdir(\"/chest-xray-pneumonia/chest_xray/test/NORMAL/\"):\n",
        "  image_name = \"/chest-xray-pneumonia/chest_xray/test/NORMAL/\"+i\n",
        "  img = tf.io.read_file(image_name)\n",
        "  images_pneu[count]= tf.image.resize(tf.io.decode_image(img, channels=3),[128,128], method=\"nearest\").numpy()\n",
        "  count = count + 1\n",
        "for i in os.listdir(\"/chest-xray-pneumonia/chest_xray/test/PNEUMONIA/\"):\n",
        "  image_name = \"/chest-xray-pneumonia/chest_xray/test/PNEUMONIA/\"+i\n",
        "  img = tf.io.read_file(image_name)\n",
        "  images_pneu[count]= tf.image.resize(tf.io.decode_image(img, channels=3),[128,128], method=\"nearest\").numpy()\n",
        "  count = count + 1"
      ],
      "metadata": {
        "id": "cDNxBiaY8D1f"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "prompts=[\"normal\", \"pneumonia\"]\n",
        "labels_pneu = np.concatenate((np.zeros(234), np.ones(390)))\n",
        "n_batches = 312"
      ],
      "metadata": {
        "id": "jFFlBuaq8j31"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Zero-shot learning"
      ],
      "metadata": {
        "id": "gVEphHg-9PlB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "predictions = CLIP.predict([images_pneu[0:n_batches*2],vectorization(np.tile(prompts,n_batches))],batch_size=2)\n",
        "predictions = np.concatenate(np.split(predictions,range(2,predictions.shape[0],2)),axis=1)"
      ],
      "metadata": {
        "id": "bCbP62Pw8zDX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "sum(np.argmax(predictions, axis=0)==labels_pneu[0:2*n_batches])/(2*n_batches)"
      ],
      "metadata": {
        "id": "G_nqcpNj82S6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The zero-shot learner does not work well. This is normal, the term \"pneumonia\" is very rare in the ROCO dataset.\n",
        "\n",
        "Therefore, we try with a few-shot learner."
      ],
      "metadata": {
        "id": "ZgIah6Un8497"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Few-shot learning\n",
        "For the few-shot learner, we keep only the CLIP's image encoder and we attach a dense layer for classification."
      ],
      "metadata": {
        "id": "xDYZhaXY9Mxv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "fsl = None\n",
        "hidden_model = tfk.Model(inputs=CLIP.get_layer(\"CNN_input\").input, outputs=CLIP.get_layer(\"CNN_flatten\").output)\n",
        "hidden_model.trainable = False\n",
        "x = tfkl.Dense(2,activation=\"sigmoid\")(hidden_model.output)\n",
        "fsl = tfk.Model(inputs=hidden_model.inputs, outputs=x)"
      ],
      "metadata": {
        "id": "BDqeVZMm8lMB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "learning_rate = 5e-5\n",
        "optimizer = tfk.optimizers.Adam(learning_rate)\n",
        "EPOCHS = 25\n",
        "BATCH_SIZE = 16"
      ],
      "metadata": {
        "id": "uMNy0buT9k6z"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "images_pneu_test = np.zeros((5216,128,128,3),dtype=\"uint8\")\n",
        "count = 0\n",
        "for i in os.listdir(\"/chest-xray-pneumonia/chest_xray/train/NORMAL/\"):\n",
        "  image_name = \"/chest-xray-pneumonia/chest_xray/train/NORMAL/\"+i\n",
        "  img = tf.io.read_file(image_name)\n",
        "  images_pneu_test[count]= tf.image.resize(tf.io.decode_image(img, channels=3),[128,128], method=\"nearest\").numpy()\n",
        "  count = count + 1\n",
        "for i in os.listdir(\"/chest-xray-pneumonia/chest_xray/train/PNEUMONIA/\"):\n",
        "  image_name = \"/chest-xray-pneumonia/chest_xray/train/PNEUMONIA/\"+i\n",
        "  img = tf.io.read_file(image_name)\n",
        "  images_pneu_test[count]= tf.image.resize(tf.io.decode_image(img, channels=3),[128,128], method=\"nearest\").numpy()\n",
        "  count = count + 1"
      ],
      "metadata": {
        "id": "b0nKa_Nw9muc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(f'Test set:{len(os.listdir(\"/chest-xray-pneumonia/chest_xray/train/NORMAL/\"))} normal xrays')\n",
        "print(f'Test set:{len(os.listdir(\"/chest-xray-pneumonia/chest_xray/train/PNEUMONIA/\"))} pneumonia xrays')"
      ],
      "metadata": {
        "id": "u6RopVel9uAR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "labels_pneu_test = np.concatenate((np.zeros(1341), np.ones(3875)))\n",
        "n_batches = 163"
      ],
      "metadata": {
        "id": "InpNGpkk9xRI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We test the few-shot learner with a growing number of training images."
      ],
      "metadata": {
        "id": "7R836QAX900c"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "n_train_fs = [25, 30, 35, 40, 45, 50, 100, 200, 234]\n",
        "accuracy_fs = []\n",
        "\n",
        "for i in n_train_fs:\n",
        "    learning_rate = 1e-3\n",
        "    optimizer = tfk.optimizers.Adam(learning_rate)\n",
        "    EPOCHS = 25\n",
        "    BATCH_SIZE = 16\n",
        "\n",
        "    fsl = None\n",
        "    hidden_model = tfk.Model(inputs=CLIP.get_layer(\"CNN_input\").input, outputs=CLIP.get_layer(\"CNN_flatten\").output)\n",
        "    hidden_model.trainable = False\n",
        "    x = tfkl.Dense(256,activation=\"relu\")(hidden_model.output)\n",
        "    x = tfkl.Dense(64,activation=\"relu\")(hidden_model.output)\n",
        "    x = tfkl.Dense(1,activation=\"sigmoid\")(x)\n",
        "    x = tfkl.Dropout(0.1)(x)\n",
        "    fsl = tfk.Model(inputs=hidden_model.inputs, outputs=x)\n",
        "\n",
        "    fsl.compile(optimizer=optimizer, loss='binary_crossentropy', metrics=\"accuracy\")\n",
        "\n",
        "    images_pneu_train = np.zeros((i*2,128,128,3), dtype=\"int\")\n",
        "    images_pneu_train[0:i] = images_pneu[0:i]\n",
        "    images_pneu_train[i:(2*i)]=images_pneu[234:(234+i)]\n",
        "    labels_pneu_train = np.concatenate((np.zeros(i), np.ones(i)))\n",
        "\n",
        "    history = fsl.fit(\n",
        "        x=images_pneu_train,\n",
        "        y=labels_pneu_train,\n",
        "        batch_size=BATCH_SIZE,\n",
        "        epochs=EPOCHS,\n",
        "        shuffle=True,\n",
        "        verbose=0\n",
        "    )\n",
        "\n",
        "    accuracy_fs.append(fsl.evaluate(images_pneu_test,labels_pneu_test)[1])"
      ],
      "metadata": {
        "id": "qr62Jpmq91Jl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot(np.array(n_train_fs)*2, accuracy_fs, \".-\")"
      ],
      "metadata": {
        "id": "Cqb1lBh194Ll"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}