Train_transform2_Colab.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "id": "013fdc7e",
      "metadata": {
        "id": "013fdc7e"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import tensorflow as tf\n",
        "import matplotlib.pyplot as plt\n",
        "from PIL import Image\n",
        "import cv2\n",
        "import os\n",
        "import sys\n",
        "from math import floor, ceil\n",
        "from tensorflow import convert_to_tensor, Tensor, constant\n",
        "import tensorflow as tf\n",
        "import PIL\n",
        "import PIL.ImageOps\n",
        "from matplotlib import cm\n",
        "from skimage.transform import hough_line, hough_line_peaks\n",
        "import numpy as np"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HZHyloPRAcrG",
        "outputId": "a2d3815c-cccb-4916-93b2-8a8db8ba748c"
      },
      "id": "HZHyloPRAcrG",
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "id": "adb7290d",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "adb7290d",
        "outputId": "c83b3a59-b47a-4edd-c3b9-5b7cf60f0243"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ],
      "source": [
        "os.path.isdir('/content/drive/MyDrive/Dataset_sketch/dataset')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "id": "5509340d",
      "metadata": {
        "id": "5509340d"
      },
      "outputs": [],
      "source": [
        "imgpaths = {}\n",
        "pth = '/content/drive/MyDrive/Dataset_sketch/dataset/png'\n",
        "for d in os.listdir(pth):\n",
        "    if not os.path.isdir(pth + '/' + d):\n",
        "        continue\n",
        "    for img in os.listdir(pth + '/' +d):\n",
        "        path = '/content/drive/MyDrive/Dataset_sketch/dataset/png/'+d\n",
        "        if d not in imgpaths:\n",
        "            imgpaths[d] = []\n",
        "        imgpaths[d].append(path + '/' + img)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "id": "618990a7",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "618990a7",
        "outputId": "af152a8b-118c-43d6-f159-caac3a7107e1"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['arm',\n",
              " 'backpack',\n",
              " 'airplane',\n",
              " 'angel',\n",
              " 'alarm clock',\n",
              " 'axe',\n",
              " 'ashtray',\n",
              " 'armchair',\n",
              " 'apple',\n",
              " 'ant']"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ],
      "source": [
        "list(imgpaths.keys())[:10]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "id": "15721da8",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "15721da8",
        "outputId": "9aa43d24-3d6d-440e-f003-eaab992a6937"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['/content/drive/MyDrive/Dataset_sketch/dataset/png/airplane/4.png',\n",
              " '/content/drive/MyDrive/Dataset_sketch/dataset/png/airplane/16.png',\n",
              " '/content/drive/MyDrive/Dataset_sketch/dataset/png/airplane/21.png',\n",
              " '/content/drive/MyDrive/Dataset_sketch/dataset/png/airplane/22.png',\n",
              " '/content/drive/MyDrive/Dataset_sketch/dataset/png/airplane/46.png',\n",
              " '/content/drive/MyDrive/Dataset_sketch/dataset/png/airplane/27.png',\n",
              " '/content/drive/MyDrive/Dataset_sketch/dataset/png/airplane/37.png',\n",
              " '/content/drive/MyDrive/Dataset_sketch/dataset/png/airplane/44.png',\n",
              " '/content/drive/MyDrive/Dataset_sketch/dataset/png/airplane/43.png',\n",
              " '/content/drive/MyDrive/Dataset_sketch/dataset/png/airplane/40.png']"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ],
      "source": [
        "imgpaths['airplane'][:10]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "id": "1ec2ce37",
      "metadata": {
        "id": "1ec2ce37"
      },
      "outputs": [],
      "source": [
        "class DataGenerator(tf.keras.utils.Sequence):\n",
        "    def __init__(self, db_dir, batch_size, input_shape, num_classes=None, \n",
        "                 shuffle=True, dir_classes=False, grayscale=True):\n",
        "\n",
        "        self.current_counter = 0\n",
        "        self.label_dict = {}\n",
        "\n",
        "        self.input_shape = input_shape\n",
        "        self.batch_size = batch_size\n",
        "        self.num_classes = num_classes\n",
        "        self.shuffle = shuffle\n",
        "        \n",
        "        # load the data from the root directory\n",
        "        self.data, self.labels = self.get_data(db_dir)\n",
        "        self.indices = np.arange(len(self.data))\n",
        "        self.on_epoch_end()\n",
        "        self.grayscale = grayscale\n",
        "\n",
        "\n",
        "    def get_data(self, root_dir):\n",
        "        \"\"\"\"\n",
        "        Loads the paths to the images and their corresponding labels from the database directory\n",
        "        \"\"\"\n",
        "        self.data = []\n",
        "        self.labels = []\n",
        "\n",
        "        labels_list = dict() # used to initialize label ids, for one-hot repr.\n",
        "        \n",
        "        imgpaths = {}\n",
        "        path = root_dir\n",
        "        pth = path\n",
        "        \n",
        "        labels_list_id = 0\n",
        "        for d in os.listdir(pth)[:9]: # remove this\n",
        "            \n",
        "            # initialize ids for one-hot vector\n",
        "            labels_list[d] = labels_list_id\n",
        "            labels_list_id += 1\n",
        "            #\n",
        "            \n",
        "            if not os.path.isdir(pth + '/' + d):\n",
        "                continue\n",
        "            for img in os.listdir(pth + '/' + d):\n",
        "                path = '/content/drive/MyDrive/Dataset_sketch/dataset/png/'+ d\n",
        "                if d not in imgpaths:\n",
        "                    imgpaths[d] = []\n",
        "                imgpaths[d].append(path + '/' + img)\n",
        "                \n",
        "        for i in imgpaths.keys():\n",
        "            for j in imgpaths[i]:\n",
        "                self.data.append(j)\n",
        "                self.labels.append(tf.one_hot(labels_list[i], depth=len(os.listdir(pth)[:9])))\n",
        "\n",
        "        return self.data, self.labels\n",
        "\n",
        "    def __len__(self):\n",
        "        \"\"\"\n",
        "        Returns the number of batches per epoch: the total size of the dataset divided by the batch size\n",
        "        \"\"\"\n",
        "        return int(np.floor(len(self.data) / self.batch_size))\n",
        "        # TODO your code  here (size of dataset divided by the batch size)\n",
        "        return 0\n",
        "    \n",
        "    def vec_to_tensor(self, v):\n",
        "      return constant(v)\n",
        "    \n",
        "    \"\"\"\n",
        "        Preprocesses before outputting to .fit()\n",
        "        This can mean: reshape, channel count check, mean subtraction and std. dev division.\n",
        "    \"\"\"\n",
        "    def batch_to_train(self, batch_x, batch_y):\n",
        "        x_train = [self.vec_to_tensor(x) for x in batch_x]\n",
        "        y_train = [self.vec_to_tensor(x) for x in batch_y]\n",
        "\n",
        "        #print(self.input_shape)\n",
        "        x_train = [cv2.resize(np.array(i), (self.input_shape[0], self.input_shape[1])) for i in x_train]\n",
        "        x_train2 = []\n",
        "        y_train2 = []\n",
        "\n",
        "        for i in range(len(x_train)):\n",
        "          if (x_train[i].shape[0] == self.input_shape[0] and x_train[i].shape[1] == self.input_shape[1]):\n",
        "            x_train2.append(x_train[i])\n",
        "            y_train2.append([y_train[i].numpy(), 0 if y_train[i].numpy() == 1 else 1])\n",
        "\n",
        "        y_test = y_train2[:floor(1/5 * self.batch_size)]\n",
        "        x_test = x_train2[:floor(1/5 * self.batch_size)]\n",
        "\n",
        "        x_train = x_train2[ceil(1/5 * self.batch_size + 1):]\n",
        "        y_train = y_train2[ceil(1/5 * self.batch_size + 1):]\n",
        "\n",
        "        \n",
        "        \n",
        "        x_train = np.array(x_train)\n",
        "        y_train = np.array(y_train)\n",
        "\n",
        "        \n",
        "        x_test = np.array(x_test)\n",
        "        y_test = np.array(y_test)\n",
        "        \n",
        "        print(x_train.shape)\n",
        "        \n",
        "        return x_train, y_train\n",
        "\n",
        "    def __getitem__(self, index):\n",
        "        \"\"\"\"\n",
        "        Generates a batch of data\n",
        "        Note: computation intensivity\n",
        "        \"\"\"\n",
        "\n",
        "        batch_indices = self.indices[index*self.batch_size : (index+1)*self.batch_size]\n",
        "        \n",
        "        batch_x = [] # TODO load the image(s) from batch_indices\n",
        "        batch_y = [] # TODO load the corresponding labels of the images you loaded\n",
        "\n",
        "        for i in batch_indices:\n",
        "          ci = self.data[i]\n",
        "          cl = self.labels[i]\n",
        "            \n",
        "          cd = Image.open(ci) #.convert('L')\n",
        "          inverted_image = PIL.ImageOps.invert(cd)\n",
        "          cd = np.array(inverted_image)\n",
        "\n",
        "          if self.grayscale:\n",
        "            cd = cv2.resize(cd, (self.input_shape[0], self.input_shape[1]))\n",
        "          else:\n",
        "            cd = cv2.resize(cd, (self.input_shape[0], self.input_shape[1]))\n",
        "            cdc = cd.copy()\n",
        "            cd = np.reshape(cd, (self.input_shape[0], self.input_shape[1], 1))\n",
        "            cd = np.append(cd, cd, axis=2)\n",
        "            cd = np.append(cd, np.reshape(cdc, (self.input_shape[0], self.input_shape[1], 1)), axis=2)\n",
        "            \n",
        "          batch_x.append(cd)\n",
        "          batch_y.append(cl)\n",
        "        \n",
        "        \n",
        "        return np.array(batch_x), batch_y\n",
        "\n",
        "    def on_epoch_end(self):\n",
        "        \"\"\"\"\n",
        "        Called at the end of each epoch\n",
        "        \"\"\"\n",
        "        self.indices = np.arange(len(self.data))\n",
        "        if self.shuffle:\n",
        "            np.random.shuffle(self.indices)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "id": "a90f6b37",
      "metadata": {
        "id": "a90f6b37"
      },
      "outputs": [],
      "source": [
        "class DataVisualizer:\n",
        "    @staticmethod\n",
        "    def plot_batch(vec, count=1):\n",
        "        fig, axes = plt.subplots(nrows=1, ncols=4, figsize=[16, 16], dpi=(200))\n",
        "        for i in range(len(axes)):\n",
        "            axes[i].imshow(vec[i], cmap=plt.get_cmap('gray'), vmin=0, vmax=255., interpolation=\"none\")\n",
        "        plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "id": "c55a58c0",
      "metadata": {
        "id": "c55a58c0"
      },
      "outputs": [],
      "source": [
        "d = DataGenerator(\n",
        "    db_dir='/content/drive/MyDrive/Dataset_sketch/dataset/png',\n",
        "    batch_size=12,\n",
        "    input_shape=(160, 160),\n",
        "    dir_classes=True\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "id": "63d537be",
      "metadata": {
        "id": "63d537be"
      },
      "outputs": [],
      "source": [
        "batch = d[0]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "id": "68123a79",
      "metadata": {
        "id": "68123a79"
      },
      "outputs": [],
      "source": [
        "one_img = batch[0][0]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "id": "0a88bfef",
      "metadata": {
        "scrolled": true,
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 403
        },
        "id": "0a88bfef",
        "outputId": "b2bd4859-d09b-46ac-98ef-125478941e2f"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 3200x3200 with 4 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "DataVisualizer.plot_batch([one_img, one_img, one_img, one_img], count=1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "id": "7ab08680",
      "metadata": {
        "id": "7ab08680"
      },
      "outputs": [],
      "source": [
        "d = DataGenerator(\n",
        "    db_dir='/content/drive/MyDrive/Dataset_sketch/dataset/png',\n",
        "    batch_size=1500,\n",
        "    input_shape=(160, 160),\n",
        "    dir_classes=True\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "id": "3d7b1ad0",
      "metadata": {
        "id": "3d7b1ad0"
      },
      "outputs": [],
      "source": [
        "vx = d[0]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "id": "19725670",
      "metadata": {
        "id": "19725670"
      },
      "outputs": [],
      "source": [
        "tested_angles = np.linspace(-np.pi / 2, np.pi / 2, 360, endpoint=False)\n",
        "def transform_img_vec(X):\n",
        "    newVec = []\n",
        "    for img in X:\n",
        "        h, theta, d = hough_line(img, theta=tested_angles)\n",
        "        newVec.append(h)\n",
        "    newVec = np.array(newVec)\n",
        "    return newVec"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "id": "434dadb1",
      "metadata": {
        "id": "434dadb1"
      },
      "outputs": [],
      "source": [
        "X_train = vx[0]\n",
        "y_train = np.array(vx[1])\n",
        "X_test = X_train[601:]\n",
        "y_test = y_train[601:]\n",
        "X_train = X_train[:600]\n",
        "y_train = y_train[:600]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "id": "2b40c7cc",
      "metadata": {
        "id": "2b40c7cc"
      },
      "outputs": [],
      "source": [
        "X_train = transform_img_vec(X_train)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "id": "fcf493f4",
      "metadata": {
        "id": "fcf493f4"
      },
      "outputs": [],
      "source": [
        "X_test = transform_img_vec(X_test)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "id": "57ec0f23",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "57ec0f23",
        "outputId": "7c4b4bac-044c-4ff5-92ea-2973089a7636"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(600, 454, 360)"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ],
      "source": [
        "X_train.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "id": "7b73320a",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7b73320a",
        "outputId": "45656d44-168e-47a5-d343-4c1fd90f5966"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(454, 360)"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ],
      "source": [
        "X_train[0].shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "id": "0c10e44b",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0c10e44b",
        "outputId": "70ba1ff0-d802-4525-a578-2a8786d9af03"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(454, 360)"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ],
      "source": [
        "X_train[1].shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "id": "f4f5fba4",
      "metadata": {
        "id": "f4f5fba4"
      },
      "outputs": [],
      "source": [
        "vgg16 = tf.keras.applications.vgg16.VGG16(\n",
        "    include_top=True,\n",
        "    input_shape=(454, 360, 1),\n",
        "    classes=9,\n",
        "    weights=None\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 38,
      "id": "c77c953c",
      "metadata": {
        "id": "c77c953c"
      },
      "outputs": [],
      "source": [
        "vgg16.compile(\n",
        "    loss=tf.keras.losses.CategoricalCrossentropy(),\n",
        "    optimizer=tf.keras.optimizers.Adam(learning_rate=0.00001),\n",
        "    metrics=['accuracy', tf.keras.metrics.Precision(), tf.keras.metrics.Recall()]\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "id": "d678733e",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d678733e",
        "outputId": "4639fb76-a86c-4061-e537-b9bda6819dd4"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/8\n",
            "300/300 [==============================] - 172s 526ms/step - loss: 1.6718 - accuracy: 0.3867\n",
            "Epoch 2/8\n",
            "300/300 [==============================] - 158s 527ms/step - loss: 0.9111 - accuracy: 0.6933\n",
            "Epoch 3/8\n",
            "300/300 [==============================] - 158s 526ms/step - loss: 0.6843 - accuracy: 0.7583\n",
            "Epoch 4/8\n",
            "300/300 [==============================] - 158s 526ms/step - loss: 0.4689 - accuracy: 0.8467\n",
            "Epoch 5/8\n",
            "300/300 [==============================] - 158s 526ms/step - loss: 0.3200 - accuracy: 0.8967\n",
            "Epoch 6/8\n",
            "300/300 [==============================] - 158s 526ms/step - loss: 0.2055 - accuracy: 0.9383\n",
            "Epoch 7/8\n",
            "300/300 [==============================] - 158s 525ms/step - loss: 0.2347 - accuracy: 0.9283\n",
            "Epoch 8/8\n",
            "300/300 [==============================] - 158s 525ms/step - loss: 0.1121 - accuracy: 0.9700\n"
          ]
        }
      ],
      "source": [
        "history = vgg16.fit(\n",
        "    X_train,\n",
        "    y_train,\n",
        "    batch_size=2,\n",
        "    epochs=8,\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot(history.history['accuracy'])\n",
        "plt.title('model accuracy')\n",
        "plt.ylabel('accuracy')\n",
        "plt.xlabel('epoch')\n",
        "plt.legend(['train', 'val'], loc='upper left')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "_IBeLp6gKxeH",
        "outputId": "329e1df2-a68e-4673-9ec6-bf53df4f7305"
      },
      "id": "_IBeLp6gKxeH",
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "history"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9H5N7oobL-8G",
        "outputId": "71a57380-819d-4821-c055-0cfe8f951e6b"
      },
      "id": "9H5N7oobL-8G",
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.callbacks.History at 0x7fc288e31990>"
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "eval = vgg16.evaluate(X_test, y_test)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "utLasb9fLjom",
        "outputId": "84d558cd-b6e2-404b-a1d8-ec8b3c2c41b0"
      },
      "id": "utLasb9fLjom",
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2/2 [==============================] - 2s 410ms/step - loss: 0.8547 - accuracy: 0.7949 - precision_1: 0.7949 - recall: 0.7949\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "eval"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "59i_lPEcMAe1",
        "outputId": "be12a8bf-f2f0-4345-abf7-11ef53d69c6a"
      },
      "id": "59i_lPEcMAe1",
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0.8547302484512329,\n",
              " 0.7948718070983887,\n",
              " 0.7948718070983887,\n",
              " 0.7948718070983887]"
            ]
          },
          "metadata": {},
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "vgg16.save_weights('/content/drive/MyDrive/Dataset_sketch/weights')"
      ],
      "metadata": {
        "id": "gmG8SBFbDJG5"
      },
      "id": "gmG8SBFbDJG5",
      "execution_count": 25,
      "outputs": []
    }
  ],
  "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.6"
    },
    "colab": {
      "name": "Train_transform2.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "accelerator": "GPU"
  },
  "nbformat": 4,
  "nbformat_minor": 5
}