train_with_Adam+Dec_data.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8aa48255",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-03-15 09:51:20.542673: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory\n",
      "2022-03-15 09:51:20.542715: I tensorflow/stream_executor/cuda/cudart_stub.cc:29] Ignore above cudart dlerror if you do not have a GPU set up on your machine.\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import matplotlib as plt\n",
    "import h5py\n",
    "from PIL import Image\n",
    "import cv2\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8eac67a9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/home/vividlee/Desktop/YeloCar'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.getcwd()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "890d4928",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-03-15 10:06:13.302209: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /home/vividlee/anaconda3/envs/py38/lib/python3.8/site-packages/cv2/../../lib64:\n",
      "2022-03-15 10:06:13.302319: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcublas.so.11'; dlerror: libcublas.so.11: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /home/vividlee/anaconda3/envs/py38/lib/python3.8/site-packages/cv2/../../lib64:\n",
      "2022-03-15 10:06:13.302393: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcublasLt.so.11'; dlerror: libcublasLt.so.11: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /home/vividlee/anaconda3/envs/py38/lib/python3.8/site-packages/cv2/../../lib64:\n",
      "2022-03-15 10:06:13.329358: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcusolver.so.11'; dlerror: libcusolver.so.11: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /home/vividlee/anaconda3/envs/py38/lib/python3.8/site-packages/cv2/../../lib64:\n",
      "2022-03-15 10:06:13.329550: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcusparse.so.11'; dlerror: libcusparse.so.11: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /home/vividlee/anaconda3/envs/py38/lib/python3.8/site-packages/cv2/../../lib64:\n",
      "2022-03-15 10:06:13.330735: W tensorflow/core/common_runtime/gpu/gpu_device.cc:1850] Cannot dlopen some GPU libraries. Please make sure the missing libraries mentioned above are installed properly if you would like to use GPU. Follow the guide at https://www.tensorflow.org/install/gpu for how to download and setup the required libraries for your platform.\n",
      "Skipping registering GPU devices...\n",
      "2022-03-15 10:06:13.331220: I tensorflow/core/platform/cpu_feature_guard.cc:151] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " conv2d (Conv2D)             (None, 46, 62, 32)        896       \n",
      "                                                                 \n",
      " max_pooling2d (MaxPooling2D  (None, 23, 31, 32)       0         \n",
      " )                                                               \n",
      "                                                                 \n",
      " conv2d_1 (Conv2D)           (None, 21, 29, 32)        9248      \n",
      "                                                                 \n",
      " max_pooling2d_1 (MaxPooling  (None, 10, 14, 32)       0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " conv2d_2 (Conv2D)           (None, 8, 12, 32)         9248      \n",
      "                                                                 \n",
      " max_pooling2d_2 (MaxPooling  (None, 4, 6, 32)         0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " flatten (Flatten)           (None, 768)               0         \n",
      "                                                                 \n",
      " dense (Dense)               (None, 128)               98432     \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 64)                8256      \n",
      "                                                                 \n",
      " dense_2 (Dense)             (None, 2)                 130       \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 126,210\n",
      "Trainable params: 126,210\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-03-15 10:06:13.412514: W tensorflow/core/framework/cpu_allocator_impl.cc:82] Allocation of 6699405312 exceeds 10% of free system memory.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/100\n",
      "710/710 [==============================] - ETA: 0s - loss: 0.0522 - mae: 0.0522 - mse: 0.0074\n",
      "Epoch 00001: val_mae improved from inf to 0.07101, saving model to ./Model/Model_test6_0315_deep4pc_test4_all/0315_model_patience5_01-0.0710\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-03-15 10:08:15.729071: W tensorflow/python/util/util.cc:368] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: ./Model/Model_test6_0315_deep4pc_test4_all/0315_model_patience5_01-0.0710/assets\n",
      "710/710 [==============================] - 120s 168ms/step - loss: 0.0522 - mae: 0.0522 - mse: 0.0074 - val_loss: 0.0710 - val_mae: 0.0710 - val_mse: 0.0112\n",
      "Epoch 2/100\n",
      "710/710 [==============================] - ETA: 0s - loss: 0.0483 - mae: 0.0483 - mse: 0.0065\n",
      "Epoch 00002: val_mae improved from 0.07101 to 0.06942, saving model to ./Model/Model_test6_0315_deep4pc_test4_all/0315_model_patience5_02-0.0694\n",
      "INFO:tensorflow:Assets written to: ./Model/Model_test6_0315_deep4pc_test4_all/0315_model_patience5_02-0.0694/assets\n",
      "710/710 [==============================] - 118s 166ms/step - loss: 0.0483 - mae: 0.0483 - mse: 0.0065 - val_loss: 0.0694 - val_mae: 0.0694 - val_mse: 0.0109\n",
      "Epoch 3/100\n",
      "710/710 [==============================] - ETA: 0s - loss: 0.0473 - mae: 0.0473 - mse: 0.0063\n",
      "Epoch 00003: val_mae improved from 0.06942 to 0.06884, saving model to ./Model/Model_test6_0315_deep4pc_test4_all/0315_model_patience5_03-0.0688\n",
      "INFO:tensorflow:Assets written to: ./Model/Model_test6_0315_deep4pc_test4_all/0315_model_patience5_03-0.0688/assets\n",
      "710/710 [==============================] - 117s 165ms/step - loss: 0.0473 - mae: 0.0473 - mse: 0.0063 - val_loss: 0.0688 - val_mae: 0.0688 - val_mse: 0.0108\n",
      "Epoch 4/100\n",
      "710/710 [==============================] - ETA: 0s - loss: 0.0465 - mae: 0.0465 - mse: 0.0060\n",
      "Epoch 00004: val_mae did not improve from 0.06884\n",
      "710/710 [==============================] - 117s 164ms/step - loss: 0.0465 - mae: 0.0465 - mse: 0.0060 - val_loss: 0.0697 - val_mae: 0.0697 - val_mse: 0.0109\n",
      "Epoch 5/100\n",
      "710/710 [==============================] - ETA: 0s - loss: 0.0458 - mae: 0.0458 - mse: 0.0058\n",
      "Epoch 00005: val_mae did not improve from 0.06884\n",
      "710/710 [==============================] - 117s 165ms/step - loss: 0.0458 - mae: 0.0458 - mse: 0.0058 - val_loss: 0.0689 - val_mae: 0.0689 - val_mse: 0.0107\n",
      "Epoch 6/100\n",
      "710/710 [==============================] - ETA: 0s - loss: 0.0449 - mae: 0.0449 - mse: 0.0056\n",
      "Epoch 00006: val_mae did not improve from 0.06884\n",
      "710/710 [==============================] - 118s 166ms/step - loss: 0.0449 - mae: 0.0449 - mse: 0.0056 - val_loss: 0.0707 - val_mae: 0.0707 - val_mse: 0.0109\n",
      "\n",
      "\n",
      "1426/1426 [==============================] - 8s 6ms/step - loss: 0.0707 - mae: 0.0707 - mse: 0.0109\n",
      "[0.07065201550722122, 0.07065201550722122, 0.010946603491902351]\n",
      "[0.07101207971572876, 0.06941789388656616, 0.06884469836950302, 0.06969855725765228, 0.06888938695192337, 0.07065195590257645]\n",
      "[0.05218978226184845, 0.04832511767745018, 0.04733075201511383, 0.04650542885065079, 0.04579167068004608, 0.044918354600667953]\n",
      "[0.07101207971572876, 0.06941789388656616, 0.06884469836950302, 0.06969855725765228, 0.06888938695192337, 0.07065195590257645]\n",
      "[0.05218978226184845, 0.04832511767745018, 0.04733075201511383, 0.04650542885065079, 0.04579167068004608, 0.044918354600667953]\n",
      "tf.Tensor(\n",
      "[[0.43163568 0.23313572]\n",
      " [0.4318049  0.23304598]\n",
      " [0.4346253  0.23069437]\n",
      " [0.46506026 0.23036483]\n",
      " [0.46757433 0.23104598]\n",
      " [0.42830858 0.2260434 ]\n",
      " [0.42716923 0.22745386]\n",
      " [0.4378176  0.22331803]\n",
      " [0.42154273 0.23109168]\n",
      " [0.4310252  0.23154967]\n",
      " [0.43657616 0.22843412]\n",
      " [0.41971004 0.22643413]\n",
      " [0.4197267  0.22644459]\n",
      " [0.3883511  0.22895265]\n",
      " [0.4044592  0.22922795]\n",
      " [0.4050874  0.22924004]\n",
      " [0.3978138  0.2304844 ]\n",
      " [0.39785838 0.23050077]\n",
      " [0.42624658 0.2299414 ]\n",
      " [0.4262635  0.229942  ]], shape=(20, 2), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "# Again, 2022.03.15\n",
    "# one final HDF5\n",
    "# Model_deep4pc_test4_all\n",
    "\n",
    "def createFolder(directory):\n",
    "    try:\n",
    "        if not os.path.exists(directory):\n",
    "            os.makedirs(directory)\n",
    "    except OSError:\n",
    "        print ('Error: Creating directory. ' +  directory)\n",
    "\n",
    "dataset_version = 'deep4pc_test4_all'\n",
    "\n",
    "model_version = '0315_model_' + 'patience3'\n",
    "\n",
    "createFolder('./Test/' + model_version)\n",
    "\n",
    "with h5py.File('./Model/Model_' + dataset_version + '/dataset_hsv_' + dataset_version + '.hdf5', 'r') as hf:\n",
    "    image_train = np.array(hf['x_train'][:, :, :, :])\n",
    "    action_train = np.array(hf['y_train'][:, :])\n",
    "    image_val = np.array(hf['x_val'][:, :, :, :])\n",
    "    action_val = np.array(hf['y_val'][:, :])\n",
    "    \n",
    "    \n",
    "(x_train, y_train), (x_test, y_test) = (image_train, action_train), (image_val, action_val)\n",
    "\n",
    "x_train /= 255.\n",
    "x_test /= 255.\n",
    "\n",
    "model = tf.keras.models.Sequential([\n",
    "    tf.keras.layers.Conv2D(32, 3, activation='relu', input_shape=(48, 64, 3)),\n",
    "    tf.keras.layers.MaxPooling2D(),\n",
    "    tf.keras.layers.Conv2D(32, 3, activation='relu'),\n",
    "    tf.keras.layers.MaxPooling2D(),\n",
    "    tf.keras.layers.Conv2D(32, 3, activation='relu'),\n",
    "    tf.keras.layers.MaxPooling2D(),\n",
    "    tf.keras.layers.Flatten(),\n",
    "    tf.keras.layers.Dense(128, activation='relu'),\n",
    "    tf.keras.layers.Dense(64, activation='relu'),\n",
    "    tf.keras.layers.Dense(2)\n",
    "])\n",
    "\n",
    "# optimizer = tf.keras.optimizers.RMSprop(0.001)\n",
    "\n",
    "model.compile(loss='mae', optimizer='adam', metrics=['mae', 'mse'])\n",
    "\n",
    "model.summary()\n",
    "\n",
    "model_path = './Model/Model_test6_0315_' + dataset_version + '/' + model_version + '_{epoch:02d}-{val_mae:.4f}'\n",
    "\n",
    "checkpointer = tf.keras.callbacks.ModelCheckpoint(filepath= model_path, monitor='val_mae', verbose=1, save_best_only=True)\n",
    "early_stopping_callback = tf.keras.callbacks.EarlyStopping(monitor='val_mae', patience=3)\n",
    "\n",
    "history = model.fit(x=x_train, y=y_train, batch_size=256, epochs=100, validation_data=(x_test, y_test), callbacks=[early_stopping_callback, checkpointer])\n",
    "\n",
    "print(\"\\n\")\n",
    "print(model.evaluate(x_test, y_test))\n",
    "\n",
    "\n",
    "y_vloss = history.history['val_loss']   # testset\n",
    "y_loss = history.history['loss']        # trainset\n",
    "\n",
    "y_vmae = history.history['val_mae']\n",
    "y_mae = history.history['mae']\n",
    "\n",
    "print(y_vloss)\n",
    "print(y_loss)\n",
    "print(y_vmae)\n",
    "print(y_mae)\n",
    "\n",
    "outputs = model(x_test[0:20])\n",
    "\n",
    "print(outputs)\n",
    "\n",
    "f = open('./Test/' + model_version + '/' + model_version + '_test.txt', 'a')\n",
    "f.write(\"{}\".format(outputs))\n",
    "\n",
    "x_test *= 255\n",
    "    \n",
    "for i in range (0, 20) :\n",
    "    cv2.imwrite('./Test/' + model_version + '/'+ model_version + '_' + str(i) + '.jpeg', x_test[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0163202c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.07101207971572876, 0.06941789388656616, 0.06884469836950302, 0.06969855725765228, 0.06888938695192337, 0.07065195590257645]\n",
      "\n",
      "\n",
      "[0.05218978226184845, 0.04832511767745018, 0.04733075201511383, 0.04650542885065079, 0.04579167068004608, 0.044918354600667953]\n",
      "\n",
      "\n",
      "[0.07101207971572876, 0.06941789388656616, 0.06884469836950302, 0.06969855725765228, 0.06888938695192337, 0.07065195590257645]\n",
      "\n",
      "\n",
      "[0.05218978226184845, 0.04832511767745018, 0.04733075201511383, 0.04650542885065079, 0.04579167068004608, 0.044918354600667953]\n",
      "\n",
      "\n",
      "6\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function matplotlib.pyplot.show(close=None, block=None)>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "y_vloss = history.history['val_loss']   # testset\n",
    "y_loss = history.history['loss']        # trainset\n",
    "print(y_vloss)\n",
    "print('\\n')\n",
    "print(y_loss)\n",
    "print('\\n')\n",
    "y_vmae = history.history['val_mae']\n",
    "y_mae = history.history['mae']\n",
    "print(y_vmae)\n",
    "print('\\n')\n",
    "print(y_mae)\n",
    "print('\\n')\n",
    "x_len = np.arange(len(y_loss))\n",
    "print(len(y_loss))\n",
    "print('\\n')\n",
    "\n",
    "plt.figure(figsize=(10, 8))\n",
    "plt.plot(x_len+1, y_vloss, 'ro--', label='val_loss')\n",
    "plt.plot(x_len+1, y_loss, 'bo-', label='loss')\n",
    "plt.xlabel('Epoch', fontsize=14)\n",
    "plt.ylabel('Loss', fontsize=14)\n",
    "plt.legend(loc='upper right', fontsize=14)\n",
    "plt.xlim([0.5, len(y_loss)+0.5])\n",
    "plt.ylim([0.03, 0.08])\n",
    "plt.xticks([1, 3, 5, 7],fontsize=13)\n",
    "plt.yticks(fontsize=13)\n",
    "plt.grid()\n",
    "plt.show()\n",
    "\n",
    "plt.figure(figsize=(10, 8))\n",
    "plt.plot(x_len+1, y_vmae, 'ro--', label='val_mae')\n",
    "plt.plot(x_len+1, y_mae, 'bo-', label='mae')\n",
    "plt.xlabel('Epoch', fontsize=14)\n",
    "plt.ylabel('MAE', fontsize=14)\n",
    "plt.legend(loc='upper right', fontsize=14)\n",
    "plt.xlim([0.5, len(y_loss)+0.5])\n",
    "plt.ylim([0.03, 0.08])\n",
    "plt.xticks([1, 3, 5, 7], fontsize=13)\n",
    "plt.yticks(fontsize=13)\n",
    "plt.grid()\n",
    "plt.show"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf5513e2",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}