Merge branch 'yomal-dev' into 'master'

Yomal dev See merge request !7

Merge branch 'yomal-dev' into 'master'
Yomal dev See merge request !7
867218c6 · Serasinghe K.A.E.Y.D · 9f877c24 · e1a6c6d6 · 867218c6 · 867218c6
Commit 867218c6 authored Nov 01, 2023 by Serasinghe K.A.E.Y.D 😊
Hide whitespace changes
Inline Side-by-side

Showing with 2557 additions and 0 deletions

ml/model/dementia_prediction.ipynb ml/model/dementia_prediction.ipynb +1929 -0

ml/model/emo_rec_v.ipynb ml/model/emo_rec_v.ipynb +628 -0

No files found.
--- a/ml/model/dementia_prediction.ipynb
+++ b/ml/model/dementia_prediction.ipynb
--- a/ml/model/emo_rec_v.ipynb
+++ b/ml/model/emo_rec_v.ipynb
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "name": "emo_rec_v.ipynb",
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "id": "aqQLzMnMBDIt"
+      },
+      "outputs": [],
+      "source": [
+        "import numpy as np\n",
+        "import cv2\n",
+        "import os\n",
+        "from sklearn.model_selection import train_test_split\n",
+        "import matplotlib.pyplot as plt\n",
+        "from keras.preprocessing.image import ImageDataGenerator\n",
+        "from keras.utils.np_utils import to_categorical\n",
+        "from keras.models import Sequential\n",
+        "from keras.layers import Dense\n",
+        "from tensorflow.keras.optimizers import Adam\n",
+        "from keras.layers import Dropout, Flatten\n",
+        "from keras.layers.convolutional import Conv2D, MaxPooling2D\n",
+        "import pickle"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install -q kaggle\n",
+        "from google.colab import files\n",
+        "files.upload()"
+      ],
+      "metadata": {
+        "colab": {
+          "resources": {
+            "http://localhost:8080/nbextensions/google.colab/files.js": {
+              "data": "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",
+              "ok": true,
+              "headers": [
+                [
+                  "content-type",
+                  "application/javascript"
+                ]
+              ],
+              "status": 200,
+              "status_text": ""
+            }
+          },
+          "base_uri": "https://localhost:8080/",
+          "height": 92
+        },
+        "id": "WPamR9iZBGMu",
+        "outputId": "3593ff5f-29d4-41ac-eb41-4a8de30efa41"
+      },
+      "execution_count": 2,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<IPython.core.display.HTML object>"
+            ],
+            "text/html": [
+              "\n",
+              "     <input type=\"file\" id=\"files-6ab2f225-c0c2-4e52-9371-47ba7ccdc9e5\" name=\"files[]\" multiple disabled\n",
+              "        style=\"border:none\" />\n",
+              "     <output id=\"result-6ab2f225-c0c2-4e52-9371-47ba7ccdc9e5\">\n",
+              "      Upload widget is only available when the cell has been executed in the\n",
+              "      current browser session. Please rerun this cell to enable.\n",
+              "      </output>\n",
+              "      <script src=\"/nbextensions/google.colab/files.js\"></script> "
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Saving kaggle.json to kaggle.json\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "{'kaggle.json': b'{\"username\":\"sankamadushanka\",\"key\":\"8e0590da8187a4634811a983f0e4560b\"}'}"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 2
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!mkdir -p ~/.kaggle\n",
+        "                                  \n",
+        "!cp kaggle.json ~/.kaggle/ \n",
+        "\n",
+        "!chmod 600 ~/.kaggle/kaggle.json"
+      ],
+      "metadata": {
+        "id": "RuMeRDhFBRHI"
+      },
+      "execution_count": 3,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!kaggle datasets download -d jonathanoheix/face-expression-recognition-dataset"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "xG9nF0GLBTRo",
+        "outputId": "c1f8d982-3010-4295-a102-c79660c7c50e"
+      },
+      "execution_count": 4,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Downloading face-expression-recognition-dataset.zip to /content\n",
+            " 96% 116M/121M [00:01<00:00, 91.2MB/s]\n",
+            "100% 121M/121M [00:01<00:00, 112MB/s] \n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from zipfile import ZipFile\n",
+        "zf = ZipFile('face-expression-recognition-dataset.zip', 'r')\n",
+        "zf.extractall('/content')\n",
+        "zf.close()"
+      ],
+      "metadata": {
+        "id": "Hp2zXsKMBWKP"
+      },
+      "execution_count": 5,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "root_dir = 'images/train'\n",
+        "img_format = {'jpg', 'png', 'bmp'}\n",
+        "test_ratio = 0.2\n",
+        "validation_ratio = 0.2\n",
+        "image_dimension = (48, 48, 3)"
+      ],
+      "metadata": {
+        "id": "O8nBHFbFucvn"
+      },
+      "execution_count": 6,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "data_list = os.listdir(root_dir)\n",
+        "no_of_data_category = len(data_list)\n",
+        "print(no_of_data_category)\n",
+        "\n",
+        "images = []\n",
+        "image_index = []\n",
+        "\n",
+        "for i in range(0, 7):\n",
+        "    img_list = os.listdir(root_dir + '/' + str(i))\n",
+        "    for img in img_list:\n",
+        "        cur_image = cv2.imread(root_dir + '/' + str(i) + '/' + img)\n",
+        "        cur_image = cv2.resize(cur_image, (48, 48))\n",
+        "        images.append(cur_image)\n",
+        "        image_index.append(i)\n",
+        "    print(i, end=' ')\n",
+        "print(' ')"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "u711h7LVufe7",
+        "outputId": "46a0153c-947c-4a2c-81c9-65558a211e9f"
+      },
+      "execution_count": 10,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "8\n",
+            "0 1 2 3 4 5 6  \n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "images = np.array(images)\n",
+        "image_index = np.array(image_index)\n",
+        "\n",
+        "print(images.shape)\n",
+        "print(image_index.shape)\n",
+        "\n",
+        "x_train, x_test, y_train, y_test = train_test_split(images, image_index, test_size=test_ratio)\n",
+        "x_train, x_validation, y_train, y_validation = train_test_split(x_train, y_train, test_size=validation_ratio)\n",
+        "\n",
+        "print(len(x_test))\n",
+        "print(len(x_validation))\n",
+        "print(np.where(y_train == 0))\n",
+        "\n",
+        "no_of_samples = []\n",
+        "for x in range(0, 7):\n",
+        "    no_of_samples.append(len(np.where(y_train == x)[0]))\n",
+        "\n",
+        "print(no_of_samples)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "uhc8-Kwuu_Tt",
+        "outputId": "8cbb6313-3083-429b-92c0-9dec399c2693"
+      },
+      "execution_count": 13,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "(28821, 48, 48, 3)\n",
+            "(28821,)\n",
+            "5765\n",
+            "4612\n",
+            "(array([    6,    19,    21, ..., 18424, 18438, 18443]),)\n",
+            "[2601, 287, 2613, 4596, 3182, 3161, 2004]\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "plt.figure(figsize=(10, 5))\n",
+        "plt.bar(range(0, 7), no_of_samples)\n",
+        "plt.title(\"No of images for each category\")\n",
+        "plt.xlabel(\"category id\")\n",
+        "plt.ylabel(\"number of images\")\n",
+        "plt.show()\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 350
+        },
+        "id": "zvfvWKlQvDms",
+        "outputId": "a3192010-e508-431d-85f4-8efb60e7825d"
+      },
+      "execution_count": 14,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 720x360 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def preProcessing(img):\n",
+        "    img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n",
+        "    img = cv2.equalizeHist(img)\n",
+        "    img = img / 255\n",
+        "    return img"
+      ],
+      "metadata": {
+        "id": "9fPqsfvKvQOL"
+      },
+      "execution_count": 15,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "x_train = np.array(list(map(preProcessing, x_train)))\n",
+        "x_test = np.array(list(map(preProcessing, x_test)))\n",
+        "x_validation = np.array(list(map(preProcessing, x_validation)))\n",
+        "\n",
+        "x_train = x_train.reshape(x_train.shape[0], x_train.shape[1], x_train.shape[2], 1)\n",
+        "x_test = x_test.reshape(x_test.shape[0], x_test.shape[1], x_test.shape[2], 1)\n",
+        "x_validation = x_validation.reshape(x_validation.shape[0], x_validation.shape[1], x_validation.shape[2], 1)"
+      ],
+      "metadata": {
+        "id": "ArVVil6rvScK"
+      },
+      "execution_count": 16,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "data_gen = ImageDataGenerator(width_shift_range=0.1,\n",
+        "                              height_shift_range=0.1,\n",
+        "                              zoom_range=0.2,\n",
+        "                              shear_range=0.1,\n",
+        "                              rotation_range=10)"
+      ],
+      "metadata": {
+        "id": "3dvFc6ctvV7Y"
+      },
+      "execution_count": 17,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "data_gen.fit(x_train)\n",
+        "\n",
+        "y_train = to_categorical(y_train, no_of_data_category)\n",
+        "y_test = to_categorical(y_test, no_of_data_category)\n",
+        "y_validation = to_categorical(y_validation, no_of_data_category)"
+      ],
+      "metadata": {
+        "id": "34BHMfjovYGc"
+      },
+      "execution_count": 18,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def cn_model():\n",
+        "    no_of_filters = 60\n",
+        "    size_of_filter_1 = (5, 5)\n",
+        "    size_of_filter_2 = (3, 3)\n",
+        "    size_of_pool = (2, 2)\n",
+        "    no_of_node = 500\n",
+        "\n",
+        "    model = Sequential()\n",
+        "    model.add((Conv2D(no_of_filters, size_of_filter_1, input_shape=(image_dimension[0],\n",
+        "                                                                    image_dimension[1], 1), activation='relu')))\n",
+        "    model.add((Conv2D(no_of_filters, size_of_filter_1, activation='relu')))\n",
+        "    model.add(MaxPooling2D(pool_size=size_of_pool))\n",
+        "    model.add((Conv2D(no_of_filters // 2, size_of_filter_2, activation='relu')))\n",
+        "    model.add((Conv2D(no_of_filters // 2, size_of_filter_2, activation='relu')))\n",
+        "    model.add(MaxPooling2D(pool_size=size_of_pool))\n",
+        "    model.add(Dropout(0.5))\n",
+        "\n",
+        "    model.add(Flatten())\n",
+        "    model.add(Dense(no_of_node, activation='relu'))\n",
+        "    model.add(Dropout(0.5))\n",
+        "    model.add(Dense(no_of_data_category, activation='softmax'))\n",
+        "\n",
+        "    model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])\n",
+        "    return model"
+      ],
+      "metadata": {
+        "id": "F0xamOjjvb4Y"
+      },
+      "execution_count": 19,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "model = cn_model()\n",
+        "print(model.summary())\n",
+        "\n",
+        "batch_size_val = 50\n",
+        "epoch_val = 10\n",
+        "steps_per_epoch = len(x_train) // batch_size_val\n",
+        "\n",
+        "history = model.fit_generator(data_gen.flow(x_train, y_train,\n",
+        "                                            batch_size=batch_size_val),\n",
+        "                              steps_per_epoch=steps_per_epoch,\n",
+        "                              epochs=epoch_val,\n",
+        "                              validation_data=(x_validation, y_validation),\n",
+        "                              shuffle=1)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "ZpkyhBECvezA",
+        "outputId": "1ee41789-74c1-4e3c-f13b-23b30423cd58"
+      },
+      "execution_count": 20,
+      "outputs": [
+        {
+          "metadata": {
+            "tags": null
+          },
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Model: \"sequential\"\n",
+            "_________________________________________________________________\n",
+            " Layer (type)                Output Shape              Param #   \n",
+            "=================================================================\n",
+            " conv2d (Conv2D)             (None, 44, 44, 60)        1560      \n",
+            "                                                                 \n",
+            " conv2d_1 (Conv2D)           (None, 40, 40, 60)        90060     \n",
+            "                                                                 \n",
+            " max_pooling2d (MaxPooling2D  (None, 20, 20, 60)       0         \n",
+            " )                                                               \n",
+            "                                                                 \n",
+            " conv2d_2 (Conv2D)           (None, 18, 18, 30)        16230     \n",
+            "                                                                 \n",
+            " conv2d_3 (Conv2D)           (None, 16, 16, 30)        8130      \n",
+            "                                                                 \n",
+            " max_pooling2d_1 (MaxPooling  (None, 8, 8, 30)         0         \n",
+            " 2D)                                                             \n",
+            "                                                                 \n",
+            " dropout (Dropout)           (None, 8, 8, 30)          0         \n",
+            "                                                                 \n",
+            " flatten (Flatten)           (None, 1920)              0         \n",
+            "                                                                 \n",
+            " dense (Dense)               (None, 500)               960500    \n",
+            "                                                                 \n",
+            " dropout_1 (Dropout)         (None, 500)               0         \n",
+            "                                                                 \n",
+            " dense_1 (Dense)             (None, 8)                 4008      \n",
+            "                                                                 \n",
+            "=================================================================\n",
+            "Total params: 1,080,488\n",
+            "Trainable params: 1,080,488\n",
+            "Non-trainable params: 0\n",
+            "_________________________________________________________________\n",
+            "None\n"
+          ]
+        },
+        {
+          "metadata": {
+            "tags": null
+          },
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:13: UserWarning: `Model.fit_generator` is deprecated and will be removed in a future version. Please use `Model.fit`, which supports generators.\n",
+            "  del sys.path[0]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Epoch 1/10\n",
+            "368/368 [==============================] - 602s 2s/step - loss: 1.8247 - accuracy: 0.2423 - val_loss: 1.7462 - val_accuracy: 0.3036\n",
+            "Epoch 2/10\n",
+            "368/368 [==============================] - 572s 2s/step - loss: 1.7615 - accuracy: 0.2831 - val_loss: 1.6564 - val_accuracy: 0.3430\n",
+            "Epoch 3/10\n",
+            "368/368 [==============================] - 565s 2s/step - loss: 1.7068 - accuracy: 0.3172 - val_loss: 1.5653 - val_accuracy: 0.3944\n",
+            "Epoch 4/10\n",
+            "368/368 [==============================] - 564s 2s/step - loss: 1.6557 - accuracy: 0.3460 - val_loss: 1.5124 - val_accuracy: 0.4159\n",
+            "Epoch 5/10\n",
+            "368/368 [==============================] - 565s 2s/step - loss: 1.6105 - accuracy: 0.3660 - val_loss: 1.4978 - val_accuracy: 0.4239\n",
+            "Epoch 6/10\n",
+            "368/368 [==============================] - 568s 2s/step - loss: 1.5633 - accuracy: 0.3867 - val_loss: 1.4112 - val_accuracy: 0.4597\n",
+            "Epoch 7/10\n",
+            "368/368 [==============================] - 571s 2s/step - loss: 1.5389 - accuracy: 0.3968 - val_loss: 1.4034 - val_accuracy: 0.4647\n",
+            "Epoch 8/10\n",
+            "368/368 [==============================] - 572s 2s/step - loss: 1.5067 - accuracy: 0.4151 - val_loss: 1.3966 - val_accuracy: 0.4751\n",
+            "Epoch 9/10\n",
+            "368/368 [==============================] - 569s 2s/step - loss: 1.4844 - accuracy: 0.4228 - val_loss: 1.3697 - val_accuracy: 0.4794\n",
+            "Epoch 10/10\n",
+            "368/368 [==============================] - 560s 2s/step - loss: 1.4695 - accuracy: 0.4280 - val_loss: 1.3494 - val_accuracy: 0.4933\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "plt.figure(1)\n",
+        "plt.plot(history.history['loss'])\n",
+        "plt.plot(history.history['val_loss'])\n",
+        "plt.legend(['training', 'validation'])\n",
+        "plt.title('Loss')\n",
+        "plt.xlabel('epoch')\n",
+        "\n",
+        "plt.figure(2)\n",
+        "plt.plot(history.history['accuracy'])\n",
+        "plt.plot(history.history['val_accuracy'])\n",
+        "plt.legend(['training', 'validation'])\n",
+        "plt.title('Accuracy')\n",
+        "plt.xlabel('epoch')\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 573
+        },
+        "id": "SNpMPCqTv31p",
+        "outputId": "0bc1c1ee-6cb1-4135-c813-478d725e5ffa"
+      },
+      "execution_count": 21,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "score = model.evaluate(x_test, y_test, verbose=0)\n",
+        "print('Test Score = ', score[0])\n",
+        "print('Test Accuracy =', score[1])"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "X90QwWZ6v6in",
+        "outputId": "7d91c715-06e8-4a2a-e110-edd623d8eacb"
+      },
+      "execution_count": 26,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Test Score =  1.3312135934829712\n",
+            "Test Accuracy = 0.48291414976119995\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "model.save('model.h5')"
+      ],
+      "metadata": {
+        "id": "M-ViLZjcv8p0"
+      },
+      "execution_count": 23,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from google.colab import drive\n",
+        "drive.mount('/content/drive')"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "gyCv3-8Sv-ls",
+        "outputId": "6d94de46-087f-4821-84bf-aa661daa66d9"
+      },
+      "execution_count": 24,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Mounted at /content/drive\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!cp model.h5 /content/drive/MyDrive"
+      ],
+      "metadata": {
+        "id": "S9TsadaGwDYg"
+      },
+      "execution_count": 25,
+      "outputs": []
+    }
+  ]
+}
\ No newline at end of file