train_v4.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import absolute_import, division, print_function, unicode_literals\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import os\n",
    "import cv2\n",
    "import matplotlib.pyplot as plt\n",
    "from collections import Counter\n",
    "import datetime\n",
    "import math\n",
    "import random\n",
    "try:\n",
    "    import cPickle as pickle\n",
    "except:\n",
    "    import pickle\n",
    "import tensorflow as tf\n",
    "from tensorflow import keras\n",
    "from tensorflow.keras import datasets, layers, models\n",
    "from tensorflow.keras.utils import multi_gpu_model\n",
    "from livelossplot.inputs.tf_keras import PlotLossesCallback"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "column_names = ['path', 'make', 'model', 'year_of_production']\n",
    "raw_dataset = pd.read_csv('./cars.csv', names = column_names, sep=';',\n",
    "                      dtype={\"path\": str, \"make\": str, 'model': str, 'year_of_production': str})\n",
    "\n",
    "raw_dataset = raw_dataset[raw_dataset.path != 'path']\n",
    "raw_dataset = raw_dataset[raw_dataset.year_of_production != 'ints']\n",
    "\n",
    "train_paths = raw_dataset['path'].values.tolist()\n",
    "make = raw_dataset['make'].values.tolist()\n",
    "model = raw_dataset['model'].values.tolist()\n",
    "year = raw_dataset['year_of_production'].values.tolist()\n",
    "\n",
    "CLASS_NAMES_MAKE = np.array(np.unique([name for name in make]))\n",
    "CLASS_NAMES_MODEL = np.array(np.unique([name for name in model]))\n",
    "CLASS_NAMES_YEAR = np.array(np.unique([name for name in year]))\n",
    "\n",
    "BATCH_SIZE = 16\n",
    "IMG_WIDTH = 220\n",
    "IMG_HEIGHT = 220\n",
    "\n",
    "image_count = len(train_paths)\n",
    "\n",
    "STEPS_PER_EPOCH = np.ceil(image_count/BATCH_SIZE)\n",
    "STEPS_PER_EPOCH_TRAIN = np.ceil(image_count/BATCH_SIZE*0.8)\n",
    "STEPS_PER_EPOCH_VAL = np.ceil(image_count/BATCH_SIZE*0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.chdir('Car_Dataset')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "AUTOTUNE = tf.data.experimental.AUTOTUNE\n",
    "\n",
    "path_list = tf.data.Dataset.from_tensor_slices(train_paths)\n",
    "\n",
    "def get_label_make(labels):\n",
    "    make = tf.strings.split(labels, '_')[0]\n",
    "    return make == CLASS_NAMES_MAKE\n",
    "def get_label_model(labels):\n",
    "    pos = tf.strings.length(tf.strings.split(labels, '_')[0])+1\n",
    "    length = tf.strings.length(labels)-pos-5\n",
    "    model = tf.strings.substr(labels, pos, length)\n",
    "    return model == CLASS_NAMES_MODEL\n",
    "def get_label_year(labels):\n",
    "    year = tf.strings.split(labels, '_')[-1]\n",
    "    return year == CLASS_NAMES_YEAR\n",
    "\n",
    "def decode_image(img):\n",
    "    img = tf.image.decode_jpeg(img, channels=3)\n",
    "    img = tf.image.convert_image_dtype(img, tf.float32)\n",
    "    return tf.image.resize(img, [IMG_WIDTH, IMG_HEIGHT])\n",
    "\n",
    "\n",
    "def process_dataset(file_path):\n",
    "    labels = tf.strings.split(file_path, '/')[0]\n",
    "    label_make = get_label_make(labels)\n",
    "    label_model = get_label_model(labels)\n",
    "    label_year = get_label_year(labels)\n",
    "     \n",
    "    img = tf.io.read_file(file_path)\n",
    "    img = decode_image(img)\n",
    "    return img, (label_make, label_model, label_year)\n",
    "\n",
    "labeled_ds = path_list.map(process_dataset, num_parallel_calls=AUTOTUNE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prepare_for_training(ds, cache=True, shuffle_buffer_size=1000):\n",
    "    if cache:\n",
    "        if isinstance(cache, str):\n",
    "            ds = ds.cache(cache)\n",
    "        else:\n",
    "            ds = ds.cache()\n",
    "    ds = ds.shuffle(buffer_size=shuffle_buffer_size)\n",
    "    ds = ds.repeat()\n",
    "    ds = ds.batch(BATCH_SIZE)\n",
    "    ds = ds.prefetch(buffer_size=AUTOTUNE)\n",
    "    return ds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_size = math.ceil(0.8 * image_count)\n",
    "train_ds = labeled_ds.take(train_size)\n",
    "val_ds = labeled_ds.skip(train_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_set = prepare_for_training(train_ds)\n",
    "val_set = prepare_for_training(val_ds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "image_input = keras.Input(shape=(IMG_WIDTH, IMG_HEIGHT, 3), name='input_image')\n",
    "x = layers.Conv2D(32, (3, 3), activation='relu')(image_input)\n",
    "x = layers.MaxPooling2D()(x)\n",
    "x = layers.Conv2D(32, (3, 3), activation='relu')(x)\n",
    "x = layers.MaxPooling2D()(x)\n",
    "x = layers.Flatten()(x)\n",
    "x = layers.Dense(64, activation='relu')(x)\n",
    "x = layers.Dense(64, activation='relu')(x)\n",
    "\n",
    "output_make = layers.Dense(len(CLASS_NAMES_MAKE), activation='softmax', name='output_make')(x)\n",
    "output_model = layers.Dense(len(CLASS_NAMES_MODEL), activation='softmax', name='output_model')(x)\n",
    "output_year = layers.Dense(len(CLASS_NAMES_YEAR), activation='softmax', name='output_year')(x)\n",
    "\n",
    "cnn = keras.Model(inputs=image_input, outputs=[output_make, output_model, output_year], name='cars_model')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cnn.compile(optimizer='adam',\n",
    "            loss='categorical_crossentropy',\n",
    "            metrics=['acc'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "plot_losses = PlotLossesCallback()\n",
    "cnn.fit(train_set,\n",
    "        steps_per_epoch = STEPS_PER_EPOCH_TRAIN,\n",
    "        epochs = 20,\n",
    "        callbacks=[plot_losses],\n",
    "        validation_data = val_set,\n",
    "        validation_steps = STEPS_PER_EPOCH_VAL\n",
    "        )"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:tf2_ala]",
   "language": "python",
   "name": "conda-env-tf2_ala-py"
  },
  "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}