sd2_d02_cnn.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Import Modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from tensorflow import keras\n",
    "from tensorflow.keras import layers\n",
    "\n",
    "from PIL import Image\n",
    "\n",
    "tf.get_logger().setLevel('INFO')\n",
    "\n",
    "data_dir = './data/data'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Download Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This cell is so someone can more easily acquire the dataset used\n",
    "# Not necessary if done manually\n",
    "\n",
    "import gdown\n",
    "url = \"https://drive.google.com/uc?id=117GBW1IkBOiKTqBnTJxE8E_Bh3J6Ha3g\"\n",
    "output = \"data.7z\"\n",
    "gdown.download(url, output, quiet=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Unpack Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyunpack import Archive\n",
    "import os \n",
    "directory = './data'\n",
    "\n",
    "try:\n",
    "    os.mkdir(directory)\n",
    "except Exception:\n",
    "    pass\n",
    "\n",
    "Archive('data.7z').extractall('./data/')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Create Dataset Objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# Generates a tf.data.Dataset from image files in a directory.\n",
    "# subsets are keywords, see api\n",
    "# 80% of the images for training, and 20% for validation\n",
    "# https://keras.io/api/preprocessing/image/\n",
    "\n",
    "img_height = 160\n",
    "img_width = 120\n",
    "img_channels = 1\n",
    "\n",
    "train_ds = tf.keras.preprocessing.image_dataset_from_directory(data_dir,\n",
    "                                                    subset=\"training\",\n",
    "                                                    validation_split=0.21,\n",
    "                                                    seed=np.random.randint(255),\n",
    "                                                    image_size=(img_height,img_width),\n",
    "                                                    color_mode='grayscale', \n",
    "                                                    batch_size=16) \n",
    "\n",
    "val_ds = tf.keras.preprocessing.image_dataset_from_directory(data_dir,\n",
    "                                                    subset=\"validation\",\n",
    "                                                    validation_split=0.21,\n",
    "                                                    seed=np.random.randint(255),\n",
    "                                                    image_size=(img_height,img_width),\n",
    "                                                    color_mode='grayscale',\n",
    "                                                    batch_size=16)\n",
    "\n",
    "\n",
    "\n",
    "# print class names\n",
    "class_names = train_ds.class_names\n",
    "print(class_names)\n",
    "\n",
    "# give examples of images from dataset\n",
    "plt.figure(figsize=(10, 10))\n",
    "for images, labels in train_ds.take(1):\n",
    "  for i in range(6):\n",
    "    ax = plt.subplot(3, 3, i + 1)\n",
    "    plt.imshow(images[i].numpy().astype(\"uint8\"))\n",
    "    plt.title(class_names[labels[i]])\n",
    "    plt.axis(\"off\")\n",
    "    \n",
    "# Speed up by prefectching and caching during model creation\n",
    "AUTOTUNE = tf.data.experimental.AUTOTUNE\n",
    "train_ds = train_ds.cache().prefetch(buffer_size=AUTOTUNE)\n",
    "val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Create Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "num_classes = 2\n",
    "\n",
    "model = tf.keras.Sequential([\n",
    "  layers.experimental.preprocessing.Rescaling(1./255, input_shape=(img_height, img_width, img_channels)),\n",
    "  layers.Dense(num_classes * 32, activation='relu'),\n",
    "  layers.Conv2D(num_classes * 16, 3, strides=2, activation='relu'),\n",
    "  layers.Dense(num_classes * 16, activation='relu'),\n",
    "  layers.Dropout(0.5),\n",
    "  layers.MaxPooling2D(),\n",
    "  layers.Conv2D(num_classes * 8, 3, strides=2),\n",
    "  layers.Dense(num_classes * 8, activation='relu'),\n",
    "  layers.MaxPooling2D(),\n",
    "  layers.Flatten(),\n",
    "  layers.Dense(num_classes * 4, activation='relu'),\n",
    "  layers.Dense(num_classes, activation='relu')\n",
    "])\n",
    "\n",
    "learning_rate=0.001\n",
    "opt = keras.optimizers.Adam(learning_rate=learning_rate)\n",
    "\n",
    "model.compile(\n",
    "  optimizer=opt,\n",
    "  loss=tf.losses.SparseCategoricalCrossentropy(from_logits=True),\n",
    "  metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "epochs = 20\n",
    "history = model.fit(\n",
    "  train_ds,\n",
    "  validation_data=val_ds,\n",
    "  epochs=epochs,\n",
    "  verbose=1\n",
    ")\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "acc = history.history['accuracy']\n",
    "val_acc = history.history['val_accuracy']\n",
    "\n",
    "loss=history.history['loss']\n",
    "val_loss=history.history['val_loss']\n",
    "\n",
    "epochs_range = range(epochs)\n",
    "\n",
    "plt.figure(figsize=(30, 30))\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.grid(b=True, which='both', axis='both')\n",
    "plt.xlabel('Epochs', fontsize='xx-large')\n",
    "plt.ylabel('Accuracy(%)', fontsize='xx-large')\n",
    "plt.plot(epochs_range, acc, label='Training Accuracy', linewidth=10)\n",
    "plt.plot(epochs_range, val_acc, label='Validation Accuracy', linewidth=10)\n",
    "plt.legend(loc='lower right', fontsize='xx-large')\n",
    "\n",
    "plt.title('Training and Validation Accuracy', fontsize='xx-large')\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.plot(epochs_range, loss, label='Training Loss', linewidth=10)\n",
    "plt.grid(b=True, which='both', axis='both')\n",
    "plt.xlabel('Epochs', fontsize='xx-large')\n",
    "plt.ylabel('Accuracy(%)', fontsize='xx-large')\n",
    "\n",
    "plt.plot(epochs_range, val_loss, label='Validation Loss', linewidth=10)\n",
    "plt.legend(loc='upper right', fontsize='xx-large')\n",
    "plt.title('Training and Validation Loss',fontsize='xx-large')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load model in lieu of training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow import keras\n",
    "\n",
    "model = keras.models.load_model('./1/')\n",
    "\n",
    "img_height = 160\n",
    "img_width = 120\n",
    "img_channels = 1\n",
    "\n",
    "class_names=['fire_smoke', 'no-fire']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.image as mpimg\n",
    "from tensorflow.keras.preprocessing import image\n",
    "filename = './no-fire-test.jpg'\n",
    "\n",
    "np_image = image.load_img(filename, color_mode='grayscale', target_size= (img_height, img_width, img_channels), interpolation='lanczos')\n",
    "input_arr = image.img_to_array(np_image)\n",
    "input_arr = np.array([input_arr])  # Convert single image to a batch.\n",
    "\n",
    "plt.title('Image for Prediction',fontsize='xx-large')\n",
    "plt.tick_params(\n",
    "    axis='both',       # changes apply to the x-axis and y-axis\n",
    "    which='both',      # both major and minor ticks are affected\n",
    "    bottom=False,      # ticks along the bottom edge are off\n",
    "    top=False,         # ticks along the top edge are off\n",
    "    left=False,        # ticks along the left edge are off\n",
    "    right=False,       # ticks along the right edge are off\n",
    "    labelleft=False,   # labels along the left edge are off\n",
    "    labelbottom=False) # labels along the bottom edge are off\n",
    "\n",
    "print(model.predict(input_arr))\n",
    "img = mpimg.imread(filename)\n",
    "imgplot = plt.imshow(img)\n",
    "class_names[np.argmax(model.predict(input_arr))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename = './fire.jpg'\n",
    "\n",
    "np_image = image.load_img(filename, color_mode='grayscale', target_size= (img_height, img_width, img_channels), interpolation='lanczos')\n",
    "input_arr = image.img_to_array(np_image)\n",
    "input_arr = np.array([input_arr])  # Convert single image to a batch.\n",
    "\n",
    "plt.title('Image for Prediction',fontsize='xx-large')\n",
    "plt.tick_params(\n",
    "    axis='both',       # changes apply to the x-axis and y-axis\n",
    "    which='both',      # both major and minor ticks are affected\n",
    "    bottom=False,      # ticks along the bottom edge are off\n",
    "    top=False,         # ticks along the top edge are off\n",
    "    left=False,        # ticks along the left edge are off\n",
    "    right=False,       # ticks along the right edge are off\n",
    "    labelleft=False,   # labels along the left edge are off\n",
    "    labelbottom=False) # labels along the bottom edge are off\n",
    "\n",
    "print(model.predict(input_arr))\n",
    "img = mpimg.imread(filename)\n",
    "imgplot = plt.imshow(img)\n",
    "class_names[np.argmax(model.predict(input_arr))]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}