train_v4.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Copy of Copy of train.ipynb",
      "private_outputs": true,
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/cbalkig/Anomaly_Detection_in_Videos/blob/master/train_v4.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z5l0wNtKs7vP"
      },
      "source": [
        "import os\n",
        "from os import listdir\n",
        "from os.path import join, isdir\n",
        "import numpy as np\n",
        "from PIL import Image\n",
        "import keras\n",
        "from keras.layers import Conv2DTranspose, ConvLSTM2D, TimeDistributed, Conv2D, Flatten, Dense, Dropout, Activation, MaxPooling2D, Activation\n",
        "from keras.models import Sequential, load_model\n",
        "from tensorflow.keras.layers import Conv2D, Conv3D, BatchNormalization\n",
        "from tensorflow.keras.optimizers import Adagrad\n",
        "import matplotlib.pyplot as plt\n",
        "import time\n",
        "from numpy import save, load, asarray\n",
        "from tensorflow.keras.optimizers import Adam\n",
        "from numpy import expand_dims\n",
        "from keras.preprocessing.image import ImageDataGenerator\n",
        "from matplotlib import pyplot\n",
        "from keras.callbacks import ModelCheckpoint, EarlyStopping\n",
        "import uuid"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hDd3-dzSs82m"
      },
      "source": [
        "working_directory = '/content/drive/MyDrive/AnomalyDetectionInVideos'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pKtCPjOYs97U"
      },
      "source": [
        "class Config:\n",
        "    DATASET_PATH = os.path.join(working_directory, \"new_files\")\n",
        "    EDIT_DATASET_PATH = os.path.join(working_directory, \"regenerated_files\")\n",
        "    BATCH_SIZE = 128\n",
        "    EPOCHS = 10\n",
        "    MODEL_PATH = os.path.join(working_directory, \"model.hdf5\")\n",
        "    MODEL_WEIGHTS_PATH = os.path.join(working_directory, \"weights_MLP.h5\")\n",
        "    IMAGE_SIZE = 256"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cqn3JAVY5nzH"
      },
      "source": [
        "def save_image(image_class, img_file_name, img):\n",
        "    img_folder = join(Config.EDIT_DATASET_PATH, image_class)\n",
        "    if not os.path.exists(img_folder):\n",
        "        os.makedirs(img_folder)\n",
        "    img_file = join(img_folder, img_file_name)\n",
        "    img.save(img_file)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bMWl_9eT4os6"
      },
      "source": [
        "def edit_images():\n",
        "    for f in sorted(listdir(Config.DATASET_PATH)):\n",
        "        directory_path = join(Config.DATASET_PATH, f)\n",
        "        if isdir(directory_path):\n",
        "            class_name = f\n",
        "            for v in sorted(listdir(directory_path)):\n",
        "              sub_directory_path = join(directory_path, v)\n",
        "              print(\"Processing\", sub_directory_path)\n",
        "              for c in sorted(listdir(sub_directory_path)):\n",
        "                  img_path = join(sub_directory_path, c)\n",
        "                  if str(img_path)[-3:] == \"tif\":\n",
        "                      try:\n",
        "                          img = Image.open(img_path)\n",
        "                          img = img.resize((Config.IMAGE_SIZE, Config.IMAGE_SIZE))\n",
        "                          new_file_name = str(uuid.uuid4()) + \".tif\"\n",
        "                          save_image(class_name, new_file_name, img)\n",
        "                      except:\n",
        "                          print(\"Problem on file\", img_path)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v7D0RpUQ-6XX"
      },
      "source": [
        "#edit_images()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OupvfKWU7xLe"
      },
      "source": [
        "print(\"Sample Count\", sum(len(files) for _, _, files in os.walk(Config.EDIT_DATASET_PATH)))\n",
        "train_datagen = ImageDataGenerator(\n",
        "        rescale=1./255,\n",
        "        shear_range=0.2,\n",
        "        rotation_range=30, \n",
        "        fill_mode='nearest',\n",
        "        brightness_range=[0.4,1.5])\n",
        "train_generator = train_datagen.flow_from_directory(\n",
        "        Config.EDIT_DATASET_PATH,\n",
        "        target_size=(Config.IMAGE_SIZE, Config.IMAGE_SIZE),\n",
        "        batch_size=Config.BATCH_SIZE,\n",
        "        shuffle=True,\n",
        "        color_mode = 'grayscale',\n",
        "        class_mode='binary')\n",
        "print(\"Sample Count after ImageDataGenerator\", train_generator.samples)\n",
        "\n",
        "def show_batch(image_batch, label_batch):\n",
        "    plt.figure(figsize=(10,10))\n",
        "    for n in range(10):\n",
        "        ax = plt.subplot(5,5,n+1)\n",
        "        plt.imshow(image_batch[n, :, :, 0], cmap='gray')\n",
        "        plt.axis('off')\n",
        "image_batch, label_batch = next(train_generator)\n",
        "show_batch(image_batch, label_batch)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rxkazTWsRyIb"
      },
      "source": [
        "def plot_acc_loss(trained):\n",
        "    fig, ax = plt.subplots(1, 2, figsize=(15,5))\n",
        "    ax[0].set_title('loss')\n",
        "    ax[0].plot(trained.epoch, trained.history[\"loss\"], label=\"Train loss\")\n",
        "    ax[1].set_title('acc')\n",
        "    ax[1].plot(trained.epoch, trained.history[\"accuracy\"], label=\"Train acc\")\n",
        "    ax[0].legend()\n",
        "    ax[1].legend()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zxThkfDO3jDe"
      },
      "source": [
        "def train_model(reload_model=True):\n",
        "    if reload_model:\n",
        "        return load_model(Config.MODEL_PATH)\n",
        "    input_shape = (Config.IMAGE_SIZE, Config.IMAGE_SIZE, 1)\n",
        "\n",
        "    model = Sequential()\n",
        "\n",
        "    #model.add(Conv2D(32, kernel_size=3, activation=\"relu\", input_shape=input_shape))\n",
        "    #model.add(MaxPooling2D(pool_size=(2, 2)))\n",
        "    #model.add(Conv2D(32, kernel_size=3, activation=\"relu\", input_shape=input_shape))\n",
        "    #model.add(MaxPooling2D(pool_size=(2, 2)))\n",
        "    #model.add(Conv2D(64, kernel_size=3, activation=\"relu\", input_shape=input_shape))\n",
        "    #model.add(MaxPooling2D(pool_size=(2, 2)))\n",
        "\n",
        "    #model.add(Flatten())\n",
        "    #model.add(Dense(64, activation=\"relu\"))\n",
        "    #model.add(Dropout(0.5))\n",
        "    #model.add(Dense(num_classes, activation=\"softmax\"))\n",
        "\n",
        "    model.add(Conv2D(32, kernel_size=3, activation=\"relu\", input_shape=input_shape))\n",
        "    model.add(MaxPooling2D(pool_size=(2, 2)))\n",
        "    model.add(Conv2D(32, kernel_size=3, activation=\"relu\", input_shape=input_shape))\n",
        "    model.add(MaxPooling2D(pool_size=(2, 2)))\n",
        "    model.add(Conv2D(64, kernel_size=3, activation=\"relu\", input_shape=input_shape))\n",
        "    model.add(MaxPooling2D(pool_size=(2, 2)))\n",
        "\n",
        "    model.add(Flatten())\n",
        "    model.add(Dense(64, activation=\"relu\"))\n",
        "    model.add(Dropout(0.5))\n",
        "    model.add(Dense(1, activation=\"sigmoid\"))\n",
        "\n",
        "    model.summary()\n",
        "\n",
        "    model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])\n",
        "    history = model.fit(train_generator, epochs=Config.EPOCHS, verbose = 1)\n",
        "    plot_acc_loss(history)\n",
        "    return model"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Fe_09tfotJjQ"
      },
      "source": [
        "model = train_model(reload_model=False)\n",
        "print(\"Model is ready.\")\n",
        "model.save_weights(Config.MODEL_WEIGHTS_PATH)\n",
        "model.save(Config.MODEL_PATH)\n",
        "print(\"Model saved : \", Config.MODEL_PATH)"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}