diff --git a/ADNI_Brain_Visual_Transformer_47306725.ipynb b/ADNI_Brain_Visual_Transformer_47306725.ipynb
new file mode 100644
index 000000000..edb65530d
--- /dev/null
+++ b/ADNI_Brain_Visual_Transformer_47306725.ipynb
@@ -0,0 +1,2761 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "view-in-github",
+ "colab_type": "text"
+ },
+ "source": [
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "NOJyVEImaEwb"
+ },
+ "source": [
+ "Name: RITIKA RANA\n",
+ "\n",
+ "Student ID: 47306725\n",
+ "\n",
+ "Email: r.rana@uqconnect.edu.au\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "LF7DbUJMVsgT",
+ "outputId": "e4fc9962-b926-4eb4-dab9-958b2b95ba3b"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Requirement already satisfied: tensorflow_addons in /usr/local/lib/python3.10/dist-packages (0.22.0)\n",
+ "Requirement already satisfied: packaging in /usr/local/lib/python3.10/dist-packages (from tensorflow_addons) (23.2)\n",
+ "Requirement already satisfied: typeguard<3.0.0,>=2.7 in /usr/local/lib/python3.10/dist-packages (from tensorflow_addons) (2.13.3)\n"
+ ]
+ }
+ ],
+ "source": [
+ "pip install tensorflow_addons\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "GHvWfV4_Um5C"
+ },
+ "outputs": [],
+ "source": [
+ "import tensorflow as tf\n",
+ "import tensorflow_addons as tfa\n",
+ "import matplotlib.pyplot as plt\n",
+ "from tensorflow.keras.layers import Layer\n",
+ "from tensorflow.keras import layers\n",
+ "import math"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "IS18eC0op7DT",
+ "outputId": "8aa83451-08ae-4c5a-e1df-837ec9260b12"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Mounted at /content/drive\n"
+ ]
+ }
+ ],
+ "source": [
+ "\n",
+ "from google.colab import drive\n",
+ "drive.mount('/content/drive')\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "3B2n51h7wI64"
+ },
+ "outputs": [],
+ "source": [
+ "import zipfile"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "hhtpJNxzwq14",
+ "outputId": "9ca0db88-204d-46e8-d99b-806f10d3b0c7"
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ">"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "test_ = zipfile.ZipFile(file = '/content/drive/MyDrive/test.zip',mode = 'r')\n",
+ "test_.extractall('./')\n",
+ "test_.close"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "Fw-Butvmw5lV",
+ "outputId": "c3da31f4-c00a-4b9c-ada4-ad7eb79d4a98"
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ">"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "train_ = zipfile.ZipFile(file = '/content/drive/MyDrive/train.zip',mode = 'r')\n",
+ "train_.extractall('./')\n",
+ "train_.close"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "_Pqf22Gn1xJo"
+ },
+ "source": [
+ "MODEL 1\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Parameters"
+ ],
+ "metadata": {
+ "id": "K6hROM2jMF4V"
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "oyHNQYqAxKOQ"
+ },
+ "outputs": [],
+ "source": [
+ "# Hyperparameters\n",
+ "IMG_SIZE = 128\n",
+ "PATCH_SIZE = 8\n",
+ "BATCH_SIZE = 32\n",
+ "EPOCHS = 10\n",
+ "WEIGHT_DECAY = 0.0001\n",
+ "PROJECTION_DIM = 512 # MLP-blocks depth\n",
+ "LEARN_RATE = 0.0005\n",
+ "TRANSF_LAYERS = 5 # No. of transformer-encoder-blocks\n",
+ "DROPOUT_RATE = 0.2\n",
+ "ATTENTION_HEADS = 5\n",
+ "MLP_HEAD_UNITS = [256, 128]\n",
+ "DATA_LOAD_DEST = \"/content\"\n",
+ "MODEL_SAVE_DEST = \"/content/vision_transformer\"\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "mOtuAPa7x6Ic"
+ },
+ "outputs": [],
+ "source": [
+ "#Calculating automat\n",
+ "INPUT_SHAPE = (IMG_SIZE, IMG_SIZE, 3)\n",
+ "HIDDEN_UNITS = [PROJECTION_DIM * 2, PROJECTION_DIM]\n",
+ "NUM_PATCHES = int((IMG_SIZE/PATCH_SIZE) ** 2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Dataset"
+ ],
+ "metadata": {
+ "id": "oKaJP5BCMK7C"
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "5mM3u3SVXA7a"
+ },
+ "outputs": [],
+ "source": [
+ "def loadData():\n",
+ " \"\"\"\n",
+ " Loading the dataset.\n",
+ " \"\"\"\n",
+ " trainData = tf.keras.preprocessing.image_dataset_from_directory(\n",
+ " DATA_LOAD_DEST + \"/train\", labels='inferred', label_mode='binary',\n",
+ " image_size=[IMG_SIZE, IMG_SIZE], shuffle=True,\n",
+ " batch_size=BATCH_SIZE, seed=8, class_names=['AD', 'NC']\n",
+ " )\n",
+ "\n",
+ " testData = tf.keras.preprocessing.image_dataset_from_directory(\n",
+ " DATA_LOAD_DEST + \"/test\", labels='inferred', label_mode='binary',\n",
+ " image_size=[IMG_SIZE, IMG_SIZE], shuffle=True,\n",
+ " batch_size=BATCH_SIZE, seed=8, class_names=['AD', 'NC']\n",
+ " )\n",
+ "\n",
+ " # Augmenting data\n",
+ " normalize = tf.keras.layers.Normalization()\n",
+ " flip = tf.keras.layers.RandomFlip(mode='horizontal', seed=8)\n",
+ " rotate = tf.keras.layers.RandomRotation(factor=0.02, seed=8)\n",
+ " zoom = tf.keras.layers.RandomZoom(height_factor=0.1, width_factor=0.1, seed=8)\n",
+ "\n",
+ " trainData = trainData.map(\n",
+ " lambda x, y: (rotate(flip(zoom(normalize(x)))), y)\n",
+ " )\n",
+ "\n",
+ " testData = testData.map(\n",
+ " lambda x, y: (rotate(flip(zoom(normalize(x)))), y)\n",
+ " )\n",
+ "\n",
+ " # Taking half of the 9000 images from the test set as validation data\n",
+ " validationData = testData.take(len(list(testData))//2)\n",
+ "\n",
+ " # Using remaining images as test set\n",
+ " testData = testData.skip(len(list(testData))//2)\n",
+ "\n",
+ " return trainData, validationData, testData"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "C7Tz1hfV1EWy"
+ },
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Modules"
+ ],
+ "metadata": {
+ "id": "Do9dN8WfIjxQ"
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "1TTNBFQhqq4W"
+ },
+ "outputs": [],
+ "source": [
+ "class PatchLayer(Layer):\n",
+ "\t\"\"\"\n",
+ "\tLayering and transforming images into patches.\n",
+ "\t\"\"\"\n",
+ "\tdef __init__(self, img_size, patch_size, num_patches, projection_dim, **kwargs):\n",
+ "\t\tsuper(PatchLayer, self).__init__(**kwargs)\n",
+ "\t\tself.img_size = img_size\n",
+ "\t\tself.patch_size = patch_size\n",
+ "\t\tself.num_patches = num_patches\n",
+ "\t\tself.projection_dim = projection_dim\n",
+ "\t\tself.half_patch = patch_size // 2\n",
+ "\t\tself.flatten_patches = layers.Reshape((num_patches, -1))\n",
+ "\t\tself.projection = layers.Dense(units=projection_dim)\n",
+ "\t\tself.layer_norm = layers.LayerNormalization(epsilon=1e-6)\n",
+ "\n",
+ "\tdef shiftImg(self, images, mode):\n",
+ "\t\t# Building diagonally-shifted images\n",
+ "\t\tif mode == 'left-up':\n",
+ "\t\t\tcropheight = self.half_patch\n",
+ "\t\t\tcropwidth = self.half_patch\n",
+ "\t\t\tshiftheight = 0\n",
+ "\t\t\tshiftwidth = 0\n",
+ "\t\telif mode == 'left-down':\n",
+ "\t\t\tcropheight = 0\n",
+ "\t\t\tcropwidth = self.half_patch\n",
+ "\t\t\tshiftheight = self.half_patch\n",
+ "\t\t\tshiftwidth = 0\n",
+ "\t\telif mode == 'right-up':\n",
+ "\t\t\tcropheight = self.half_patch\n",
+ "\t\t\tcropwidth = 0\n",
+ "\t\t\tshiftheight = 0\n",
+ "\t\t\tshiftwidth = self.half_patch\n",
+ "\t\telse:\n",
+ "\t\t\tcropheight = 0\n",
+ "\t\t\tcropwidth = 0\n",
+ "\t\t\tshiftheight = self.half_patch\n",
+ "\t\t\tshiftwidth = self.half_patch\n",
+ "\n",
+ "\t\tcrop = tf.image.crop_to_bounding_box(\n",
+ "\t\t\timages,\n",
+ "\t\t\toffset_height=cropheight,\n",
+ "\t\t\toffset_width=cropwidth,\n",
+ "\t\t\ttarget_height=self.img_size - self.half_patch,\n",
+ "\t\t\ttarget_width=self.img_size - self.half_patch\n",
+ "\t\t)\n",
+ "\n",
+ "\t\tshiftPad = tf.image.pad_to_bounding_box(\n",
+ "\t\t\tcrop,\n",
+ "\t\t\toffset_height=shiftheight,\n",
+ "\t\t\toffset_width=shiftwidth,\n",
+ "\t\t\ttarget_height=self.img_size,\n",
+ "\t\t\ttarget_width=self.img_size\n",
+ "\t\t)\n",
+ "\t\treturn shiftPad\n",
+ "\n",
+ "\tdef call(self, images):\n",
+ "\t\timages = tf.concat(\n",
+ "\t\t\t[\n",
+ "\t\t\t\timages,\n",
+ "\t\t\t\tself.shiftImg(images, mode='left-up'),\n",
+ "\t\t\t\tself.shiftImg(images, mode='left-down'),\n",
+ "\t\t\t\tself.shiftImg(images, mode='right-up'),\n",
+ "\t\t\t\tself.shiftImg(images, mode='right-down'),\n",
+ "\t\t\t],\n",
+ "\t\t\taxis=-1\n",
+ "\t\t)\n",
+ "\t\tpatches = tf.image.extract_patches(\n",
+ "\t\t\timages=images,\n",
+ "\t\t\tsizes=[1, self.patch_size, self.patch_size, 1],\n",
+ "\t\t\tstrides=[1, self.patch_size, self.patch_size, 1],\n",
+ "\t\t\trates=[1, 1, 1, 1],\n",
+ "\t\t\tpadding='VALID'\n",
+ "\t\t)\n",
+ "\t\tflat_patches = self.flatten_patches(patches)\n",
+ "\t\ttokens = self.layer_norm(flat_patches)\n",
+ "\t\ttokens = self.projection(tokens)\n",
+ "\n",
+ "\t\treturn (tokens, patches)\n",
+ "\n",
+ "\tdef getConfig_(self):\n",
+ "\t\tconfig_ = super(PatchLayer, self).getConfig_()\n",
+ "\t\tconfig_.update(\n",
+ "\t\t\t{\n",
+ "\t\t\t\t'img_size': self.img_size,\n",
+ "\t\t\t\t'patch_size': self.patch_size,\n",
+ "\t\t\t\t'num_patches': self.num_patches,\n",
+ "\t\t\t\t'projection_dim': self.projection_dim\n",
+ "\t\t\t}\n",
+ "\t\t)\n",
+ "\t\treturn config_"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "cLmlIuEgWUqr"
+ },
+ "outputs": [],
+ "source": [
+ "class Embed_Patch(Layer):\n",
+ "\t\"\"\"\n",
+ "\tLayering for projecting patches into a vector.\n",
+ "\t\"\"\"\n",
+ "\tdef __init__(self, num_patches, projection_dim, **kwargs):\n",
+ "\t\tsuper(Embed_Patch, self).__init__(**kwargs)\n",
+ "\t\tself.num_patches = num_patches\n",
+ "\t\tself.projection_dim = projection_dim\n",
+ "\t\tself.position_embedding = layers.Embedding(\n",
+ "\t\t\tinput_dim=self.num_patches, output_dim=projection_dim\n",
+ "\t\t)\n",
+ "\n",
+ "\tdef call(self, patches):\n",
+ "\t\tpositions = tf.range(0, self.num_patches, delta=1)\n",
+ "\t\treturn patches + self.position_embedding(positions)\n",
+ "\n",
+ "\tdef getConfig_(self):\n",
+ "\t\tconfig_ = super(Embed_Patch, self).getConfig_()\n",
+ "\t\tconfig_.update(\n",
+ "\t\t\t{\n",
+ "\t\t\t\t'num_patches': self.num_patches,\n",
+ "\t\t\t\t'projection_dim': self.projection_dim\n",
+ "\t\t\t}\n",
+ "\t\t)\n",
+ "\t\treturn config_"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "GYzbNKTyWUk4"
+ },
+ "outputs": [],
+ "source": [
+ "class Multi_Head_AttentionLSA(layers.MultiHeadAttention):\n",
+ "\t\"\"\"\n",
+ "\tMulti Head Attention layer for the transformer-encoder block, but with the\n",
+ "\taddition of using Local-Self-Attention to improve feature\tlearning.\n",
+ "\n",
+ "\t\"\"\"\n",
+ "\tdef __init__(self, **kwargs):\n",
+ "\t\tsuper(Multi_Head_AttentionLSA, self).__init__(**kwargs)\n",
+ "\t\tself.tau = tf.Variable(math.sqrt(float(self._key_dim)), trainable=True)\n",
+ "\n",
+ "\tdef computeAttention(self, query, key, value, attention_mask=None,\n",
+ "\t\t\ttraining=None):\n",
+ "\t\tquery = tf.multiply(query, 1.0/self.tau)\n",
+ "\t\tattention_scores = tf.einsum(self._dot_product_equation, key, query)\n",
+ "\t\tattention_mask = tf.convert_to_tensor(attention_mask)\n",
+ "\t\tattention_scores = self._masked_softmax(attention_scores, attention_mask)\n",
+ "\t\tattention_scores_dropout = self._dropout_layer(\n",
+ "\t\t\tattention_scores, training=training\n",
+ "\t\t)\n",
+ "\t\tattention_output = tf.einsum(\n",
+ "\t\t\tself._combine_equation, attention_scores_dropout, value\n",
+ "\t\t)\n",
+ "\t\treturn attention_output, attention_scores\n",
+ "\n",
+ "\tdef getConfig_(self):\n",
+ "\t\tconfig_ = super(Multi_Head_AttentionLSA, self).getConfig_()\n",
+ "\t\treturn config_\n",
+ "\n",
+ "\n",
+ "def buildVisionTransformer(input_shape, img_size, patch_size, num_patches,\n",
+ "\t\t\tattention_heads, projection_dim, hidden_units, dropout_rate,\n",
+ "\t\t\ttransf_layers, mlp_head_units):\n",
+ "\t\"\"\"\n",
+ "\tBuilding the vision transformer.\n",
+ "\t\"\"\"\n",
+ "\t# Input layer\n",
+ "\tinputs = layers.Input(shape=input_shape)\n",
+ "\n",
+ "\t# Convert image data into patches\n",
+ "\t(tokens, _) = PatchLayer(\n",
+ "\t\timg_size,\n",
+ "\t\tpatch_size,\n",
+ "\t\tnum_patches,\n",
+ "\t\tprojection_dim\n",
+ "\t)(inputs)\n",
+ "\n",
+ "\t# Encode patches\n",
+ "\tencodedPatches = Embed_Patch(num_patches, projection_dim)(tokens)\n",
+ "\n",
+ "\t# Create transformer layers\n",
+ "\tfor _ in range(transf_layers):\n",
+ "\t\t# First layer normalisation\n",
+ "\t\tlayerNorm1 = layers.LayerNormalization(\n",
+ "\t\t\tepsilon=1e-6\n",
+ "\t\t)(encodedPatches)\n",
+ "\n",
+ "\t\t# Build diagoanl attention mask\n",
+ "\t\tdiagAttnMask = 1 - tf.eye(num_patches)\n",
+ "\t\tdiagAttnMask = tf.cast([diagAttnMask], dtype=tf.int8)\n",
+ "\n",
+ "\t\t# Multi-head attention layer\n",
+ "\t\tattention_output = Multi_Head_AttentionLSA(\n",
+ "\t\t\tnum_heads=attention_heads, key_dim=projection_dim,\n",
+ "\t\t\tdropout=dropout_rate\n",
+ "\t\t)(layerNorm1, layerNorm1, attention_mask=diagAttnMask)\n",
+ "\n",
+ "\t\t# First skip connection\n",
+ "\t\tskip1 = layers.Add()([attention_output, encodedPatches])\n",
+ "\n",
+ "\t\t# Second layer normalisation\n",
+ "\t\tlayerNorm2 = layers.LayerNormalization(epsilon=1e-6)(skip1)\n",
+ "\n",
+ "\t\t# Multi-Layer Perceptron\n",
+ "\t\tmlpLayer = layerNorm2\n",
+ "\t\tfor units in hidden_units:\n",
+ "\t\t\tmlpLayer = layers.Dense(units, activation=tf.nn.gelu)(mlpLayer)\n",
+ "\t\t\tmlpLayer = layers.Dropout(dropout_rate)(mlpLayer, training=False)\n",
+ "\n",
+ "\t\t# Second skip connection\n",
+ "\t\tencodedPatches = layers.Add()([mlpLayer, skip1])\n",
+ "\n",
+ "\t# Create a [batch_size, projection_dim] tensor\n",
+ "\trepresenttn = layers.LayerNormalization(epsilon=1e-6)(encodedPatches)\n",
+ "\trepresenttn = layers.Flatten()(representtn)\n",
+ "\trepresenttn = layers.Dropout(dropout_rate)(representtn, training=False)\n",
+ "\n",
+ "\t# MLP layer for learning features\n",
+ "\tfeatures = representtn\n",
+ "\tfor units in mlp_head_units:\n",
+ "\t\tfeatures = layers.Dense(units, activation=tf.nn.gelu)(features)\n",
+ "\t\tfeatures = layers.Dropout(dropout_rate)(features, training=False)\n",
+ "\n",
+ "\t# Classify outputs\n",
+ "\tlogits = layers.Dense(1)(features)\n",
+ "\n",
+ "\t# Create Keras model\n",
+ "\tmodel = tf.keras.Model(inputs=inputs, outputs=logits)\n",
+ "\n",
+ "\treturn model\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Train"
+ ],
+ "metadata": {
+ "id": "LyN46DtlIr3j"
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 1000
+ },
+ "id": "EX2VUyfAamkl",
+ "outputId": "921bc090-1dfa-4f7d-b9e3-717be3c26ee6"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Found 21520 files belonging to 2 classes.\n",
+ "Found 9000 files belonging to 2 classes.\n",
+ "Model: \"model\"\n",
+ "__________________________________________________________________________________________________\n",
+ " Layer (type) Output Shape Param # Connected to \n",
+ "==================================================================================================\n",
+ " input_1 (InputLayer) [(None, 128, 128, 3)] 0 [] \n",
+ " \n",
+ " patch_layer (PatchLayer) ((None, 256, 512), 493952 ['input_1[0][0]'] \n",
+ " (None, 16, 16, 960)) \n",
+ " \n",
+ " embed__patch (Embed_Patch) (None, 256, 512) 131072 ['patch_layer[0][0]'] \n",
+ " \n",
+ " layer_normalization_1 (Lay (None, 256, 512) 1024 ['embed__patch[0][0]'] \n",
+ " erNormalization) \n",
+ " \n",
+ " multi__head__attention_lsa (None, 256, 512) 5251073 ['layer_normalization_1[0][0]'\n",
+ " (Multi_Head_AttentionLSA) , 'layer_normalization_1[0][0]\n",
+ " '] \n",
+ " \n",
+ " add (Add) (None, 256, 512) 0 ['multi__head__attention_lsa[0\n",
+ " ][0]', \n",
+ " 'embed__patch[0][0]'] \n",
+ " \n",
+ " layer_normalization_2 (Lay (None, 256, 512) 1024 ['add[0][0]'] \n",
+ " erNormalization) \n",
+ " \n",
+ " dense_1 (Dense) (None, 256, 1024) 525312 ['layer_normalization_2[0][0]'\n",
+ " ] \n",
+ " \n",
+ " dropout (Dropout) (None, 256, 1024) 0 ['dense_1[0][0]'] \n",
+ " \n",
+ " dense_2 (Dense) (None, 256, 512) 524800 ['dropout[0][0]'] \n",
+ " \n",
+ " dropout_1 (Dropout) (None, 256, 512) 0 ['dense_2[0][0]'] \n",
+ " \n",
+ " add_1 (Add) (None, 256, 512) 0 ['dropout_1[0][0]', \n",
+ " 'add[0][0]'] \n",
+ " \n",
+ " layer_normalization_3 (Lay (None, 256, 512) 1024 ['add_1[0][0]'] \n",
+ " erNormalization) \n",
+ " \n",
+ " multi__head__attention_lsa (None, 256, 512) 5251073 ['layer_normalization_3[0][0]'\n",
+ " _1 (Multi_Head_AttentionLS , 'layer_normalization_3[0][0]\n",
+ " A) '] \n",
+ " \n",
+ " add_2 (Add) (None, 256, 512) 0 ['multi__head__attention_lsa_1\n",
+ " [0][0]', \n",
+ " 'add_1[0][0]'] \n",
+ " \n",
+ " layer_normalization_4 (Lay (None, 256, 512) 1024 ['add_2[0][0]'] \n",
+ " erNormalization) \n",
+ " \n",
+ " dense_3 (Dense) (None, 256, 1024) 525312 ['layer_normalization_4[0][0]'\n",
+ " ] \n",
+ " \n",
+ " dropout_2 (Dropout) (None, 256, 1024) 0 ['dense_3[0][0]'] \n",
+ " \n",
+ " dense_4 (Dense) (None, 256, 512) 524800 ['dropout_2[0][0]'] \n",
+ " \n",
+ " dropout_3 (Dropout) (None, 256, 512) 0 ['dense_4[0][0]'] \n",
+ " \n",
+ " add_3 (Add) (None, 256, 512) 0 ['dropout_3[0][0]', \n",
+ " 'add_2[0][0]'] \n",
+ " \n",
+ " layer_normalization_5 (Lay (None, 256, 512) 1024 ['add_3[0][0]'] \n",
+ " erNormalization) \n",
+ " \n",
+ " multi__head__attention_lsa (None, 256, 512) 5251073 ['layer_normalization_5[0][0]'\n",
+ " _2 (Multi_Head_AttentionLS , 'layer_normalization_5[0][0]\n",
+ " A) '] \n",
+ " \n",
+ " add_4 (Add) (None, 256, 512) 0 ['multi__head__attention_lsa_2\n",
+ " [0][0]', \n",
+ " 'add_3[0][0]'] \n",
+ " \n",
+ " layer_normalization_6 (Lay (None, 256, 512) 1024 ['add_4[0][0]'] \n",
+ " erNormalization) \n",
+ " \n",
+ " dense_5 (Dense) (None, 256, 1024) 525312 ['layer_normalization_6[0][0]'\n",
+ " ] \n",
+ " \n",
+ " dropout_4 (Dropout) (None, 256, 1024) 0 ['dense_5[0][0]'] \n",
+ " \n",
+ " dense_6 (Dense) (None, 256, 512) 524800 ['dropout_4[0][0]'] \n",
+ " \n",
+ " dropout_5 (Dropout) (None, 256, 512) 0 ['dense_6[0][0]'] \n",
+ " \n",
+ " add_5 (Add) (None, 256, 512) 0 ['dropout_5[0][0]', \n",
+ " 'add_4[0][0]'] \n",
+ " \n",
+ " layer_normalization_7 (Lay (None, 256, 512) 1024 ['add_5[0][0]'] \n",
+ " erNormalization) \n",
+ " \n",
+ " multi__head__attention_lsa (None, 256, 512) 5251073 ['layer_normalization_7[0][0]'\n",
+ " _3 (Multi_Head_AttentionLS , 'layer_normalization_7[0][0]\n",
+ " A) '] \n",
+ " \n",
+ " add_6 (Add) (None, 256, 512) 0 ['multi__head__attention_lsa_3\n",
+ " [0][0]', \n",
+ " 'add_5[0][0]'] \n",
+ " \n",
+ " layer_normalization_8 (Lay (None, 256, 512) 1024 ['add_6[0][0]'] \n",
+ " erNormalization) \n",
+ " \n",
+ " dense_7 (Dense) (None, 256, 1024) 525312 ['layer_normalization_8[0][0]'\n",
+ " ] \n",
+ " \n",
+ " dropout_6 (Dropout) (None, 256, 1024) 0 ['dense_7[0][0]'] \n",
+ " \n",
+ " dense_8 (Dense) (None, 256, 512) 524800 ['dropout_6[0][0]'] \n",
+ " \n",
+ " dropout_7 (Dropout) (None, 256, 512) 0 ['dense_8[0][0]'] \n",
+ " \n",
+ " add_7 (Add) (None, 256, 512) 0 ['dropout_7[0][0]', \n",
+ " 'add_6[0][0]'] \n",
+ " \n",
+ " layer_normalization_9 (Lay (None, 256, 512) 1024 ['add_7[0][0]'] \n",
+ " erNormalization) \n",
+ " \n",
+ " multi__head__attention_lsa (None, 256, 512) 5251073 ['layer_normalization_9[0][0]'\n",
+ " _4 (Multi_Head_AttentionLS , 'layer_normalization_9[0][0]\n",
+ " A) '] \n",
+ " \n",
+ " add_8 (Add) (None, 256, 512) 0 ['multi__head__attention_lsa_4\n",
+ " [0][0]', \n",
+ " 'add_7[0][0]'] \n",
+ " \n",
+ " layer_normalization_10 (La (None, 256, 512) 1024 ['add_8[0][0]'] \n",
+ " yerNormalization) \n",
+ " \n",
+ " dense_9 (Dense) (None, 256, 1024) 525312 ['layer_normalization_10[0][0]\n",
+ " '] \n",
+ " \n",
+ " dropout_8 (Dropout) (None, 256, 1024) 0 ['dense_9[0][0]'] \n",
+ " \n",
+ " dense_10 (Dense) (None, 256, 512) 524800 ['dropout_8[0][0]'] \n",
+ " \n",
+ " dropout_9 (Dropout) (None, 256, 512) 0 ['dense_10[0][0]'] \n",
+ " \n",
+ " add_9 (Add) (None, 256, 512) 0 ['dropout_9[0][0]', \n",
+ " 'add_8[0][0]'] \n",
+ " \n",
+ " layer_normalization_11 (La (None, 256, 512) 1024 ['add_9[0][0]'] \n",
+ " yerNormalization) \n",
+ " \n",
+ " flatten (Flatten) (None, 131072) 0 ['layer_normalization_11[0][0]\n",
+ " '] \n",
+ " \n",
+ " dropout_10 (Dropout) (None, 131072) 0 ['flatten[0][0]'] \n",
+ " \n",
+ " dense_11 (Dense) (None, 256) 3355468 ['dropout_10[0][0]'] \n",
+ " 8 \n",
+ " \n",
+ " dropout_11 (Dropout) (None, 256) 0 ['dense_11[0][0]'] \n",
+ " \n",
+ " dense_12 (Dense) (None, 128) 32896 ['dropout_11[0][0]'] \n",
+ " \n",
+ " dropout_12 (Dropout) (None, 128) 0 ['dense_12[0][0]'] \n",
+ " \n",
+ " dense_13 (Dense) (None, 1) 129 ['dropout_12[0][0]'] \n",
+ " \n",
+ "==================================================================================================\n",
+ "Total params: 65729926 (250.74 MB)\n",
+ "Trainable params: 65729926 (250.74 MB)\n",
+ "Non-trainable params: 0 (0.00 Byte)\n",
+ "__________________________________________________________________________________________________\n",
+ "None\n",
+ "Epoch 1/10\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "WARNING:tensorflow:Gradients do not exist for variables ['Variable:0', 'Variable:0', 'Variable:0', 'Variable:0', 'Variable:0'] when minimizing the loss. If you're using `model.compile()`, did you forget to provide a `loss` argument?\n",
+ "WARNING:tensorflow:Gradients do not exist for variables ['Variable:0', 'Variable:0', 'Variable:0', 'Variable:0', 'Variable:0'] when minimizing the loss. If you're using `model.compile()`, did you forget to provide a `loss` argument?\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "673/673 [==============================] - 538s 783ms/step - loss: 1.3290 - accuracy: 0.5515 - val_loss: 0.7497 - val_accuracy: 0.5199\n",
+ "Epoch 2/10\n",
+ "673/673 [==============================] - 532s 791ms/step - loss: 0.6585 - accuracy: 0.5887 - val_loss: 0.7390 - val_accuracy: 0.5148\n",
+ "Epoch 3/10\n",
+ "673/673 [==============================] - 528s 785ms/step - loss: 0.6184 - accuracy: 0.6322 - val_loss: 0.7304 - val_accuracy: 0.5780\n",
+ "Epoch 4/10\n",
+ "673/673 [==============================] - 528s 784ms/step - loss: 0.5843 - accuracy: 0.6649 - val_loss: 0.7581 - val_accuracy: 0.5477\n",
+ "Epoch 5/10\n",
+ "673/673 [==============================] - 527s 783ms/step - loss: 0.5607 - accuracy: 0.6953 - val_loss: 0.7644 - val_accuracy: 0.5727\n",
+ "Epoch 6/10\n",
+ "673/673 [==============================] - 526s 782ms/step - loss: 0.5645 - accuracy: 0.6891 - val_loss: 0.7315 - val_accuracy: 0.5720\n",
+ "Epoch 7/10\n",
+ "673/673 [==============================] - 526s 782ms/step - loss: 0.5570 - accuracy: 0.6960 - val_loss: 0.7427 - val_accuracy: 0.5902\n",
+ "Epoch 8/10\n",
+ "673/673 [==============================] - 532s 790ms/step - loss: 0.6075 - accuracy: 0.6461 - val_loss: 0.7506 - val_accuracy: 0.5601\n",
+ "Epoch 9/10\n",
+ "673/673 [==============================] - 525s 780ms/step - loss: 0.6296 - accuracy: 0.6172 - val_loss: 0.7134 - val_accuracy: 0.5636\n",
+ "Epoch 10/10\n",
+ "673/673 [==============================] - 525s 780ms/step - loss: 0.6060 - accuracy: 0.6465 - val_loss: 0.7593 - val_accuracy: 0.5585\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "def compileModel():\n",
+ " \"\"\"\n",
+ " compiles the model.\n",
+ " \"\"\"\n",
+ " # Build and compile model\n",
+ " optimizer = tfa.optimizers.AdamW(\n",
+ " learning_rate=LEARN_RATE,\n",
+ " weight_decay=WEIGHT_DECAY\n",
+ " )\n",
+ "\n",
+ " model = buildVisionTransformer(\n",
+ " INPUT_SHAPE,\n",
+ " IMG_SIZE,\n",
+ " PATCH_SIZE,\n",
+ " NUM_PATCHES,\n",
+ " ATTENTION_HEADS,\n",
+ " PROJECTION_DIM,\n",
+ " HIDDEN_UNITS,\n",
+ " DROPOUT_RATE,\n",
+ " TRANSF_LAYERS,\n",
+ " MLP_HEAD_UNITS\n",
+ " )\n",
+ "\n",
+ " model.compile(\n",
+ " optimizer=optimizer,\n",
+ " loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),\n",
+ " metrics=[\n",
+ " tf.keras.metrics.BinaryAccuracy(name='accuracy')\n",
+ " ]\n",
+ " )\n",
+ "\n",
+ " return model\n",
+ "\n",
+ "\n",
+ "def trainModel(model, trainData, val_data):\n",
+ " \"\"\"\n",
+ " Trains and saves the model.\n",
+ " \"\"\"\n",
+ "\n",
+ " # Train model\n",
+ " history = model.fit(\n",
+ " x=trainData,\n",
+ " batch_size=BATCH_SIZE,\n",
+ " epochs=EPOCHS,\n",
+ " validation_data=val_data\n",
+ " )\n",
+ "\n",
+ " # Save model\n",
+ " model.save(\n",
+ " MODEL_SAVE_DEST,\n",
+ " overwrite=True,\n",
+ " include_optimizer=True,\n",
+ " save_format='tf'\n",
+ " )\n",
+ "\n",
+ " # Plot and save accuracy curves\n",
+ " plt.plot(history.history['accuracy'])\n",
+ " plt.plot(history.history['val_accuracy'])\n",
+ " plt.suptitle('Model Accuracy')\n",
+ " plt.ylabel('Accuracy')\n",
+ " plt.xlabel('Epoch')\n",
+ " plt.legend(['train', 'val'])\n",
+ " plt.savefig('accuracy.png')\n",
+ " plt.clf()\n",
+ "\n",
+ " # Plot and save loss curves\n",
+ " plt.plot(history.history['loss'])\n",
+ " plt.plot(history.history['val_loss'])\n",
+ " plt.suptitle('Model Loss')\n",
+ " plt.ylabel('Loss')\n",
+ " plt.xlabel('Epoch')\n",
+ " plt.legend(['train', 'val'])\n",
+ " plt.savefig('losses.png')\n",
+ " plt.clf()\n",
+ "\n",
+ "\n",
+ "if __name__ == '__main__':\n",
+ " # Load data\n",
+ " train, val, test = loadData()\n",
+ "\n",
+ " # Compile and train model\n",
+ " model = compileModel()\n",
+ " print(model.summary())\n",
+ " trainModel(model, train, val)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Predict"
+ ],
+ "metadata": {
+ "id": "7xRwdEXNIvji"
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 86
+ },
+ "id": "Y-ikCZahq8wa",
+ "outputId": "3784c42d-427d-4765-bea8-d9049d238d27"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Found 21520 files belonging to 2 classes.\n",
+ "Found 9000 files belonging to 2 classes.\n",
+ "141/141 [==============================] - 61s 258ms/step - loss: 0.7488 - accuracy: 0.5541\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "def predict(load_path, testData):\n",
+ " optimizer = tfa.optimizers.AdamW(\n",
+ " learning_rate=LEARN_RATE,\n",
+ " weight_decay=WEIGHT_DECAY\n",
+ " )\n",
+ "\n",
+ " model = tf.keras.models.load_model(\n",
+ " load_path,\n",
+ " custom_objects={\n",
+ " 'PatchLayer': PatchLayer,\n",
+ " 'Embed_Patch': Embed_Patch,\n",
+ " 'MultiheadattentionLSA': Multi_Head_AttentionLSA,\n",
+ " 'AdamW': optimizer\n",
+ " }\n",
+ " )\n",
+ "\n",
+ " model.evaluate(testData)\n",
+ "\n",
+ " # Plot confusion matrix\n",
+ " y_true = []\n",
+ " y_pred = []\n",
+ "\n",
+ " for image_batch, label_batch in testData:\n",
+ " y_true.append(label_batch)\n",
+ " y_pred.append((model.predict(image_batch, verbose=0) > 0.5).astype('int32'))\n",
+ "\n",
+ " labels_true = tf.concat([tf.cast(item[0], tf.int32) for item in y_true], axis=0)\n",
+ " labels_pred = tf.concat([item[0] for item in y_pred], axis=0)\n",
+ "\n",
+ " matrix = tf.math.confusion_matrix(labels_true, labels_pred, 2).numpy()\n",
+ "\n",
+ " fig, ax = plt.subplots(figsize=(8,8))\n",
+ " ax.matshow(matrix, cmap=plt.cm.Blues, alpha=0.3)\n",
+ " for i in range(matrix.shape[0]):\n",
+ " for j in range(matrix.shape[1]):\n",
+ " ax.text(x=j, y=i, s=matrix[i, j], va='center', ha='center', size='xx-large')\n",
+ "\n",
+ " plt.xlabel('Predictions', fontsize=18)\n",
+ " plt.ylabel('Actual Label', fontsize=18)\n",
+ " plt.suptitle('Confusion Matrix', fontsize=18)\n",
+ " plt.savefig('confusion_matrix')\n",
+ " plt.clf()\n",
+ "\n",
+ "\n",
+ "if __name__ == '__main__':\n",
+ " train, val, test = loadData()\n",
+ " predict(MODEL_SAVE_DEST, test)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "utils"
+ ],
+ "metadata": {
+ "id": "rmrdU9-eIzrn"
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 1000
+ },
+ "id": "VJx3Hxn_nPeE",
+ "outputId": "c6ee1365-8e18-4ae9-9e16-58d7f862413b"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Found 21520 files belonging to 2 classes.\n",
+ "Found 9000 files belonging to 2 classes.\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "def plot_image(dataset):\n",
+ " \"\"\"\n",
+ " Ploting image from the given dataset.\n",
+ " \"\"\"\n",
+ " plt.figure(figsize=(5, 5))\n",
+ " datasetIt = dataset.__iter__()\n",
+ " image = datasetIt.next()[0][0]\n",
+ " plt.imshow(image.numpy().astype('uint8'))\n",
+ " plt.axis('off')\n",
+ " plt.show()\n",
+ "\n",
+ "\n",
+ "def plot_patches(dataset):\n",
+ " \"\"\"\n",
+ " Ploting image from the given dataset after applying Patch_Layer to it.\n",
+ " \"\"\"\n",
+ " datasetIt = dataset.__iter__()\n",
+ " image = datasetIt.next()[0][0]\n",
+ "\n",
+ " resized_image = tf.image.resize(\n",
+ " tf.convert_to_tensor([image]), size=(IMG_SIZE, IMG_SIZE)\n",
+ " )\n",
+ "\n",
+ " (token, patch) = PatchLayer(IMG_SIZE, PATCH_SIZE, NUM_PATCHES, PROJECTION_DIM)(resized_image/255.0)\n",
+ " (token, patch) = (token[0], patch[0])\n",
+ " n = patch.shape[0]\n",
+ " shiftedImg = [\"ORIGINAL\", \"LEFT-UP\", \"LEFT-DOWN\", \"RIGHT-UP\", \"RIGHT-DOWN\"]\n",
+ "\n",
+ " for index, name in enumerate(shiftedImg):\n",
+ " count = 1\n",
+ " plt.figure(figsize=(5, 5))\n",
+ " plt.suptitle(name)\n",
+ "\n",
+ " for row in range(n):\n",
+ " for col in range(n):\n",
+ " plt.subplot(n, n, count)\n",
+ " count = count + 1\n",
+ " image= tf.reshape(patch[row][col], (PATCH_SIZE, PATCH_SIZE, 3 * 5))\n",
+ " plt.imshow(image[..., 3 * index : 3 * index + 3])\n",
+ " plt.axis('off')\n",
+ "\n",
+ " plt.show()\n",
+ "\n",
+ "\n",
+ "if __name__ == '__main__':\n",
+ " train, val, test = loadData()\n",
+ " plot_image(train)\n",
+ " plot_patches(train)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "ogy6maejnPeF"
+ },
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "UzSqnauVt2Lb"
+ },
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "mLpBAY4b2gDZ"
+ },
+ "source": [
+ "MODEL 2\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "z8aG0UxZXRLv"
+ },
+ "outputs": [],
+ "source": [
+ "# Hyperparameters\n",
+ "IMG_SIZE = 128\n",
+ "PATCH_SIZE = 8\n",
+ "BATCH_SIZE = 32\n",
+ "EPOCHS = 10\n",
+ "WEIGHT_DECAY = 0.0001\n",
+ "PROJECTION_DIM = 128 # MLP-blocks depth\n",
+ "LEARN_RATE = 0.001\n",
+ "TRANSF_LAYERS = 3 # No. of transformer-encoder-blocks\n",
+ "DROPOUT_RATE = 0.4\n",
+ "ATTENTION_HEADS = 5\n",
+ "MLP_HEAD_UNITS = [64, 32]\n",
+ "DATA_LOAD_DEST = \"/content\"\n",
+ "MODEL_SAVE_DEST = \"/content/vision_transformer\"\n",
+ "\n",
+ "#Calculating automat\n",
+ "INPUT_SHAPE = (IMG_SIZE, IMG_SIZE, 3)\n",
+ "HIDDEN_UNITS = [PROJECTION_DIM * 2, PROJECTION_DIM]\n",
+ "NUM_PATCHES = int((IMG_SIZE/PATCH_SIZE) ** 2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "OMNpEBufXRLx"
+ },
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "fx0Agt-eXRLy"
+ },
+ "outputs": [],
+ "source": [
+ "def loadData():\n",
+ " \"\"\"\n",
+ " Loading the dataset.\n",
+ " \"\"\"\n",
+ " trainData = tf.keras.preprocessing.image_dataset_from_directory(\n",
+ " DATA_LOAD_DEST + \"/train\", labels='inferred', label_mode='binary',\n",
+ " image_size=[IMG_SIZE, IMG_SIZE], shuffle=True,\n",
+ " batch_size=BATCH_SIZE, seed=8, class_names=['AD', 'NC']\n",
+ " )\n",
+ "\n",
+ " testData = tf.keras.preprocessing.image_dataset_from_directory(\n",
+ " DATA_LOAD_DEST + \"/test\", labels='inferred', label_mode='binary',\n",
+ " image_size=[IMG_SIZE, IMG_SIZE], shuffle=True,\n",
+ " batch_size=BATCH_SIZE, seed=8, class_names=['AD', 'NC']\n",
+ " )\n",
+ "\n",
+ " # Augment data\n",
+ " normalize = tf.keras.layers.Normalization()\n",
+ " flip = tf.keras.layers.RandomFlip(mode='horizontal', seed=8)\n",
+ " rotate = tf.keras.layers.RandomRotation(factor=0.02, seed=8)\n",
+ " zoom = tf.keras.layers.RandomZoom(height_factor=0.1, width_factor=0.1, seed=8)\n",
+ "\n",
+ " trainData = trainData.map(\n",
+ " lambda x, y: (rotate(flip(zoom(normalize(x)))), y)\n",
+ " )\n",
+ "\n",
+ " testData = testData.map(\n",
+ " lambda x, y: (rotate(flip(zoom(normalize(x)))), y)\n",
+ " )\n",
+ "\n",
+ " # Taking half of the 9000 images from the test set as validation data\n",
+ " validationData = testData.take(len(list(testData))//2)\n",
+ "\n",
+ " # Using remaining images as test set\n",
+ " testData = testData.skip(len(list(testData))//2)\n",
+ "\n",
+ " return trainData, validationData, testData"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "jZe8af5FXRLz"
+ },
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "tK-I7bX7XRLz"
+ },
+ "outputs": [],
+ "source": [
+ "class PatchLayer(Layer):\n",
+ "\t\"\"\"\n",
+ "\tLayering and transforming images into patches.\n",
+ "\t\"\"\"\n",
+ "\tdef __init__(self, img_size, patch_size, num_patches, projection_dim, **kwargs):\n",
+ "\t\tsuper(PatchLayer, self).__init__(**kwargs)\n",
+ "\t\tself.img_size = img_size\n",
+ "\t\tself.patch_size = patch_size\n",
+ "\t\tself.num_patches = num_patches\n",
+ "\t\tself.projection_dim = projection_dim\n",
+ "\t\tself.half_patch = patch_size // 2\n",
+ "\t\tself.flatten_patches = layers.Reshape((num_patches, -1))\n",
+ "\t\tself.projection = layers.Dense(units=projection_dim)\n",
+ "\t\tself.layer_norm = layers.LayerNormalization(epsilon=1e-6)\n",
+ "\n",
+ "\tdef shiftImg(self, images, mode):\n",
+ "\t\t# Build diagonally shifted images\n",
+ "\t\tif mode == 'left-up':\n",
+ "\t\t\tcropheight = self.half_patch\n",
+ "\t\t\tcropwidth = self.half_patch\n",
+ "\t\t\tshiftheight = 0\n",
+ "\t\t\tshiftwidth = 0\n",
+ "\t\telif mode == 'left-down':\n",
+ "\t\t\tcropheight = 0\n",
+ "\t\t\tcropwidth = self.half_patch\n",
+ "\t\t\tshiftheight = self.half_patch\n",
+ "\t\t\tshiftwidth = 0\n",
+ "\t\telif mode == 'right-up':\n",
+ "\t\t\tcropheight = self.half_patch\n",
+ "\t\t\tcropwidth = 0\n",
+ "\t\t\tshiftheight = 0\n",
+ "\t\t\tshiftwidth = self.half_patch\n",
+ "\t\telse:\n",
+ "\t\t\tcropheight = 0\n",
+ "\t\t\tcropwidth = 0\n",
+ "\t\t\tshiftheight = self.half_patch\n",
+ "\t\t\tshiftwidth = self.half_patch\n",
+ "\n",
+ "\t\tcrop = tf.image.crop_to_bounding_box(\n",
+ "\t\t\timages,\n",
+ "\t\t\toffset_height=cropheight,\n",
+ "\t\t\toffset_width=cropwidth,\n",
+ "\t\t\ttarget_height=self.img_size - self.half_patch,\n",
+ "\t\t\ttarget_width=self.img_size - self.half_patch\n",
+ "\t\t)\n",
+ "\n",
+ "\t\tshiftPad = tf.image.pad_to_bounding_box(\n",
+ "\t\t\tcrop,\n",
+ "\t\t\toffset_height=shiftheight,\n",
+ "\t\t\toffset_width=shiftwidth,\n",
+ "\t\t\ttarget_height=self.img_size,\n",
+ "\t\t\ttarget_width=self.img_size\n",
+ "\t\t)\n",
+ "\t\treturn shiftPad\n",
+ "\n",
+ "\tdef call(self, images):\n",
+ "\t\timages = tf.concat(\n",
+ "\t\t\t[\n",
+ "\t\t\t\timages,\n",
+ "\t\t\t\tself.shiftImg(images, mode='left-up'),\n",
+ "\t\t\t\tself.shiftImg(images, mode='left-down'),\n",
+ "\t\t\t\tself.shiftImg(images, mode='right-up'),\n",
+ "\t\t\t\tself.shiftImg(images, mode='right-down'),\n",
+ "\t\t\t],\n",
+ "\t\t\taxis=-1\n",
+ "\t\t)\n",
+ "\t\tpatches = tf.image.extract_patches(\n",
+ "\t\t\timages=images,\n",
+ "\t\t\tsizes=[1, self.patch_size, self.patch_size, 1],\n",
+ "\t\t\tstrides=[1, self.patch_size, self.patch_size, 1],\n",
+ "\t\t\trates=[1, 1, 1, 1],\n",
+ "\t\t\tpadding='VALID'\n",
+ "\t\t)\n",
+ "\t\tflat_patches = self.flatten_patches(patches)\n",
+ "\t\ttokens = self.layer_norm(flat_patches)\n",
+ "\t\ttokens = self.projection(tokens)\n",
+ "\n",
+ "\t\treturn (tokens, patches)\n",
+ "\n",
+ "\tdef getConfig_(self):\n",
+ "\t\tconfig_ = super(PatchLayer, self).getConfig_()\n",
+ "\t\tconfig_.update(\n",
+ "\t\t\t{\n",
+ "\t\t\t\t'img_size': self.img_size,\n",
+ "\t\t\t\t'patch_size': self.patch_size,\n",
+ "\t\t\t\t'num_patches': self.num_patches,\n",
+ "\t\t\t\t'projection_dim': self.projection_dim\n",
+ "\t\t\t}\n",
+ "\t\t)\n",
+ "\t\treturn config_"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "gsBkwfokXRL0"
+ },
+ "outputs": [],
+ "source": [
+ "class Embed_Patch(Layer):\n",
+ "\t\"\"\"\n",
+ "\tLayer for projecting patches into a vector.\n",
+ "\t\"\"\"\n",
+ "\tdef __init__(self, num_patches, projection_dim, **kwargs):\n",
+ "\t\tsuper(Embed_Patch, self).__init__(**kwargs)\n",
+ "\t\tself.num_patches = num_patches\n",
+ "\t\tself.projection_dim = projection_dim\n",
+ "\t\tself.position_embedding = layers.Embedding(\n",
+ "\t\t\tinput_dim=self.num_patches, output_dim=projection_dim\n",
+ "\t\t)\n",
+ "\n",
+ "\tdef call(self, patches):\n",
+ "\t\tpositions = tf.range(0, self.num_patches, delta=1)\n",
+ "\t\treturn patches + self.position_embedding(positions)\n",
+ "\n",
+ "\tdef getConfig_(self):\n",
+ "\t\tconfig_ = super(Embed_Patch, self).getConfig_()\n",
+ "\t\tconfig_.update(\n",
+ "\t\t\t{\n",
+ "\t\t\t\t'num_patches': self.num_patches,\n",
+ "\t\t\t\t'projection_dim': self.projection_dim\n",
+ "\t\t\t}\n",
+ "\t\t)\n",
+ "\t\treturn config_"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "L7Ocn6O3XRL0"
+ },
+ "outputs": [],
+ "source": [
+ "class Multi_Head_AttentionLSA(layers.MultiHeadAttention):\n",
+ "\t\"\"\"\n",
+ "\tMulti Head Attention layer for the transformer-encoder-block, but with the\n",
+ "\taddition of using Local-Self-Attention to improve feature\n",
+ "\tlearning.\n",
+ "\t\"\"\"\n",
+ "\tdef __init__(self, **kwargs):\n",
+ "\t\tsuper(Multi_Head_AttentionLSA, self).__init__(**kwargs)\n",
+ "\t\tself.tau = tf.Variable(math.sqrt(float(self._key_dim)), trainable=True)\n",
+ "\n",
+ "\tdef computeAttention(self, query, key, value, attention_mask=None,\n",
+ "\t\t\ttraining=None):\n",
+ "\t\tquery = tf.multiply(query, 1.0/self.tau)\n",
+ "\t\tattention_scores = tf.einsum(self._dot_product_equation, key, query)\n",
+ "\t\tattention_mask = tf.convert_to_tensor(attention_mask)\n",
+ "\t\tattention_scores = self._masked_softmax(attention_scores, attention_mask)\n",
+ "\t\tattention_scores_dropout = self._dropout_layer(\n",
+ "\t\t\tattention_scores, training=training\n",
+ "\t\t)\n",
+ "\t\tattention_output = tf.einsum(\n",
+ "\t\t\tself._combine_equation, attention_scores_dropout, value\n",
+ "\t\t)\n",
+ "\t\treturn attention_output, attention_scores\n",
+ "\n",
+ "\tdef getConfig_(self):\n",
+ "\t\tconfig_ = super(Multi_Head_AttentionLSA, self).getConfig_()\n",
+ "\t\treturn config_\n",
+ "\n",
+ "\n",
+ "def buildVisionTransformer(input_shape, img_size, patch_size, num_patches,\n",
+ "\t\t\tattention_heads, projection_dim, hidden_units, dropout_rate,\n",
+ "\t\t\ttransf_layers, mlp_head_units):\n",
+ "\t\"\"\"\n",
+ "\tBuilding the vision transformer.\n",
+ "\t\"\"\"\n",
+ "\t# Input layer\n",
+ "\tinputs = layers.Input(shape=input_shape)\n",
+ "\n",
+ "\t# Convert image data into patches\n",
+ "\t(tokens, _) = PatchLayer(\n",
+ "\t\timg_size,\n",
+ "\t\tpatch_size,\n",
+ "\t\tnum_patches,\n",
+ "\t\tprojection_dim\n",
+ "\t)(inputs)\n",
+ "\n",
+ "\t# Encode patches\n",
+ "\tencodedPatches = Embed_Patch(num_patches, projection_dim)(tokens)\n",
+ "\n",
+ "\t# Create transformer layers\n",
+ "\tfor _ in range(transf_layers):\n",
+ "\t\t# First layer normalisation\n",
+ "\t\tlayerNorm1 = layers.LayerNormalization(\n",
+ "\t\t\tepsilon=1e-6\n",
+ "\t\t)(encodedPatches)\n",
+ "\n",
+ "\t\t# Build diagoanl attention mask\n",
+ "\t\tdiagAttnMask = 1 - tf.eye(num_patches)\n",
+ "\t\tdiagAttnMask = tf.cast([diagAttnMask], dtype=tf.int8)\n",
+ "\n",
+ "\t\t# Multi-head attention layer\n",
+ "\t\tattention_output = Multi_Head_AttentionLSA(\n",
+ "\t\t\tnum_heads=attention_heads, key_dim=projection_dim,\n",
+ "\t\t\tdropout=dropout_rate\n",
+ "\t\t)(layerNorm1, layerNorm1, attention_mask=diagAttnMask)\n",
+ "\n",
+ "\t\t# First skip connection\n",
+ "\t\tskip1 = layers.Add()([attention_output, encodedPatches])\n",
+ "\n",
+ "\t\t# Second layer normalisation\n",
+ "\t\tlayerNorm2 = layers.LayerNormalization(epsilon=1e-6)(skip1)\n",
+ "\n",
+ "\t\t# Multi-Layer Perceptron\n",
+ "\t\tmlpLayer = layerNorm2\n",
+ "\t\tfor units in hidden_units:\n",
+ "\t\t\tmlpLayer = layers.Dense(units, activation=tf.nn.gelu)(mlpLayer)\n",
+ "\t\t\tmlpLayer = layers.Dropout(dropout_rate)(mlpLayer, training=False)\n",
+ "\n",
+ "\t\t# Second skip connection\n",
+ "\t\tencodedPatches = layers.Add()([mlpLayer, skip1])\n",
+ "\n",
+ "\t# Create a [batch_size, projection_dim] tensor\n",
+ "\trepresenttn = layers.LayerNormalization(epsilon=1e-6)(encodedPatches)\n",
+ "\trepresenttn = layers.Flatten()(representtn)\n",
+ "\trepresenttn = layers.Dropout(dropout_rate)(representtn, training=False)\n",
+ "\n",
+ "\t# MLP layer for learning features\n",
+ "\tfeatures = representtn\n",
+ "\tfor units in mlp_head_units:\n",
+ "\t\tfeatures = layers.Dense(units, activation=tf.nn.gelu)(features)\n",
+ "\t\tfeatures = layers.Dropout(dropout_rate)(features, training=False)\n",
+ "\n",
+ "\t# Classify outputs\n",
+ "\tlogits = layers.Dense(1)(features)\n",
+ "\n",
+ "\t# Create Keras model\n",
+ "\tmodel = tf.keras.Model(inputs=inputs, outputs=logits)\n",
+ "\n",
+ "\treturn model\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [],
+ "metadata": {
+ "id": "zFvMhpFk80-F"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "def compileModel():\n",
+ " \"\"\"\n",
+ " compiles the model.\n",
+ " \"\"\"\n",
+ " # Build and compile model\n",
+ " optimizer = tfa.optimizers.AdamW(\n",
+ " learning_rate=LEARN_RATE,\n",
+ " weight_decay=WEIGHT_DECAY\n",
+ " )\n",
+ "\n",
+ " model = buildVisionTransformer(\n",
+ " INPUT_SHAPE,\n",
+ " IMG_SIZE,\n",
+ " PATCH_SIZE,\n",
+ " NUM_PATCHES,\n",
+ " ATTENTION_HEADS,\n",
+ " PROJECTION_DIM,\n",
+ " HIDDEN_UNITS,\n",
+ " DROPOUT_RATE,\n",
+ " TRANSF_LAYERS,\n",
+ " MLP_HEAD_UNITS\n",
+ " )\n",
+ "\n",
+ " model.compile(\n",
+ " optimizer=optimizer,\n",
+ " loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),\n",
+ " metrics=[\n",
+ " tf.keras.metrics.BinaryAccuracy(name='accuracy')\n",
+ " ]\n",
+ " )\n",
+ "\n",
+ " return model\n",
+ "\n",
+ "\n",
+ "def trainModel(model, trainData, val_data):\n",
+ " \"\"\"\n",
+ " Trains and saves the model.\n",
+ " \"\"\"\n",
+ "\n",
+ " # Train model\n",
+ " history = model.fit(\n",
+ " x=trainData,\n",
+ " batch_size=BATCH_SIZE,\n",
+ " epochs=EPOCHS,\n",
+ " validation_data=val_data\n",
+ " )\n",
+ "\n",
+ " # Save model\n",
+ " model.save(\n",
+ " MODEL_SAVE_DEST,\n",
+ " overwrite=True,\n",
+ " include_optimizer=True,\n",
+ " save_format='tf'\n",
+ " )\n",
+ "\n",
+ " # Plot and save accuracy curves\n",
+ " plt.plot(history.history['accuracy'])\n",
+ " plt.plot(history.history['val_accuracy'])\n",
+ " plt.suptitle('Model Accuracy')\n",
+ " plt.ylabel('Accuracy')\n",
+ " plt.xlabel('Epoch')\n",
+ " plt.legend(['train', 'val'])\n",
+ " plt.savefig('accuracy.png')\n",
+ " plt.clf()\n",
+ "\n",
+ " # Plot and save loss curves\n",
+ " plt.plot(history.history['loss'])\n",
+ " plt.plot(history.history['val_loss'])\n",
+ " plt.suptitle('Model Loss')\n",
+ " plt.ylabel('Loss')\n",
+ " plt.xlabel('Epoch')\n",
+ " plt.legend(['train', 'val'])\n",
+ " plt.savefig('losses.png')\n",
+ " plt.clf()\n",
+ "\n",
+ "\n",
+ "if __name__ == '__main__':\n",
+ " # Load data\n",
+ " train, val, test = loadData()\n",
+ "\n",
+ " # Compile and train model\n",
+ " model = compileModel()\n",
+ " print(model.summary())\n",
+ " trainModel(model, train, val)"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 1000
+ },
+ "outputId": "fd3c6ca4-7f44-4162-f5e1-cac77129fad5",
+ "id": "089tGucFXRL1"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Found 21520 files belonging to 2 classes.\n",
+ "Found 9000 files belonging to 2 classes.\n",
+ "Model: \"model\"\n",
+ "__________________________________________________________________________________________________\n",
+ " Layer (type) Output Shape Param # Connected to \n",
+ "==================================================================================================\n",
+ " input_1 (InputLayer) [(None, 128, 128, 3)] 0 [] \n",
+ " \n",
+ " patch_layer (PatchLayer) ((None, 256, 128), 124928 ['input_1[0][0]'] \n",
+ " (None, 16, 16, 960)) \n",
+ " \n",
+ " embed__patch (Embed_Patch) (None, 256, 128) 32768 ['patch_layer[0][0]'] \n",
+ " \n",
+ " layer_normalization_1 (Lay (None, 256, 128) 256 ['embed__patch[0][0]'] \n",
+ " erNormalization) \n",
+ " \n",
+ " multi__head__attention_lsa (None, 256, 128) 329729 ['layer_normalization_1[0][0]'\n",
+ " (Multi_Head_AttentionLSA) , 'layer_normalization_1[0][0]\n",
+ " '] \n",
+ " \n",
+ " add (Add) (None, 256, 128) 0 ['multi__head__attention_lsa[0\n",
+ " ][0]', \n",
+ " 'embed__patch[0][0]'] \n",
+ " \n",
+ " layer_normalization_2 (Lay (None, 256, 128) 256 ['add[0][0]'] \n",
+ " erNormalization) \n",
+ " \n",
+ " dense_1 (Dense) (None, 256, 256) 33024 ['layer_normalization_2[0][0]'\n",
+ " ] \n",
+ " \n",
+ " dropout (Dropout) (None, 256, 256) 0 ['dense_1[0][0]'] \n",
+ " \n",
+ " dense_2 (Dense) (None, 256, 128) 32896 ['dropout[0][0]'] \n",
+ " \n",
+ " dropout_1 (Dropout) (None, 256, 128) 0 ['dense_2[0][0]'] \n",
+ " \n",
+ " add_1 (Add) (None, 256, 128) 0 ['dropout_1[0][0]', \n",
+ " 'add[0][0]'] \n",
+ " \n",
+ " layer_normalization_3 (Lay (None, 256, 128) 256 ['add_1[0][0]'] \n",
+ " erNormalization) \n",
+ " \n",
+ " multi__head__attention_lsa (None, 256, 128) 329729 ['layer_normalization_3[0][0]'\n",
+ " _1 (Multi_Head_AttentionLS , 'layer_normalization_3[0][0]\n",
+ " A) '] \n",
+ " \n",
+ " add_2 (Add) (None, 256, 128) 0 ['multi__head__attention_lsa_1\n",
+ " [0][0]', \n",
+ " 'add_1[0][0]'] \n",
+ " \n",
+ " layer_normalization_4 (Lay (None, 256, 128) 256 ['add_2[0][0]'] \n",
+ " erNormalization) \n",
+ " \n",
+ " dense_3 (Dense) (None, 256, 256) 33024 ['layer_normalization_4[0][0]'\n",
+ " ] \n",
+ " \n",
+ " dropout_2 (Dropout) (None, 256, 256) 0 ['dense_3[0][0]'] \n",
+ " \n",
+ " dense_4 (Dense) (None, 256, 128) 32896 ['dropout_2[0][0]'] \n",
+ " \n",
+ " dropout_3 (Dropout) (None, 256, 128) 0 ['dense_4[0][0]'] \n",
+ " \n",
+ " add_3 (Add) (None, 256, 128) 0 ['dropout_3[0][0]', \n",
+ " 'add_2[0][0]'] \n",
+ " \n",
+ " layer_normalization_5 (Lay (None, 256, 128) 256 ['add_3[0][0]'] \n",
+ " erNormalization) \n",
+ " \n",
+ " multi__head__attention_lsa (None, 256, 128) 329729 ['layer_normalization_5[0][0]'\n",
+ " _2 (Multi_Head_AttentionLS , 'layer_normalization_5[0][0]\n",
+ " A) '] \n",
+ " \n",
+ " add_4 (Add) (None, 256, 128) 0 ['multi__head__attention_lsa_2\n",
+ " [0][0]', \n",
+ " 'add_3[0][0]'] \n",
+ " \n",
+ " layer_normalization_6 (Lay (None, 256, 128) 256 ['add_4[0][0]'] \n",
+ " erNormalization) \n",
+ " \n",
+ " dense_5 (Dense) (None, 256, 256) 33024 ['layer_normalization_6[0][0]'\n",
+ " ] \n",
+ " \n",
+ " dropout_4 (Dropout) (None, 256, 256) 0 ['dense_5[0][0]'] \n",
+ " \n",
+ " dense_6 (Dense) (None, 256, 128) 32896 ['dropout_4[0][0]'] \n",
+ " \n",
+ " dropout_5 (Dropout) (None, 256, 128) 0 ['dense_6[0][0]'] \n",
+ " \n",
+ " add_5 (Add) (None, 256, 128) 0 ['dropout_5[0][0]', \n",
+ " 'add_4[0][0]'] \n",
+ " \n",
+ " layer_normalization_7 (Lay (None, 256, 128) 256 ['add_5[0][0]'] \n",
+ " erNormalization) \n",
+ " \n",
+ " flatten (Flatten) (None, 32768) 0 ['layer_normalization_7[0][0]'\n",
+ " ] \n",
+ " \n",
+ " dropout_6 (Dropout) (None, 32768) 0 ['flatten[0][0]'] \n",
+ " \n",
+ " dense_7 (Dense) (None, 64) 2097216 ['dropout_6[0][0]'] \n",
+ " \n",
+ " dropout_7 (Dropout) (None, 64) 0 ['dense_7[0][0]'] \n",
+ " \n",
+ " dense_8 (Dense) (None, 32) 2080 ['dropout_7[0][0]'] \n",
+ " \n",
+ " dropout_8 (Dropout) (None, 32) 0 ['dense_8[0][0]'] \n",
+ " \n",
+ " dense_9 (Dense) (None, 1) 33 ['dropout_8[0][0]'] \n",
+ " \n",
+ "==================================================================================================\n",
+ "Total params: 3445764 (13.14 MB)\n",
+ "Trainable params: 3445764 (13.14 MB)\n",
+ "Non-trainable params: 0 (0.00 Byte)\n",
+ "__________________________________________________________________________________________________\n",
+ "None\n",
+ "Epoch 1/10\n"
+ ]
+ },
+ {
+ "output_type": "stream",
+ "name": "stderr",
+ "text": [
+ "WARNING:tensorflow:Gradients do not exist for variables ['Variable:0', 'Variable:0', 'Variable:0'] when minimizing the loss. If you're using `model.compile()`, did you forget to provide a `loss` argument?\n",
+ "WARNING:tensorflow:Gradients do not exist for variables ['Variable:0', 'Variable:0', 'Variable:0'] when minimizing the loss. If you're using `model.compile()`, did you forget to provide a `loss` argument?\n"
+ ]
+ },
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "673/673 [==============================] - 146s 204ms/step - loss: 0.6551 - accuracy: 0.6070 - val_loss: 0.7717 - val_accuracy: 0.5563\n",
+ "Epoch 2/10\n",
+ "673/673 [==============================] - 136s 202ms/step - loss: 0.5926 - accuracy: 0.6620 - val_loss: 0.7256 - val_accuracy: 0.5452\n",
+ "Epoch 3/10\n",
+ "673/673 [==============================] - 135s 200ms/step - loss: 0.5541 - accuracy: 0.6976 - val_loss: 0.7354 - val_accuracy: 0.5809\n",
+ "Epoch 4/10\n",
+ "673/673 [==============================] - 138s 204ms/step - loss: 0.5145 - accuracy: 0.7278 - val_loss: 0.8016 - val_accuracy: 0.5758\n",
+ "Epoch 5/10\n",
+ "673/673 [==============================] - 153s 226ms/step - loss: 0.4914 - accuracy: 0.7445 - val_loss: 0.7997 - val_accuracy: 0.5900\n",
+ "Epoch 6/10\n",
+ "673/673 [==============================] - 137s 203ms/step - loss: 0.4708 - accuracy: 0.7610 - val_loss: 0.7998 - val_accuracy: 0.6000\n",
+ "Epoch 7/10\n",
+ "673/673 [==============================] - 137s 204ms/step - loss: 0.4425 - accuracy: 0.7815 - val_loss: 0.8101 - val_accuracy: 0.6199\n",
+ "Epoch 8/10\n",
+ "673/673 [==============================] - 136s 202ms/step - loss: 0.4291 - accuracy: 0.7909 - val_loss: 0.8250 - val_accuracy: 0.6152\n",
+ "Epoch 9/10\n",
+ "673/673 [==============================] - 135s 200ms/step - loss: 0.4151 - accuracy: 0.7967 - val_loss: 0.9212 - val_accuracy: 0.6057\n",
+ "Epoch 10/10\n",
+ "673/673 [==============================] - 135s 200ms/step - loss: 0.3887 - accuracy: 0.8131 - val_loss: 0.8797 - val_accuracy: 0.6268\n"
+ ]
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {}
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "def predict(load_path, testData):\n",
+ " optimizer = tfa.optimizers.AdamW(\n",
+ " learning_rate=LEARN_RATE,\n",
+ " weight_decay=WEIGHT_DECAY\n",
+ " )\n",
+ "\n",
+ " model = tf.keras.models.load_model(\n",
+ " load_path,\n",
+ " custom_objects={\n",
+ " 'PatchLayer': PatchLayer,\n",
+ " 'Embed_Patch': Embed_Patch,\n",
+ " 'MultiheadattentionLSA': Multi_Head_AttentionLSA,\n",
+ " 'AdamW': optimizer\n",
+ " }\n",
+ " )\n",
+ "\n",
+ " model.evaluate(testData)\n",
+ "\n",
+ " # Plot confusion matrix\n",
+ " y_true = []\n",
+ " y_pred = []\n",
+ "\n",
+ " for image_batch, label_batch in testData:\n",
+ " y_true.append(label_batch)\n",
+ " y_pred.append((model.predict(image_batch, verbose=0) > 0.5).astype('int32'))\n",
+ "\n",
+ " labels_true = tf.concat([tf.cast(item[0], tf.int32) for item in y_true], axis=0)\n",
+ " labels_pred = tf.concat([item[0] for item in y_pred], axis=0)\n",
+ "\n",
+ " matrix = tf.math.confusion_matrix(labels_true, labels_pred, 2).numpy()\n",
+ "\n",
+ " fig, ax = plt.subplots(figsize=(8,8))\n",
+ " ax.matshow(matrix, cmap=plt.cm.Blues, alpha=0.3)\n",
+ " for i in range(matrix.shape[0]):\n",
+ " for j in range(matrix.shape[1]):\n",
+ " ax.text(x=j, y=i, s=matrix[i, j], va='center', ha='center', size='xx-large')\n",
+ "\n",
+ " plt.xlabel('Predictions', fontsize=18)\n",
+ " plt.ylabel('Actual Label', fontsize=18)\n",
+ " plt.suptitle('Confusion Matrix', fontsize=18)\n",
+ " plt.savefig('confusion_matrix')\n",
+ " plt.clf()\n",
+ "\n",
+ "\n",
+ "if __name__ == '__main__':\n",
+ " train, val, test = loadData()\n",
+ " predict(MODEL_SAVE_DEST, test)"
+ ],
+ "metadata": {
+ "id": "mudFm666XRL3",
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 86
+ },
+ "outputId": "65d1deb9-9595-4ab3-fb65-85f1aeae746e"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Found 21520 files belonging to 2 classes.\n",
+ "Found 9000 files belonging to 2 classes.\n",
+ "141/141 [==============================] - 48s 158ms/step - loss: 0.8687 - accuracy: 0.6286\n"
+ ]
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {}
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "def plot_image(dataset):\n",
+ " \"\"\"\n",
+ " Ploting image from the given dataset.\n",
+ " \"\"\"\n",
+ " plt.figure(figsize=(5, 5))\n",
+ " datasetIt = dataset.__iter__()\n",
+ " image = datasetIt.next()[0][0]\n",
+ " plt.imshow(image.numpy().astype('uint8'))\n",
+ " plt.axis('off')\n",
+ " plt.show()\n",
+ "\n",
+ "\n",
+ "def plot_patches(dataset):\n",
+ " \"\"\"\n",
+ " Ploting image from the given dataset after applying Patch_Layer to it.\n",
+ " \"\"\"\n",
+ " datasetIt = dataset.__iter__()\n",
+ " image = datasetIt.next()[0][0]\n",
+ "\n",
+ " resized_image = tf.image.resize(\n",
+ " tf.convert_to_tensor([image]), size=(IMG_SIZE, IMG_SIZE)\n",
+ " )\n",
+ "\n",
+ " (token, patch) = PatchLayer(IMG_SIZE, PATCH_SIZE, NUM_PATCHES, PROJECTION_DIM)(resized_image/255.0)\n",
+ " (token, patch) = (token[0], patch[0])\n",
+ " n = patch.shape[0]\n",
+ " shiftedImg = [\"ORIGINAL\", \"LEFT-UP\", \"LEFT-DOWN\", \"RIGHT-UP\", \"RIGHT-DOWN\"]\n",
+ "\n",
+ " for index, name in enumerate(shiftedImg):\n",
+ " count = 1\n",
+ " plt.figure(figsize=(5, 5))\n",
+ " plt.suptitle(name)\n",
+ "\n",
+ " for row in range(n):\n",
+ " for col in range(n):\n",
+ " plt.subplot(n, n, count)\n",
+ " count = count + 1\n",
+ " image= tf.reshape(patch[row][col], (PATCH_SIZE, PATCH_SIZE, 3 * 5))\n",
+ " plt.imshow(image[..., 3 * index : 3 * index + 3])\n",
+ " plt.axis('off')\n",
+ "\n",
+ " plt.show()\n",
+ "\n",
+ "\n",
+ "if __name__ == '__main__':\n",
+ " train, val, test = loadData()\n",
+ " plot_image(train)\n",
+ " plot_patches(train)"
+ ],
+ "metadata": {
+ "id": "ZjmSOP6bXRL4",
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 1000
+ },
+ "outputId": "f39cf97e-0be1-4a6c-e9e7-e9acfc6c71f2"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Found 21520 files belonging to 2 classes.\n",
+ "Found 9000 files belonging to 2 classes.\n"
+ ]
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ],
+ "image/png": "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\n"
+ },
+ "metadata": {}
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ],
+ "image/png": "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\n"
+ },
+ "metadata": {}
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ],
+ "image/png": "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\n"
+ },
+ "metadata": {}
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ],
+ "image/png": "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\n"
+ },
+ "metadata": {}
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ],
+ "image/png": "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\n"
+ },
+ "metadata": {}
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ],
+ "image/png": "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\n"
+ },
+ "metadata": {}
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [],
+ "metadata": {
+ "id": "aT_wjNQS7-YH"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "-9YEyTqPXV7e"
+ },
+ "source": [
+ "MODEL 3"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "s-sz8yFwXX6F"
+ },
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "-q_tlg3wXYpZ"
+ },
+ "outputs": [],
+ "source": [
+ "# Hyperparameters\n",
+ "IMG_SIZE = 128\n",
+ "PATCH_SIZE = 8\n",
+ "BATCH_SIZE = 32\n",
+ "EPOCHS = 10\n",
+ "WEIGHT_DECAY = 0.0001\n",
+ "PROJECTION_DIM = 16 # MLP-blocks depth\n",
+ "LEARN_RATE = 0.0001\n",
+ "TRANSF_LAYERS = 1 # No. of transformer-encoder-blocks\n",
+ "DROPOUT_RATE = 0.3\n",
+ "ATTENTION_HEADS = 2\n",
+ "MLP_HEAD_UNITS = [16, 8]\n",
+ "DATA_LOAD_DEST = \"/content\"\n",
+ "MODEL_SAVE_DEST = \"/content/vision_transformer\"\n",
+ "\n",
+ "#Calculating automat\n",
+ "INPUT_SHAPE = (IMG_SIZE, IMG_SIZE, 3)\n",
+ "HIDDEN_UNITS = [PROJECTION_DIM * 2, PROJECTION_DIM]\n",
+ "NUM_PATCHES = int((IMG_SIZE/PATCH_SIZE) ** 2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "gVIZF23iXYpr"
+ },
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "mEK5G7eROdId"
+ },
+ "outputs": [],
+ "source": [
+ "def loadData():\n",
+ " \"\"\"\n",
+ " Loading the dataset.\n",
+ " \"\"\"\n",
+ " trainData = tf.keras.preprocessing.image_dataset_from_directory(\n",
+ " DATA_LOAD_DEST + \"/train\", labels='inferred', label_mode='binary',\n",
+ " image_size=[IMG_SIZE, IMG_SIZE], shuffle=True,\n",
+ " batch_size=BATCH_SIZE, seed=8, class_names=['AD', 'NC']\n",
+ " )\n",
+ "\n",
+ " testData = tf.keras.preprocessing.image_dataset_from_directory(\n",
+ " DATA_LOAD_DEST + \"/test\", labels='inferred', label_mode='binary',\n",
+ " image_size=[IMG_SIZE, IMG_SIZE], shuffle=True,\n",
+ " batch_size=BATCH_SIZE, seed=8, class_names=['AD', 'NC']\n",
+ " )\n",
+ "\n",
+ " # Augment data\n",
+ " normalize = tf.keras.layers.Normalization()\n",
+ " flip = tf.keras.layers.RandomFlip(mode='horizontal', seed=8)\n",
+ " rotate = tf.keras.layers.RandomRotation(factor=0.02, seed=8)\n",
+ " zoom = tf.keras.layers.RandomZoom(height_factor=0.1, width_factor=0.1, seed=8)\n",
+ "\n",
+ " trainData = trainData.map(\n",
+ " lambda x, y: (rotate(flip(zoom(normalize(x)))), y)\n",
+ " )\n",
+ "\n",
+ " testData = testData.map(\n",
+ " lambda x, y: (rotate(flip(zoom(normalize(x)))), y)\n",
+ " )\n",
+ "\n",
+ " # Taking half of the 9000 images from the test set as validation data\n",
+ " validationData = testData.take(len(list(testData))//2)\n",
+ "\n",
+ " # Using remaining images as test set\n",
+ " testData = testData.skip(len(list(testData))//2)\n",
+ "\n",
+ " return trainData, validationData, testData"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "lH7iFcpaOdIe"
+ },
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "GQAbeC70OdIf"
+ },
+ "outputs": [],
+ "source": [
+ "class PatchLayer(Layer):\n",
+ "\t\"\"\"\n",
+ "\tLayering and transforming images into patches.\n",
+ "\t\"\"\"\n",
+ "\tdef __init__(self, img_size, patch_size, num_patches, projection_dim, **kwargs):\n",
+ "\t\tsuper(PatchLayer, self).__init__(**kwargs)\n",
+ "\t\tself.img_size = img_size\n",
+ "\t\tself.patch_size = patch_size\n",
+ "\t\tself.num_patches = num_patches\n",
+ "\t\tself.projection_dim = projection_dim\n",
+ "\t\tself.half_patch = patch_size // 2\n",
+ "\t\tself.flatten_patches = layers.Reshape((num_patches, -1))\n",
+ "\t\tself.projection = layers.Dense(units=projection_dim)\n",
+ "\t\tself.layer_norm = layers.LayerNormalization(epsilon=1e-6)\n",
+ "\n",
+ "\tdef shiftImg(self, images, mode):\n",
+ "\t\t# Build diagonally shifted images\n",
+ "\t\tif mode == 'left-up':\n",
+ "\t\t\tcropheight = self.half_patch\n",
+ "\t\t\tcropwidth = self.half_patch\n",
+ "\t\t\tshiftheight = 0\n",
+ "\t\t\tshiftwidth = 0\n",
+ "\t\telif mode == 'left-down':\n",
+ "\t\t\tcropheight = 0\n",
+ "\t\t\tcropwidth = self.half_patch\n",
+ "\t\t\tshiftheight = self.half_patch\n",
+ "\t\t\tshiftwidth = 0\n",
+ "\t\telif mode == 'right-up':\n",
+ "\t\t\tcropheight = self.half_patch\n",
+ "\t\t\tcropwidth = 0\n",
+ "\t\t\tshiftheight = 0\n",
+ "\t\t\tshiftwidth = self.half_patch\n",
+ "\t\telse:\n",
+ "\t\t\tcropheight = 0\n",
+ "\t\t\tcropwidth = 0\n",
+ "\t\t\tshiftheight = self.half_patch\n",
+ "\t\t\tshiftwidth = self.half_patch\n",
+ "\n",
+ "\t\tcrop = tf.image.crop_to_bounding_box(\n",
+ "\t\t\timages,\n",
+ "\t\t\toffset_height=cropheight,\n",
+ "\t\t\toffset_width=cropwidth,\n",
+ "\t\t\ttarget_height=self.img_size - self.half_patch,\n",
+ "\t\t\ttarget_width=self.img_size - self.half_patch\n",
+ "\t\t)\n",
+ "\n",
+ "\t\tshiftPad = tf.image.pad_to_bounding_box(\n",
+ "\t\t\tcrop,\n",
+ "\t\t\toffset_height=shiftheight,\n",
+ "\t\t\toffset_width=shiftwidth,\n",
+ "\t\t\ttarget_height=self.img_size,\n",
+ "\t\t\ttarget_width=self.img_size\n",
+ "\t\t)\n",
+ "\t\treturn shiftPad\n",
+ "\n",
+ "\tdef call(self, images):\n",
+ "\t\timages = tf.concat(\n",
+ "\t\t\t[\n",
+ "\t\t\t\timages,\n",
+ "\t\t\t\tself.shiftImg(images, mode='left-up'),\n",
+ "\t\t\t\tself.shiftImg(images, mode='left-down'),\n",
+ "\t\t\t\tself.shiftImg(images, mode='right-up'),\n",
+ "\t\t\t\tself.shiftImg(images, mode='right-down'),\n",
+ "\t\t\t],\n",
+ "\t\t\taxis=-1\n",
+ "\t\t)\n",
+ "\t\tpatches = tf.image.extract_patches(\n",
+ "\t\t\timages=images,\n",
+ "\t\t\tsizes=[1, self.patch_size, self.patch_size, 1],\n",
+ "\t\t\tstrides=[1, self.patch_size, self.patch_size, 1],\n",
+ "\t\t\trates=[1, 1, 1, 1],\n",
+ "\t\t\tpadding='VALID'\n",
+ "\t\t)\n",
+ "\t\tflat_patches = self.flatten_patches(patches)\n",
+ "\t\ttokens = self.layer_norm(flat_patches)\n",
+ "\t\ttokens = self.projection(tokens)\n",
+ "\n",
+ "\t\treturn (tokens, patches)\n",
+ "\n",
+ "\tdef getConfig_(self):\n",
+ "\t\tconfig_ = super(PatchLayer, self).getConfig_()\n",
+ "\t\tconfig_.update(\n",
+ "\t\t\t{\n",
+ "\t\t\t\t'img_size': self.img_size,\n",
+ "\t\t\t\t'patch_size': self.patch_size,\n",
+ "\t\t\t\t'num_patches': self.num_patches,\n",
+ "\t\t\t\t'projection_dim': self.projection_dim\n",
+ "\t\t\t}\n",
+ "\t\t)\n",
+ "\t\treturn config_"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "KaAFB6eOOdIf"
+ },
+ "outputs": [],
+ "source": [
+ "class Embed_Patch(Layer):\n",
+ "\t\"\"\"\n",
+ "\tLayer for projecting patches into a vector.\n",
+ "\t\"\"\"\n",
+ "\tdef __init__(self, num_patches, projection_dim, **kwargs):\n",
+ "\t\tsuper(Embed_Patch, self).__init__(**kwargs)\n",
+ "\t\tself.num_patches = num_patches\n",
+ "\t\tself.projection_dim = projection_dim\n",
+ "\t\tself.position_embedding = layers.Embedding(\n",
+ "\t\t\tinput_dim=self.num_patches, output_dim=projection_dim\n",
+ "\t\t)\n",
+ "\n",
+ "\tdef call(self, patches):\n",
+ "\t\tpositions = tf.range(0, self.num_patches, delta=1)\n",
+ "\t\treturn patches + self.position_embedding(positions)\n",
+ "\n",
+ "\tdef getConfig_(self):\n",
+ "\t\tconfig_ = super(Embed_Patch, self).getConfig_()\n",
+ "\t\tconfig_.update(\n",
+ "\t\t\t{\n",
+ "\t\t\t\t'num_patches': self.num_patches,\n",
+ "\t\t\t\t'projection_dim': self.projection_dim\n",
+ "\t\t\t}\n",
+ "\t\t)\n",
+ "\t\treturn config_"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "yEoXCwEZOdIf"
+ },
+ "outputs": [],
+ "source": [
+ "class Multi_Head_AttentionLSA(layers.MultiHeadAttention):\n",
+ "\t\"\"\"\n",
+ "\tMulti Head Attention layer for the transformer-encoder-block, but with the\n",
+ "\taddition of using Local-Self-Attention to improve feature\n",
+ "\tlearning.\n",
+ "\t\"\"\"\n",
+ "\tdef __init__(self, **kwargs):\n",
+ "\t\tsuper(Multi_Head_AttentionLSA, self).__init__(**kwargs)\n",
+ "\t\tself.tau = tf.Variable(math.sqrt(float(self._key_dim)), trainable=True)\n",
+ "\n",
+ "\tdef computeAttention(self, query, key, value, attention_mask=None,\n",
+ "\t\t\ttraining=None):\n",
+ "\t\tquery = tf.multiply(query, 1.0/self.tau)\n",
+ "\t\tattention_scores = tf.einsum(self._dot_product_equation, key, query)\n",
+ "\t\tattention_mask = tf.convert_to_tensor(attention_mask)\n",
+ "\t\tattention_scores = self._masked_softmax(attention_scores, attention_mask)\n",
+ "\t\tattention_scores_dropout = self._dropout_layer(\n",
+ "\t\t\tattention_scores, training=training\n",
+ "\t\t)\n",
+ "\t\tattention_output = tf.einsum(\n",
+ "\t\t\tself._combine_equation, attention_scores_dropout, value\n",
+ "\t\t)\n",
+ "\t\treturn attention_output, attention_scores\n",
+ "\n",
+ "\tdef getConfig_(self):\n",
+ "\t\tconfig_ = super(Multi_Head_AttentionLSA, self).getConfig_()\n",
+ "\t\treturn config_\n",
+ "\n",
+ "\n",
+ "def buildVisionTransformer(input_shape, img_size, patch_size, num_patches,\n",
+ "\t\t\tattention_heads, projection_dim, hidden_units, dropout_rate,\n",
+ "\t\t\ttransf_layers, mlp_head_units):\n",
+ "\t\"\"\"\n",
+ "\tBuilding the vision transformer.\n",
+ "\t\"\"\"\n",
+ "\t# Input layer\n",
+ "\tinputs = layers.Input(shape=input_shape)\n",
+ "\n",
+ "\t# Convert image data into patches\n",
+ "\t(tokens, _) = PatchLayer(\n",
+ "\t\timg_size,\n",
+ "\t\tpatch_size,\n",
+ "\t\tnum_patches,\n",
+ "\t\tprojection_dim\n",
+ "\t)(inputs)\n",
+ "\n",
+ "\t# Encode patches\n",
+ "\tencodedPatches = Embed_Patch(num_patches, projection_dim)(tokens)\n",
+ "\n",
+ "\t# Create transformer layers\n",
+ "\tfor _ in range(transf_layers):\n",
+ "\t\t# First layer normalisation\n",
+ "\t\tlayerNorm1 = layers.LayerNormalization(\n",
+ "\t\t\tepsilon=1e-6\n",
+ "\t\t)(encodedPatches)\n",
+ "\n",
+ "\t\t# Build diagoanl attention mask\n",
+ "\t\tdiagAttnMask = 1 - tf.eye(num_patches)\n",
+ "\t\tdiagAttnMask = tf.cast([diagAttnMask], dtype=tf.int8)\n",
+ "\n",
+ "\t\t# Multi-head attention layer\n",
+ "\t\tattention_output = Multi_Head_AttentionLSA(\n",
+ "\t\t\tnum_heads=attention_heads, key_dim=projection_dim,\n",
+ "\t\t\tdropout=dropout_rate\n",
+ "\t\t)(layerNorm1, layerNorm1, attention_mask=diagAttnMask)\n",
+ "\n",
+ "\t\t# First skip connection\n",
+ "\t\tskip1 = layers.Add()([attention_output, encodedPatches])\n",
+ "\n",
+ "\t\t# Second layer normalisation\n",
+ "\t\tlayerNorm2 = layers.LayerNormalization(epsilon=1e-6)(skip1)\n",
+ "\n",
+ "\t\t# Multi-Layer Perceptron\n",
+ "\t\tmlpLayer = layerNorm2\n",
+ "\t\tfor units in hidden_units:\n",
+ "\t\t\tmlpLayer = layers.Dense(units, activation=tf.nn.gelu)(mlpLayer)\n",
+ "\t\t\tmlpLayer = layers.Dropout(dropout_rate)(mlpLayer, training=False)\n",
+ "\n",
+ "\t\t# Second skip connection\n",
+ "\t\tencodedPatches = layers.Add()([mlpLayer, skip1])\n",
+ "\n",
+ "\t# Create a [batch_size, projection_dim] tensor\n",
+ "\trepresenttn = layers.LayerNormalization(epsilon=1e-6)(encodedPatches)\n",
+ "\trepresenttn = layers.Flatten()(representtn)\n",
+ "\trepresenttn = layers.Dropout(dropout_rate)(representtn, training=False)\n",
+ "\n",
+ "\t# MLP layer for learning features\n",
+ "\tfeatures = representtn\n",
+ "\tfor units in mlp_head_units:\n",
+ "\t\tfeatures = layers.Dense(units, activation=tf.nn.gelu)(features)\n",
+ "\t\tfeatures = layers.Dropout(dropout_rate)(features, training=False)\n",
+ "\n",
+ "\t# Classify outputs\n",
+ "\tlogits = layers.Dense(1)(features)\n",
+ "\n",
+ "\t# Create Keras model\n",
+ "\tmodel = tf.keras.Model(inputs=inputs, outputs=logits)\n",
+ "\n",
+ "\treturn model\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [],
+ "metadata": {
+ "id": "iymmQ6_wK0ei"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 1000
+ },
+ "outputId": "0a021902-d899-40df-87d3-2d6cfa5fc47c",
+ "id": "Fc8FBUZtK04q"
+ },
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Found 21520 files belonging to 2 classes.\n",
+ "Found 9000 files belonging to 2 classes.\n",
+ "Model: \"model_2\"\n",
+ "__________________________________________________________________________________________________\n",
+ " Layer (type) Output Shape Param # Connected to \n",
+ "==================================================================================================\n",
+ " input_3 (InputLayer) [(None, 128, 128, 3)] 0 [] \n",
+ " \n",
+ " patch_layer_3 (PatchLayer) ((None, 256, 16), 17296 ['input_3[0][0]'] \n",
+ " (None, 16, 16, 960)) \n",
+ " \n",
+ " embed__patch_2 (Embed_Patc (None, 256, 16) 4096 ['patch_layer_3[0][0]'] \n",
+ " h) \n",
+ " \n",
+ " layer_normalization_16 (La (None, 256, 16) 32 ['embed__patch_2[0][0]'] \n",
+ " yerNormalization) \n",
+ " \n",
+ " multi__head__attention_lsa (None, 256, 16) 2161 ['layer_normalization_16[0][0]\n",
+ " _4 (Multi_Head_AttentionLS ', \n",
+ " A) 'layer_normalization_16[0][0]\n",
+ " '] \n",
+ " \n",
+ " add_8 (Add) (None, 256, 16) 0 ['multi__head__attention_lsa_4\n",
+ " [0][0]', \n",
+ " 'embed__patch_2[0][0]'] \n",
+ " \n",
+ " layer_normalization_17 (La (None, 256, 16) 32 ['add_8[0][0]'] \n",
+ " yerNormalization) \n",
+ " \n",
+ " dense_20 (Dense) (None, 256, 32) 544 ['layer_normalization_17[0][0]\n",
+ " '] \n",
+ " \n",
+ " dropout_15 (Dropout) (None, 256, 32) 0 ['dense_20[0][0]'] \n",
+ " \n",
+ " dense_21 (Dense) (None, 256, 16) 528 ['dropout_15[0][0]'] \n",
+ " \n",
+ " dropout_16 (Dropout) (None, 256, 16) 0 ['dense_21[0][0]'] \n",
+ " \n",
+ " add_9 (Add) (None, 256, 16) 0 ['dropout_16[0][0]', \n",
+ " 'add_8[0][0]'] \n",
+ " \n",
+ " layer_normalization_18 (La (None, 256, 16) 32 ['add_9[0][0]'] \n",
+ " yerNormalization) \n",
+ " \n",
+ " flatten_2 (Flatten) (None, 4096) 0 ['layer_normalization_18[0][0]\n",
+ " '] \n",
+ " \n",
+ " dropout_17 (Dropout) (None, 4096) 0 ['flatten_2[0][0]'] \n",
+ " \n",
+ " dense_22 (Dense) (None, 16) 65552 ['dropout_17[0][0]'] \n",
+ " \n",
+ " dropout_18 (Dropout) (None, 16) 0 ['dense_22[0][0]'] \n",
+ " \n",
+ " dense_23 (Dense) (None, 8) 136 ['dropout_18[0][0]'] \n",
+ " \n",
+ " dropout_19 (Dropout) (None, 8) 0 ['dense_23[0][0]'] \n",
+ " \n",
+ " dense_24 (Dense) (None, 1) 9 ['dropout_19[0][0]'] \n",
+ " \n",
+ "==================================================================================================\n",
+ "Total params: 90418 (353.20 KB)\n",
+ "Trainable params: 90418 (353.20 KB)\n",
+ "Non-trainable params: 0 (0.00 Byte)\n",
+ "__________________________________________________________________________________________________\n",
+ "None\n",
+ "Epoch 1/10\n"
+ ]
+ },
+ {
+ "output_type": "stream",
+ "name": "stderr",
+ "text": [
+ "WARNING:tensorflow:Gradients do not exist for variables ['Variable:0'] when minimizing the loss. If you're using `model.compile()`, did you forget to provide a `loss` argument?\n",
+ "WARNING:tensorflow:Gradients do not exist for variables ['Variable:0'] when minimizing the loss. If you're using `model.compile()`, did you forget to provide a `loss` argument?\n"
+ ]
+ },
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "673/673 [==============================] - 126s 183ms/step - loss: 0.6638 - accuracy: 0.5546 - val_loss: 0.7267 - val_accuracy: 0.5208\n",
+ "Epoch 2/10\n",
+ "673/673 [==============================] - 124s 185ms/step - loss: 0.6232 - accuracy: 0.6208 - val_loss: 0.7103 - val_accuracy: 0.5341\n",
+ "Epoch 3/10\n",
+ "673/673 [==============================] - 121s 180ms/step - loss: 0.5988 - accuracy: 0.6488 - val_loss: 0.6996 - val_accuracy: 0.5317\n",
+ "Epoch 4/10\n",
+ "673/673 [==============================] - 122s 182ms/step - loss: 0.5848 - accuracy: 0.6643 - val_loss: 0.7071 - val_accuracy: 0.5709\n",
+ "Epoch 5/10\n",
+ "673/673 [==============================] - 123s 182ms/step - loss: 0.5743 - accuracy: 0.6705 - val_loss: 0.7020 - val_accuracy: 0.5561\n",
+ "Epoch 6/10\n",
+ "673/673 [==============================] - 129s 192ms/step - loss: 0.5652 - accuracy: 0.6848 - val_loss: 0.7034 - val_accuracy: 0.5667\n",
+ "Epoch 7/10\n",
+ "673/673 [==============================] - 123s 182ms/step - loss: 0.5551 - accuracy: 0.6919 - val_loss: 0.7035 - val_accuracy: 0.5742\n",
+ "Epoch 8/10\n",
+ "673/673 [==============================] - 125s 185ms/step - loss: 0.5477 - accuracy: 0.7010 - val_loss: 0.7015 - val_accuracy: 0.5645\n",
+ "Epoch 9/10\n",
+ "673/673 [==============================] - 123s 183ms/step - loss: 0.5411 - accuracy: 0.7042 - val_loss: 0.7012 - val_accuracy: 0.5851\n",
+ "Epoch 10/10\n",
+ "673/673 [==============================] - 124s 184ms/step - loss: 0.5303 - accuracy: 0.7155 - val_loss: 0.7136 - val_accuracy: 0.5796\n"
+ ]
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {}
+ }
+ ],
+ "source": [
+ "def compileModel():\n",
+ " \"\"\"\n",
+ " compiles the model.\n",
+ " \"\"\"\n",
+ " # Build and compile model\n",
+ " optimizer = tfa.optimizers.AdamW(\n",
+ " learning_rate=LEARN_RATE,\n",
+ " weight_decay=WEIGHT_DECAY\n",
+ " )\n",
+ "\n",
+ " model = buildVisionTransformer(\n",
+ " INPUT_SHAPE,\n",
+ " IMG_SIZE,\n",
+ " PATCH_SIZE,\n",
+ " NUM_PATCHES,\n",
+ " ATTENTION_HEADS,\n",
+ " PROJECTION_DIM,\n",
+ " HIDDEN_UNITS,\n",
+ " DROPOUT_RATE,\n",
+ " TRANSF_LAYERS,\n",
+ " MLP_HEAD_UNITS\n",
+ " )\n",
+ "\n",
+ " model.compile(\n",
+ " optimizer=optimizer,\n",
+ " loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),\n",
+ " metrics=[\n",
+ " tf.keras.metrics.BinaryAccuracy(name='accuracy')\n",
+ " ]\n",
+ " )\n",
+ "\n",
+ " return model\n",
+ "\n",
+ "\n",
+ "def trainModel(model, trainData, val_data):\n",
+ " \"\"\"\n",
+ " Trains and saves the model.\n",
+ " \"\"\"\n",
+ "\n",
+ " # Train model\n",
+ " history = model.fit(\n",
+ " x=trainData,\n",
+ " batch_size=BATCH_SIZE,\n",
+ " epochs=EPOCHS,\n",
+ " validation_data=val_data\n",
+ " )\n",
+ "\n",
+ " # Save model\n",
+ " model.save(\n",
+ " MODEL_SAVE_DEST,\n",
+ " overwrite=True,\n",
+ " include_optimizer=True,\n",
+ " save_format='tf'\n",
+ " )\n",
+ "\n",
+ " # Plot and save accuracy curves\n",
+ " plt.plot(history.history['accuracy'])\n",
+ " plt.plot(history.history['val_accuracy'])\n",
+ " plt.suptitle('Model Accuracy')\n",
+ " plt.ylabel('Accuracy')\n",
+ " plt.xlabel('Epoch')\n",
+ " plt.legend(['train', 'val'])\n",
+ " plt.savefig('accuracy.png')\n",
+ " plt.clf()\n",
+ "\n",
+ " # Plot and save loss curves\n",
+ " plt.plot(history.history['loss'])\n",
+ " plt.plot(history.history['val_loss'])\n",
+ " plt.suptitle('Model Loss')\n",
+ " plt.ylabel('Loss')\n",
+ " plt.xlabel('Epoch')\n",
+ " plt.legend(['train', 'val'])\n",
+ " plt.savefig('losses.png')\n",
+ " plt.clf()\n",
+ "\n",
+ "\n",
+ "if __name__ == '__main__':\n",
+ " # Load data\n",
+ " train, val, test = loadData()\n",
+ "\n",
+ " # Compile and train model\n",
+ " model = compileModel()\n",
+ " print(model.summary())\n",
+ " trainModel(model, train, val)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 106
+ },
+ "outputId": "d9d7d343-3b37-4b3c-8637-550d4c55e2bf",
+ "id": "JcV-zTIMK04r"
+ },
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Found 21520 files belonging to 2 classes.\n",
+ "Found 9000 files belonging to 2 classes.\n",
+ "141/141 [==============================] - 42s 146ms/step - loss: 0.7035 - accuracy: 0.5851\n"
+ ]
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {}
+ }
+ ],
+ "source": [
+ "def predict(load_path, testData):\n",
+ " optimizer = tfa.optimizers.AdamW(\n",
+ " learning_rate=LEARN_RATE,\n",
+ " weight_decay=WEIGHT_DECAY\n",
+ " )\n",
+ "\n",
+ " model = tf.keras.models.load_model(\n",
+ " load_path,\n",
+ " custom_objects={\n",
+ " 'PatchLayer': PatchLayer,\n",
+ " 'Embed_Patch': Embed_Patch,\n",
+ " 'MultiheadattentionLSA': Multi_Head_AttentionLSA,\n",
+ " 'AdamW': optimizer\n",
+ " }\n",
+ " )\n",
+ "\n",
+ " model.evaluate(testData)\n",
+ "\n",
+ " # Plot confusion matrix\n",
+ " y_true = []\n",
+ " y_pred = []\n",
+ "\n",
+ " for image_batch, label_batch in testData:\n",
+ " y_true.append(label_batch)\n",
+ " y_pred.append((model.predict(image_batch, verbose=0) > 0.5).astype('int32'))\n",
+ "\n",
+ " labels_true = tf.concat([tf.cast(item[0], tf.int32) for item in y_true], axis=0)\n",
+ " labels_pred = tf.concat([item[0] for item in y_pred], axis=0)\n",
+ "\n",
+ " matrix = tf.math.confusion_matrix(labels_true, labels_pred, 2).numpy()\n",
+ "\n",
+ " fig, ax = plt.subplots(figsize=(8,8))\n",
+ " ax.matshow(matrix, cmap=plt.cm.Blues, alpha=0.3)\n",
+ " for i in range(matrix.shape[0]):\n",
+ " for j in range(matrix.shape[1]):\n",
+ " ax.text(x=j, y=i, s=matrix[i, j], va='center', ha='center', size='xx-large')\n",
+ "\n",
+ " plt.xlabel('Predictions', fontsize=18)\n",
+ " plt.ylabel('Actual Label', fontsize=18)\n",
+ " plt.suptitle('Confusion Matrix', fontsize=18)\n",
+ " plt.savefig('confusion_matrix')\n",
+ " plt.clf()\n",
+ "\n",
+ "\n",
+ "if __name__ == '__main__':\n",
+ " train, val, test = loadData()\n",
+ " predict(MODEL_SAVE_DEST, test)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 1000
+ },
+ "outputId": "206b76a5-6cf0-4586-aaec-956d192cdc6d",
+ "id": "jmFE2DSkK04r"
+ },
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Found 21520 files belonging to 2 classes.\n",
+ "Found 9000 files belonging to 2 classes.\n"
+ ]
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ],
+ "image/png": "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\n"
+ },
+ "metadata": {}
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ],
+ "image/png": "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\n"
+ },
+ "metadata": {}
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ],
+ "image/png": "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\n"
+ },
+ "metadata": {}
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ],
+ "image/png": "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\n"
+ },
+ "metadata": {}
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ],
+ "image/png": "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\n"
+ },
+ "metadata": {}
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ],
+ "image/png": "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\n"
+ },
+ "metadata": {}
+ }
+ ],
+ "source": [
+ "def plot_image(dataset):\n",
+ " \"\"\"\n",
+ " Ploting image from the given dataset.\n",
+ " \"\"\"\n",
+ " plt.figure(figsize=(5, 5))\n",
+ " datasetIt = dataset.__iter__()\n",
+ " image = datasetIt.next()[0][0]\n",
+ " plt.imshow(image.numpy().astype('uint8'))\n",
+ " plt.axis('off')\n",
+ " plt.show()\n",
+ "\n",
+ "\n",
+ "def plot_patches(dataset):\n",
+ " \"\"\"\n",
+ " Ploting image from the given dataset after applying Patch_Layer to it.\n",
+ " \"\"\"\n",
+ " datasetIt = dataset.__iter__()\n",
+ " image = datasetIt.next()[0][0]\n",
+ "\n",
+ " resized_image = tf.image.resize(\n",
+ " tf.convert_to_tensor([image]), size=(IMG_SIZE, IMG_SIZE)\n",
+ " )\n",
+ "\n",
+ " (token, patch) = PatchLayer(IMG_SIZE, PATCH_SIZE, NUM_PATCHES, PROJECTION_DIM)(resized_image/255.0)\n",
+ " (token, patch) = (token[0], patch[0])\n",
+ " n = patch.shape[0]\n",
+ " shiftedImg = [\"ORIGINAL\", \"LEFT-UP\", \"LEFT-DOWN\", \"RIGHT-UP\", \"RIGHT-DOWN\"]\n",
+ "\n",
+ " for index, name in enumerate(shiftedImg):\n",
+ " count = 1\n",
+ " plt.figure(figsize=(5, 5))\n",
+ " plt.suptitle(name)\n",
+ "\n",
+ " for row in range(n):\n",
+ " for col in range(n):\n",
+ " plt.subplot(n, n, count)\n",
+ " count = count + 1\n",
+ " image= tf.reshape(patch[row][col], (PATCH_SIZE, PATCH_SIZE, 3 * 5))\n",
+ " plt.imshow(image[..., 3 * index : 3 * index + 3])\n",
+ " plt.axis('off')\n",
+ "\n",
+ " plt.show()\n",
+ "\n",
+ "\n",
+ "if __name__ == '__main__':\n",
+ " train, val, test = loadData()\n",
+ " plot_image(train)\n",
+ " plot_patches(train)"
+ ]
+ }
+ ],
+ "metadata": {
+ "accelerator": "GPU",
+ "colab": {
+ "provenance": [],
+ "authorship_tag": "ABX9TyOcZ7J7pISQjn/D/Wkfv50/",
+ "include_colab_link": true
+ },
+ "kernelspec": {
+ "display_name": "Python 3",
+ "name": "python3"
+ },
+ "language_info": {
+ "name": "python"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/README.md b/README.md
index 4a064f841..d0d283df0 100644
--- a/README.md
+++ b/README.md
@@ -1,15 +1,279 @@
-# Pattern Analysis
-Pattern Analysis of various datasets by COMP3710 students at the University of Queensland.
+ADNI_Brain_Visual_Transformer_47306725
+# Visual Transformer for the Classification of Alzheimer's Disease of the ADNI brain data
-We create pattern recognition and image processing library for Tensorflow (TF), PyTorch or JAX.
+Ritika Rana (Student Noumber : 47306725)
-This library is created and maintained by The University of Queensland [COMP3710](https://my.uq.edu.au/programs-courses/course.html?course_code=comp3710) students.
+## Overview
+The rapidly expanding field of medical imaging leverages deep learning and neural networks to enhance diagnostic accuracy and reduce human errors in healthcare and medicine. This project seeks to create a Vision Transformer. The objective is to enable the Vision Transformer to categorize MRI brain scans as either indicative of Alzheimer's Disease or Normal Cognitive function as Vision Transformers can achieve excellent results compared to convolutional networks while demanding fewer training resources. The target for this model is a testing accuracy of at least 80%.
-The library includes the following implemented in Tensorflow:
-* fractals
-* recognition problems
+## Vision Transformers
+Conventional Transformers employ the self-attention mechanism to discern the interplay among multiple inputs. Referred to as ViT (Vision Transformers), these models take the original Transformer architecture and adapt the attention mechanism to process 2D images, making them suitable for classification tasks.
-In the recognition folder, you will find many recognition problems solved including:
-* OASIS brain segmentation
-* Classification
-etc.
+You can input 2D images into the Vision Transformer (ViT), and the images are divided into smaller patches. These patches are then transformed into 1D vectors through linear projections. Learnable class embeddings can be included, and to maintain the patch ordering, positional encodings can be introduced. These flattened patches, enriched with class or positional embeddings, are subsequently processed by conventional Transformer encoders to identify relationships within the image data patches. Finally, a Multi-Layer Perceptron (MLP), a neural network capable of learning relationships, is employed for the classification of inputs.
+Components in a Transformer Encoder are as follows:
+
+
+
+
+
+
+
+## Overview of the Repository
+
+The document has the following sections:
+
+The resources/ directory houses the images utilized in this README document.
+
+"Parameters" includes the hyperparameters employed to define data loading and model configurations.
+
+"Modules" has the elements that make up the Vision Transformer.
+
+"Dataset" contains the function responsible for data loading.
+
+"Train" can access the functions for assembling and training the model.
+
+"Predict" comprises the functions required for making predictions using the trained model.
+
+Lastly, "Utils" encompasses functions dedicated to data visualization.
+
+## Setting Parameters
+Prior to initiating model training, make sure to configure the global variables located in parameters.py. The variables that require configuration include:
+
+IMG_SIZE: The height and width of the image.
+
+PATCH_SIZE: The height and width of individual patches.
+
+BATCH_SIZE: The batch size for both training and testing data.
+
+PROJECTION_DIM: The dimensions of the attention layer.
+
+LEARN_RATE: The learning rate for the optimizer.
+
+ATTENTION_HEADS: The number of attention heads.
+
+DROPOUT_RATE: The fraction of units to drop out in each Dense Layer.
+
+TRANSFORMER_LAYERS: The quantity of transformer encoders to incorporate.
+
+WEIGHT_DECAY: The weight decay used by the optimizer.
+
+EPOCHS: The number of epochs for model training.
+
+MLP_HEAD_UNITS: The number of units in the MLP head classifier for feature learning.
+
+DATA_LOAD_DEST: The path from which the dataset will be loaded.
+
+MODEL_SAVE_DEST: The location to save the model.
+
+The variables INPUT_SHAPE, HIDDEN_UNITS, and NUM_PATCHES are calculated automatically.
+
+## Build and Train the Model
+After configuring the parameters, execute till train. Upon completion of training, the model will be saved in HDF5 format at the directory specified by MODEL_SAVE_DEST. Additionally, loss and accuracy curves will be generated and saved in the working directory.
+
+To make predictions using the trained model, run predict. This script loads the model from MODEL_SAVE_DEST and evaluates the test set. A confusion matrix will be automatically generated and saved in the working directory.
+
+## Dataset
+we can download the original dataset from the ADNI website. To specify the data source path, modify the DATA_LOAD_DEST constant in parameters. The data has the following file structure:
+
+```
+train/
+ AD/
+ images
+ ...
+ NC/
+ images
+ ...
+test/
+ AD/
+ images
+ ...
+ NC/
+ images
+ ...
+
+```
+
+Given that this dataset exclusively contains two categories, it is loaded using binary encoding. In this scheme, the value 0 represents the AD class for brains afflicted with Alzheimer's Disease, and 1 is assigned to NC, signifying brains with normal cognitive function.
+
+## Training, Validation and Test Splits
+The provided dataset consisted of 21,520 images in the training folder, and 9000 images in the testing folder. Since Vision Transformers are very data-hungry models which require a lot of data for training, it was decided that the validation set would be split from half of the image data in the testing folder. This gives a dataset split of:
+
+21,520 images in training set
+4500 images in validation set
+4500 images in testing set
+
+## Data Augmentation
+The data loaded was also augmented before passing to the model for training and prediction.
+Normalization, RandomFlip, RandomZoom and RandomRotate layers were applied to each image in the three datasets.
+By augmenting the data, the model would be less likely to overfit on the already small set of training data. The randomized actions have all been passed a seed parameter to allow for the reproducibility of results.
+for example:
+
+
+
+
+
+
+## Vision Transformer Implementation
+### Changes made to Original Vision Transformer
+The architecture of the implemented Vision Transformer model exhibits slight deviations from the original model.
+
+The key distinctions include the incorporation of Shifted Patch Tokenization and the utilization of Local Self-Attention.
+Transformers, along with these techniques, can enhance the learning process of Vision Transformers, particularly when dealing with smaller datasets. Given our relatively limited dataset consisting of only 30,520 images, we made the deliberate choice to incorporate the aforementioned methods into the model.
+
+Shifted Patch Tokenization is a method that involves making slight adjustments to input images by shifting them either to the right or left and up or down. This adjustment effectively expands the Transformer's receptive field, thereby improving its capacity to recognize the connections between different patches within the image.
+
+Local Self-Attention shares similarities with the conventional Multi-Head Attention (MHA) layer, but it introduces an extra diagonal mask. This mask redirects the Vision Transformer's attention towards relationships between tokens, as opposed to focusing solely on its own tokens. Additionally, a Learnable Temperature Scaling component is integrated into the model, enabling it to autonomously adapt the temperature of the Softmax layer within the MHA layer. This adjustment aids in fine-tuning the score distribution or attention distribution, enhancing the model's performance.
+
+
+
+
+
+Furthermore, in our model, the classification task is executed by employing an MLP (comprising Dense layers) designed to acquire and learn features.
+
+## Architecture of Vision Transformer
+Following the initial input layer of the Vision Transformer, the data proceeds to the PatchLayer. Within this layer, the images are divided into patches, each with dimensions defined by the constant PATCH_SIZE. Moreover, Shifted Patch Tokenization is employed on the input images before the patching process. As a result of this operation, the original image is partitioned into patches as follows:
+
+
+
+
+
+The images which have Shifted Patch Tokenization applied and are patched become:
+
+
+
+
+
+
+
+
+
+
+Subsequently, these images are transformed into vectors through flattening and then directed to the EmbedPatch layer. This layer is responsible for embedding positional information into the flattened vectors. Once the patches have been encoded with their respective positions, these vectors are passed into the Transformer blocks. Within these Transformer blocks, a structure akin to the original model is adhered to, with the exception that Local Self-Attention is applied in conjunction with the Multi-Head Attention layer, rather than utilizing the Multi-Head Attention layer in isolation. After the Transformer encoder blocks, MLP layers come into play for feature learning and final classification, given that the class token is no longer employed.
+
+During testing, it was observed that maintaining logits and performing BinaryCrossEntropy evaluation based on logits yielded more stable results. Consequently, the final MLP classification layer does not incorporate any activation functions.
+
+## Training and Testing Process
+Numerous permutations of hyperparameters were experimented with and adjusted, guided by the outcomes derived from training, validation, and testing accuracies. The subsequent section details the outcomes of three distinct models, each characterized by varying levels of complexity.
+
+### Model 1
+This model was initially trained with the following hyperparameters:
+
+```
+IMG_SIZE = 128
+PATCH_SIZE = 8
+BATCH_SIZE = 32
+EPOCHS = 10
+WEIGHT_DECAY = 0.0001
+PROJECTION_DIM = 512 # MLP-blocks depth
+LEARN_RATE = 0.0005
+TRANSF_LAYERS = 5 # No. of transformer-encoder-blocks
+DROPOUT_RATE = 0.2
+ATTENTION_HEADS = 5
+MLP_HEAD_UNITS = [256, 128]
+```
+
+these parameters give 65,729,926 trainable parameters. The loss and accuracy plots of training and validation for this model were as follows:
+
+
+
+
+
+
+
+
+
+The confusion matrix for the test set is presented. In this matrix, the label '0' corresponds to brains afflicted with Alzheimer's Disease, whereas '1' corresponds to brains with Normal Cognitive function.
+
+
+
+
+
+From the plots above, it is evident that the model is greatly overfitting in only 10 epochs. When training the model for more epochs, overfitting would worsen. Evaluating the test set on this model resulted in a 64.65% accuracy, not meeting the 80% accuracy goal.
+
+### Model 2
+
+In a subsequent effort to train the model and mitigate the observed overfitting from the previous outcome, alterations were made to the hyperparameters, resulting in the following configuration:
+```
+IMG_SIZE = 128
+PATCH_SIZE = 8
+BATCH_SIZE = 32
+EPOCHS = 10
+WEIGHT_DECAY = 0.0001
+PROJECTION_DIM = 128 # MLP-blocks depth
+LEARN_RATE = 0.001
+TRANSF_LAYERS = 3 # No. of transformer-encoder-blocks
+DROPOUT_RATE = 0.4
+ATTENTION_HEADS = 5
+MLP_HEAD_UNITS = [64, 32]
+```
+
+This specific set of parameters results in 3,445,764 trainable parameters. Notably, the model's complexity was substantially reduced, aiming to make it more challenging for the model to overfit during training. The outcome of this model was a testing accuracy of 62.68%. Below, you can find the representations of the loss and accuracy curves, as well as the confusion matrix.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+The visual representations make it apparent that the overfitting issue remains unaddressed, and the outcomes closely resemble those observed previously. The confusion matrix further underscores that there has been no enhancement in testing dataset accuracy.
+
+### Model 3
+
+A final model, characterized by substantially reduced complexity, was trained using the subsequent parameters:
+```
+IMG_SIZE = 128
+PATCH_SIZE = 8
+BATCH_SIZE = 32
+EPOCHS = 10
+WEIGHT_DECAY = 0.0001
+PROJECTION_DIM = 16 # MLP-blocks depth
+LEARN_RATE = 0.0001
+TRANSF_LAYERS = 1 # No. of transformer-encoder-blocks
+DROPOUT_RATE = 0.3
+ATTENTION_HEADS = 2
+MLP_HEAD_UNITS = [16, 8]
+```
+
+This particular model comprises a mere 90,418 trainable parameters and achieved a testing accuracy of 57.96%. Below, you will find the visualizations of the accuracy and loss curves, along with the confusion matrix.
+
+
+
+
+
+
+
+
+
+
+
+
+
+Once more, it is evident that the model displays noticeable overfitting characteristics. Furthermore, this less intricate model resulted in a reduction in accuracy compared to the initial Model 1. Consequently, the determination was made that training less complex models would not effectively address the overfitting problem and would, in fact, lead to more significant declines in testing accuracy.
+
+Additional attempts were made to fine-tune the model by experimenting with diverse hyperparameters, encompassing both larger and smaller models. Various optimizers and learning rates were also tested, yet all the models exhibited overfitting tendencies. Ultimately, the highest testing accuracy achieved was the 57.96% attained by Model 1.
+
+## Conclusion
+The results from the three models trained and assessed above underscore a substantial problem with model overfitting, given the inability to attain validation or testing accuracy above 64.65%.
+
+To enhance this project and potentially bring the model's accuracy closer to the 80% objective, it is recommended to consider employing a larger dataset.
+
+Another viable strategy for enhancing accuracy involves leveraging pre-trained Vision Transformers and subsequently fine-tuning the model on the specific dataset. This approach has the potential to boost the model's accuracy.
+
+
+## References
+[1] Shifted-Patch-Tokenization and Locality-Self-Attention, https://keras.io/examples/vision/vit_small_ds/
+
+[2] Vision Transformer for Small-Size-Datasets, https://arxiv.org/abs/2112.13492
+
+[3] Vision Transformer Implementation, https://keras.io/examples/vision/image_classification_with_vision_transformer/
+
+[4] dataset, https://adni.loni.usc.edu/
+
+[5] Vision transformer understanding, https://en.wikipedia.org/wiki/Vision_transformer
diff --git a/dataset.py b/dataset.py
new file mode 100644
index 000000000..e1187e416
--- /dev/null
+++ b/dataset.py
@@ -0,0 +1,38 @@
+def loadData():
+ """
+ Loading the dataset.
+ """
+ trainData = tf.keras.preprocessing.image_dataset_from_directory(
+ DATA_LOAD_DEST + "/train", labels='inferred', label_mode='binary',
+ image_size=[IMG_SIZE, IMG_SIZE], shuffle=True,
+ batch_size=BATCH_SIZE, seed=8, class_names=['AD', 'NC']
+ )
+
+ testData = tf.keras.preprocessing.image_dataset_from_directory(
+ DATA_LOAD_DEST + "/test", labels='inferred', label_mode='binary',
+ image_size=[IMG_SIZE, IMG_SIZE], shuffle=True,
+ batch_size=BATCH_SIZE, seed=8, class_names=['AD', 'NC']
+ )
+
+ # Augmenting data
+ normalize = tf.keras.layers.Normalization()
+ flip = tf.keras.layers.RandomFlip(mode='horizontal', seed=8)
+ rotate = tf.keras.layers.RandomRotation(factor=0.02, seed=8)
+ zoom = tf.keras.layers.RandomZoom(height_factor=0.1, width_factor=0.1, seed=8)
+
+ trainData = trainData.map(
+ lambda x, y: (rotate(flip(zoom(normalize(x)))), y)
+ )
+
+ testData = testData.map(
+ lambda x, y: (rotate(flip(zoom(normalize(x)))), y)
+ )
+
+ # Taking half of the 9000 images from the test set as validation data
+ validationData = testData.take(len(list(testData))//2)
+
+ # Using remaining images as test set
+ testData = testData.skip(len(list(testData))//2)
+
+ return trainData, validationData, testData
+
diff --git a/google colab commit logs/Screenshot (136).png b/google colab commit logs/Screenshot (136).png
new file mode 100644
index 000000000..07969073c
Binary files /dev/null and b/google colab commit logs/Screenshot (136).png differ
diff --git a/google colab commit logs/Screenshot (137).png b/google colab commit logs/Screenshot (137).png
new file mode 100644
index 000000000..bcbe6c15c
Binary files /dev/null and b/google colab commit logs/Screenshot (137).png differ
diff --git a/google colab commit logs/Screenshot (138).png b/google colab commit logs/Screenshot (138).png
new file mode 100644
index 000000000..e0f3acc60
Binary files /dev/null and b/google colab commit logs/Screenshot (138).png differ
diff --git a/modules.py b/modules.py
new file mode 100644
index 000000000..caf6c2de0
--- /dev/null
+++ b/modules.py
@@ -0,0 +1,216 @@
+class PatchLayer(Layer):
+ """
+ Layering and transforming images into patches.
+ """
+ def __init__(self, img_size, patch_size, num_patches, projection_dim, **kwargs):
+ super(PatchLayer, self).__init__(**kwargs)
+ self.img_size = img_size
+ self.patch_size = patch_size
+ self.num_patches = num_patches
+ self.projection_dim = projection_dim
+ self.half_patch = patch_size // 2
+ self.flatten_patches = layers.Reshape((num_patches, -1))
+ self.projection = layers.Dense(units=projection_dim)
+ self.layer_norm = layers.LayerNormalization(epsilon=1e-6)
+
+ def shiftImg(self, images, mode):
+ # Building diagonally-shifted images
+ if mode == 'left-up':
+ cropheight = self.half_patch
+ cropwidth = self.half_patch
+ shiftheight = 0
+ shiftwidth = 0
+ elif mode == 'left-down':
+ cropheight = 0
+ cropwidth = self.half_patch
+ shiftheight = self.half_patch
+ shiftwidth = 0
+ elif mode == 'right-up':
+ cropheight = self.half_patch
+ cropwidth = 0
+ shiftheight = 0
+ shiftwidth = self.half_patch
+ else:
+ cropheight = 0
+ cropwidth = 0
+ shiftheight = self.half_patch
+ shiftwidth = self.half_patch
+
+ crop = tf.image.crop_to_bounding_box(
+ images,
+ offset_height=cropheight,
+ offset_width=cropwidth,
+ target_height=self.img_size - self.half_patch,
+ target_width=self.img_size - self.half_patch
+ )
+
+ shiftPad = tf.image.pad_to_bounding_box(
+ crop,
+ offset_height=shiftheight,
+ offset_width=shiftwidth,
+ target_height=self.img_size,
+ target_width=self.img_size
+ )
+ return shiftPad
+
+ def call(self, images):
+ images = tf.concat(
+ [
+ images,
+ self.shiftImg(images, mode='left-up'),
+ self.shiftImg(images, mode='left-down'),
+ self.shiftImg(images, mode='right-up'),
+ self.shiftImg(images, mode='right-down'),
+ ],
+ axis=-1
+ )
+ patches = tf.image.extract_patches(
+ images=images,
+ sizes=[1, self.patch_size, self.patch_size, 1],
+ strides=[1, self.patch_size, self.patch_size, 1],
+ rates=[1, 1, 1, 1],
+ padding='VALID'
+ )
+ flat_patches = self.flatten_patches(patches)
+ tokens = self.layer_norm(flat_patches)
+ tokens = self.projection(tokens)
+
+ return (tokens, patches)
+
+ def getConfig_(self):
+ config_ = super(PatchLayer, self).getConfig_()
+ config_.update(
+ {
+ 'img_size': self.img_size,
+ 'patch_size': self.patch_size,
+ 'num_patches': self.num_patches,
+ 'projection_dim': self.projection_dim
+ }
+ )
+ return config_
+
+class Embed_Patch(Layer):
+ """
+ Layering for projecting patches into a vector.
+ """
+ def __init__(self, num_patches, projection_dim, **kwargs):
+ super(Embed_Patch, self).__init__(**kwargs)
+ self.num_patches = num_patches
+ self.projection_dim = projection_dim
+ self.position_embedding = layers.Embedding(
+ input_dim=self.num_patches, output_dim=projection_dim
+ )
+
+ def call(self, patches):
+ positions = tf.range(0, self.num_patches, delta=1)
+ return patches + self.position_embedding(positions)
+
+ def getConfig_(self):
+ config_ = super(Embed_Patch, self).getConfig_()
+ config_.update(
+ {
+ 'num_patches': self.num_patches,
+ 'projection_dim': self.projection_dim
+ }
+ )
+ return config_
+
+class Multi_Head_AttentionLSA(layers.MultiHeadAttention):
+ """
+ Multi Head Attention layer for the transformer-encoder block, but with the
+ addition of using Local-Self-Attention to improve feature learning.
+
+ """
+ def __init__(self, **kwargs):
+ super(Multi_Head_AttentionLSA, self).__init__(**kwargs)
+ self.tau = tf.Variable(math.sqrt(float(self._key_dim)), trainable=True)
+
+ def computeAttention(self, query, key, value, attention_mask=None,
+ training=None):
+ query = tf.multiply(query, 1.0/self.tau)
+ attention_scores = tf.einsum(self._dot_product_equation, key, query)
+ attention_mask = tf.convert_to_tensor(attention_mask)
+ attention_scores = self._masked_softmax(attention_scores, attention_mask)
+ attention_scores_dropout = self._dropout_layer(
+ attention_scores, training=training
+ )
+ attention_output = tf.einsum(
+ self._combine_equation, attention_scores_dropout, value
+ )
+ return attention_output, attention_scores
+
+ def getConfig_(self):
+ config_ = super(Multi_Head_AttentionLSA, self).getConfig_()
+ return config_
+
+
+def buildVisionTransformer(input_shape, img_size, patch_size, num_patches,
+ attention_heads, projection_dim, hidden_units, dropout_rate,
+ transf_layers, mlp_head_units):
+ """
+ Building the vision transformer.
+ """
+ # Input layer
+ inputs = layers.Input(shape=input_shape)
+
+ # Convert image data into patches
+ (tokens, _) = PatchLayer(
+ img_size,
+ patch_size,
+ num_patches,
+ projection_dim
+ )(inputs)
+
+ # Encode patches
+ encodedPatches = Embed_Patch(num_patches, projection_dim)(tokens)
+
+ # Create transformer layers
+ for _ in range(transf_layers):
+ # First layer normalisation
+ layerNorm1 = layers.LayerNormalization(
+ epsilon=1e-6
+ )(encodedPatches)
+
+ # Build diagoanl attention mask
+ diagAttnMask = 1 - tf.eye(num_patches)
+ diagAttnMask = tf.cast([diagAttnMask], dtype=tf.int8)
+
+ # Multi-head attention layer
+ attention_output = Multi_Head_AttentionLSA(
+ num_heads=attention_heads, key_dim=projection_dim,
+ dropout=dropout_rate
+ )(layerNorm1, layerNorm1, attention_mask=diagAttnMask)
+
+ # First skip connection
+ skip1 = layers.Add()([attention_output, encodedPatches])
+
+ # Second layer normalisation
+ layerNorm2 = layers.LayerNormalization(epsilon=1e-6)(skip1)
+
+ # Multi-Layer Perceptron
+ mlpLayer = layerNorm2
+ for units in hidden_units:
+ mlpLayer = layers.Dense(units, activation=tf.nn.gelu)(mlpLayer)
+ mlpLayer = layers.Dropout(dropout_rate)(mlpLayer, training=False)
+
+ # Second skip connection
+ encodedPatches = layers.Add()([mlpLayer, skip1])
+
+ # Create a [batch_size, projection_dim] tensor
+ representtn = layers.LayerNormalization(epsilon=1e-6)(encodedPatches)
+ representtn = layers.Flatten()(representtn)
+ representtn = layers.Dropout(dropout_rate)(representtn, training=False)
+
+ # MLP layer for learning features
+ features = representtn
+ for units in mlp_head_units:
+ features = layers.Dense(units, activation=tf.nn.gelu)(features)
+ features = layers.Dropout(dropout_rate)(features, training=False)
+
+ # Classify outputs
+ logits = layers.Dense(1)(features)
+
+ # Create Keras model
+ model = tf.keras.Model(inputs=inputs, outputs=logits)
+
+ return model
diff --git a/parameters.py b/parameters.py
new file mode 100644
index 000000000..0742886e5
--- /dev/null
+++ b/parameters.py
@@ -0,0 +1,20 @@
+# Hyperparameters
+IMG_SIZE = 128
+PATCH_SIZE = 8
+BATCH_SIZE = 32
+EPOCHS = 10
+WEIGHT_DECAY = 0.0001
+PROJECTION_DIM = 512 # MLP-blocks depth
+LEARN_RATE = 0.0005
+TRANSF_LAYERS = 5 # No. of transformer-encoder-blocks
+DROPOUT_RATE = 0.2
+ATTENTION_HEADS = 5
+MLP_HEAD_UNITS = [256, 128]
+DATA_LOAD_DEST = "/content"
+MODEL_SAVE_DEST = "/content/vision_transformer"
+
+
+#Calculating automat
+INPUT_SHAPE = (IMG_SIZE, IMG_SIZE, 3)
+HIDDEN_UNITS = [PROJECTION_DIM * 2, PROJECTION_DIM]
+NUM_PATCHES = int((IMG_SIZE/PATCH_SIZE) ** 2)
diff --git a/predict.py b/predict.py
new file mode 100644
index 000000000..9c90024bd
--- /dev/null
+++ b/predict.py
@@ -0,0 +1,47 @@
+def predict(load_path, testData):
+ optimizer = tfa.optimizers.AdamW(
+ learning_rate=LEARN_RATE,
+ weight_decay=WEIGHT_DECAY
+ )
+
+ model = tf.keras.models.load_model(
+ load_path,
+ custom_objects={
+ 'PatchLayer': PatchLayer,
+ 'Embed_Patch': Embed_Patch,
+ 'MultiheadattentionLSA': Multi_Head_AttentionLSA,
+ 'AdamW': optimizer
+ }
+ )
+
+ model.evaluate(testData)
+
+ # Plot confusion matrix
+ y_true = []
+ y_pred = []
+
+ for image_batch, label_batch in testData:
+ y_true.append(label_batch)
+ y_pred.append((model.predict(image_batch, verbose=0) > 0.5).astype('int32'))
+
+ labels_true = tf.concat([tf.cast(item[0], tf.int32) for item in y_true], axis=0)
+ labels_pred = tf.concat([item[0] for item in y_pred], axis=0)
+
+ matrix = tf.math.confusion_matrix(labels_true, labels_pred, 2).numpy()
+
+ fig, ax = plt.subplots(figsize=(8,8))
+ ax.matshow(matrix, cmap=plt.cm.Blues, alpha=0.3)
+ for i in range(matrix.shape[0]):
+ for j in range(matrix.shape[1]):
+ ax.text(x=j, y=i, s=matrix[i, j], va='center', ha='center', size='xx-large')
+
+ plt.xlabel('Predictions', fontsize=18)
+ plt.ylabel('Actual Label', fontsize=18)
+ plt.suptitle('Confusion Matrix', fontsize=18)
+ plt.savefig('confusion_matrix')
+ plt.clf()
+
+
+if __name__ == '__main__':
+ train, val, test = loadData()
+ predict(MODEL_SAVE_DEST, test)
diff --git a/resources/accuracy (1).png b/resources/accuracy (1).png
new file mode 100644
index 000000000..afd80a9d7
Binary files /dev/null and b/resources/accuracy (1).png differ
diff --git a/resources/accuracy (2).png b/resources/accuracy (2).png
new file mode 100644
index 000000000..15836bae0
Binary files /dev/null and b/resources/accuracy (2).png differ
diff --git a/resources/accuracy (3).png b/resources/accuracy (3).png
new file mode 100644
index 000000000..68b271e00
Binary files /dev/null and b/resources/accuracy (3).png differ
diff --git a/resources/accuracy.png b/resources/accuracy.png
new file mode 100644
index 000000000..13a0dd2ba
Binary files /dev/null and b/resources/accuracy.png differ
diff --git a/resources/brain1.png b/resources/brain1.png
new file mode 100644
index 000000000..0d76a104d
Binary files /dev/null and b/resources/brain1.png differ
diff --git a/resources/brainl.png b/resources/brainl.png
new file mode 100644
index 000000000..70a2bc133
Binary files /dev/null and b/resources/brainl.png differ
diff --git a/resources/brainld.png b/resources/brainld.png
new file mode 100644
index 000000000..1a82074b8
Binary files /dev/null and b/resources/brainld.png differ
diff --git a/resources/brainr.png b/resources/brainr.png
new file mode 100644
index 000000000..546571175
Binary files /dev/null and b/resources/brainr.png differ
diff --git a/resources/brainrd.png b/resources/brainrd.png
new file mode 100644
index 000000000..cd74c5892
Binary files /dev/null and b/resources/brainrd.png differ
diff --git a/resources/confusion_matrix (1).png b/resources/confusion_matrix (1).png
new file mode 100644
index 000000000..e7db730fb
Binary files /dev/null and b/resources/confusion_matrix (1).png differ
diff --git a/resources/confusion_matrix (2).png b/resources/confusion_matrix (2).png
new file mode 100644
index 000000000..34181330d
Binary files /dev/null and b/resources/confusion_matrix (2).png differ
diff --git a/resources/confusion_matrix.png b/resources/confusion_matrix.png
new file mode 100644
index 000000000..6dbb3f954
Binary files /dev/null and b/resources/confusion_matrix.png differ
diff --git a/resources/image.png b/resources/image.png
new file mode 100644
index 000000000..667bbe430
Binary files /dev/null and b/resources/image.png differ
diff --git a/resources/localitattention.png b/resources/localitattention.png
new file mode 100644
index 000000000..9d9a6c04e
Binary files /dev/null and b/resources/localitattention.png differ
diff --git a/resources/losses (1).png b/resources/losses (1).png
new file mode 100644
index 000000000..230a52120
Binary files /dev/null and b/resources/losses (1).png differ
diff --git a/resources/losses (2).png b/resources/losses (2).png
new file mode 100644
index 000000000..383494bd9
Binary files /dev/null and b/resources/losses (2).png differ
diff --git a/resources/losses (3).png b/resources/losses (3).png
new file mode 100644
index 000000000..258269da0
Binary files /dev/null and b/resources/losses (3).png differ
diff --git a/resources/losses.png b/resources/losses.png
new file mode 100644
index 000000000..21a724062
Binary files /dev/null and b/resources/losses.png differ
diff --git a/resources/transformer_block.png b/resources/transformer_block.png
new file mode 100644
index 000000000..4303ada61
Binary files /dev/null and b/resources/transformer_block.png differ
diff --git a/resources/vt.gif b/resources/vt.gif
new file mode 100644
index 000000000..583bb8ad8
Binary files /dev/null and b/resources/vt.gif differ