FruitClassifier-Sandbox.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fruit Classifier Sandbox"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Sandbox to test out any of our augmentations.\n",
    "- Settings are commented out and provide a selection to use.\n",
    "- Maybe you can obtain a better result with the variations in settings we created!"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import libs\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "import seaborn as sns\n",
    "import cv2\n",
    "import random\n",
    "from PIL import Image\n",
    "from keras.callbacks import CSVLogger\n",
    "from keras.callbacks import EarlyStopping\n",
    "from datetime import datetime\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from imblearn.over_sampling import RandomOverSampler"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Core Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Global variables\n",
    "\n",
    "channel_dict = {\n",
    "    'RGB' : 3,\n",
    "    'RGBcanny' : 4,\n",
    "    'Grayscale' : 1,\n",
    "    'Canny' : 1\n",
    "}\n",
    "\n",
    "fruit_array = [\"apple\",\"banana\", \"orange\", \"mixed\"]\n",
    "\n",
    "seed=42\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "tf.random.set_seed(seed)\n",
    "\n",
    "reset_variables_dict = {\n",
    "    #default variables\n",
    "    'img_size' : 224,\n",
    "    'epochs' : 64,\n",
    "    'batchsize' : 10, \n",
    "    'validation_split' :0.1,\n",
    "    'patience_value' : 5 ,\n",
    "    'retain_aspect_ratio' : False,\n",
    "    'use_classweights' : True,\n",
    "    'use_random_oversampling' : False,\n",
    "    'var_model' : 'Optimal',\n",
    "    'var_data' : '01RELABELLED',\n",
    "    'var_aug' : ['RGB', None],\n",
    "}\n",
    "\n",
    "# Need to autosave to load model in later steps! Setting to false will break this.\n",
    "is_autosave = True"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Function Definitions (Image Layer Augmentation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def first_augmentation_step(first_aug, img):\n",
    "    '''\n",
    "    For pre-processing image channels- Edge maps, color, etc.\n",
    "    ALWAYS accept and return a PIL image\n",
    "    ALWAYS return a PIL image, even if preprocessing with CV2\n",
    "    '''\n",
    "\n",
    "    if  first_aug=='RGB':\n",
    "        return img\n",
    "    \n",
    "    elif first_aug=='RGBcanny':\n",
    "        #convert to np ndarray\n",
    "        PIL_array = np.array(img)\n",
    "\n",
    "        ## debugging\n",
    "        # print(type(PIL_array)) #np.ndarray\n",
    "        # print(PIL_array.shape) #349,3\n",
    "\n",
    "        cv2_image = cv2.cvtColor(PIL_array, cv2.COLOR_RGB2BGR)\n",
    "        gray = cv2.cvtColor(cv2_image, cv2.COLOR_BGR2GRAY) #convert to grayscale\n",
    "        blurred = cv2.GaussianBlur(gray, (5, 5), 0)\n",
    "        edges = cv2.Canny(blurred, 30, 100)\n",
    "\n",
    "        ## debugging\n",
    "        # print(type(edges)) #np.ndarray\n",
    "        # print(edges.shape) #349,\n",
    "\n",
    "        final_img_array = np.dstack((PIL_array, edges))\n",
    "        RGBwMap = Image.fromarray(final_img_array)\n",
    "        return RGBwMap\n",
    "    \n",
    "    elif first_aug=='Grayscale':\n",
    "        grayscale = img.convert('L')\n",
    "        return grayscale\n",
    "    \n",
    "    elif first_aug=='Canny':\n",
    "        PIL_array = np.array(img)\n",
    "\n",
    "        cv2_image = cv2.cvtColor(PIL_array, cv2.COLOR_RGB2BGR)\n",
    "        gray = cv2.cvtColor(cv2_image, cv2.COLOR_BGR2GRAY) #convert to grayscale\n",
    "        \n",
    "        blurred = cv2.GaussianBlur(gray, (5, 5), 0)\n",
    "        edges = cv2.Canny(blurred, 30, 100)\n",
    "\n",
    "        canny = Image.fromarray(edges)\n",
    "        return canny\n",
    "    \n",
    "    else:\n",
    "        print('ERROR: No image augmentation selected!')\n",
    "    "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Function Definitions (Image Position Augmentation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def second_augmentation_step(second_aug, img):\n",
    "    '''\n",
    "    For pre-processing image loci- translation, rotation, zooming, flipping \n",
    "    ALWAYS accept and return a PIL image\n",
    "    '''\n",
    "\n",
    "    second_aug_tuple = (\n",
    "        \"rotation\",\n",
    "        \"translation\",\n",
    "        \"zoom\",\n",
    "        \"flip_horizontal\",\n",
    "        \"flip_vertical\",\n",
    "        \"flip_vertical_horizontal\")\n",
    "    \n",
    "    # if no second aug, return\n",
    "    if second_aug not in second_aug_tuple:\n",
    "        return img\n",
    "    \n",
    "    # convert to preserve first aug\n",
    "    if channels ==1:\n",
    "        cv2_image = cv2.cvtColor(np.array(img),cv2.COLOR_GRAY2BGR)\n",
    "    elif channels ==3:\n",
    "        cv2_image = cv2.cvtColor(np.array(img),cv2.COLOR_RGBA2BGR)\n",
    "    elif channels==4:\n",
    "        cv2_image = cv2.cvtColor(np.array(img),cv2.COLOR_RGBA2BGRA)\n",
    "\n",
    "        \n",
    "    if second_aug == \"rotation\":\n",
    "        cv2_final_image = cv2.rotate(cv2_image,cv2.ROTATE_90_CLOCKWISE)\n",
    "\n",
    "    elif second_aug == \"translation\":\n",
    "        tx = 50\n",
    "        ty = 30\n",
    "        translation_matrix = np.array([[1,0,tx],\n",
    "                                   [0,1,ty]], dtype=np.float32)\n",
    "        cv2_final_image = cv2.warpAffine(src=cv2_image, M=translation_matrix,dsize=(img.size[0], img.size[1]))\n",
    "\n",
    "    elif second_aug == \"zoom\":\n",
    "        zf = 2\n",
    "        rows, cols = img.size[1],img.size[0]\n",
    "        new_rows = int(rows*zf)\n",
    "        new_cols = int(cols*zf)\n",
    "        cv2_final_image = cv2.resize(cv2_image,(new_rows,new_cols))\n",
    "  \n",
    "    elif second_aug=='flip_horizontal':\n",
    "        # Flip the image horizontally\n",
    "        cv2_final_image = cv2.flip(cv2_image, 1)\n",
    "        \n",
    "    elif second_aug=='flip_vertical':\n",
    "        # Flip the image vertically\n",
    "        cv2_final_image = cv2.flip(cv2_image, 0)\n",
    "        \n",
    "    elif second_aug=='flip_vertical_horizontal':\n",
    "        cv2_flipped_vertc_image = cv2.flip(cv2_image, 0)\n",
    "        cv2_final_image = cv2.flip(cv2_flipped_vertc_image, 1)\n",
    "\n",
    "\n",
    "    # convert to preserve first aug\n",
    "    if channels ==1:\n",
    "        edited_image = Image.fromarray(\n",
    "            cv2.cvtColor(cv2_final_image, \n",
    "                         cv2.COLOR_BGR2RGB))\n",
    "        edited_image = edited_image.convert('L')\n",
    "        \n",
    "    elif channels ==3:\n",
    "        edited_image = Image.fromarray(\n",
    "            cv2.cvtColor(cv2_final_image, \n",
    "                         cv2.COLOR_BGR2RGB))\n",
    "        \n",
    "    elif channels==4:\n",
    "        edited_image = Image.fromarray(\n",
    "            cv2.cvtColor(\n",
    "                cv2_final_image, \n",
    "                cv2.COLOR_BGRA2RGBA))\n",
    "        \n",
    "\n",
    "    return edited_image"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Function Definitions (Model Augmentation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_model(input_dimension, channels, model_type=None, num_classifications=4):\n",
    "    '''\n",
    "    Create a model\n",
    "    Use 'flatten' or 'pooling' depending on settings\n",
    "    '''\n",
    "    model = tf.keras.Sequential()\n",
    "    num_classifications=num_classifications\n",
    "    \n",
    "    if model_type=='FewLayers':\n",
    "        model.add(tf.keras.layers.Conv2D(\n",
    "                filters=16,\n",
    "                kernel_size=(3, 3),\n",
    "                activation='relu',\n",
    "                input_shape=(input_dimension, input_dimension, channels)))\n",
    "\n",
    "        model.add(tf.keras.layers.GlobalAveragePooling2D())\n",
    "\n",
    "        model.add(tf.keras.layers.Dense(units=num_classifications, activation='softmax'))\n",
    "\n",
    "        model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])\n",
    "\n",
    "    elif model_type=='Overtuned':\n",
    "        model.add(tf.keras.layers.Conv2D(\n",
    "                filters=64,\n",
    "                kernel_size=(3, 3),\n",
    "                activation='relu',\n",
    "                input_shape=(input_dimension, input_dimension, channels)))\n",
    "        model.add(tf.keras.layers.Conv2D(\n",
    "                filters=64,\n",
    "                kernel_size=(3, 3),\n",
    "                activation='relu'))\n",
    "        model.add(tf.keras.layers.MaxPooling2D((2, 2), (2, 2)))\n",
    "\n",
    "        model.add(tf.keras.layers.Conv2D(\n",
    "                filters=128,\n",
    "                kernel_size=(3, 3),\n",
    "                activation='relu'))\n",
    "        model.add(tf.keras.layers.Conv2D(\n",
    "                filters=128,\n",
    "                kernel_size=(3, 3),\n",
    "                activation='relu'))\n",
    "        model.add(tf.keras.layers.MaxPooling2D((2, 2), (2, 2)))\n",
    "\n",
    "        model.add(tf.keras.layers.GlobalAveragePooling2D())\n",
    "        model.add(tf.keras.layers.Dense(units=256, activation='relu'))\n",
    "        model.add(tf.keras.layers.Dropout(0.5))\n",
    "        model.add(tf.keras.layers.Dense(units=128, activation='relu'))\n",
    "        model.add(tf.keras.layers.Dropout(0.5))\n",
    "        model.add(tf.keras.layers.Dense(units=num_classifications, activation='softmax'))\n",
    "\n",
    "        model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])\n",
    "\n",
    "    elif model_type =='9x9':\n",
    "        model.add(tf.keras.layers.Conv2D(64,(9,9),activation = 'relu',input_shape = (input_dimension,input_dimension,channels)))\n",
    "        model.add(tf.keras.layers.Conv2D(64, (9,9), activation='relu'))\n",
    "        model.add(tf.keras.layers.MaxPooling2D((2,2),(2,2)))\n",
    "        model.add(tf.keras.layers.Conv2D(64, (9,9), activation='relu'))\n",
    "        model.add(tf.keras.layers.Conv2D(64, (9,9), activation='relu'))\n",
    "        model.add(tf.keras.layers.MaxPooling2D((2,2),(2,2)))\n",
    "        model.add(tf.keras.layers.GlobalAveragePooling2D())\n",
    "        model.add(tf.keras.layers.Dense(units=128, activation='relu'))\n",
    "        model.add(tf.keras.layers.Dense(units=num_classifications, activation='softmax'))\n",
    "        model.compile(loss='categorical_crossentropy', \n",
    "                  optimizer='adam', \n",
    "                  metrics=['accuracy'])\n",
    "\n",
    "    elif model_type=='Optimal':\n",
    "        model.add(tf.keras.layers.Conv2D(\n",
    "            filters = 32, \n",
    "            kernel_size = (3,3),\n",
    "            activation = 'relu', \n",
    "            input_shape = (input_dimension,input_dimension,channels)))\n",
    "        model.add(tf.keras.layers.Conv2D(\n",
    "            filters = 32, \n",
    "            kernel_size = (3,3),\n",
    "            activation='relu'))\n",
    "        model.add(tf.keras.layers.MaxPooling2D((2,2),(2,2)))\n",
    "\n",
    "        model.add(tf.keras.layers.Conv2D(32, (3,3), activation='relu'))\n",
    "        model.add(tf.keras.layers.Conv2D(32, (3,3), activation='relu'))\n",
    "        model.add(tf.keras.layers.MaxPooling2D((2,2),(2,2)))\n",
    "\n",
    "        model.add(tf.keras.layers.GlobalAveragePooling2D())\n",
    "        model.add(tf.keras.layers.Dense(units=128, activation='relu'))\n",
    "\n",
    "        # 4 classifications- Apple, Banana, Orange, Mixed\n",
    "        model.add(tf.keras.layers.Dense(units=num_classifications, activation='softmax'))\n",
    "        model.compile(loss='categorical_crossentropy', \n",
    "                  optimizer='adam', \n",
    "                  metrics=['accuracy'])\n",
    "\n",
    "\n",
    "    \n",
    "\n",
    "    return model"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Function Definitions (Primary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define func\n",
    "\n",
    "def show_image(X_train,index):\n",
    "    '''\n",
    "    Display the image at the specific index of the reshaped array\n",
    "    '''\n",
    "    if not index  < X_train.shape[0]:\n",
    "        print(\"Array does not contain your desired image index.\")\n",
    "    image_array = X_train[index]\n",
    "    image = Image.fromarray(np.uint8(image_array))\n",
    "    image.show()\n",
    "\n",
    "def prep_train_data(subfolder_name, desired_size, var_aug_type):\n",
    "    new_size = desired_size\n",
    "    paths = []\n",
    "    is_train_data=True\n",
    "    \n",
    "    for fruit in fruit_array:\n",
    "        paths.append('ML_Proj_Data/train/{subfolder}/{fruit}'.format(subfolder=subfolder_name,fruit=fruit))\n",
    "\n",
    "    return prep_data(paths, new_size, var_aug_type, is_train_data)\n",
    "\n",
    "def prep_test_data(desired_size, var_aug_type):\n",
    "    new_size = desired_size\n",
    "    paths = []\n",
    "    is_train_data=False\n",
    "\n",
    "    for fruit in fruit_array:\n",
    "        paths.append('ML_Proj_Data/test/{fruit}'.format(fruit=fruit))\n",
    "\n",
    "    return prep_data(paths, new_size, var_aug_type, is_train_data)\n",
    "\n",
    "def prep_data(paths, desired_size, var_aug_type, is_train_data):\n",
    "    '''\n",
    "    Pre-process all images in each of the 4 paths.\n",
    "    '''\n",
    "    new_size = desired_size\n",
    "\n",
    "    for i in range(len(paths)):\n",
    "        data = read_img_data(paths[i],new_size, var_aug_type, is_train_data)\n",
    "        \n",
    "        #test if it works by showing image\n",
    "        # show_image(data,0)\n",
    "        # show_image(data,1)\n",
    "\n",
    "        try: \n",
    "            # concatenate if initialized\n",
    "            X = np.concatenate((X,data))\n",
    "        except:\n",
    "            # initialize if not\n",
    "            X = data\n",
    "\n",
    "        y_onehots = map_type_to_onehot(paths[i], data.shape[0])\n",
    "        try:\n",
    "            y = np.concatenate((y,y_onehots))\n",
    "        except:\n",
    "            y = y_onehots\n",
    "        \n",
    "    return X,y\n",
    "\n",
    "def map_type_to_onehot(file_path, n_rows):\n",
    "    '''\n",
    "    Map the type of image to digit.\n",
    "    Takes in a specific file path.\n",
    "    Returns a onehot encoded 1D array.\n",
    "    '''\n",
    "    y_onehot = [0]*4\n",
    "    fruit_onehot_dict =\t{\n",
    "    \"apple\": [1,0,0,0],\n",
    "    \"banana\": [0,1,0,0],\n",
    "    \"orange\": [0,0,1,0],\n",
    "    \"mixed\": [0,0,0,1]\n",
    "    }\n",
    "\n",
    "    normalized_path = file_path.replace('\\\\','/')\n",
    "    segments = normalized_path.split('/')\n",
    "    final_segment = segments[-1]\n",
    "\n",
    "    if '.jpg' in final_segment:\n",
    "        # incorrect path structure but handle it anyway\n",
    "        prefix = final_segment.split('_')[0]\n",
    "    else:\n",
    "        prefix = final_segment\n",
    "\n",
    "    if prefix in fruit_onehot_dict:\n",
    "        y_onehot =  fruit_onehot_dict[prefix]\n",
    "\n",
    "    y_onehots = [y_onehot] * n_rows\n",
    "    # convert python list to numpy array\n",
    "    # as keras requires numpy array\n",
    "    return np.array(y_onehots)\n",
    "\n",
    "def read_img_data(path, desired_size, var_aug_type, is_train_data):\n",
    "    '''\n",
    "    Loops through every file in a specific path\n",
    "    Opens, pre-processes, and adds each image to X_train\n",
    "    '''\n",
    "\n",
    "    for file in os.listdir(path):\n",
    "        if file[0] == '.':  # skip hidden files\n",
    "            continue\n",
    "\n",
    "        img = Image.open(\"{path}/{file}\".format(path=path,file=file))\n",
    "        img = preprocess_image(img, desired_size, var_aug_type, is_train_data)\n",
    "    \n",
    "        try:\n",
    "            # concatenate every subsequent img to x_train after it has been initialized at (i=0)\n",
    "            X_train = np.concatenate((X_train, img))\n",
    "        except:\n",
    "            # initialize x_train and assign img to it as the first value if it does not exist (i=0)\n",
    "            X_train = img\n",
    "\n",
    "            #code for ndim canny map in channels in np.reshape\n",
    "            channels=channel_dict[var_aug_type[0]]\n",
    "    \n",
    "    # returns the entire folder of images as a single array\n",
    "\n",
    "    return np.reshape(X_train, (-1,desired_size,desired_size,channels))\n",
    "\n",
    "\n",
    "def preprocess_image(img, desired_size, var_aug_type, is_train_data):\n",
    "    '''\n",
    "    Pre-process specific image object ONLY.\n",
    "    Convert to RGB to reduce unnecessary features (remove alpha, ndim 4-> 3) and increase training speed.\n",
    "    (!) must be for looped!\n",
    "    '''\n",
    "    # new 2D image size\n",
    "    new_size = (desired_size,desired_size)\n",
    "\n",
    "    # remove alpha channel\n",
    "    if img.mode in ('RGBA', 'LA') or (img.mode == 'P' and 'transparency' in img.info):\n",
    "        #convert to RGBA to use alpha_composite function\n",
    "        img = img.convert('RGBA')\n",
    "        bg = Image.new('RGBA',img.size, (255, 255, 255))\n",
    "\n",
    "        bg.alpha_composite(img, (0,0))\n",
    "        img = bg.convert('RGB')\n",
    "\n",
    "    if img.mode != 'RGB':\n",
    "        img = img.convert('RGB')\n",
    "\n",
    "    ##ASPECT RATIO CODE##\n",
    "    if retain_aspect_ratio == True:\n",
    "        background = Image.new('RGB', new_size,(255,255,255)) #white background\n",
    "\n",
    "        #calculate the aspect ratio of augmented image\n",
    "        img_ratio = img.width/img.height\n",
    "        # print(img_ratio) #debug\n",
    "        # Calculate the dimensions of the resized image based on the aspect ratio and the desired size\n",
    "        if img_ratio > 1:\n",
    "            #landscape image\n",
    "            new_width = desired_size\n",
    "            new_height = int(desired_size/img_ratio)\n",
    "        else:\n",
    "            #portrait or symmetrical image\n",
    "            new_width = int(desired_size/img_ratio)\n",
    "            new_height = desired_size\n",
    "\n",
    "        # Resize image while retaining the aspect ratio\n",
    "        img.thumbnail((new_width, new_height))\n",
    "        #Calculate the absolute center to paste img onto background\n",
    "        pos_x = (desired_size-img.width) //2\n",
    "        pos_y = (desired_size-img.height) //2\n",
    "        #Paste at calculated pos\n",
    "        background.paste(img,(pos_x, pos_y))\n",
    "        img = background\n",
    "        img = img.resize(new_size)\n",
    "\n",
    "    else:\n",
    "        img = img.resize(new_size)\n",
    "    ##END ASPECT RATIO CODE##\n",
    "\n",
    "    img = first_augmentation_step(first_aug=var_aug_type[0], img=img)\n",
    "\n",
    "    if is_train_data:\n",
    "        img = second_augmentation_step(second_aug=var_aug_type[1], img=img)\n",
    "\n",
    "    # resized_img = img.resize(new_size)\n",
    "    return img\n",
    "\n",
    "def assign_class_weights(use_classweights, y_data):\n",
    "    if use_classweights:\n",
    "        # Class weights calculation\n",
    "        class_weights = {}\n",
    "\n",
    "        y_data_copy = y_data.copy()\n",
    "        y_data_copy = np.sum(y_data_copy, axis=0)\n",
    "        total_class = float(len(y_data_copy))\n",
    "        total_images = np.sum(y_data_copy)\n",
    "\n",
    "        for i in range(len(y_data_copy)):\n",
    "            class_weights[i] = (1/y_data_copy[i]) * (total_images/total_class)\n",
    "    else:\n",
    "        class_weights = {0:1,1:1,2:1,3:1}\n",
    "        \n",
    "    # print(class_weights)\n",
    "    return class_weights\n",
    "\n",
    "def random_oversampling(X, y):\n",
    "    # Perform random oversampling\n",
    "    oversampler = RandomOverSampler()\n",
    "    X_resampled, y_resampled = oversampler.fit_resample(X.reshape(X.shape[0], -1), y)\n",
    "\n",
    "    # Reshape X_resampled back to the original shape\n",
    "    X_resampled = X_resampled.reshape(-1, img_size, img_size, X.shape[-1])\n",
    "\n",
    "    return X_resampled, y_resampled\n",
    "\n",
    "def save_model(model, path_fragment):\n",
    "    path = 'ML_Proj_Data/model/{pathfragment}'.format(pathfragment=path_fragment)\n",
    "    model.save(path)\n",
    "\n",
    "def load_model(path_fragment):\n",
    "    path = 'ML_Proj_Data/model/{pathfragment}'.format(pathfragment=path_fragment)\n",
    "    return tf.keras.models.load_model(path)\n",
    "\n",
    "def test_model(model, X_test, y_test):\n",
    "    return model.evaluate(x=X_test, y=y_test)\n",
    "\n",
    "def setup_graph_data(callback):\n",
    "    tl = callback.history['loss']\n",
    "    vl = callback.history['val_loss']\n",
    "    ta = callback.history['accuracy']\n",
    "    va = callback.history['val_accuracy']\n",
    "\n",
    "    df_train_loss = pd.DataFrame({\"training loss\":tl,\"validation loss\":vl})\n",
    "    df_train_acc = pd.DataFrame({\"training accuracy\":ta,\"validation accuracy\":va})\n",
    "    return df_train_loss,df_train_acc\n",
    "\n",
    "def save_plot(plt,path_fragment,plotname):\n",
    "\tpath = 'ML_Proj_Data/model/{pathfragment}/{plotname}.png'.format(pathfragment=path_fragment, plotname=plotname)\n",
    "\tplt.savefig(path)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Function Definitions (Utility)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reset_instance_variables(reset_variables_dict):\n",
    "    \n",
    "    for var_name, var_value in reset_variables_dict.items():\n",
    "        globals()[var_name] = var_value\n",
    "\n",
    "    set_automatic_variables()\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sandbox Model"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Instanced Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Set Variables\n",
    "img_size = 224\n",
    "epochs = 64\n",
    "batchsize= 10\n",
    "validation_split=0.2\n",
    "patience_value = 5\n",
    "retain_aspect_ratio = True\n",
    "use_classweights = True\n",
    "use_random_oversampling = True\n",
    "\n",
    "# Model Variant- See Function Definitions (Model Augmentation)\n",
    "var_model = 'Optimal' \n",
    "    # OPTIONS: \n",
    "    # # 'FewLayers' # 'Overtuned' # 'Optimal' # '9x9'\n",
    "\n",
    "# Data Variant- See \\ML_Proj_Data\\train\n",
    "var_data = '03EXPANDED' \n",
    "    # OPTIONS: \n",
    "    # # '00BASE' # '01RELABELLED' # '02INCREASED' # '03EXPANDED'\n",
    "\n",
    "# Augmentation Variant- See Function Definitions (Image Augmentation)\n",
    "var_aug= ['RGBcanny', \"flip_horizontal\"]\n",
    "    # OPTIONS: \n",
    "    # # First Aug\n",
    "        #'RGB' # 'RGBcanny' # 'Grayscale' # 'Canny' \n",
    "    # # Second Aug\n",
    "        #\"rotation\" #\"translation\" #\"zoom\" #\"flip_horizontal\" #\"flip_vertical\" #\"flip_vertical_horizontal\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Automatic Variables\n",
    "\n",
    "def set_automatic_variables():\n",
    "    global model_data_id \n",
    "    model_data_id = '[{model}]-[{data}]-[{imgaug01}]-[{imgaug02}]'.format(\n",
    "        model=var_model,\n",
    "        data=var_data,    \n",
    "        imgaug01=var_aug[0],\n",
    "        imgaug02=var_aug[1]) \n",
    "    global channels\n",
    "    channels=channel_dict[var_aug[0]]\n",
    "\n",
    "set_automatic_variables()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Preparation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train: (320, 224, 224, 4), y_train: (320, 4)\n",
      "X_validate: (80, 224, 224, 4), y_validate: (80, 4)\n",
      "X_test: (60, 224, 224, 4), y_test: (60, 4)\n",
      "Class weights= {0: 1.0, 1: 1.0, 2: 1.0, 3: 1.0}\n"
     ]
    }
   ],
   "source": [
    "# Prep training, validation and test data\n",
    "\n",
    "X_data, y_data = prep_train_data(subfolder_name=var_data, desired_size=img_size, var_aug_type=var_aug)\n",
    "\n",
    "if use_random_oversampling==True:\n",
    "    X_data, y_data = random_oversampling(X_data, y_data)\n",
    "\n",
    "X_train, X_validate, y_train, y_validate = train_test_split(X_data, y_data, test_size=validation_split, stratify=y_data)\n",
    "\n",
    "X_test, y_test = prep_test_data(img_size, var_aug_type=var_aug)\n",
    "\n",
    "print('X_train: {X_train}, y_train: {y_train}'.format(X_train=X_train.shape, y_train=y_train.shape))\n",
    "print('X_validate: {X_validate}, y_validate: {y_validate}'.format(X_validate=X_validate.shape, y_validate=y_validate.shape))\n",
    "print('X_test: {X_test}, y_test: {y_test}'.format(X_test=X_test.shape, y_test=y_test.shape))\n",
    "\n",
    "set_automatic_variables()\n",
    "\n",
    "class_weights = assign_class_weights(use_classweights, y_data)\n",
    "print(\"Class weights= {}\".format(class_weights))\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## (Optional) Check Validation Set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Onehots= [[0 0 0 1]\n",
      " [0 0 1 0]\n",
      " [0 1 0 0]\n",
      " [1 0 0 0]]\n",
      "Onehot data distribution count= [20 20 20 20]\n"
     ]
    }
   ],
   "source": [
    "# Check if validation sample is evenly distributed\n",
    "\n",
    "# print(type(y_validate))\n",
    "yv_urows, yv_counts = np.unique(y_validate, axis=0, return_counts=True)\n",
    "print (\"Onehots= {}\".format(yv_urows))\n",
    "print (\"Onehot data distribution count= {}\".format(yv_counts))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create and Fit Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/64\n",
      "32/32 [==============================] - 12s 51ms/step - loss: 1.3898 - accuracy: 0.2500 - val_loss: 1.3748 - val_accuracy: 0.4125\n",
      "Epoch 2/64\n",
      "32/32 [==============================] - 1s 22ms/step - loss: 1.3254 - accuracy: 0.4313 - val_loss: 1.0886 - val_accuracy: 0.5125\n",
      "Epoch 3/64\n",
      "32/32 [==============================] - 1s 23ms/step - loss: 1.1734 - accuracy: 0.4875 - val_loss: 1.0522 - val_accuracy: 0.4875\n",
      "Epoch 4/64\n",
      "32/32 [==============================] - 1s 22ms/step - loss: 1.1828 - accuracy: 0.5406 - val_loss: 1.0271 - val_accuracy: 0.6500\n",
      "Epoch 5/64\n",
      "32/32 [==============================] - 1s 21ms/step - loss: 1.0390 - accuracy: 0.5562 - val_loss: 0.8420 - val_accuracy: 0.6750\n",
      "Epoch 6/64\n",
      "32/32 [==============================] - 1s 21ms/step - loss: 0.8792 - accuracy: 0.6875 - val_loss: 0.7876 - val_accuracy: 0.7000\n",
      "Epoch 7/64\n",
      "32/32 [==============================] - 1s 22ms/step - loss: 0.7810 - accuracy: 0.7281 - val_loss: 0.4379 - val_accuracy: 0.8750\n",
      "Epoch 8/64\n",
      "32/32 [==============================] - 1s 21ms/step - loss: 0.4874 - accuracy: 0.8562 - val_loss: 0.3169 - val_accuracy: 0.8500\n",
      "Epoch 9/64\n",
      "32/32 [==============================] - 1s 21ms/step - loss: 0.4319 - accuracy: 0.8656 - val_loss: 0.2624 - val_accuracy: 0.9250\n",
      "Epoch 10/64\n",
      "32/32 [==============================] - 1s 21ms/step - loss: 0.3754 - accuracy: 0.8562 - val_loss: 0.3862 - val_accuracy: 0.8625\n",
      "Epoch 11/64\n",
      "32/32 [==============================] - 1s 22ms/step - loss: 0.3601 - accuracy: 0.8656 - val_loss: 0.5315 - val_accuracy: 0.8250\n",
      "Epoch 12/64\n",
      "32/32 [==============================] - 1s 22ms/step - loss: 0.3116 - accuracy: 0.8969 - val_loss: 0.2552 - val_accuracy: 0.8875\n",
      "Epoch 13/64\n",
      "32/32 [==============================] - 1s 21ms/step - loss: 0.2714 - accuracy: 0.9094 - val_loss: 0.3331 - val_accuracy: 0.8750\n",
      "Epoch 14/64\n",
      "32/32 [==============================] - 1s 22ms/step - loss: 0.3203 - accuracy: 0.8687 - val_loss: 0.6426 - val_accuracy: 0.8125\n",
      "Epoch 15/64\n",
      "32/32 [==============================] - 1s 21ms/step - loss: 0.2572 - accuracy: 0.9031 - val_loss: 0.3827 - val_accuracy: 0.8875\n",
      "Epoch 16/64\n",
      "32/32 [==============================] - 1s 22ms/step - loss: 0.2283 - accuracy: 0.9187 - val_loss: 0.2989 - val_accuracy: 0.9000\n",
      "Epoch 17/64\n",
      "32/32 [==============================] - 1s 22ms/step - loss: 0.2202 - accuracy: 0.9250 - val_loss: 0.1883 - val_accuracy: 0.9250\n",
      "Epoch 18/64\n",
      "32/32 [==============================] - 1s 22ms/step - loss: 0.2650 - accuracy: 0.9187 - val_loss: 0.3184 - val_accuracy: 0.8625\n",
      "Epoch 19/64\n",
      "32/32 [==============================] - 1s 22ms/step - loss: 0.1996 - accuracy: 0.9312 - val_loss: 0.5032 - val_accuracy: 0.8500\n",
      "Epoch 20/64\n",
      "32/32 [==============================] - 1s 23ms/step - loss: 0.1695 - accuracy: 0.9344 - val_loss: 0.2896 - val_accuracy: 0.8750\n",
      "Epoch 21/64\n",
      "32/32 [==============================] - 1s 22ms/step - loss: 0.1497 - accuracy: 0.9500 - val_loss: 0.3031 - val_accuracy: 0.9125\n",
      "Epoch 22/64\n",
      "32/32 [==============================] - 1s 22ms/step - loss: 0.1771 - accuracy: 0.9281 - val_loss: 0.1960 - val_accuracy: 0.9500\n",
      "Epoch 23/64\n",
      "32/32 [==============================] - 1s 21ms/step - loss: 0.1969 - accuracy: 0.9281 - val_loss: 0.2494 - val_accuracy: 0.9125\n",
      "Epoch 24/64\n",
      "32/32 [==============================] - 1s 21ms/step - loss: 0.1903 - accuracy: 0.9438 - val_loss: 0.1248 - val_accuracy: 0.9375\n",
      "Epoch 25/64\n",
      "32/32 [==============================] - 1s 21ms/step - loss: 0.2397 - accuracy: 0.9344 - val_loss: 0.3349 - val_accuracy: 0.8875\n",
      "Epoch 26/64\n",
      "32/32 [==============================] - 1s 22ms/step - loss: 0.1716 - accuracy: 0.9375 - val_loss: 0.3543 - val_accuracy: 0.9125\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 4 of 4). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: ML_Proj_Data/model/[Optimal]-[03EXPANDED]-[RGBcanny]-[flip_horizontal]\\assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: ML_Proj_Data/model/[Optimal]-[03EXPANDED]-[RGBcanny]-[flip_horizontal]\\assets\n"
     ]
    }
   ],
   "source": [
    "# Create\n",
    "model = create_model(input_dimension=img_size, channels = channels, model_type=var_model)\n",
    "now = datetime.now()\n",
    "\n",
    "save_path = 'ML_Proj_Data/model/{model}'.format(model=model_data_id)\n",
    "if not os.path.exists(save_path):\n",
    "    os.makedirs(save_path)\n",
    "\n",
    "csv_logger = CSVLogger('{sp}/LOG-[{date}]-[{time}].csv'.format(\n",
    "    sp=save_path,\n",
    "    date=now.strftime(\"%Y%m%d\"),\n",
    "    time=now.strftime(\"%H%M%S\")))\n",
    "\n",
    "early_stopping = EarlyStopping(monitor='accuracy', patience=patience_value)\n",
    "\n",
    "# Train and Save\n",
    "\n",
    "callback = model.fit(x=X_train/255, \n",
    "                     y=y_train, \n",
    "                     batch_size=batchsize, \n",
    "                     epochs=epochs, \n",
    "                     validation_data=(X_validate/255,y_validate), \n",
    "                     callbacks = [early_stopping,csv_logger],\n",
    "                     class_weight = class_weights)\n",
    "save_model(model,model_data_id)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluate Model Against Test Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2/2 [==============================] - 1s 382ms/step - loss: 0.3022 - accuracy: 0.9000\n"
     ]
    }
   ],
   "source": [
    "# Test against Cher Wah's Test Data\n",
    "model = load_model(model_data_id)\n",
    "test_result= test_model(model, X_test/255, y_test)\n",
    "\n",
    "#Autosave\n",
    "if is_autosave:\n",
    "    df = pd.DataFrame(test_result)\n",
    "    path = 'ML_Proj_Data/model/{pathfragment}/{testname}.csv'.format(pathfragment=model_data_id, testname='evaluationtest')\n",
    "    df.to_csv(path)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Graph Data Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(26, 2)\n",
      "    training loss  validation loss\n",
      "21       0.177098         0.195982\n",
      "22       0.196866         0.249379\n",
      "23       0.190336         0.124830\n",
      "24       0.239659         0.334866\n",
      "25       0.171627         0.354296\n",
      "(26, 2)\n",
      "    training accuracy  validation accuracy\n",
      "21           0.928125               0.9500\n",
      "22           0.928125               0.9125\n",
      "23           0.943750               0.9375\n",
      "24           0.934375               0.8875\n",
      "25           0.937500               0.9125\n"
     ]
    }
   ],
   "source": [
    "# Prepare DataFrames for Graphing\n",
    "\n",
    "df_train_loss, df_train_acc= setup_graph_data(callback)\n",
    "\n",
    "print(df_train_loss.shape)\n",
    "print (df_train_loss.tail())\n",
    "print(df_train_acc.shape)\n",
    "print (df_train_acc.tail())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Graph Model Performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.lineplot(data= df_train_loss).set(xlabel=\"Epochs\", ylabel=\"Loss\")\n",
    "plt.suptitle(t=\"Loss Curves\")\n",
    "if is_autosave:\n",
    "    save_plot(plt, model_data_id, 'LossCurve')\n",
    "plt.show()\n",
    "\n",
    "\n",
    "sns.lineplot(data = df_train_acc).set(xlabel=\"Epochs\", ylabel=\"Accuracy\")\n",
    "plt.suptitle(t=\"Accuracy Curves\")\n",
    "if is_autosave:\n",
    "    save_plot(plt, model_data_id, 'AccCurve')\n",
    "plt.show()\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Heat Maps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2/2 [==============================] - 0s 15ms/step\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "y_pred = model.predict(X_test/255)\n",
    "y_truth = np.argmax(y_test, axis=1)\n",
    "y_pred = np.argmax(y_pred, axis=1)\n",
    "\n",
    "cm = confusion_matrix(y_truth, y_pred)\n",
    "sns.heatmap(\n",
    "    cm,\n",
    "    xticklabels=fruit_array,\n",
    "    yticklabels=fruit_array,\n",
    "    annot=True)\n",
    "\n",
    "plt.xlabel(\"Predicted\")\n",
    "plt.ylabel(\"Truth\")\n",
    "if is_autosave:\n",
    "    save_plot(plt, model_data_id, 'HeatMap')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "gdipsa",
   "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.8.16"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}