{ "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": null, "metadata": {}, "outputs": [ { "ename": "", "evalue": "", "output_type": "error", "traceback": [ "\u001b[1;31mnotebook controller is DISPOSED. \n", "View Jupyter log for further details." ] } ], "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": null, "metadata": {}, "outputs": [ { "ename": "", "evalue": "", "output_type": "error", "traceback": [ "\u001b[1;31mnotebook controller is DISPOSED. \n", "View Jupyter log for further details." ] } ], "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": null, "metadata": {}, "outputs": [ { "ename": "", "evalue": "", "output_type": "error", "traceback": [ "\u001b[1;31mnotebook controller is DISPOSED. \n", "View Jupyter log for further details." ] } ], "source": [ "x, y = load_data()\n", "x = x / 255" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "ename": "", "evalue": "", "output_type": "error", "traceback": [ "\u001b[1;31mnotebook controller is DISPOSED. \n", "View Jupyter log for further details." ] } ], "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": null, "metadata": {}, "outputs": [ { "ename": "", "evalue": "", "output_type": "error", "traceback": [ "\u001b[1;31mnotebook controller is DISPOSED. \n", "View Jupyter log for further details." ] } ], "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": null, "metadata": {}, "outputs": [ { "ename": "", "evalue": "", "output_type": "error", "traceback": [ "\u001b[1;31mnotebook controller is DISPOSED. \n", "View Jupyter log for further details." ] } ], "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": null, "metadata": {}, "outputs": [ { "ename": "", "evalue": "", "output_type": "error", "traceback": [ "\u001b[1;31mnotebook controller is DISPOSED. \n", "View Jupyter log for further details." ] } ], "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": 3, "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": 6, "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": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "dataset_length = 10000\n", "batch size = 32\n", "number of batchs = 312\n", "\n", "train_size = 250\n", "validation_size = 9750\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 = 32\n", "SHUFFLE_SIZE = 32\n", "LIMIT = 10000\n", "\n", "def customGenerator():\n", " data = sqlite3.connect(f\"{DATASET_PATH}/index.db\").execute(f\"SELECT uuid, model from data LIMIT {LIMIT}\").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", " 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", "def set_shapes(image, label):\n", " image.set_shape(RESIZED_SIZE)\n", " label.set_shape([])\n", " return image, 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", "dataset_length = min(dataset_length, LIMIT)\n", "\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 / BATCH_SIZE)\n", "print(f\"train_size = {train_size}\")\n", "print(f\"validation_size = {dataset_length - train_size}\")\n", "\n", "dataset = (\n", " dataset.shuffle(SHUFFLE_SIZE)\n", " .map(set_shapes)\n", " .batch(BATCH_SIZE)\n", " # .map(cutout)\n", " .prefetch(AUTOTUNE)\n", ")\n", "\n", "dataset_train = dataset.take(train_size)\n", "dataset_validate = dataset.skip(train_size)\n", "\n", "# print()\n", "# print(RESIZED_SIZE)\n", "# for boop in dataset_train.take(2):\n", "# print(boop)\n", "\n", "# for image_batch, label_batch in dataset.take(1):\n", "# print(label_batch.shape, image_batch.shape)\n", "# pass\n", "# for image_batch, label_batch in dataset_train.take(1):\n", "# print(label_batch.shape, image_batch.shape)\n", "# pass\n", "# for image_batch, label_batch in dataset_validate.take(1):\n", "# print(label_batch.shape, image_batch.shape)\n", "# pass" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Model: \"sequential_7\"\n", "_________________________________________________________________\n", " Layer (type) Output Shape Param # \n", "=================================================================\n", " conv2d_21 (Conv2D) (None, 98, 48, 32) 896 \n", " \n", " max_pooling2d_21 (MaxPoolin (None, 49, 24, 32) 0 \n", " g2D) \n", " \n", " conv2d_22 (Conv2D) (None, 47, 22, 64) 18496 \n", " \n", " max_pooling2d_22 (MaxPoolin (None, 23, 11, 64) 0 \n", " g2D) \n", " \n", " conv2d_23 (Conv2D) (None, 21, 9, 92) 53084 \n", " \n", " max_pooling2d_23 (MaxPoolin (None, 10, 4, 92) 0 \n", " g2D) \n", " \n", " flatten_7 (Flatten) (None, 3680) 0 \n", " \n", " dense_14 (Dense) (None, 250) 920250 \n", " \n", " dense_15 (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/25\n", "250/250 [==============================] - 53s 211ms/step - loss: 0.9718 - accuracy: 0.6635 - val_loss: 2.2070 - val_accuracy: 0.1400\n", "Epoch 2/25\n", "250/250 [==============================] - 52s 209ms/step - loss: 0.7459 - accuracy: 0.6416 - val_loss: 2.2988 - val_accuracy: 0.1400\n", "Epoch 3/25\n", "250/250 [==============================] - 53s 210ms/step - loss: 0.6746 - accuracy: 0.6664 - val_loss: 2.4333 - val_accuracy: 0.1400\n", "Epoch 4/25\n", "250/250 [==============================] - 53s 211ms/step - loss: 0.6437 - accuracy: 0.6920 - val_loss: 2.3739 - val_accuracy: 0.1400\n", "Epoch 5/25\n", "250/250 [==============================] - 53s 211ms/step - loss: 0.5982 - accuracy: 0.7157 - val_loss: 2.1336 - val_accuracy: 0.1400\n", "Epoch 6/25\n", "250/250 [==============================] - 53s 210ms/step - loss: 0.5497 - accuracy: 0.7380 - val_loss: 2.0098 - val_accuracy: 0.1400\n", "Epoch 7/25\n", "250/250 [==============================] - 53s 210ms/step - loss: 0.5108 - accuracy: 0.7561 - val_loss: 1.9775 - val_accuracy: 0.1400\n", "Epoch 8/25\n", "250/250 [==============================] - 53s 211ms/step - loss: 0.4761 - accuracy: 0.7725 - val_loss: 1.9294 - val_accuracy: 0.1400\n", "Epoch 9/25\n", "250/250 [==============================] - 53s 210ms/step - loss: 0.4304 - accuracy: 0.7940 - val_loss: 2.0166 - val_accuracy: 0.1400\n", "Epoch 10/25\n", "250/250 [==============================] - 53s 214ms/step - loss: 0.4140 - accuracy: 0.8075 - val_loss: 1.7652 - val_accuracy: 0.1400\n", "Epoch 11/25\n", "250/250 [==============================] - 53s 211ms/step - loss: 0.3672 - accuracy: 0.8279 - val_loss: 1.6594 - val_accuracy: 0.1400\n", "Epoch 12/25\n", "250/250 [==============================] - 53s 211ms/step - loss: 0.3285 - accuracy: 0.8512 - val_loss: 1.5178 - val_accuracy: 0.1400\n", "Epoch 13/25\n", "250/250 [==============================] - 52s 210ms/step - loss: 0.2867 - accuracy: 0.8702 - val_loss: 1.4753 - val_accuracy: 0.1400\n", "Epoch 14/25\n", "250/250 [==============================] - 52s 209ms/step - loss: 0.2500 - accuracy: 0.8905 - val_loss: 1.3835 - val_accuracy: 0.1400\n", "Epoch 15/25\n", "250/250 [==============================] - 53s 210ms/step - loss: 0.2186 - accuracy: 0.9100 - val_loss: 1.1579 - val_accuracy: 0.1405\n", "Epoch 16/25\n", "250/250 [==============================] - 53s 210ms/step - loss: 0.1810 - accuracy: 0.9309 - val_loss: 1.0902 - val_accuracy: 0.1510\n", "Epoch 17/25\n", "250/250 [==============================] - 52s 210ms/step - loss: 0.1555 - accuracy: 0.9451 - val_loss: 0.9250 - val_accuracy: 0.2240\n", "Epoch 18/25\n", "250/250 [==============================] - 53s 210ms/step - loss: 0.1280 - accuracy: 0.9626 - val_loss: 0.7926 - val_accuracy: 0.3720\n", "Epoch 19/25\n", "250/250 [==============================] - 53s 212ms/step - loss: 0.1065 - accuracy: 0.9728 - val_loss: 0.6717 - val_accuracy: 0.5145\n", "Epoch 20/25\n", "250/250 [==============================] - 53s 211ms/step - loss: 0.0878 - accuracy: 0.9816 - val_loss: 0.5564 - val_accuracy: 0.6530\n", "Epoch 21/25\n", "250/250 [==============================] - 53s 212ms/step - loss: 0.0714 - accuracy: 0.9901 - val_loss: 0.4285 - val_accuracy: 0.8095\n", "Epoch 22/25\n", "250/250 [==============================] - 53s 212ms/step - loss: 0.0567 - accuracy: 0.9942 - val_loss: 0.3829 - val_accuracy: 0.8545\n", "Epoch 23/25\n", "250/250 [==============================] - 53s 213ms/step - loss: 0.0473 - accuracy: 0.9975 - val_loss: 0.2913 - val_accuracy: 0.9285\n", "Epoch 24/25\n", "250/250 [==============================] - 53s 210ms/step - loss: 0.0383 - accuracy: 0.9990 - val_loss: 0.2352 - val_accuracy: 0.9615\n", "Epoch 25/25\n", "250/250 [==============================] - 53s 211ms/step - loss: 0.0311 - accuracy: 0.9996 - val_loss: 0.1907 - val_accuracy: 0.9815\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'])\n", "history = model.fit(dataset_train, validation_data=dataset_validate, epochs=25, batch_size=BATCH_SIZE)" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "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", "\n", "plot_training_analysis()\n" ] } ], "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 }