Donkeycar_Keras-Cropping.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import sys\n",
    "import time\n",
    "import json\n",
    "import datetime\n",
    "import random\n",
    "import tarfile\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from PIL import Image\n",
    "PATH = \"../tubs/tub5\" #Shadow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.8.0\n"
     ]
    }
   ],
   "source": [
    "#make sure tensorflow version is the same as one installed on donkeycar (1.8.0)\n",
    "import tensorflow as tf\n",
    "print(tf.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['/device:GPU:0']"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from tensorflow.python.client import device_lib\n",
    "\n",
    "def get_available_gpus():\n",
    "    local_device_protos = device_lib.list_local_devices()\n",
    "    return [x.name for x in local_device_protos if x.device_type == 'GPU']\n",
    "get_available_gpus()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "#create df from path\n",
    "def df_from_jsons(PATH, max_items=None):\n",
    "    \n",
    "    #Get json files from path\n",
    "    json_files = [file for file in os.listdir(PATH) if file.endswith('json') ]\n",
    "    \n",
    "    df = pd.DataFrame()\n",
    "    for i, j in enumerate(json_files[1:max_items]):\n",
    "        with open(f'{PATH}/{j}') as f:\n",
    "            data = json.load(f)\n",
    "\n",
    "            userThrottle = data[\"user/throttle\"]\n",
    "            userAngle = data[\"user/angle\"]\n",
    "            camImage_path = data[\"cam/image_array\"]\n",
    "            index = int(camImage_path[:-21])\n",
    "            camImage_path =  PATH + \"/\" + camImage_path\n",
    "            df_row = pd.DataFrame([[userThrottle, userAngle, camImage_path]], index = [index], \n",
    "                                  columns = [\"user/throttle\", \"user/angle\", \"cam/image_array\"])\n",
    "\n",
    "            df = df.append(df_row)\n",
    "    df = df.sort_index()\n",
    "    print(\"Loaded {} json files\".format(len(json_files)))\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "#df = df_from_jsons(PATH, max_items=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "#df.to_feather('tmp/df_wPath')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Jason\\Anaconda3\\envs\\tf-gpu\\lib\\site-packages\\pandas\\io\\feather_format.py:112: FutureWarning: `nthreads` argument is deprecated, pass `use_threads` instead\n",
      "  return feather.read_dataframe(path, nthreads=nthreads)\n"
     ]
    }
   ],
   "source": [
    "df = pd.read_feather('tmp/df_wPATH')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(38574, 3)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>user/throttle</th>\n",
       "      <th>user/angle</th>\n",
       "      <th>cam/image_array</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.08</td>\n",
       "      <td>0.01</td>\n",
       "      <td>../tubs/tub5/0_cam-image_array_.jpg</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.12</td>\n",
       "      <td>-0.03</td>\n",
       "      <td>../tubs/tub5/1_cam-image_array_.jpg</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.12</td>\n",
       "      <td>-0.03</td>\n",
       "      <td>../tubs/tub5/2_cam-image_array_.jpg</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.14</td>\n",
       "      <td>-0.06</td>\n",
       "      <td>../tubs/tub5/3_cam-image_array_.jpg</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.14</td>\n",
       "      <td>-0.06</td>\n",
       "      <td>../tubs/tub5/4_cam-image_array_.jpg</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   user/throttle  user/angle                      cam/image_array\n",
       "0           0.08        0.01  ../tubs/tub5/0_cam-image_array_.jpg\n",
       "1           0.12       -0.03  ../tubs/tub5/1_cam-image_array_.jpg\n",
       "2           0.12       -0.03  ../tubs/tub5/2_cam-image_array_.jpg\n",
       "3           0.14       -0.06  ../tubs/tub5/3_cam-image_array_.jpg\n",
       "4           0.14       -0.06  ../tubs/tub5/4_cam-image_array_.jpg"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_keys = ['cam/image_array']\n",
    "y_keys = ['user/angle', 'user/throttle']\n",
    "new_model_path = 'models/pilot_jn'\n",
    "bs = 256\n",
    "train_frac = 0.8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def to_bin(a):\n",
    "    arr = np.zeros(15)\n",
    "    a = a + 1\n",
    "    b = round(a/(2/14))\n",
    "    arr[int(b)] = 1\n",
    "    return arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_record(record_dict, path = PATH):\n",
    "    data = {}\n",
    "    for key, val in record_dict.items():\n",
    "        if key == 'cam/image_array':\n",
    "            img = Image.open(f'{val}')\n",
    "            val = np.array(img)\n",
    "        \n",
    "        data[key] = val\n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=160x120 at 0x2A766CA8908>"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Testing\n",
    "df_t = df.sample(n=1).to_dict(orient='record')[0]\n",
    "record = read_record(df_t)\n",
    "data = record['cam/image_array']\n",
    "pic = Image.fromarray(data, 'RGB')\n",
    "pic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_record_gen(record_transform=None, shuffle=True, df=None):\n",
    "    while True:\n",
    "        for _ in df.iterrows():\n",
    "            if shuffle:\n",
    "                record_dict = df.sample(n=1).to_dict(orient='record')[0]\n",
    "            \n",
    "            record_dict = read_record(record_dict)\n",
    "            \n",
    "            if record_transform:\n",
    "                record_dict = record_transform(record_dict)\n",
    "            \n",
    "            yield record_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# record_gen = get_record_gen(record_transform=None, shuffle=True, df=df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# next(record_gen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_batch_gen(keys=None, batch_size=128, record_transform=None, shuffle=True, df=None):\n",
    "    \n",
    "    record_gen = get_record_gen(record_transform=record_transform, shuffle=shuffle, df=df)\n",
    "    \n",
    "    while True:\n",
    "        record_list = [next(record_gen) for _ in range(batch_size)]\n",
    "        \n",
    "        batch_arrays = {}\n",
    "        for i, k in enumerate(keys):\n",
    "            arr = np.array([r[k] for r in record_list])\n",
    "            batch_arrays[k] = arr\n",
    "        yield batch_arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_train_gen(X_keys, Y_keys, batch_size=128, record_transform=None, df=None): #\n",
    "    batch_gen = get_batch_gen(X_keys + Y_keys, batch_size=batch_size,\n",
    "                                  record_transform=record_transform, df=df)\n",
    "    while True:\n",
    "        batch = next(batch_gen)\n",
    "        X = [batch[k] for k in X_keys]\n",
    "        Y = [batch[k] for k in Y_keys] \n",
    "        yield X, Y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_train_val_gen(df, X_keys, Y_keys, batch_size = 128, train_frac=0.8, #\n",
    "                      train_record_transform=None, val_record_transform=None): #\n",
    "    train_df = df.sample(frac=train_frac, random_state=200) #\n",
    "    val_df = df.drop(train_df.index) #\n",
    "    \n",
    "    train_gen = get_train_gen(X_keys=X_keys, Y_keys=Y_keys, batch_size=batch_size,\n",
    "                             record_transform=train_record_transform, df=train_df)\n",
    "    val_gen = get_train_gen(X_keys=X_keys, Y_keys=Y_keys, batch_size=batch_size,\n",
    "                           record_transform=val_record_transform, df=val_df)\n",
    "    return train_gen, val_gen\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "def record_transform(record):\n",
    "    record['user/angle'] = to_bin(record['user/angle'])\n",
    "    return record"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_gen, val_gen = get_train_val_gen(df, X_keys, y_keys,\n",
    "                                               train_record_transform=record_transform, #\n",
    "                                               val_record_transform=record_transform, #\n",
    "                                               batch_size=bs, #\n",
    "                                               train_frac=train_frac) #"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.python.keras.layers import Input\n",
    "from tensorflow.python.keras.models import Model, load_model\n",
    "from tensorflow.python.keras.layers import Convolution2D, MaxPooling2D, BatchNormalization, Cropping2D\n",
    "from tensorflow.python.keras.layers import Dropout, Flatten, Dense, Cropping2D, Lambda\n",
    "from tensorflow.python.keras.callbacks import ModelCheckpoint, EarlyStopping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "def default_categorical():\n",
    "    img_in = Input(shape=(120, 160, 3),\n",
    "                   name='img_in')  # First layer, input layer, Shape comes from camera.py resolution, RGB\n",
    "    x = img_in\n",
    "    x = Cropping2D(cropping=((60, 0), (0, 0)))(x)\n",
    "    \n",
    "    x = Convolution2D(16, (3, 3), strides=(2, 2), activation='relu')(x)\n",
    "    x = BatchNormalization()(x)\n",
    "    \n",
    "    x = Convolution2D(24, (3, 3), strides=(2, 2), activation='relu')(x)\n",
    "    x = BatchNormalization()(x)\n",
    "    \n",
    "    x = Convolution2D(32, (3, 3), strides=(2, 2), activation='relu')(x)\n",
    "    x = BatchNormalization()(x)\n",
    "    x = Dropout(0.1)(x)\n",
    "    \n",
    "    x = Convolution2D(64, (3, 3), strides=(1, 1), activation='relu')(x)\n",
    "    x = MaxPooling2D()(x)\n",
    "    x = BatchNormalization()(x)\n",
    "    x = Dropout(0.1)(x)\n",
    "\n",
    "    x = Flatten(name='flattened')(x)\n",
    "    x = Dense(50, activation='relu')(x)\n",
    "    x = Dropout(.2)(x)\n",
    "    \n",
    "    angle_out = Dense(15, activation='softmax', name='angle_out')(x)\n",
    "    throttle_out = Dense(1, activation='relu', name='throttle_out')(x)\n",
    "\n",
    "    model = Model(inputs=[img_in], outputs=[angle_out, throttle_out])\n",
    "    model.compile(optimizer='adam',\n",
    "                  loss={'angle_out': 'categorical_crossentropy',\n",
    "                        'throttle_out': 'mean_absolute_error'},\n",
    "                  loss_weights={'angle_out': 0.9, 'throttle_out': .01})\n",
    "\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "__________________________________________________________________________________________________\n",
      "Layer (type)                    Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      "img_in (InputLayer)             (None, 120, 160, 3)  0                                            \n",
      "__________________________________________________________________________________________________\n",
      "cropping2d_8 (Cropping2D)       (None, 60, 160, 3)   0           img_in[0][0]                     \n",
      "__________________________________________________________________________________________________\n",
      "conv2d_29 (Conv2D)              (None, 29, 79, 16)   448         cropping2d_8[0][0]               \n",
      "__________________________________________________________________________________________________\n",
      "batch_normalization_28 (BatchNo (None, 29, 79, 16)   64          conv2d_29[0][0]                  \n",
      "__________________________________________________________________________________________________\n",
      "conv2d_30 (Conv2D)              (None, 14, 39, 24)   3480        batch_normalization_28[0][0]     \n",
      "__________________________________________________________________________________________________\n",
      "batch_normalization_29 (BatchNo (None, 14, 39, 24)   96          conv2d_30[0][0]                  \n",
      "__________________________________________________________________________________________________\n",
      "conv2d_31 (Conv2D)              (None, 6, 19, 32)    6944        batch_normalization_29[0][0]     \n",
      "__________________________________________________________________________________________________\n",
      "batch_normalization_30 (BatchNo (None, 6, 19, 32)    128         conv2d_31[0][0]                  \n",
      "__________________________________________________________________________________________________\n",
      "dropout_20 (Dropout)            (None, 6, 19, 32)    0           batch_normalization_30[0][0]     \n",
      "__________________________________________________________________________________________________\n",
      "conv2d_32 (Conv2D)              (None, 4, 17, 64)    18496       dropout_20[0][0]                 \n",
      "__________________________________________________________________________________________________\n",
      "max_pooling2d_8 (MaxPooling2D)  (None, 2, 8, 64)     0           conv2d_32[0][0]                  \n",
      "__________________________________________________________________________________________________\n",
      "batch_normalization_31 (BatchNo (None, 2, 8, 64)     256         max_pooling2d_8[0][0]            \n",
      "__________________________________________________________________________________________________\n",
      "dropout_21 (Dropout)            (None, 2, 8, 64)     0           batch_normalization_31[0][0]     \n",
      "__________________________________________________________________________________________________\n",
      "flattened (Flatten)             (None, 1024)         0           dropout_21[0][0]                 \n",
      "__________________________________________________________________________________________________\n",
      "dense_7 (Dense)                 (None, 50)           51250       flattened[0][0]                  \n",
      "__________________________________________________________________________________________________\n",
      "dropout_22 (Dropout)            (None, 50)           0           dense_7[0][0]                    \n",
      "__________________________________________________________________________________________________\n",
      "angle_out (Dense)               (None, 15)           765         dropout_22[0][0]                 \n",
      "__________________________________________________________________________________________________\n",
      "throttle_out (Dense)            (None, 1)            51          dropout_22[0][0]                 \n",
      "==================================================================================================\n",
      "Total params: 81,978\n",
      "Trainable params: 81,706\n",
      "Non-trainable params: 272\n",
      "__________________________________________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model = default_categorical()\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(train_gen, val_gen, saved_model_path, epochs=100, steps=100, train_split=0.8,\n",
    "         verbose=1, min_delta=0.0005, patience=5, use_early_stop=True):\n",
    "    \n",
    "#     checkpoint to save model\n",
    "    save_best = ModelCheckpoint(saved_model_path, monitor='val_loss', verbose=verbose, save_best_only=True, mode='min')\n",
    "    \n",
    "    #stop training if stop improving\n",
    "    early_stop = EarlyStopping(monitor='val_loss', min_delta=min_delta, patience=patience, verbose=verbose, mode='auto')\n",
    "    \n",
    "    callbacks_list = [save_best]\n",
    "    \n",
    "    if use_early_stop:\n",
    "        callbacks_list.append(early_stop)\n",
    "        \n",
    "    hist = model.fit_generator(train_gen, steps_per_epoch=steps, epochs=epochs, verbose=1, validation_data=val_gen,\n",
    "                                callbacks=callbacks_list, validation_steps=steps * (1.0 - train_frac)//train_frac)\n",
    "    return hist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total_records = len(df)\n",
    "total_train = int(total_records * train_frac)\n",
    "total_val = total_records - total_train\n",
    "steps_per_epoch = total_train // bs\n",
    "steps_per_epoch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 1.6746 - angle_out_loss: 1.8566 - throttle_out_loss: 0.3722\n",
      "Epoch 00001: val_loss improved from inf to 1.59611, saving model to models/pilot_jn\n",
      "120/120 [==============================] - 83s 688ms/step - loss: 1.6729 - angle_out_loss: 1.8546 - throttle_out_loss: 0.3718 - val_loss: 1.5961 - val_angle_out_loss: 1.7700 - val_throttle_out_loss: 0.3147\n",
      "Epoch 2/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 1.3567 - angle_out_loss: 1.5039 - throttle_out_loss: 0.3261\n",
      "Epoch 00002: val_loss improved from 1.59611 to 1.32288, saving model to models/pilot_jn\n",
      "120/120 [==============================] - 77s 642ms/step - loss: 1.3569 - angle_out_loss: 1.5040 - throttle_out_loss: 0.3261 - val_loss: 1.3229 - val_angle_out_loss: 1.4663 - val_throttle_out_loss: 0.3187\n",
      "Epoch 3/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 1.2505 - angle_out_loss: 1.3858 - throttle_out_loss: 0.3210\n",
      "Epoch 00003: val_loss improved from 1.32288 to 1.21723, saving model to models/pilot_jn\n",
      "120/120 [==============================] - 77s 638ms/step - loss: 1.2510 - angle_out_loss: 1.3864 - throttle_out_loss: 0.3211 - val_loss: 1.2172 - val_angle_out_loss: 1.3489 - val_throttle_out_loss: 0.3183\n",
      "Epoch 4/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 1.1658 - angle_out_loss: 1.2918 - throttle_out_loss: 0.3209\n",
      "Epoch 00004: val_loss improved from 1.21723 to 1.15642, saving model to models/pilot_jn\n",
      "120/120 [==============================] - 75s 627ms/step - loss: 1.1657 - angle_out_loss: 1.2916 - throttle_out_loss: 0.3209 - val_loss: 1.1564 - val_angle_out_loss: 1.2814 - val_throttle_out_loss: 0.3187\n",
      "Epoch 5/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 1.1111 - angle_out_loss: 1.2310 - throttle_out_loss: 0.3208\n",
      "Epoch 00005: val_loss improved from 1.15642 to 1.11014, saving model to models/pilot_jn\n",
      "120/120 [==============================] - 75s 622ms/step - loss: 1.1109 - angle_out_loss: 1.2307 - throttle_out_loss: 0.3207 - val_loss: 1.1101 - val_angle_out_loss: 1.2299 - val_throttle_out_loss: 0.3203\n",
      "Epoch 6/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 1.0563 - angle_out_loss: 1.1701 - throttle_out_loss: 0.3207\n",
      "Epoch 00006: val_loss improved from 1.11014 to 1.07649, saving model to models/pilot_jn\n",
      "120/120 [==============================] - 70s 584ms/step - loss: 1.0561 - angle_out_loss: 1.1698 - throttle_out_loss: 0.3207 - val_loss: 1.0765 - val_angle_out_loss: 1.1926 - val_throttle_out_loss: 0.3192\n",
      "Epoch 7/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 1.0146 - angle_out_loss: 1.1238 - throttle_out_loss: 0.3208\n",
      "Epoch 00007: val_loss improved from 1.07649 to 1.03411, saving model to models/pilot_jn\n",
      "120/120 [==============================] - 70s 582ms/step - loss: 1.0141 - angle_out_loss: 1.1232 - throttle_out_loss: 0.3208 - val_loss: 1.0341 - val_angle_out_loss: 1.1455 - val_throttle_out_loss: 0.3187\n",
      "Epoch 8/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 0.9754 - angle_out_loss: 1.0802 - throttle_out_loss: 0.3211\n",
      "Epoch 00008: val_loss improved from 1.03411 to 1.02485, saving model to models/pilot_jn\n",
      "120/120 [==============================] - 71s 591ms/step - loss: 0.9757 - angle_out_loss: 1.0805 - throttle_out_loss: 0.3211 - val_loss: 1.0249 - val_angle_out_loss: 1.1352 - val_throttle_out_loss: 0.3193\n",
      "Epoch 9/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 0.9325 - angle_out_loss: 1.0325 - throttle_out_loss: 0.3207\n",
      "Epoch 00009: val_loss improved from 1.02485 to 1.00572, saving model to models/pilot_jn\n",
      "120/120 [==============================] - 70s 585ms/step - loss: 0.9326 - angle_out_loss: 1.0327 - throttle_out_loss: 0.3207 - val_loss: 1.0057 - val_angle_out_loss: 1.1139 - val_throttle_out_loss: 0.3198\n",
      "Epoch 10/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 0.9018 - angle_out_loss: 0.9984 - throttle_out_loss: 0.3211\n",
      "Epoch 00010: val_loss improved from 1.00572 to 0.99596, saving model to models/pilot_jn\n",
      "120/120 [==============================] - 71s 588ms/step - loss: 0.9019 - angle_out_loss: 0.9985 - throttle_out_loss: 0.3211 - val_loss: 0.9960 - val_angle_out_loss: 1.1031 - val_throttle_out_loss: 0.3191\n",
      "Epoch 11/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 0.8812 - angle_out_loss: 0.9755 - throttle_out_loss: 0.3207\n",
      "Epoch 00011: val_loss improved from 0.99596 to 0.98519, saving model to models/pilot_jn\n",
      "120/120 [==============================] - 71s 592ms/step - loss: 0.8814 - angle_out_loss: 0.9757 - throttle_out_loss: 0.3207 - val_loss: 0.9852 - val_angle_out_loss: 1.0911 - val_throttle_out_loss: 0.3183\n",
      "Epoch 12/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 0.8397 - angle_out_loss: 0.9294 - throttle_out_loss: 0.3213\n",
      "Epoch 00012: val_loss improved from 0.98519 to 0.95584, saving model to models/pilot_jn\n",
      "120/120 [==============================] - 71s 594ms/step - loss: 0.8387 - angle_out_loss: 0.9283 - throttle_out_loss: 0.3213 - val_loss: 0.9558 - val_angle_out_loss: 1.0585 - val_throttle_out_loss: 0.3193\n",
      "Epoch 13/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 0.8155 - angle_out_loss: 0.9025 - throttle_out_loss: 0.3206\n",
      "Epoch 00013: val_loss improved from 0.95584 to 0.93844, saving model to models/pilot_jn\n",
      "120/120 [==============================] - 71s 588ms/step - loss: 0.8157 - angle_out_loss: 0.9028 - throttle_out_loss: 0.3206 - val_loss: 0.9384 - val_angle_out_loss: 1.0392 - val_throttle_out_loss: 0.3201\n",
      "Epoch 14/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 0.7974 - angle_out_loss: 0.8824 - throttle_out_loss: 0.3209\n",
      "Epoch 00014: val_loss improved from 0.93844 to 0.93737, saving model to models/pilot_jn\n",
      "120/120 [==============================] - 71s 592ms/step - loss: 0.7971 - angle_out_loss: 0.8821 - throttle_out_loss: 0.3209 - val_loss: 0.9374 - val_angle_out_loss: 1.0380 - val_throttle_out_loss: 0.3191\n",
      "Epoch 15/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 0.7672 - angle_out_loss: 0.8489 - throttle_out_loss: 0.3202\n",
      "Epoch 00015: val_loss did not improve\n",
      "120/120 [==============================] - 72s 598ms/step - loss: 0.7682 - angle_out_loss: 0.8500 - throttle_out_loss: 0.3203 - val_loss: 0.9447 - val_angle_out_loss: 1.0462 - val_throttle_out_loss: 0.3200\n",
      "Epoch 16/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 0.7522 - angle_out_loss: 0.8323 - throttle_out_loss: 0.3211\n",
      "Epoch 00016: val_loss improved from 0.93737 to 0.85408, saving model to models/pilot_jn\n",
      "120/120 [==============================] - 71s 594ms/step - loss: 0.7515 - angle_out_loss: 0.8315 - throttle_out_loss: 0.3211 - val_loss: 0.8541 - val_angle_out_loss: 0.9454 - val_throttle_out_loss: 0.3196\n",
      "Epoch 17/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 0.7418 - angle_out_loss: 0.8207 - throttle_out_loss: 0.3207\n",
      "Epoch 00017: val_loss improved from 0.85408 to 0.84120, saving model to models/pilot_jn\n",
      "120/120 [==============================] - 70s 583ms/step - loss: 0.7412 - angle_out_loss: 0.8199 - throttle_out_loss: 0.3207 - val_loss: 0.8412 - val_angle_out_loss: 0.9311 - val_throttle_out_loss: 0.3197\n",
      "Epoch 18/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 0.7299 - angle_out_loss: 0.8075 - throttle_out_loss: 0.3200\n",
      "Epoch 00018: val_loss did not improve\n",
      "120/120 [==============================] - 70s 584ms/step - loss: 0.7298 - angle_out_loss: 0.8074 - throttle_out_loss: 0.3200 - val_loss: 0.8891 - val_angle_out_loss: 0.9844 - val_throttle_out_loss: 0.3190\n",
      "Epoch 19/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 0.7084 - angle_out_loss: 0.7835 - throttle_out_loss: 0.3204\n",
      "Epoch 00019: val_loss did not improve\n",
      "120/120 [==============================] - 70s 586ms/step - loss: 0.7082 - angle_out_loss: 0.7833 - throttle_out_loss: 0.3204 - val_loss: 0.8770 - val_angle_out_loss: 0.9709 - val_throttle_out_loss: 0.3191\n",
      "Epoch 20/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 0.6898 - angle_out_loss: 0.7629 - throttle_out_loss: 0.3209\n",
      "Epoch 00020: val_loss improved from 0.84120 to 0.82066, saving model to models/pilot_jn\n",
      "120/120 [==============================] - 70s 585ms/step - loss: 0.6902 - angle_out_loss: 0.7633 - throttle_out_loss: 0.3209 - val_loss: 0.8207 - val_angle_out_loss: 0.9083 - val_throttle_out_loss: 0.3186\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 21/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 0.6817 - angle_out_loss: 0.7539 - throttle_out_loss: 0.3200\n",
      "Epoch 00021: val_loss improved from 0.82066 to 0.81659, saving model to models/pilot_jn\n",
      "120/120 [==============================] - 70s 585ms/step - loss: 0.6821 - angle_out_loss: 0.7543 - throttle_out_loss: 0.3201 - val_loss: 0.8166 - val_angle_out_loss: 0.9038 - val_throttle_out_loss: 0.3191\n",
      "Epoch 22/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 0.6736 - angle_out_loss: 0.7449 - throttle_out_loss: 0.3207\n",
      "Epoch 00022: val_loss did not improve\n",
      "120/120 [==============================] - 70s 583ms/step - loss: 0.6735 - angle_out_loss: 0.7448 - throttle_out_loss: 0.3207 - val_loss: 0.8537 - val_angle_out_loss: 0.9450 - val_throttle_out_loss: 0.3190\n",
      "Epoch 23/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 0.6642 - angle_out_loss: 0.7344 - throttle_out_loss: 0.3204\n",
      "Epoch 00023: val_loss did not improve\n",
      "120/120 [==============================] - 70s 584ms/step - loss: 0.6639 - angle_out_loss: 0.7341 - throttle_out_loss: 0.3204 - val_loss: 0.8267 - val_angle_out_loss: 0.9150 - val_throttle_out_loss: 0.3195\n",
      "Epoch 24/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 0.6517 - angle_out_loss: 0.7206 - throttle_out_loss: 0.3202\n",
      "Epoch 00024: val_loss improved from 0.81659 to 0.79956, saving model to models/pilot_jn\n",
      "120/120 [==============================] - 71s 593ms/step - loss: 0.6515 - angle_out_loss: 0.7204 - throttle_out_loss: 0.3202 - val_loss: 0.7996 - val_angle_out_loss: 0.8848 - val_throttle_out_loss: 0.3197\n",
      "Epoch 25/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 0.6486 - angle_out_loss: 0.7171 - throttle_out_loss: 0.3203\n",
      "Epoch 00025: val_loss did not improve\n",
      "120/120 [==============================] - 70s 583ms/step - loss: 0.6489 - angle_out_loss: 0.7174 - throttle_out_loss: 0.3203 - val_loss: 0.8156 - val_angle_out_loss: 0.9027 - val_throttle_out_loss: 0.3178\n",
      "Epoch 26/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 0.6312 - angle_out_loss: 0.6978 - throttle_out_loss: 0.3198\n",
      "Epoch 00026: val_loss did not improve\n",
      "120/120 [==============================] - 70s 585ms/step - loss: 0.6318 - angle_out_loss: 0.6985 - throttle_out_loss: 0.3197 - val_loss: 0.8213 - val_angle_out_loss: 0.9090 - val_throttle_out_loss: 0.3194\n",
      "Epoch 27/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 0.6385 - angle_out_loss: 0.7058 - throttle_out_loss: 0.3187\n",
      "Epoch 00027: val_loss improved from 0.79956 to 0.77921, saving model to models/pilot_jn\n",
      "120/120 [==============================] - 70s 584ms/step - loss: 0.6389 - angle_out_loss: 0.7064 - throttle_out_loss: 0.3186 - val_loss: 0.7792 - val_angle_out_loss: 0.8623 - val_throttle_out_loss: 0.3182\n",
      "Epoch 28/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 0.6200 - angle_out_loss: 0.6854 - throttle_out_loss: 0.3168\n",
      "Epoch 00028: val_loss improved from 0.77921 to 0.76699, saving model to models/pilot_jn\n",
      "120/120 [==============================] - 70s 583ms/step - loss: 0.6201 - angle_out_loss: 0.6855 - throttle_out_loss: 0.3167 - val_loss: 0.7670 - val_angle_out_loss: 0.8488 - val_throttle_out_loss: 0.3075\n",
      "Epoch 29/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 0.6115 - angle_out_loss: 0.6761 - throttle_out_loss: 0.2947\n",
      "Epoch 00029: val_loss did not improve\n",
      "120/120 [==============================] - 70s 582ms/step - loss: 0.6113 - angle_out_loss: 0.6759 - throttle_out_loss: 0.2944 - val_loss: 0.7931 - val_angle_out_loss: 0.8785 - val_throttle_out_loss: 0.2494\n",
      "Epoch 30/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 0.6032 - angle_out_loss: 0.6690 - throttle_out_loss: 0.1076\n",
      "Epoch 00030: val_loss did not improve\n",
      "120/120 [==============================] - 70s 583ms/step - loss: 0.6031 - angle_out_loss: 0.6690 - throttle_out_loss: 0.1070 - val_loss: 0.7866 - val_angle_out_loss: 0.8735 - val_throttle_out_loss: 0.0444\n",
      "Epoch 31/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 0.6039 - angle_out_loss: 0.6706 - throttle_out_loss: 0.0369\n",
      "Epoch 00031: val_loss did not improve\n",
      "120/120 [==============================] - 70s 583ms/step - loss: 0.6031 - angle_out_loss: 0.6697 - throttle_out_loss: 0.0369 - val_loss: 0.8049 - val_angle_out_loss: 0.8939 - val_throttle_out_loss: 0.0363\n",
      "Epoch 32/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 0.5964 - angle_out_loss: 0.6622 - throttle_out_loss: 0.0357\n",
      "Epoch 00032: val_loss improved from 0.76699 to 0.74551, saving model to models/pilot_jn\n",
      "120/120 [==============================] - 71s 592ms/step - loss: 0.5964 - angle_out_loss: 0.6623 - throttle_out_loss: 0.0357 - val_loss: 0.7455 - val_angle_out_loss: 0.8279 - val_throttle_out_loss: 0.0357\n",
      "Epoch 33/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 0.5861 - angle_out_loss: 0.6508 - throttle_out_loss: 0.0356\n",
      "Epoch 00033: val_loss did not improve\n",
      "120/120 [==============================] - 70s 583ms/step - loss: 0.5864 - angle_out_loss: 0.6512 - throttle_out_loss: 0.0356 - val_loss: 0.7935 - val_angle_out_loss: 0.8812 - val_throttle_out_loss: 0.0379\n",
      "Epoch 34/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 0.5795 - angle_out_loss: 0.6435 - throttle_out_loss: 0.0355\n",
      "Epoch 00034: val_loss did not improve\n",
      "120/120 [==============================] - 75s 622ms/step - loss: 0.5794 - angle_out_loss: 0.6434 - throttle_out_loss: 0.0355 - val_loss: 0.7859 - val_angle_out_loss: 0.8729 - val_throttle_out_loss: 0.0374\n",
      "Epoch 35/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 0.5812 - angle_out_loss: 0.6454 - throttle_out_loss: 0.0351\n",
      "Epoch 00035: val_loss did not improve\n",
      "120/120 [==============================] - 72s 602ms/step - loss: 0.5810 - angle_out_loss: 0.6452 - throttle_out_loss: 0.0351 - val_loss: 0.7715 - val_angle_out_loss: 0.8568 - val_throttle_out_loss: 0.0353\n",
      "Epoch 36/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 0.5834 - angle_out_loss: 0.6478 - throttle_out_loss: 0.0356\n",
      "Epoch 00036: val_loss did not improve\n",
      "120/120 [==============================] - 78s 647ms/step - loss: 0.5838 - angle_out_loss: 0.6482 - throttle_out_loss: 0.0356 - val_loss: 0.7532 - val_angle_out_loss: 0.8364 - val_throttle_out_loss: 0.0354\n",
      "Epoch 37/100\n",
      "119/120 [============================>.] - ETA: 0s - loss: 0.5683 - angle_out_loss: 0.6311 - throttle_out_loss: 0.0349\n",
      "Epoch 00037: val_loss did not improve\n",
      "120/120 [==============================] - 78s 654ms/step - loss: 0.5680 - angle_out_loss: 0.6307 - throttle_out_loss: 0.0349 - val_loss: 0.7459 - val_angle_out_loss: 0.8284 - val_throttle_out_loss: 0.0372\n",
      "Epoch 00037: early stopping\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras._impl.keras.callbacks.History at 0x2aa77db2e10>"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train(train_gen, val_gen, saved_model_path=new_model_path, steps=steps_per_epoch, train_split=0.8) #change train_split to 0.9 for large data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nRecords\\n\\nOriginal architecture with 79k samples\\n498/498 [==============================] - 215s 432ms/step - loss: 0.4393 - angle_out_loss: 0.4875 \\n- throttle_out_loss: 0.0551 - val_loss: 0.8894 - val_angle_out_loss: 0.9876 - val_throttle_out_loss: 0.0586\\nEpoch 00028: early stopping\\n\\nOriginal architecture with 79k samples and 0.2 and 0.3 dropout at the end\\n498/498 [==============================] - 239s 480ms/step - loss: 0.5324 - angle_out_loss: 0.5910 - \\nthrottle_out_loss: 0.0585 - val_loss: 0.9268 - val_angle_out_loss: 1.0292 - val_throttle_out_loss: 0.0530\\nEpoch 00030: early stopping\\n\\nOriginal architecture with 79k samples and 0.3 and 0.5 dropout at the end\\n\\n'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "Records\n",
    "\n",
    "Original architecture with 79k samples\n",
    "498/498 [==============================] - 215s 432ms/step - loss: 0.4393 - angle_out_loss: 0.4875 \n",
    "- throttle_out_loss: 0.0551 - val_loss: 0.8894 - val_angle_out_loss: 0.9876 - val_throttle_out_loss: 0.0586\n",
    "Epoch 00028: early stopping\n",
    "\n",
    "Original architecture with 79k samples and 0.2 and 0.3 dropout at the end\n",
    "498/498 [==============================] - 239s 480ms/step - loss: 0.5324 - angle_out_loss: 0.5910 - \n",
    "throttle_out_loss: 0.0585 - val_loss: 0.9268 - val_angle_out_loss: 1.0292 - val_throttle_out_loss: 0.0530\n",
    "Epoch 00030: early stopping\n",
    "\n",
    "Original architecture with 79k samples and 0.3 and 0.5 dropout at the end\n",
    "\n",
    "\"\"\"\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [],
   "source": [
    "#check against original\n",
    "def unbin(arr):\n",
    "    index = np.argmax(arr)\n",
    "    return index/14*2-1\n",
    "#     return index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unbin([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run(img_arr):\n",
    "    img_arr = img_arr.reshape((1,) + img_arr.shape)\n",
    "    angle_binned, throttle = model.predict(img_arr)\n",
    "    angle_unbinned = unbin(angle_binned[0])\n",
    "    return angle_unbinned, throttle[0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=160x120 at 0x2119C0EA780>"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "img_name = df['cam/image_array'][150]\n",
    "img = Image.open(f'{PATH}/{img_name}')\n",
    "img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [],
   "source": [
    "val = np.array(img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(120, 160, 3)"
      ]
     },
     "execution_count": 196,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "val.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-0.4285714285714286, 0.31011686)"
      ]
     },
     "execution_count": 198,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#prediction\n",
    "run(val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-0.42, 0.27)"
      ]
     },
     "execution_count": 199,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#compare to actual data\n",
    "df['user/angle'][150], df['user/throttle'][150]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Record\n",
    ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n",
    "def default_categorical():\n",
    "    img_in = Input(shape=(120, 160, 3),\n",
    "                   name='img_in')  # First layer, input layer, Shape comes from camera.py resolution, RGB\n",
    "    x = img_in\n",
    "    x = Convolution2D(24, (5, 5), strides=(2, 2), activation='relu')(x)\n",
    "    x = MaxPooling2D(pool_size=(2, 2))(x)\n",
    "    x = Convolution2D(32, (4, 4), strides=(2, 2), activation='relu')(x)\n",
    "    x = MaxPooling2D(pool_size=(2, 2))(x)\n",
    "    x = Dropout(0.3)(x)\n",
    "    x = Convolution2D(64, (3, 3), strides=(1, 1), activation='relu')(x)\n",
    "    x = MaxPooling2D(pool_size=(2, 2))(x)\n",
    "    x = Dropout(0.5)(x)\n",
    "\n",
    "    x = Flatten(name='flattened')(x)\n",
    "    x = Dense(30, activation='relu')(x)\n",
    "    x = Dropout(0.5)(x)\n",
    "    \n",
    "    angle_out = Dense(15, activation='softmax', name='angle_out')(x)\n",
    "    throttle_out = Dense(1, activation='relu', name='throttle_out')(x)\n",
    "\n",
    "    model = Model(inputs=[img_in], outputs=[angle_out, throttle_out])\n",
    "    model.compile(optimizer='adam',\n",
    "                  loss={'angle_out': 'categorical_crossentropy',\n",
    "                        'throttle_out': 'mean_absolute_error'},\n",
    "                  loss_weights={'angle_out': 0.9, 'throttle_out': .01})\n",
    "\n",
    "    return model\n",
    "\"\"\"\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Tensorflow-GPU",
   "language": "python",
   "name": "tf-gpu"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}