projet-reseaux-profond/notebook.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import PIL.Image\n",
    "import glob\n",
    "import os\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/tmp/deepl/dataset_rot\n",
      "['octane', 'werewolf', 'breakout', 'aftershock']\n"
     ]
    }
   ],
   "source": [
    "IMAGE_SIZE = (400, 150, 3)\n",
    "RESIZED_SIZE = (100, 50, 3)\n",
    "RESIZED_SIZE_PIL = (RESIZED_SIZE[1], RESIZED_SIZE[0], RESIZED_SIZE[2])\n",
    "DATASET_PATH = \"./dataset_rot/\"\n",
    "DATASET_PATH = os.path.abspath(DATASET_PATH)\n",
    "CLASSES = next(os.walk(DATASET_PATH))[1]\n",
    "\n",
    "print(DATASET_PATH)\n",
    "print(CLASSES)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_data():\n",
    "    # Récupération des fichiers\n",
    "    files = glob.glob(f\"{DATASET_PATH}/**/*.jpg\", recursive = True)\n",
    "\n",
    "    # Initialise les structures de données\n",
    "    x = np.zeros((len(files), *RESIZED_SIZE_PIL))\n",
    "    y = np.zeros((len(files), 1))\n",
    "\n",
    "    # print(f\"x.shape = {x.shape}\")\n",
    "\n",
    "    for i, path in enumerate(files):\n",
    "        # Lecture de l'image\n",
    "        img = PIL.Image.open(path)\n",
    "\n",
    "        # print(f\"img.size = {img.size}\")\n",
    "\n",
    "        # Redimensionnement de l'image\n",
    "        img = img.resize(RESIZED_SIZE[:-1], PIL.Image.ANTIALIAS)\n",
    "\n",
    "        # print(f\"img.size = {img.size}\")\n",
    "\n",
    "        test = np.asarray(img)\n",
    "\n",
    "        # print(f\"test.shape = {test.shape}\")\n",
    "\n",
    "        # Remplissage de la variable x\n",
    "        x[i] = test\n",
    "\n",
    "        # On récupère l'index dans le path\n",
    "        class_label = path.split(\"/\")[-2]\n",
    "\n",
    "        # On récupère le numéro de la classe à partir du string\n",
    "        class_label = CLASSES.index(class_label)\n",
    "        \n",
    "        # Remplissage de la variable y\n",
    "        y[i] = class_label\n",
    "\n",
    "    return x, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = load_data()\n",
    "x = x / 255"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 864x432 with 9 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Randomisation des indices et affichage de 9 images alétoires de la base d'apprentissage\n",
    "indices = np.arange(x.shape[0])\n",
    "np.random.shuffle(indices)\n",
    "\n",
    "plt.figure(figsize=(12, 6))\n",
    "\n",
    "for i in range(0, 3*3):\n",
    "    plt.subplot(3, 3, i+1)\n",
    "    plt.title(CLASSES[int(y[indices[i]])])\n",
    "    plt.imshow(x[indices[i]])\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import InputLayer, Dense, Flatten, Conv2D, MaxPooling2D\n",
    "from tensorflow.keras import optimizers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-04-05 22:28:37.416102: 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",
      "2022-04-05 22:28:40.750736: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 1538 MB memory:  -> device: 0, name: Quadro K620, pci bus id: 0000:03:00.0, compute capability: 5.0\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " conv2d (Conv2D)             (None, 48, 98, 32)        896       \n",
      "                                                                 \n",
      " max_pooling2d (MaxPooling2D  (None, 24, 49, 32)       0         \n",
      " )                                                               \n",
      "                                                                 \n",
      " conv2d_1 (Conv2D)           (None, 22, 47, 64)        18496     \n",
      "                                                                 \n",
      " max_pooling2d_1 (MaxPooling  (None, 11, 23, 64)       0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " conv2d_2 (Conv2D)           (None, 9, 21, 92)         53084     \n",
      "                                                                 \n",
      " max_pooling2d_2 (MaxPooling  (None, 4, 10, 92)        0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " flatten (Flatten)           (None, 3680)              0         \n",
      "                                                                 \n",
      " dense (Dense)               (None, 250)               920250    \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 4)                 1004      \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 993,730\n",
      "Trainable params: 993,730\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "Epoch 1/10\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-04-05 22:28:44.035945: I tensorflow/stream_executor/cuda/cuda_dnn.cc:368] Loaded cuDNN version 8100\n",
      "2022-04-05 22:28:44.502196: W tensorflow/stream_executor/gpu/asm_compiler.cc:111] *** WARNING *** You are using ptxas 10.1.243, which is older than 11.1. ptxas before 11.1 is known to miscompile XLA code, leading to incorrect results or invalid-address errors.\n",
      "\n",
      "You may not need to update to CUDA 11.1; cherry-picking the ptxas binary is often sufficient.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "136/136 [==============================] - 8s 38ms/step - loss: 1.3556 - accuracy: 0.3171 - val_loss: 1.8914 - val_accuracy: 0.0000e+00\n",
      "Epoch 2/10\n",
      "136/136 [==============================] - 5s 35ms/step - loss: 1.2893 - accuracy: 0.6168 - val_loss: 2.0711 - val_accuracy: 0.0000e+00\n",
      "Epoch 3/10\n",
      "136/136 [==============================] - 5s 35ms/step - loss: 1.2347 - accuracy: 0.7135 - val_loss: 2.0556 - val_accuracy: 0.0000e+00\n",
      "Epoch 4/10\n",
      "136/136 [==============================] - 5s 35ms/step - loss: 1.1550 - accuracy: 0.7450 - val_loss: 1.9452 - val_accuracy: 0.0000e+00\n",
      "Epoch 5/10\n",
      "136/136 [==============================] - 5s 35ms/step - loss: 1.0499 - accuracy: 0.7638 - val_loss: 1.9318 - val_accuracy: 0.0000e+00\n",
      "Epoch 6/10\n",
      "136/136 [==============================] - 5s 35ms/step - loss: 0.9393 - accuracy: 0.7618 - val_loss: 1.7806 - val_accuracy: 0.0000e+00\n",
      "Epoch 7/10\n",
      "136/136 [==============================] - 5s 35ms/step - loss: 0.8375 - accuracy: 0.7762 - val_loss: 1.5481 - val_accuracy: 0.0650\n",
      "Epoch 8/10\n",
      "136/136 [==============================] - 5s 35ms/step - loss: 0.7452 - accuracy: 0.7985 - val_loss: 1.5029 - val_accuracy: 0.0717\n",
      "Epoch 9/10\n",
      "136/136 [==============================] - 5s 35ms/step - loss: 0.6600 - accuracy: 0.8229 - val_loss: 1.3571 - val_accuracy: 0.2733\n",
      "Epoch 10/10\n",
      "136/136 [==============================] - 5s 35ms/step - loss: 0.5855 - accuracy: 0.8603 - val_loss: 1.1708 - val_accuracy: 0.4583\n"
     ]
    }
   ],
   "source": [
    "model = Sequential()\n",
    "\n",
    "model.add(InputLayer(input_shape=RESIZED_SIZE_PIL))\n",
    "\n",
    "model.add(Conv2D(32, 3, activation=\"relu\"))\n",
    "model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "\n",
    "model.add(Conv2D(64, 3, activation=\"relu\"))\n",
    "model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "\n",
    "model.add(Conv2D(92, 3, activation=\"relu\"))\n",
    "model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "\n",
    "model.add(Flatten())\n",
    "\n",
    "model.add(Dense(250, activation=\"relu\"))\n",
    "\n",
    "model.add(Dense(4, activation=\"softmax\"))\n",
    "\n",
    "model.summary()\n",
    "\n",
    "adam = optimizers.Adam(learning_rate=7e-6)\n",
    "model.compile(optimizer=adam, loss='sparse_categorical_crossentropy', metrics=['accuracy'])\n",
    "history = model.fit(x, y, validation_split=0.15, epochs=10, batch_size=25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_training_analysis():\n",
    "  acc = history.history['accuracy']\n",
    "  val_acc = history.history['val_accuracy']\n",
    "  loss = history.history['loss']\n",
    "  val_loss = history.history['val_loss']\n",
    "\n",
    "  epochs = range(len(acc))\n",
    "\n",
    "  plt.plot(epochs, acc, 'b', linestyle=\"--\",label='Training acc')\n",
    "  plt.plot(epochs, val_acc, 'g', label='Validation acc')\n",
    "  plt.title('Training and validation accuracy')\n",
    "  plt.legend()\n",
    "\n",
    "  plt.figure()\n",
    "\n",
    "  plt.plot(epochs, loss, 'b', linestyle=\"--\",label='Training loss')\n",
    "  plt.plot(epochs, val_loss,'g', label='Validation loss')\n",
    "  plt.title('Training and validation loss')\n",
    "  plt.legend()\n",
    "\n",
    "  plt.show()\n",
    "\n",
    "plot_training_analysis()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/tmp/deepl/data\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "IMAGE_SIZE = (400, 150, 3)\n",
    "RESIZED_SIZE = (100, 50, 3)\n",
    "RESIZED_SIZE_PIL = (RESIZED_SIZE[1], RESIZED_SIZE[0], RESIZED_SIZE[2])\n",
    "DATASET_PATH = \"./data/\"\n",
    "DATASET_PATH = os.path.abspath(DATASET_PATH)\n",
    "CLASSES = next(os.walk(DATASET_PATH))[1]\n",
    "\n",
    "print(DATASET_PATH)\n",
    "print(CLASSES)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dataset_length = 380870\n",
      "batch size = 16\n",
      "number of batchs = 23804\n",
      "\n",
      "train_size = 304696\n",
      "validation_size = 76174\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "import tensorflow_addons as tfa\n",
    "import sqlite3\n",
    "\n",
    "AUTOTUNE = tf.data.experimental.AUTOTUNE\n",
    "BATCH_SIZE = 16\n",
    "\n",
    "def customGenerator():\n",
    "    data = sqlite3.connect(f\"{DATASET_PATH}/index.db\").execute(\"SELECT uuid, model from data LIMIT 10000\").fetchall()\n",
    "\n",
    "    for uuid, model in data:\n",
    "        img = tf.io.read_file(f\"{DATASET_PATH}/{uuid}.jpg\")\n",
    "        img = tf.image.decode_jpeg(img, channels=IMAGE_SIZE[2])\n",
    "        img = tf.image.convert_image_dtype(img, tf.float32)\n",
    "        img = tf.image.resize(img, RESIZED_SIZE[:-1])\n",
    "        \n",
    "        label = tf.convert_to_tensor(model, dtype=tf.uint8)\n",
    "        \n",
    "        # img.set_shape(RESIZED_SIZE)\n",
    "        # label.set_shape([])\n",
    "        \n",
    "        yield img, label\n",
    "\n",
    "def cutout(image, label):\n",
    "    img = tfa.image.random_cutout(image, (6, 6), constant_values=1)\n",
    "    return (img, label)\n",
    "\n",
    "def rotate(image,label) :\n",
    "    img = tfa.image.rotate(image, tf.constant(np.pi))   \n",
    "    return (img, label)\n",
    "\n",
    "dataset = tf.data.Dataset.from_generator(\n",
    "    generator=customGenerator, \n",
    "    output_types=(tf.float32, tf.uint8)\n",
    ")\n",
    "\n",
    "(dataset_length,) = sqlite3.connect(f\"{DATASET_PATH}/index.db\").execute(\"SELECT count(uuid) from data\").fetchone()\n",
    "print(f\"dataset_length = {dataset_length}\")\n",
    "print(f\"batch size = {BATCH_SIZE}\")\n",
    "print(f\"number of batchs = {dataset_length // BATCH_SIZE}\")\n",
    "\n",
    "print()\n",
    "\n",
    "train_size = int(0.8 * dataset_length)\n",
    "print(f\"train_size = {train_size}\")\n",
    "print(f\"validation_size = {dataset_length - train_size}\")\n",
    "\n",
    "dataset = (\n",
    "    dataset.batch(BATCH_SIZE)\n",
    "    .prefetch(AUTOTUNE)\n",
    "    # .map(cutout)\n",
    ")\n",
    "\n",
    "dataset_train = dataset.take(train_size)\n",
    "dataset_validate = dataset.skip(train_size)\n",
    "\n",
    "dataset_train = dataset_train.shuffle(10)\n",
    "\n",
    "# print(RESIZED_SIZE)\n",
    "# for boop in dataset_train.take(2):\n",
    "#     print(boop)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_1\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " conv2d_3 (Conv2D)           (None, 98, 48, 32)        896       \n",
      "                                                                 \n",
      " max_pooling2d_3 (MaxPooling  (None, 49, 24, 32)       0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " conv2d_4 (Conv2D)           (None, 47, 22, 64)        18496     \n",
      "                                                                 \n",
      " max_pooling2d_4 (MaxPooling  (None, 23, 11, 64)       0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " conv2d_5 (Conv2D)           (None, 21, 9, 92)         53084     \n",
      "                                                                 \n",
      " max_pooling2d_5 (MaxPooling  (None, 10, 4, 92)        0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " flatten_1 (Flatten)         (None, 3680)              0         \n",
      "                                                                 \n",
      " dense_2 (Dense)             (None, 250)               920250    \n",
      "                                                                 \n",
      " dense_3 (Dense)             (None, 4)                 1004      \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 993,730\n",
      "Trainable params: 993,730\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "Epoch 1/10\n",
      "625/625 [==============================] - 89s 139ms/step - loss: 0.7095\n",
      "Epoch 2/10\n",
      "625/625 [==============================] - 37s 59ms/step - loss: 0.4486\n",
      "Epoch 3/10\n",
      "625/625 [==============================] - 37s 59ms/step - loss: 0.3915\n",
      "Epoch 4/10\n",
      "625/625 [==============================] - 37s 59ms/step - loss: 0.3414\n",
      "Epoch 5/10\n",
      "625/625 [==============================] - 37s 59ms/step - loss: 0.3116\n",
      "Epoch 6/10\n",
      "625/625 [==============================] - 37s 59ms/step - loss: 0.2882\n",
      "Epoch 7/10\n",
      "625/625 [==============================] - 37s 59ms/step - loss: 0.2601\n",
      "Epoch 8/10\n",
      "625/625 [==============================] - 37s 59ms/step - loss: 0.2375\n",
      "Epoch 9/10\n",
      "625/625 [==============================] - 37s 59ms/step - loss: 0.2176\n",
      "Epoch 10/10\n",
      "625/625 [==============================] - 37s 59ms/step - loss: 0.1952\n"
     ]
    }
   ],
   "source": [
    "model = Sequential([\n",
    "    InputLayer(input_shape=RESIZED_SIZE),\n",
    "    \n",
    "    Conv2D(32, 3, activation=\"relu\"),\n",
    "    MaxPooling2D(pool_size=(2, 2)),\n",
    "    \n",
    "    Conv2D(64, 3, activation=\"relu\"),\n",
    "    MaxPooling2D(pool_size=(2, 2)),\n",
    "\n",
    "    Conv2D(92, 3, activation=\"relu\"),\n",
    "    MaxPooling2D(pool_size=(2, 2)),\n",
    "\n",
    "    Flatten(),\n",
    "\n",
    "    Dense(250, activation=\"relu\"),\n",
    "    Dense(4, activation=\"softmax\")\n",
    "])\n",
    "\n",
    "model.summary()\n",
    "\n",
    "adam = optimizers.Adam(learning_rate=7e-6)\n",
    "# model.compile(optimizer=adam, loss='sparse_categorical_crossentropy', metrics=['accuracy']) # not currently working\n",
    "model.compile(optimizer=adam, loss='sparse_categorical_crossentropy')\n",
    "history = model.fit(dataset_train, validation_data=dataset_validate, epochs=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_training_analysis():\n",
    "#   acc = history.history['accuracy']\n",
    "#   val_acc = history.history['val_accuracy']\n",
    "  loss = history.history['loss']\n",
    "#   val_loss = history.history['val_loss']\n",
    "\n",
    "  epochs = range(len(loss))\n",
    "\n",
    "#   plt.plot(epochs, acc, 'b', linestyle=\"--\",label='Training acc')\n",
    "#   plt.plot(epochs, val_acc, 'g', label='Validation acc')\n",
    "#   plt.title('Training and validation accuracy')\n",
    "#   plt.legend()\n",
    "\n",
    "#   plt.figure()\n",
    "\n",
    "  plt.plot(epochs, loss, 'b', linestyle=\"--\",label='Training loss')\n",
    "#   plt.plot(epochs, val_loss,'g', label='Validation loss')\n",
    "  plt.title('Training and validation loss')\n",
    "  plt.legend()\n",
    "\n",
    "  plt.show()\n",
    "\n",
    "plot_training_analysis()"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "e55666fbbf217aa3df372b978577f47b6009e2f78e2ec76a584f49cd54a1e62c"
  },
  "kernelspec": {
   "display_name": ".env",
   "language": "python",
   "name": ".env"
  },
  "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.10"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}