0_SequentialModel.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "0_SequentialModel.ipynb",
      "private_outputs": true,
      "provenance": [],
      "collapsed_sections": [],
      "machine_shape": "hm",
      "include_colab_link": true
    },
    "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.10"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/iypc-team/CoLab/blob/master/0_SequentialModel.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BhDOl--lfmjS"
      },
      "source": [
        "# 06/25/2021-2\n",
        "from __future__ import absolute_import\n",
        "from IPython.display import display, Image\n",
        "import glob, os, shutil, sys, tarfile\n",
        "from os.path import *\n",
        "\n",
        "contentPth = os.getcwd()\n",
        "tensorflowImagesPth = join(contentPth, 'TensorflowImages')\n",
        "\n",
        "try:\n",
        "    from google.colab import drive, files\n",
        "    if exists('/content/sample_data'):\n",
        "        shutil.rmtree('/content/sample_data')\n",
        "    if exists(tensorflowImagesPth):\n",
        "        shutil.rmtree(tensorflowImagesPth)\n",
        "    \n",
        "    drive.mount('/content/gdrive', force_remount=True)\n",
        "    myDrivePth = '/content/gdrive/My Drive'\n",
        "    imagesPth = join('/content/gdrive/My Drive/TensorflowResizedImages')\n",
        "    \n",
        "    os.chdir(myDrivePth)\n",
        "    from BashColors import C\n",
        "    from TarfileFunctions import *\n",
        "    os.chdir(contentPth)\n",
        "    \n",
        "    if not exists(tensorflowImagesPth):\n",
        "        shutil.copytree(imagesPth, tensorflowImagesPth)\n",
        "    else: print(f'{C.Green}{tensorflowImagesPth}{C.ColorOff} exists')\n",
        "        \n",
        "except ModuleNotFoundError as err: \n",
        "    # print(err)\n",
        "    from BashColors import C\n",
        "    from TarfileFunctions import *\n",
        "    if not exists(tensorflowImagesPth):\n",
        "        tar = tarfile.open(\n",
        "            'New_Jovyan_Defcon_Augmented_Images.tar.gz')\n",
        "        tar.extractall()\n",
        "        tar.close()\n",
        "    else: print(f'{C.Green}{tensorflowImagesPth}{C.ColorOff} exists')\n",
        "    \n",
        "try:\n",
        "    import tensorflow as tf\n",
        "    print(f'tensorflow: {C.IBlue}{tf.__version__}{C.ColorOff}')\n",
        "except ModuleNotFoundError:\n",
        "    %pip install tensorflow\n",
        "    import tensorflow as tf\n",
        "    \n",
        "try:\n",
        "    import tensorflow_datasets as tfds\n",
        "except ModuleNotFoundError:\n",
        "    %pip install tensorflow-datasets\n",
        "    import tensorflow_datasets as tfds\n",
        "    \n",
        "try:\n",
        "    import numpy as np\n",
        "    # np.set_printoptions(precision=4)\n",
        "except ModuleNotFoundError:\n",
        "    %pip install numpy\n",
        "    import numpy as np\n",
        "    np.set_printoptions(precision=4)\n",
        "\n",
        "try:\n",
        "    import PIL\n",
        "    import PIL.Image\n",
        "except ModuleNotFoundError:\n",
        "    %pip install pillow\n",
        "    import PIL\n",
        "    import PIL.Image\n",
        "\n",
        "try:\n",
        "    import matplotlib as mpl\n",
        "    import matplotlib.pyplot as plt\n",
        "    mpl.rcParams['figure.figsize'] = (11, 11)\n",
        "    mpl.rcParams['axes.grid'] = False\n",
        "except ModuleNotFoundError:\n",
        "    %pip install matplotlib\n",
        "    import matplotlib as mpl\n",
        "    import matplotlib.pyplot as plt\n",
        "    mpl.rcParams['figure.figsize'] = (11, 11)\n",
        "    mpl.rcParams['axes.grid'] = False\n",
        "\n",
        "try: import pydot\n",
        "except ModuleNotFoundError as err:\n",
        "    %pip install pydot\n",
        "    import pydot\n",
        "    \n",
        "try: import graphviz\n",
        "except Exception as err:\n",
        "    %pip install graphviz\n",
        "    import graphviz\n",
        "    print(f'{C.IRed}{err}{C.ColorOff}')\n",
        "\n",
        "print(f'cwd: {C.IBlue}{os.getcwd()}')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S3580Je-YUvT"
      },
      "source": [
        "# Augment images"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "imagB49ZuJiU"
      },
      "source": [
        "try:\n",
        "    os.chdir(myDrivePth)\n",
        "    # %ls *.gz -l\n",
        "    # tff.listTarfiles()\n",
        "    # tff.inspectTarfile(named='Defcon_Augmented_Images.tar.gz')\n",
        "    tff.extractTarfiles(fileName='Defcon_Augmented_Images.tar.gz')\n",
        "    os.chdir(contentPth)\n",
        "except: pass"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LTWnUtxKlAtX"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vi6eMZWyuKF5"
      },
      "source": [
        "from tensorflow.config.experimental import list_physical_devices\n",
        "from tensorflow.config.experimental import set_memory_growth\n",
        "physicalDevices = list_physical_devices()\n",
        "try:\n",
        "    print(physicalDevices)\n",
        "    set_memory_growth(physicalDevices[1], True)\n",
        "except: pass"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W29k8q-DOjQ0"
      },
      "source": [
        "import tensorflow\n",
        "from tensorflow.keras.utils import plot_model\n",
        "\n",
        "def plotModel(thisModel):\n",
        "    fileName = thisModel.name + '.png'\n",
        "    print(fileName)\n",
        "    plot_model(model=thisModel,\n",
        "               to_file=fileName,\n",
        "               show_shapes=True,\n",
        "               show_dtype=True,\n",
        "               expand_nested=True)\n",
        "    img = Image(filename=fileName)\n",
        "    display(img)\n",
        "print('ok')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bdxh2J2aOjQ3"
      },
      "source": [
        "from tensorflow.keras.preprocessing import image\n",
        "\n",
        "def prepare_image(filePath):\n",
        "    img = image.load_img(path=filePath, target_size=(224, 224))\n",
        "    image_array = image.img_to_array(img)\n",
        "    image_array_expanded_dims = np.expand_dims(image_array, axis=0)\n",
        "    return tf.keras.applications.mobilenet.preprocess_input(\n",
        "        image_array_expanded_dims\n",
        "    )\n",
        "print('ok')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jxycuX5OomKo"
      },
      "source": [
        "from IPython.display import Image\n",
        "def showImage(fromPath):\n",
        "    showImage = Image(filename=fromPath,\n",
        "                 width=96, height=96,\n",
        "                 retina=False)\n",
        "    display(showImage)\n",
        "print('ok')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ej60hzlYBtG-"
      },
      "source": [
        "# from tensorflow.python.framework.ops import disable_eager_execution\n",
        "# disable_eager_execution\n",
        "# tf.config.run_functions_eagerly('True')\n",
        "print('executing_eagerly:', tf.executing_eagerly())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qJdpyqK541ty"
      },
      "source": [
        "batch_size = 8\n",
        "img_height = 224\n",
        "img_width = 224"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "chqakIP14PDm"
      },
      "source": [
        "train_dataset = tf.keras.preprocessing.image_dataset_from_directory(\n",
        "  tensorflowImagesPth,\n",
        "  validation_split=0.2,\n",
        "  subset=\"training\",\n",
        "  seed=123,\n",
        "  image_size=(img_height, img_width),\n",
        "  batch_size=batch_size)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pb2Af2lsUShk"
      },
      "source": [
        "validation_dataset = tf.keras.preprocessing.image_dataset_from_directory(\n",
        "  tensorflowImagesPth,\n",
        "  validation_split=0.2,\n",
        "  subset=\"validation\",\n",
        "  seed=123,\n",
        "  image_size=(img_height, img_width),\n",
        "  batch_size=batch_size)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z-hCtvemWMq5"
      },
      "source": [
        "class_names = train_dataset.class_names\n",
        "print(class_names[0])\n",
        "print(class_names[1])\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1eQwMsOUWMq9"
      },
      "source": [
        "for images, labels in train_dataset.take(1):\n",
        "  for i in range(8):\n",
        "    ax = plt.subplot(3, 3, i + 1)\n",
        "    plt.imshow(images[i].numpy().astype(\"uint8\"))\n",
        "    # title=labels[i].numpy().astype('uint8')\n",
        "    title=labels[i]\n",
        "    # plt.title(label=title)\n",
        "    # plt.title([labels[i]])\n",
        "    plt.axis(\"off\")\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jUI0fr7igPtA"
      },
      "source": [
        "You can train a model using these datasets by passing them to `model.fit` (shown later in this tutorial). If you like, you can also manually iterate over the dataset and retrieve batches of images:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BdPHeHXt9sjA"
      },
      "source": [
        "for image_batch, labels_batch in train_dataset:\n",
        "    print(image_batch.shape)\n",
        "    print(labels_batch.shape)\n",
        "    break"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2ZgIZeXaDUsF"
      },
      "source": [
        "The `image_batch` is a tensor of the shape `(32, 180, 180, 3)`. This is a batch of 32 images of shape `180x180x3` (the last dimension referes to color channels RGB). The `label_batch` is a tensor of the shape `(32,)`, these are corresponding labels to the 32 images. \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LyM2y47W-cxJ"
      },
      "source": [
        "Note: you can call `.numpy()` on either of these tensors to convert them to a `numpy.ndarray`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ybl6a2YCg1rV"
      },
      "source": [
        "### Standardize the data\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IdogGjM2K6OU"
      },
      "source": [
        "The RGB channel values are in the `[0, 255]` range. This is not ideal for a neural network; in general you should seek to make your input values small. Here, we will standardize values to be in the `[0, 1]` by using a Rescaling layer."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "16yNdZXdExyM"
      },
      "source": [
        "from tensorflow.keras import layers\n",
        "from tensorflow.keras.layers.experimental.preprocessing import Rescaling\n",
        "normalization_layer = Rescaling(scale=1./127.5,offset=-1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Nd0_enkb8uxZ"
      },
      "source": [
        "There are two ways to use this layer. You can apply it to the dataset by calling map:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QgOnza-U_z5Y"
      },
      "source": [
        "normalized_ds = train_dataset.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 pixels values are now in `[0,1]`.\n",
        "print(np.min(first_image), 'to', np.max(first_image)) "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z39nXayj9ioS"
      },
      "source": [
        "Or, you can include the layer inside your model definition to simplify deployment. We will use the second approach here."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hXLd3wMpDIkp"
      },
      "source": [
        "Note: If you would like to scale pixel values to `[-1,1]` you can instead write `Rescaling(1./127.5, offset=-1)`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LeNWVa8qRBGm"
      },
      "source": [
        "Note: we previously resized images using the `image_size` argument of `image_dataset_from_directory`. If you want to include the resizing logic in your model, you can use the [Resizing](https://www.tensorflow.org/api_docs/python/tf/keras/layers/experimental/preprocessing/Resizing) layer instead.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ti8avTlLofoJ"
      },
      "source": [
        "### Configure the dataset for performance\n",
        "\n",
        "Let's make sure to use buffered prefetching so we can yield data from disk without having I/O become blocking. These are two important methods you should use when loading data.\n",
        "\n",
        "`.cache()` keeps the images in memory after they're loaded off disk during the first epoch. This will ensure the dataset does not become a bottleneck while training your model. If your dataset is too large to fit into memory, you can also use this method to create a performant on-disk cache.\n",
        "\n",
        "`.prefetch()` overlaps data preprocessing and model execution while training. \n",
        "\n",
        "Interested readers can learn more about both methods, as well as how to cache data to disk in the [data performance guide](https://www.tensorflow.org/guide/data_performance#prefetching)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ea3kbMe-pGDw"
      },
      "source": [
        "AUTOTUNE = tf.data.AUTOTUNE\n",
        "\n",
        "train_dataset = train_dataset.cache().prefetch(buffer_size=AUTOTUNE)\n",
        "validation_dataset = validation_dataset.cache().prefetch(buffer_size=AUTOTUNE)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XqHjIr6cplwY"
      },
      "source": [
        "### Train a model\n",
        "\n",
        "For completeness, we will show how to train a simple model using the datasets we just prepared. This model has not been tuned in any way - the goal is to show you the mechanics using the datasets you just created. To learn more about image classification, visit this [tutorial](https://www.tensorflow.org/tutorials/images/classification)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LdR0BzCcqxw0"
      },
      "source": [
        "num_classes = 2\n",
        "\n",
        "model = tf.keras.Sequential([\n",
        "  # layers.experimental.preprocessing.Rescaling(1./255),\n",
        "  layers.experimental.preprocessing.Rescaling(1/127.5, offset=-1),\n",
        "  layers.Conv2D(32, 3, activation='relu'),\n",
        "  layers.MaxPooling2D(),\n",
        "  layers.Conv2D(32, 3, activation='relu'),\n",
        "  layers.MaxPooling2D(),\n",
        "  layers.Conv2D(32, 3, activation='relu'),\n",
        "  layers.MaxPooling2D(),\n",
        "  layers.Flatten(),\n",
        "  layers.Dense(128, activation='relu'),\n",
        "  layers.Dense(num_classes)\n",
        "])\n",
        "print(1./127.5, 'ok')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AJG3l00jWMrs"
      },
      "source": [
        "model.build(input_shape=(8, 224, 224, 3))\n",
        "print('model output shape:' ,model.output_shape)\n",
        "# model.summary()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t_BlmsnmsEr4"
      },
      "source": [
        "model.compile(\n",
        "  optimizer = 'adam',\n",
        "  loss = tf.losses.SparseCategoricalCrossentropy(from_logits=True),\n",
        "  metrics = ['accuracy'])\n",
        "\n",
        "# model.summary()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S08ZKKODsnGW"
      },
      "source": [
        "model.fit(\n",
        "  train_dataset,\n",
        "  validation_data=validation_dataset,\n",
        "  epochs=2\n",
        ")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZJfiEbq-x_6k"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CvIAPIPeOjQ5"
      },
      "source": [
        "from tensorflow.keras.applications import imagenet_utils\n",
        "os.chdir(tensorflowImagesPth)\n",
        "imageGlob=glob.glob('**', recursive=True)\n",
        "\n",
        "for fil in sorted(imageGlob):\n",
        "    if isfile(fil) and fil.endswith('.png'):\n",
        "        newFilPath=abspath(fil)\n",
        "        prepared_image = prepare_image(filePath=newFilPath)\n",
        "        print(basename(newFilPath))\n",
        "        showImage(newFilPath)\n",
        "        # print(prepared_image)\n",
        "        # thisPrediction = mobile.predict(prepared_image)\n",
        "        # result = imagenet_utils.decode_predictions(thisPrediction)\n",
        "        # print(result)\n",
        "        print()\n",
        "\n",
        "os.chdir(contentPth)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MEtT9YGjSAOK"
      },
      "source": [
        "Note: you can also write a custom training loop instead of using `model.fit`. To learn more, visit this [tutorial](https://www.tensorflow.org/guide/keras/writing_a_training_loop_from_scratch)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BaW4wx5L7hrZ"
      },
      "source": [
        "You may notice the validation accuracy is low to the compared to the training accuracy, indicating our model is overfitting. You can learn more about overfitting and how to reduce it in this [tutorial](https://www.tensorflow.org/tutorials/keras/overfit_and_underfit)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AxS1cLzM8mEp"
      },
      "source": [
        "## Using tf.data for finer control"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ylj9fgkamgWZ"
      },
      "source": [
        "The above keras.preprocessing utilities are a convenient way to create a `tf.data.Dataset` from a directory of images. For finer grain control, you can write your own input pipeline using `tf.data`. This section shows how to do just that, beginning with the file paths from the zip we downloaded earlier."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "coORvEH-NGwc"
      },
      "source": [
        "data_dir=tensorflowImagesPth\n",
        "searchString=join(tensorflowImagesPth, '*/*')\n",
        "searchString=str(searchString)\n",
        "datasetList=tf.data.Dataset.list_files(searchString)\n",
        "print(f'datasetList: {len(datasetList)}')\n",
        "\n",
        "image_count = len(datasetList)\n",
        "datasetList = datasetList.shuffle(buffer_size=image_count,\n",
        "                                  reshuffle_each_iteration=False,)\n",
        "\n",
        "for fil in datasetList.take(len(datasetList)):\n",
        "    print(fil.numpy())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GWHNPzXclpVr"
      },
      "source": [
        "val_size = int(image_count * 0.2)\n",
        "train_dataset = datasetList.skip(val_size)\n",
        "validation_dataset = datasetList.take(val_size)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rkB-IR4-pS3U"
      },
      "source": [
        "You can see the length of each dataset as follows:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SiKQrb9ppS-7"
      },
      "source": [
        "print(tf.data.experimental.cardinality(train_dataset).numpy())\n",
        "print(tf.data.experimental.cardinality(validation_dataset).numpy())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MGlq4IP4Aktb"
      },
      "source": [
        "def get_label(file_path): # convert the path to a list of path components\n",
        "    parts = tf.strings.split(file_path, os.path.sep)\n",
        "    # The second to last is the class-directory\n",
        "    one_hot = parts[-2] == class_names\n",
        "    # Integer encode the label\n",
        "    return tf.argmax(one_hot)\n",
        "\n",
        "def decode_img(img): # convert the compressed string to a 3D uint8 tensor\n",
        "    # img = tf.image.decode_jpeg(img, channels=3)\n",
        "    img = tf.image.decode_png(img, channels=3)\n",
        "    # resize the image to the desired size\n",
        "    return tf.image.resize(img, [img_height, img_width])\n",
        "\n",
        "def process_path(file_path):\n",
        "    label = get_label(file_path)\n",
        "    # load the raw data from the file as a string\n",
        "    img = tf.io.read_file(file_path)\n",
        "    img = decode_img(img)\n",
        "    return img, label\n",
        "\n",
        "def getLabelName(forPath):\n",
        "    img, label = process_path(forPath)\n",
        "    index = label.numpy()\n",
        "    return class_names[index]\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YHRMx0Bv4HrC"
      },
      "source": [
        "os.chdir(tensorflowImagesPth)\n",
        "\n",
        "for fil in sorted(imageGlob):\n",
        "    # print(fil)\n",
        "    fullPath=abspath(fil)\n",
        "    if fullPath.endswith('.png'):\n",
        "        # print(fullPath)\n",
        "        showImage(fullPath)\n",
        "        className = getLabelName(fullPath)\n",
        "        print(className)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "evejYajd4soJ"
      },
      "source": [
        "\n",
        "enemyPth = join(tensorflowImagesPth, 'Enemy')\n",
        "enemyPth = join(enemyPth, 'enemy_1.png')\n",
        "if exists(enemyPth):\n",
        "    showImage(enemyPth)\n",
        "    print(getLabelName(enemyPth))\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3SDhbo8lOBQv"
      },
      "source": [
        "# Set `num_parallel_calls` so multiple images are loaded/processed in parallel.\n",
        "train_dataset = train_dataset.map(process_path, num_parallel_calls=AUTOTUNE)\n",
        "validation_dataset = validation_dataset.map(process_path, num_parallel_calls=AUTOTUNE)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kxrl0lGdnpRz"
      },
      "source": [
        "for image, label in train_dataset.take(len(train_dataset)):\n",
        "    print(\"Image shape: \", image.shape)\n",
        "    print(\"Label: \", label.shape, '\\n')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vYGCgJuR_9Qp"
      },
      "source": [
        "### Configure dataset for performance"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wwZavzgsIytz"
      },
      "source": [
        "To train a model with this dataset you will want the data:\n",
        "\n",
        "* To be well shuffled.\n",
        "* To be batched.\n",
        "* Batches to be available as soon as possible.\n",
        "\n",
        "These features can be added using the `tf.data` API. For more details, see the [Input Pipeline Performance](../../guide/performance/datasets) guide."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uZmZJx8ePw_5"
      },
      "source": [
        "def configure_for_performance(ds):\n",
        "    ds = ds.cache()\n",
        "    ds = ds.shuffle(buffer_size=1000)\n",
        "    ds = ds.batch(batch_size)\n",
        "    ds = ds.prefetch(buffer_size=AUTOTUNE)\n",
        "    return ds\n",
        "\n",
        "train_dataset = configure_for_performance(train_dataset)\n",
        "validation_dataset = configure_for_performance(validation_dataset)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Vm_bi7NKXOzW"
      },
      "source": [
        "model.fit(train_dataset,\n",
        "          validation_data=validation_dataset,\n",
        "          epochs=3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oCpht0ekYdUV"
      },
      "source": [
        "modelName = model.name + '_1.00.h5'\n",
        "print(modelName)\n",
        "modelSavePath = join(contentPth, modelName)\n",
        "print(f'{C.IBlue}{modelSavePath}')\n",
        "model.save(filepath=modelSavePath)\n",
        "try:\n",
        "    if exists(myDrivePth):\n",
        "            modelSavePath = join(myDrivePth, modelName)\n",
        "            print(modelSavePath)\n",
        "            model.save(modelSavePath)\n",
        "    else: pass\n",
        "except: pass"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yuc6Vh7L5Dm9"
      },
      "source": [
        "from tensorflow.keras.applications import imagenet_utils\n",
        "from tensorflow.keras.preprocessing.image import img_to_array, array_to_img\n",
        "os.chdir(tensorflowImagesPth)\n",
        "imageGlob=glob.glob('**', recursive=True)\n",
        "\n",
        "trainedModel = tf.keras.models.load_model(filepath=modelSavePath)\n",
        "# trainedModel.summary()\n",
        "for fil in sorted(imageGlob):\n",
        "    if fil.endswith('.png'):\n",
        "        newFilPath = abspath(fil)\n",
        "        # print(fil)\n",
        "        # print(newFilPath)\n",
        "\n",
        "        newImage = PIL.Image.open(fp=newFilPath, mode='r')\n",
        "        newImageArray = img_to_array(img=newImage)\n",
        "        print(newImageArray)\n",
        "        # prepared_image = prepare_image(filePath=newFilPath)\n",
        "        print(basename(newFilPath))\n",
        "        showImage(newFilPath)\n",
        "\n",
        "        preparedImage = prepare_image(filePath=newImage)\n",
        "        # print(prepared_image)\n",
        "        # prediction = trainedModel.predict(newFilPath)\n",
        "        # result = imagenet_utils.decode_predictions(prediction)\n",
        "        # result = np.argmax(prediction)\n",
        "        # print(result)\n",
        "        print()\n",
        "\n",
        "os.chdir(contentPth)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AMV6GtZiwfGP"
      },
      "source": [
        "train_dataset = configure_for_performance(train_dataset)\n",
        "validation_dataset = configure_for_performance(validation_dataset)\n",
        "# test_ds = configure_for_performance(test_ds)"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}