tensorflow-model.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "6e3def01",
   "metadata": {},
   "source": [
    "## Implementation using TensorFlow"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6dcdf024",
   "metadata": {},
   "source": [
    "Previously having implemented this using FastAI, although not the best is still functional, I have decided to use TensorFlow to implement this again, to allow me to be more flexible and learn more about this framework. After a lot of learning I am now at a point in understanding where creating this model shouldnt be too difficult. This project will be split into 4 parts:\n",
    "* Loading and preparing the data\n",
    "* Creation and compilation of the model\n",
    "* Training the model\n",
    "* Creating the agent (this time not in the notebook!)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a32e93b",
   "metadata": {},
   "source": [
    "### Library imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "449d2a45",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "from tensorflow.keras import layers, models\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import os, warnings\n",
    "from PIL import Image\n",
    "\n",
    "import os\n",
    "import sys\n",
    "import math\n",
    "\n",
    "from pathlib import Path\n",
    "\n",
    "# matplotlib defaults\n",
    "plt.rc('figure', autolayout=True)\n",
    "plt.rc('axes', labelweight='bold', labelsize='large',\n",
    "       titleweight='bold', titlesize=18, titlepad=10)\n",
    "plt.rc('image', cmap='magma')\n",
    "warnings.filterwarnings(\"ignore\") # to clean up output cells"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92289efc",
   "metadata": {},
   "source": [
    "### Part 1 - Loading the Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e4702e1a",
   "metadata": {},
   "outputs": [],
   "source": [
    "tf.random.set_seed(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "725f78dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_frames(frames_path):\n",
    "    files = os.listdir(frames_path)\n",
    "    print(\"Number of files in the path is : \", len(files))\n",
    "\n",
    "    frame_list = []\n",
    "    for i in range(len(files)):\n",
    "        frame_name = 'frame-'+str(i)+\".jpg\"\n",
    "        file = os.path.join(frames_path, frame_name)\n",
    "        frame_list.append(file)\n",
    "        # print(file)\n",
    "        # print(os.path.exists(file))\n",
    "        # cnt +=1\n",
    "        # if cnt>=10:\n",
    "        #   break\n",
    "    return frame_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f8af39c7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Coordinates of first dataset\n",
      "       x      y\n",
      "0  46.40  13.90\n",
      "1  46.55  13.35\n",
      "2  46.40  13.20\n",
      "3  46.40  13.20\n",
      "4  46.55  13.30\n"
     ]
    }
   ],
   "source": [
    "coordinates = pd.read_csv(\"C:/Users/Joshua/Desktop/Projects/Python/osu-ai/osu-ai/data/coordinates.csv\")\n",
    "print(\"Coordinates of first dataset\")\n",
    "print(coordinates.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "6fefdd3f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_coordinates_with_frame_name(coordinates, frames_path):\n",
    "    frame_list = get_frames(frames_path)\n",
    "    assert (len(frame_list) == len(coordinates)), \"Number of frames and co-ordinates must be equal\"\n",
    "    coordinates.insert(0, 'frame', frame_list )\n",
    "    return coordinates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "692f7b09",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of files in the path is :  7770\n",
      "                                               frame      x      y\n",
      "0  C:/Users/Joshua/Desktop/Projects/Python/osu-ai...  46.40  13.90\n",
      "1  C:/Users/Joshua/Desktop/Projects/Python/osu-ai...  46.55  13.35\n",
      "2  C:/Users/Joshua/Desktop/Projects/Python/osu-ai...  46.40  13.20\n",
      "3  C:/Users/Joshua/Desktop/Projects/Python/osu-ai...  46.40  13.20\n",
      "4  C:/Users/Joshua/Desktop/Projects/Python/osu-ai...  46.55  13.30\n"
     ]
    }
   ],
   "source": [
    "coordinates = get_coordinates_with_frame_name(coordinates, \"C:/Users/Joshua/Desktop/Projects/Python/osu-ai/osu-ai/data/frames\")\n",
    "print(coordinates.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "904d79ad",
   "metadata": {},
   "source": [
    "### Part 2 - Processing the Data (Dataloaders)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "1e9257d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "from skimage.io import imread\n",
    "from skimage.transform import resize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "c944c709",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here, `x_set` is list of path to the images\n",
    "# and `y_set` are the associated classes.\n",
    "\n",
    "class TrainDataSequence(tf.keras.utils.Sequence):\n",
    "\n",
    "    def __init__(self, df, batch_size):\n",
    "        self.batch_size = batch_size\n",
    "        self.df = df\n",
    "\n",
    "    def __len__(self):\n",
    "        return math.ceil(len(self.df) / self.batch_size)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        batch_x = self.df['frame'][idx * self.batch_size:(idx + 1) *\n",
    "        self.batch_size]\n",
    "        batch_y1 = self.df['x'][idx * self.batch_size:(idx + 1) *\n",
    "        self.batch_size]\n",
    "        batch_y2 = self.df[' y'][idx * self.batch_size:(idx + 1) *\n",
    "        self.batch_size]\n",
    "\n",
    "        frames = []\n",
    "        positions = []\n",
    "        for frame, x, y in zip(batch_x, batch_y1,batch_y2):\n",
    "            frame_img = resize(imread(frame), (60,80,1))\n",
    "            frames.append(frame_img)\n",
    "            positions.append([x,y])\n",
    "\n",
    "        return np.array(frames), np.array(positions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "8d3e53e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here, `x_set` is list of path to the images\n",
    "# and `y_set` are the associated classes.\n",
    "\n",
    "class TestDataSequence(tf.keras.utils.Sequence):\n",
    "\n",
    "    def __init__(self, df, batch_size):\n",
    "        self.batch_size = batch_size\n",
    "        self.df = df\n",
    "\n",
    "    def __len__(self):\n",
    "        return math.ceil(len(self.df) / self.batch_size)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        batch_x = self.df['frame'][idx * self.batch_size:(idx + 1) *\n",
    "        self.batch_size]\n",
    "        batch_y1 = self.df['x'][idx * self.batch_size:(idx + 1) *\n",
    "        self.batch_size]\n",
    "        batch_y2 = self.df[' y'][idx * self.batch_size:(idx + 1) *\n",
    "        self.batch_size]\n",
    "\n",
    "        frames = []\n",
    "        positions = []\n",
    "        for frame, x, y in zip(batch_x, batch_y1,batch_y2):\n",
    "            frame_img = resize(imread(frame), (60,80,1))\n",
    "            frames.append(frame_img)\n",
    "            positions.append([x,y])\n",
    "\n",
    "        return np.array(frames), np.array(positions)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4bf59aae",
   "metadata": {},
   "source": [
    "### Part 3 - Creation and compilation of Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "6adecee4",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras import regularizers\n",
    "from tensorflow.keras.utils import plot_model\n",
    "from IPython.display import Image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "28b801f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = models.Sequential()\n",
    "model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(60, 80,1),))\n",
    "# model.add(layers.Conv2D(64, (3, 3), activation='relu'))\n",
    "model.add(layers.MaxPooling2D((2, 2)))\n",
    "model.add(layers.Conv2D(64, (3, 3), activation='relu'))\n",
    "# model.add(layers.Conv2D(32, (3, 3), activation='relu'))\n",
    "model.add(layers.MaxPooling2D((2, 2)))\n",
    "model.add(layers.Conv2D(32, (3, 3), activation='relu'))\n",
    "model.add(layers.Flatten())\n",
    "model.add(layers.Dense(64, activation='relu'))\n",
    "model.add(layers.Dense(32, activation='relu'))\n",
    "model.add(layers.Dropout(0.2))\n",
    "model.add(layers.Dense(2, activation='linear'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "e9d996af",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] compiling model...\n"
     ]
    }
   ],
   "source": [
    "print(\"[INFO] compiling model...\")\n",
    "model.compile(loss=tf.keras.losses.MeanAbsoluteError(), optimizer=tf.keras.optimizers.Adam(learning_rate=0.001))\n",
    "# metrics=tf.keras.metrics.mean_absolute_error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "133bbd58",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_2\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " conv2d_6 (Conv2D)           (None, 58, 78, 32)        320       \n",
      "                                                                 \n",
      " max_pooling2d_4 (MaxPooling  (None, 29, 39, 32)       0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " conv2d_7 (Conv2D)           (None, 27, 37, 64)        18496     \n",
      "                                                                 \n",
      " max_pooling2d_5 (MaxPooling  (None, 13, 18, 64)       0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " conv2d_8 (Conv2D)           (None, 11, 16, 32)        18464     \n",
      "                                                                 \n",
      " flatten_2 (Flatten)         (None, 5632)              0         \n",
      "                                                                 \n",
      " dense_6 (Dense)             (None, 64)                360512    \n",
      "                                                                 \n",
      " dense_7 (Dense)             (None, 32)                2080      \n",
      "                                                                 \n",
      " dropout_2 (Dropout)         (None, 32)                0         \n",
      "                                                                 \n",
      " dense_8 (Dense)             (None, 2)                 66        \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 399,938\n",
      "Trainable params: 399,938\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95f8fa42",
   "metadata": {},
   "source": [
    "### Part 4 - Training the Model"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "b0d6fdc4",
   "metadata": {},
   "source": [
    "Depending on how many images you are using, change the split below for train and test data below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "d05c80e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_sequence =  TrainDataSequence(coordinates[:5000],batch_size = 32)\n",
    "# print(*train_sequence)\n",
    "test_sequence =  TestDataSequence(coordinates[5000:],batch_size = 32)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e75948e9",
   "metadata": {},
   "source": [
    "Create a callback function for the model to stop overfitting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5ca95e37",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "157/157 [==============================] - 16s 101ms/step - loss: 7.3447 - val_loss: 6.8406\n",
      "Epoch 2/10\n",
      "157/157 [==============================] - 15s 95ms/step - loss: 7.4085 - val_loss: 6.8389\n",
      "Epoch 3/10\n",
      "157/157 [==============================] - 14s 91ms/step - loss: 7.4197 - val_loss: 6.8432\n",
      "Epoch 4/10\n",
      "157/157 [==============================] - 14s 90ms/step - loss: 7.4475 - val_loss: 6.8405\n",
      "Epoch 5/10\n",
      "157/157 [==============================] - 14s 88ms/step - loss: 7.4224 - val_loss: 6.8366\n",
      "Epoch 6/10\n",
      "157/157 [==============================] - ETA: 0s - loss: 7.4543"
     ]
    }
   ],
   "source": [
    "history = model.fit(train_sequence, validation_data = test_sequence, epochs = 10, verbose=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "2324a7a1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x197eafef580>"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# epoch vs loss graph\n",
    "plt.title('Loss')\n",
    "plt.plot(history.history['loss'], label='train')\n",
    "plt.plot(history.history['val_loss'], label='test')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "a80e9f37",
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_prediction(img_path):\n",
    "    img = resize(imread(img_path), (60,80,1))\n",
    "    img = np.expand_dims(img, axis=0)\n",
    "    pred = model.predict(img)\n",
    "    print(pred)\n",
    "\n",
    "    return pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dbd05159",
   "metadata": {},
   "outputs": [],
   "source": [
    "img_path = \"\"\n",
    "pred = make_prediction(img_path)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}