CV2_Images_Training.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9ede9926",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 11/2/2021-1\n",
    "# https://www.tensorflow.org/tutorials/load_data/images\n",
    "from __future__ import absolute_import\n",
    "from IPython.display import clear_output\n",
    "import glob, os, shutil, sys, uuid\n",
    "from os.path import *\n",
    "from time import sleep\n",
    "# import TarfileFunctions\n",
    "from TarfileFunctions import *\n",
    "from BashColors import C\n",
    "# from CV2_Utils import *\n",
    "\n",
    "contentPath = os.getcwd()\n",
    "\n",
    "os.chdir(contentPath)\n",
    "cv2Path = join(contentPath, 'CV2Images')\n",
    "\n",
    "if not exists(cv2Path):\n",
    "    os.mkdir(cv2Path)\n",
    "    tff.extractTarfiles('All_CV2_Images.tar.gz')\n",
    "\n",
    "try:\n",
    "    import tensorflow as tf\n",
    "except Exception as err:\n",
    "    print(err)\n",
    "    %pip install tensorflow\n",
    "    \n",
    "import numpy as np\n",
    "\n",
    "try: \n",
    "    from matplotlib import pyplot as plt\n",
    "except Exception as err:\n",
    "        %pip install matplotlib\n",
    "        from matplotlib import pyplot as plt\n",
    "\n",
    "os.chdir(contentPath)\n",
    "clear_output()\n",
    "import tensorflow as tf\n",
    "print(f'tf version: {C.IBlue}{tf.__version__}{C.ColorOff}')\n",
    "print(f'cwd: {C.IBlue}{os.getcwd()}{C.ColorOff}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fff4b291",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.utils import image_dataset_from_directory\n",
    "if exists(cv2Path):\n",
    "    print(cv2Path)\n",
    "train_ds = image_dataset_from_directory(\n",
    "    cv2Path,\n",
    "    color_mode='rgba',\n",
    "    validation_split=0.2,\n",
    "    subset=\"training\",\n",
    "    seed=456,\n",
    "    image_size=(224, 224),\n",
    "    batch_size=4)\n",
    "print()\n",
    "val_ds = image_dataset_from_directory(\n",
    "    cv2Path,\n",
    "    color_mode='rgba',\n",
    "    validation_split=0.2,\n",
    "    subset=\"validation\",\n",
    "    seed=456,\n",
    "    image_size=(224, 224),\n",
    "    batch_size=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "89d4e842",
   "metadata": {},
   "outputs": [],
   "source": [
    "class_names = train_ds.class_names\n",
    "print(class_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f9ceb2d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# import matplotlib as plt\n",
    "plt.figure(figsize=(10, 10))\n",
    "for images, labels in train_ds.take(2):\n",
    "    for i in range(3):\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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ce5b86aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "for image_batch, labels_batch in train_ds:\n",
    "    print(image_batch.shape)\n",
    "    print(labels_batch.shape)\n",
    "    break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "785b6022",
   "metadata": {},
   "outputs": [],
   "source": [
    "normalization_layer = tf.keras.layers.Rescaling(1./255)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e59df412",
   "metadata": {},
   "outputs": [],
   "source": [
    "normalized_ds = train_ds.map(lambda x, y: (normalization_layer(x), y))\n",
    "image_batch, labels_batch = next(iter(normalized_ds))\n",
    "first_image = image_batch[0]\n",
    "# Notice the pixel values are now in `[0,1]`.\n",
    "print(np.min(first_image),'-', np.max(first_image))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6bd002f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "AUTOTUNE = tf.data.AUTOTUNE\n",
    "\n",
    "train_ds = train_ds.cache().prefetch(buffer_size=AUTOTUNE)\n",
    "val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c72bc790",
   "metadata": {},
   "outputs": [],
   "source": [
    "num_classes = 2\n",
    "\n",
    "model = tf.keras.Sequential([\n",
    "    tf.keras.layers.Rescaling(1./255),\n",
    "    tf.keras.layers.Conv2D(32, 3, activation='relu'),\n",
    "    tf.keras.layers.MaxPooling2D(),\n",
    "    tf.keras.layers.Conv2D(32, 3, activation='relu'),\n",
    "    tf.keras.layers.MaxPooling2D(),\n",
    "    tf.keras.layers.Conv2D(32, 3, activation='relu'),\n",
    "    tf.keras.layers.MaxPooling2D(),\n",
    "    tf.keras.layers.Flatten(),\n",
    "    tf.keras.layers.Dense(128, activation='relu'),\n",
    "    tf.keras.layers.Dense(num_classes)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "51d0034f",
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(\n",
    "  optimizer='adam',\n",
    "  loss=tf.losses.SparseCategoricalCrossentropy(from_logits=True),\n",
    "    metrics=['accuracy'])\n",
    "\n",
    "model.build(image_batch.shape) # only needed to view model summary \n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d4b4ef5",
   "metadata": {},
   "outputs": [],
   "source": [
    "model.fit(\n",
    "  train_ds,\n",
    "  validation_data=val_ds,\n",
    "  epochs=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9667b997",
   "metadata": {},
   "outputs": [],
   "source": [
    "# print(model.summary())\n",
    "history = tf.keras.callbacks.History.history\n",
    "\n",
    "acc = history.history['accuracy']\n",
    "val_acc = history.history['val_accuracy']\n",
    "\n",
    "loss = history.history['loss']\n",
    "# loss = tf.keras.callbacks.History.history['']\n",
    "val_loss = history.history['val_loss']\n",
    "\n",
    "epochs_range = range(epochs)\n",
    "\n",
    "plt.figure(figsize=(8, 8))\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.plot(epochs_range, acc, label='Training Accuracy')\n",
    "plt.plot(epochs_range, val_acc, label='Validation Accuracy')\n",
    "plt.legend(loc='lower right')\n",
    "plt.title('Training and Validation Accuracy')\n",
    "\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.plot(epochs_range, loss, label='Training Loss')\n",
    "plt.plot(epochs_range, val_loss, label='Validation Loss')\n",
    "plt.legend(loc='upper right')\n",
    "plt.title('Training and Validation Loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e907986b",
   "metadata": {},
   "outputs": [],
   "source": [
    "image_batch, label_batch = next(iter(train_ds))\n",
    "\n",
    "plt.figure(figsize=(10, 10))\n",
    "for i in range(3):\n",
    "    ax = plt.subplot(3, 3, i + 1)\n",
    "    plt.imshow(image_batch[i].numpy().astype(\"uint8\"))\n",
    "    label = label_batch[i]\n",
    "    plt.title(class_names[label])\n",
    "    plt.axis(\"off\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fffc21a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "model_path=join(contentPath, 'first_model.h5')\n",
    "model.save(model_path)\n",
    "model.save_weights(model_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8c91ecd",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(model)\n",
    "print(model.count_params())\n",
    "print('model.input_shape: ', model.input_shape)\n",
    "print('run_eagerly: ', model.run_eagerly)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ce59cad3",
   "metadata": {},
   "outputs": [],
   "source": [
    "path=join(contentPath, 'enemy.png')\n",
    "array=np.copy(path)\n",
    "\n",
    "# Load the model\n",
    "model = tf.keras.models.load_model(model_path,compile=True\n",
    "# custom_objects=None,compile=True,options=None)\n",
    "\n",
    "# try a sample\n",
    "samples_to_predict=array\n",
    "\n",
    "# Convert into Numpy array\n",
    "samples_to_predict = np.array(samples_to_predict)\n",
    "\n",
    "# Generate predictions for samples\n",
    "predictions = model.predict(samples_to_predict)\n",
    "print(predictions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71a48ab6",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}