LSTM_V3_dawit.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyMkHCI3eVS3hH/cnsefXMfV",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/dawitfamanu/dawitfamanu.github.io/blob/main/LSTM_V3_dawit.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rVauI-Zs25bT",
        "outputId": "cafe9117-d6b8-4e6f-9329-54a4fa23fc6f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Requirement already satisfied: tensorflow in /usr/local/lib/python3.10/dist-packages (2.12.0)\n",
            "Requirement already satisfied: absl-py>=1.0.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (1.4.0)\n",
            "Requirement already satisfied: astunparse>=1.6.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (1.6.3)\n",
            "Requirement already satisfied: flatbuffers>=2.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (23.3.3)\n",
            "Requirement already satisfied: gast<=0.4.0,>=0.2.1 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (0.4.0)\n",
            "Requirement already satisfied: google-pasta>=0.1.1 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (0.2.0)\n",
            "Requirement already satisfied: grpcio<2.0,>=1.24.3 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (1.54.0)\n",
            "Requirement already satisfied: h5py>=2.9.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (3.8.0)\n",
            "Requirement already satisfied: jax>=0.3.15 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (0.4.10)\n",
            "Requirement already satisfied: keras<2.13,>=2.12.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (2.12.0)\n",
            "Requirement already satisfied: libclang>=13.0.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (16.0.0)\n",
            "Requirement already satisfied: numpy<1.24,>=1.22 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (1.22.4)\n",
            "Requirement already satisfied: opt-einsum>=2.3.2 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (3.3.0)\n",
            "Requirement already satisfied: packaging in /usr/local/lib/python3.10/dist-packages (from tensorflow) (23.1)\n",
            "Requirement already satisfied: protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<5.0.0dev,>=3.20.3 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (3.20.3)\n",
            "Requirement already satisfied: setuptools in /usr/local/lib/python3.10/dist-packages (from tensorflow) (67.7.2)\n",
            "Requirement already satisfied: six>=1.12.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (1.16.0)\n",
            "Requirement already satisfied: tensorboard<2.13,>=2.12 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (2.12.2)\n",
            "Requirement already satisfied: tensorflow-estimator<2.13,>=2.12.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (2.12.0)\n",
            "Requirement already satisfied: termcolor>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (2.3.0)\n",
            "Requirement already satisfied: typing-extensions>=3.6.6 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (4.5.0)\n",
            "Requirement already satisfied: wrapt<1.15,>=1.11.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (1.14.1)\n",
            "Requirement already satisfied: tensorflow-io-gcs-filesystem>=0.23.1 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (0.32.0)\n",
            "Requirement already satisfied: wheel<1.0,>=0.23.0 in /usr/local/lib/python3.10/dist-packages (from astunparse>=1.6.0->tensorflow) (0.40.0)\n",
            "Requirement already satisfied: ml-dtypes>=0.1.0 in /usr/local/lib/python3.10/dist-packages (from jax>=0.3.15->tensorflow) (0.1.0)\n",
            "Requirement already satisfied: scipy>=1.7 in /usr/local/lib/python3.10/dist-packages (from jax>=0.3.15->tensorflow) (1.10.1)\n",
            "Requirement already satisfied: google-auth<3,>=1.6.3 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.13,>=2.12->tensorflow) (2.17.3)\n",
            "Requirement already satisfied: google-auth-oauthlib<1.1,>=0.5 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.13,>=2.12->tensorflow) (1.0.0)\n",
            "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.13,>=2.12->tensorflow) (3.4.3)\n",
            "Requirement already satisfied: requests<3,>=2.21.0 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.13,>=2.12->tensorflow) (2.27.1)\n",
            "Requirement already satisfied: tensorboard-data-server<0.8.0,>=0.7.0 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.13,>=2.12->tensorflow) (0.7.0)\n",
            "Requirement already satisfied: tensorboard-plugin-wit>=1.6.0 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.13,>=2.12->tensorflow) (1.8.1)\n",
            "Requirement already satisfied: werkzeug>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.13,>=2.12->tensorflow) (2.3.0)\n",
            "Requirement already satisfied: cachetools<6.0,>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from google-auth<3,>=1.6.3->tensorboard<2.13,>=2.12->tensorflow) (5.3.0)\n",
            "Requirement already satisfied: pyasn1-modules>=0.2.1 in /usr/local/lib/python3.10/dist-packages (from google-auth<3,>=1.6.3->tensorboard<2.13,>=2.12->tensorflow) (0.3.0)\n",
            "Requirement already satisfied: rsa<5,>=3.1.4 in /usr/local/lib/python3.10/dist-packages (from google-auth<3,>=1.6.3->tensorboard<2.13,>=2.12->tensorflow) (4.9)\n",
            "Requirement already satisfied: requests-oauthlib>=0.7.0 in /usr/local/lib/python3.10/dist-packages (from google-auth-oauthlib<1.1,>=0.5->tensorboard<2.13,>=2.12->tensorflow) (1.3.1)\n",
            "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests<3,>=2.21.0->tensorboard<2.13,>=2.12->tensorflow) (1.26.15)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests<3,>=2.21.0->tensorboard<2.13,>=2.12->tensorflow) (2022.12.7)\n",
            "Requirement already satisfied: charset-normalizer~=2.0.0 in /usr/local/lib/python3.10/dist-packages (from requests<3,>=2.21.0->tensorboard<2.13,>=2.12->tensorflow) (2.0.12)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests<3,>=2.21.0->tensorboard<2.13,>=2.12->tensorflow) (3.4)\n",
            "Requirement already satisfied: MarkupSafe>=2.1.1 in /usr/local/lib/python3.10/dist-packages (from werkzeug>=1.0.1->tensorboard<2.13,>=2.12->tensorflow) (2.1.2)\n",
            "Requirement already satisfied: pyasn1<0.6.0,>=0.4.6 in /usr/local/lib/python3.10/dist-packages (from pyasn1-modules>=0.2.1->google-auth<3,>=1.6.3->tensorboard<2.13,>=2.12->tensorflow) (0.5.0)\n",
            "Requirement already satisfied: oauthlib>=3.0.0 in /usr/local/lib/python3.10/dist-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<1.1,>=0.5->tensorboard<2.13,>=2.12->tensorflow) (3.2.2)\n"
          ]
        }
      ],
      "source": [
        "!pip install tensorflow"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import tensorflow as tf\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.preprocessing import MinMaxScaler\n",
        "from keras.models import Sequential\n",
        "from keras.layers import Dense, LSTM, Dropout\n",
        "from keras.optimizers import Adam\n",
        "from keras.callbacks import EarlyStopping\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "from sklearn.metrics import confusion_matrix\n",
        "import seaborn as sns\n",
        "import random\n",
        "import csv"
      ],
      "metadata": {
        "id": "Bwq4XuJX48tM"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Pe5pF0UH5JEt",
        "outputId": "d19a02bf-d8e6-4305-e017-8360661df2d7"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# set the directory path for the two classes\n",
        "n_data_dir = \"/content/drive/MyDrive/final_dataset/n_data\"\n",
        "d_data_dir = \"/content/drive/MyDrive/final_dataset/d_data\"\n",
        "\n",
        "# read all csv files from the n_data directory and remove outliers\n",
        "min = 200 #the minimum number of rows in the entire dataset\n",
        "n_data_files = os.listdir(n_data_dir)\n",
        "n_data = pd.DataFrame()\n",
        "outlier_n_data = []\n",
        "for file in n_data_files:\n",
        "    if file.endswith(\".csv\"):\n",
        "      file_path = os.path.join(n_data_dir, file)\n",
        "      df = pd.read_csv(file_path)\n",
        "      if df.shape[0] <min:\n",
        "        continue\n",
        "\n",
        "      max_t = df.iloc[:, 2]\n",
        "      for i in range(len(max_t)): # find outliers in max_temp (>50 degrees)\n",
        "        if max_t[i] > 50:\n",
        "          outlier_n_data.append(file_path)\n",
        "      \n",
        "      if file_path in outlier_n_data: \n",
        "        continue\n",
        "      else: # add the files only if they are not an outlier\n",
        "        n_data = pd.concat([n_data, df.iloc[:min, :]])\n",
        "\n",
        "outlier_n_data = set(outlier_n_data)\n",
        "\n",
        "# read all csv files from the d_data directory\n",
        "d_data_files = os.listdir(d_data_dir)\n",
        "d_data = pd.DataFrame()\n",
        "for file in d_data_files:\n",
        "    if file.endswith(\".csv\"):\n",
        "      file_path = os.path.join(d_data_dir, file)\n",
        "      df = pd.read_csv(file_path)\n",
        "      if df.shape[0] <min:\n",
        "        continue\n",
        "      \n",
        "      d_data = pd.concat([d_data, df.iloc[:min, :]])"
      ],
      "metadata": {
        "id": "x6ZtW56Z_ERA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Normal = 0, #Disease = 1\n",
        "n_data[\"Status\"] = 0\n",
        "d_data[\"Status\"] = 1"
      ],
      "metadata": {
        "id": "m2Lwe0k8doJa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "combined_data = pd.concat([n_data, d_data], axis = 0)"
      ],
      "metadata": {
        "id": "f3b117e1Vsu0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "combined_data.drop([\"time\" ,\" CO2_avg\", \" CO2_max\", \" CO2_min\"], axis = 1, inplace=True)"
      ],
      "metadata": {
        "id": "7Diksu78TwV1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "combined_data.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NurIZezmcWEF",
        "outputId": "75ea132f-5eb1-46e4-98ca-843dd5933952"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(1777200, 10)"
            ]
          },
          "metadata": {},
          "execution_count": 80
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "combined_data"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 165
        },
        "id": "QoPN4WHuxNgz",
        "outputId": "a8c324ab-9046-4fb0-a4be-afb5de1a62eb"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-19-45e93a0c9e8d>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mcombined_data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m: name 'combined_data' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "dfs = np.array_split(combined_data, len(combined_data)/ 200)\n",
        "\n",
        "# save each chunk to a separate csv file\n",
        "for i, df_chunk in enumerate(dfs):\n",
        "    df_chunk.to_csv(f'/content/drive/MyDrive/output/output_{i+1}.csv', index=False)"
      ],
      "metadata": {
        "id": "yPLVbIx8nEW5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "len(dfs)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "R_BOcZ6JbISX",
        "outputId": "0a9b1a00-21b3-486a-b2aa-8a4337384ad9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "8886"
            ]
          },
          "metadata": {},
          "execution_count": 84
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "data_dir = \"/content/drive/MyDrive/output\""
      ],
      "metadata": {
        "id": "NIXYU7rLcVP9"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def read_csv_files(folder_path): #reads csv files and returns puts all the data in 1 list\n",
        "    data_list = []\n",
        "\n",
        "    for file in os.listdir(folder_path):\n",
        "        file_path = os.path.join(folder_path, file)\n",
        "        df = pd.read_csv(file_path)\n",
        "\n",
        "        data_list.append(df.values[:, :]) \n",
        "    \n",
        "    return list(data_list)\n",
        "\n",
        "#splits features and labels into two different arrays\n",
        "def get_features_and_labels(data_list):\n",
        "  features_X = []\n",
        "  labels_y = []\n",
        "  for data in data_list:\n",
        "    labels_y.append(data[:, -1]) #store the label of data \n",
        "    features_X.append(data[:, :-1]) #store the features of data exculding label\n",
        "  \n",
        "  return np.array(features_X), np.array(labels_y)\n",
        "\n",
        "\n",
        "def create_sequences_from_list(features_list, labels_list, seq_length):#slightly modified from Jungi's function\n",
        "    feat_sequences = []\n",
        "    labels_seq = []\n",
        "    for data in features_list: # create seq for features list\n",
        "      feat_sequences.append(data[:seq_length, :])\n",
        "    for data in labels_list: # create seq for labels list\n",
        "      labels_seq.append(data[:1][0]) \n",
        "\n",
        "    return np.array(feat_sequences), np.array(labels_seq) #return feature and label sequences as pandas array\n",
        "\n",
        "\n",
        "all_data_list = read_csv_files(data_dir)"
      ],
      "metadata": {
        "id": "ldZ_0g7_fEIx"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Total # of plants: \", len(all_data_list))\n",
        "print(\"Recordings per plant: \", len(all_data_list[0]))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dFUGQrodmxI7",
        "outputId": "b239b119-6680-4314-8e61-f374b9f89c87"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Total # of plants:  8886\n",
            "Recordings per plant:  200\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gqRGwnr4wsrR",
        "outputId": "e10900fd-b9a4-4313-9230-148f47c96abb"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([22.2, 23.1, 21. , 75.2, 80.4, 72.2, 17.6, 18.4, 16.6,  0. ])"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#shuffle all_data_list\n",
        "random.shuffle(all_data_list)"
      ],
      "metadata": {
        "id": "A95zZxqdk2LP"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#first, store labels and features separately\n",
        "features_X, labels_y = get_features_and_labels(all_data_list)"
      ],
      "metadata": {
        "id": "dv8_7A6wl4KQ"
      },
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "features_X"
      ],
      "metadata": {
        "id": "O2pmoASRxBLZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "features_X.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8s8w4GZVvZcJ",
        "outputId": "548ee424-8a10-47a6-f71a-286283c20c52"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(8886, 200, 9)"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "labels_y.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "08OPe6bQve-J",
        "outputId": "e661cbb2-d2db-461f-9047-f21574465732"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(8886, 200)"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#train test split \n",
        "train_features_X, test_features_X, train_labels_y, test_labels_y = train_test_split(features_X, labels_y, test_size=0.2, random_state=20)"
      ],
      "metadata": {
        "id": "gEIGPgoAl65S"
      },
      "execution_count": 29,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Create sequences\n",
        "seq_length = 200\n",
        "\n",
        "#make sequences of length 200 for X_train, X_test, y_train, y_test\n",
        "X_train, y_train = create_sequences_from_list(train_features_X, train_labels_y, seq_length)\n",
        "X_test, y_test = create_sequences_from_list(test_features_X, test_labels_y, seq_length)"
      ],
      "metadata": {
        "id": "wWCX9szTmDAa"
      },
      "execution_count": 30,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "X_train.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xWuNP-fIt8py",
        "outputId": "0e7a49ec-27dc-42fa-93fb-f4d5a0ee0d1e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(7108, 200, 9)"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "y_train.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DOsrlRgf6N8H",
        "outputId": "88d42dce-f875-4588-a0ac-e07afa2c8564"
      },
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(7108,)"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create the LSTM model\n",
        "model = Sequential()\n",
        "model.add(LSTM(10, input_shape=(X_train.shape[1], X_train.shape[2]), return_sequences=True))\n",
        "model.add(Dropout(0.4))\n",
        "model.add(LSTM(10))\n",
        "model.add(Dropout(0.4))\n",
        "model.add(Dense(1, activation='sigmoid'))\n",
        "\n",
        "# Compile the model\n",
        "model.compile(optimizer=Adam(learning_rate=1e-4), loss='binary_crossentropy', metrics=['accuracy'])\n",
        "\n",
        "# Train the model\n",
        "early_stopping = EarlyStopping(monitor='val_loss', patience=5)\n",
        "history = model.fit(X_train, y_train, validation_split=0.2, epochs=10, batch_size=32, callbacks=[early_stopping])\n",
        "\n",
        "# Evaluate the model\n",
        "loss, accuracy = model.evaluate(X_test, y_test)\n",
        "print(\"Test loss:\", loss)\n",
        "print(\"Test accuracy:\", accuracy)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i_M7_jT_mHVW",
        "outputId": "4a2e8f94-5c1d-4392-a757-eb25f588074a"
      },
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/10\n",
            "178/178 [==============================] - 35s 174ms/step - loss: 0.6894 - accuracy: 0.5375 - val_loss: 0.6672 - val_accuracy: 0.8896\n",
            "Epoch 2/10\n",
            "178/178 [==============================] - 44s 250ms/step - loss: 0.6286 - accuracy: 0.6864 - val_loss: 0.5558 - val_accuracy: 0.9135\n",
            "Epoch 3/10\n",
            "178/178 [==============================] - 35s 196ms/step - loss: 0.5273 - accuracy: 0.8519 - val_loss: 0.4265 - val_accuracy: 0.9297\n",
            "Epoch 4/10\n",
            "178/178 [==============================] - 40s 225ms/step - loss: 0.3955 - accuracy: 0.9370 - val_loss: 0.2958 - val_accuracy: 0.9810\n",
            "Epoch 5/10\n",
            "178/178 [==============================] - 31s 170ms/step - loss: 0.3062 - accuracy: 0.9567 - val_loss: 0.2282 - val_accuracy: 0.9810\n",
            "Epoch 6/10\n",
            "178/178 [==============================] - 38s 215ms/step - loss: 0.2574 - accuracy: 0.9666 - val_loss: 0.2358 - val_accuracy: 0.9346\n",
            "Epoch 7/10\n",
            "178/178 [==============================] - 37s 209ms/step - loss: 0.2288 - accuracy: 0.9705 - val_loss: 0.1756 - val_accuracy: 0.9810\n",
            "Epoch 8/10\n",
            "178/178 [==============================] - 31s 172ms/step - loss: 0.2107 - accuracy: 0.9722 - val_loss: 0.1593 - val_accuracy: 0.9810\n",
            "Epoch 9/10\n",
            "178/178 [==============================] - 40s 223ms/step - loss: 0.1910 - accuracy: 0.9750 - val_loss: 0.1531 - val_accuracy: 0.9810\n",
            "Epoch 10/10\n",
            "178/178 [==============================] - 42s 238ms/step - loss: 0.1775 - accuracy: 0.9756 - val_loss: 0.1946 - val_accuracy: 0.9177\n",
            "56/56 [==============================] - 2s 31ms/step - loss: 0.1850 - accuracy: 0.9308\n",
            "Test loss: 0.18499299883842468\n",
            "Test accuracy: 0.9308211207389832\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model.save('/content/drive/MyDrive/LSTM_model_v3.h5')"
      ],
      "metadata": {
        "id": "pYynHJ3XDi9M"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "features_X.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dBfXxWUjrFul",
        "outputId": "67363082-c089-4e84-dbd6-2d74a3fb9ced"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(8886, 200, 9)"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Retrieve the training history from the 'history' object returned by model.fit()\n",
        "training_loss = history.history['loss']\n",
        "validation_loss = history.history['val_loss']\n",
        "\n",
        "print(training_loss) \n",
        "print(validation_loss)\n",
        "\n",
        "# Plot the training and validation loss\n",
        "epochs = range(1, len(training_loss) + 1)\n",
        "plt.plot(epochs, training_loss, color='blue', label='Training Loss')\n",
        "plt.plot(epochs, validation_loss, color='red', label='Validation Loss')\n",
        "plt.title('Training and Validation Loss')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 527
        },
        "id": "1XGNl4EBznsU",
        "outputId": "5784c71a-cd81-4183-ff7d-0515529cdb42"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0.7006781697273254, 0.69779372215271, 0.6973297595977783, 0.6934391260147095, 0.6874143481254578, 0.6478405594825745, 0.5260475873947144, 0.412683367729187, 0.31604817509651184, 0.2467910349369049]\n",
            "[0.6930176019668579, 0.6920228004455566, 0.6910223364830017, 0.6872806549072266, 0.6726872324943542, 0.5768558979034424, 0.44182345271110535, 0.32548362016677856, 0.2467072606086731, 0.1916394829750061]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Retrieve the training history from the 'history' object returned by model.fit()\n",
        "training_accuracy = history.history['accuracy']\n",
        "validation_accuracy = history.history['val_accuracy']\n",
        "\n",
        "print(training_accuracy) \n",
        "print(validation_accuracy)\n",
        "# Plot the training and validation accuracy\n",
        "epochs = range(1, len(training_accuracy) + 1)\n",
        "plt.plot(epochs, training_accuracy, color='blue', label='Training Accuracy')\n",
        "plt.plot(epochs, validation_accuracy, color='red', label='Validation Accuracy')\n",
        "plt.title('Training and Validation Accuracy')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "fI9R3SP4zwBZ",
        "outputId": "a260e487-b51a-4e6d-d03c-d7f271684261",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 527
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0.5035173892974854, 0.5131902694702148, 0.4996482729911804, 0.5121350884437561, 0.5392191410064697, 0.6598663330078125, 0.8279985785484314, 0.8879704475402832, 0.9294759035110474, 0.952690839767456]\n",
            "[0.5168776512145996, 0.5168776512145996, 0.5168776512145996, 0.4697608947753906, 0.7046413421630859, 0.8157524466514587, 0.8544303774833679, 0.9282700419425964, 0.9367088675498962, 0.9697608947753906]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import confusion_matrix\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Predict on test data\n",
        "y_pred = model.predict(X_test)\n",
        "y_pred = (y_pred > 0.5)\n",
        "\n",
        "# Calculate confusion matrix\n",
        "cm = confusion_matrix(y_test, y_pred)\n",
        "\n",
        "# Define class names\n",
        "class_names = ['Diseased', 'Healthy']\n",
        "\n",
        "# Plot confusion matrix\n",
        "plt.imshow(cm, cmap=plt.cm.Blues)\n",
        "plt.title('Confusion Matrix')\n",
        "plt.colorbar()\n",
        "tick_marks = np.arange(len(class_names))\n",
        "plt.xticks(tick_marks, class_names, rotation=45)\n",
        "plt.yticks(tick_marks, class_names)\n",
        "plt.xlabel('Predicted')\n",
        "plt.ylabel('True')\n",
        "plt.tight_layout()\n",
        "for i in range(len(class_names)):\n",
        "    for j in range(len(class_names)):\n",
        "        plt.text(j, i, format(cm[i, j], 'd'), horizontalalignment=\"center\", color=\"white\" if cm[i, j] > (cm.max() / 2) else \"black\")\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "15mWwBYlzwjR",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 504
        },
        "outputId": "3ff21f8d-a14d-4694-ef96-21dc1077999e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "56/56 [==============================] - 3s 30ms/step\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from keras.models import load_model\n",
        "\n",
        "filepath = \"/content/drive/MyDrive/final_dataset/n_data/n_770079.csv\"\n",
        "\n",
        "df = pd.read_csv(filepath)\n",
        "\n",
        "row_count = len(df)\n",
        "min = 200\n",
        "\n",
        "model = load_model('/content/drive/MyDrive/LSTM_model_v3.h5')\n",
        "\n",
        "#Check if the input csv has enough number of recordings. We need at least 200 recordings\n",
        "\n",
        "if(row_count >= min):\n",
        "    test = df.iloc[:min, 1:10].values\n",
        "    test = test.reshape((1, 200, 9))\n",
        "    prediction = model.predict(test)\n",
        "    if(prediction <= 0.5):\n",
        "        condition = \"Healthy\"\n",
        "        prediction = 1-prediction\n",
        "    else:\n",
        "        condition = \"Unhealthy\"\n",
        "    print(f\"There is {prediction*100}% chance that the plant is {condition}\")\n",
        "\n",
        "else:\n",
        "    print(\"Not enough number of recordings. The model requires at least 200 recordings in the csv file\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I859x3ZHKpog",
        "outputId": "b3ec1635-3f5e-475c-b7c8-07f11a5c3f02"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1/1 [==============================] - 1s 1s/step\n",
            "There is [[97.26929]]% chance that the plant is Healthy\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "from sklearn.metrics import roc_curve, auc\n",
        "\n",
        "# Get the model's predicted probabilities for the positive class\n",
        "y_pred_prob = model.predict(X_test)\n",
        "\n",
        "# Compute the false positive rate (fpr), true positive rate (tpr), and thresholds\n",
        "fpr, tpr, thresholds = roc_curve(y_test, y_pred_prob)\n",
        "\n",
        "# Calculate the Area Under the Curve (AUC)\n",
        "auc_score = auc(fpr, tpr)\n",
        "\n",
        "# Plot the ROC curve\n",
        "plt.plot(fpr, tpr, label='ROC curve (AUC = %0.2f)' % auc_score)\n",
        "plt.plot([0, 1], [0, 1], 'k--')  # Diagonal line for random guessing\n",
        "plt.xlabel('False Positive Rate')\n",
        "plt.ylabel('True Positive Rate')\n",
        "plt.title('Receiver Operating Characteristic (ROC) Curve')\n",
        "plt.legend(loc='lower right')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 489
        },
        "id": "H7dgPy1pnlhE",
        "outputId": "b9f01cce-bfe9-4f87-9e79-64db42349702"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "56/56 [==============================] - 2s 43ms/step\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import r2_score\n",
        "\n",
        "# Train the model\n",
        "history = model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=10, batch_size=32, callbacks=[early_stopping])\n",
        "\n",
        "# Evaluate the model on train and validation sets\n",
        "train_predictions = model.predict(X_train)\n",
        "train_r2_score = r2_score(y_train, train_predictions)\n",
        "\n",
        "val_predictions = model.predict(X_test)\n",
        "val_r2_score = r2_score(y_test, val_predictions)\n",
        "\n",
        "print(\"Train R2 score:\", train_r2_score)\n",
        "print(\"Validation R2 score:\", val_r2_score)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FTsYQAognleX",
        "outputId": "48064927-acc5-42bb-9997-0bb6551b6c1d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/10\n",
            "223/223 [==============================] - 52s 220ms/step - loss: 0.0574 - accuracy: 0.9958 - val_loss: 0.0309 - val_accuracy: 0.9989\n",
            "Epoch 2/10\n",
            "223/223 [==============================] - 52s 232ms/step - loss: 0.0497 - accuracy: 0.9968 - val_loss: 0.2962 - val_accuracy: 0.9207\n",
            "Epoch 3/10\n",
            "223/223 [==============================] - 58s 260ms/step - loss: 0.0816 - accuracy: 0.9826 - val_loss: 0.0209 - val_accuracy: 1.0000\n",
            "Epoch 4/10\n",
            "223/223 [==============================] - 57s 257ms/step - loss: 0.0387 - accuracy: 0.9980 - val_loss: 0.0170 - val_accuracy: 1.0000\n",
            "Epoch 5/10\n",
            "223/223 [==============================] - 44s 197ms/step - loss: 0.0343 - accuracy: 0.9975 - val_loss: 0.0203 - val_accuracy: 0.9972\n",
            "Epoch 6/10\n",
            "223/223 [==============================] - 50s 223ms/step - loss: 0.1130 - accuracy: 0.9757 - val_loss: 0.5418 - val_accuracy: 0.8667\n",
            "Epoch 7/10\n",
            "223/223 [==============================] - 46s 208ms/step - loss: 0.1387 - accuracy: 0.9622 - val_loss: 0.0229 - val_accuracy: 1.0000\n",
            "Epoch 8/10\n",
            "223/223 [==============================] - 45s 204ms/step - loss: 0.0441 - accuracy: 0.9927 - val_loss: 0.0163 - val_accuracy: 0.9961\n",
            "Epoch 9/10\n",
            "223/223 [==============================] - 43s 193ms/step - loss: 0.0311 - accuracy: 0.9975 - val_loss: 0.0154 - val_accuracy: 0.9961\n",
            "Epoch 10/10\n",
            "223/223 [==============================] - 43s 191ms/step - loss: 0.0268 - accuracy: 0.9979 - val_loss: 0.0127 - val_accuracy: 0.9966\n",
            "223/223 [==============================] - 8s 35ms/step\n",
            "56/56 [==============================] - 3s 53ms/step\n",
            "Train R2 score: 0.9951608681721105\n",
            "Validation R2 score: 0.9955561574876691\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"X shape:\", X_train.shape)\n",
        "print(\"y shape:\", y_train.shape)\n"
      ],
      "metadata": {
        "id": "V49Fb4OCnlbI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"X_train shape:\", X_train)"
      ],
      "metadata": {
        "id": "ocRJIJcCnlYQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"y_train shape:\", y_train)"
      ],
      "metadata": {
        "id": "diLuIwplnlVh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"X_test shape:\", X_test)"
      ],
      "metadata": {
        "id": "OHu5pMU2nlTF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"y_test shape:\", y_test)"
      ],
      "metadata": {
        "id": "MRETVvllnlOD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import precision_recall_fscore_support\n",
        "\n",
        "# Predict on test data\n",
        "y_pred = model.predict(X_test)\n",
        "y_pred = (y_pred > 0.5)\n",
        "\n",
        "# Calculate precision, recall, F1-score, and support\n",
        "precision, recall, f1_score, support = precision_recall_fscore_support(y_test, y_pred)\n",
        "\n",
        "# Print the results\n",
        "print('Precision:', precision)\n",
        "print('Recall:', recall)\n",
        "print('F1-score:', f1_score)\n",
        "print('Support:', support)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Umi_ILiunlKx",
        "outputId": "14746568-6073-40c0-d864-69187287f556"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "56/56 [==============================] - 2s 35ms/step\n",
            "Precision: [0.99302326 1.        ]\n",
            "Recall: [1.         0.99350649]\n",
            "F1-score: [0.99649942 0.99674267]\n",
            "Support: [854 924]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def preprocess_single_file(file_path, seq_length):\n",
        "    df = pd.read_csv(file_path)\n",
        "    df[\"label\"] = 0  # Add a dummy label column\n",
        "    data = df.values[:seq_length, :]  # Truncate to seq_length rows if needed\n",
        "    #scaled_data = scaler.transform(data)\n",
        "    #X = np.array([scaled_data[:, :-1]])  # Create a 3D array with just one sample\n",
        "    X = np.array([data[:, :-1]])  # Create a 3D array with just one sample\n",
        "\n",
        "    return X\n",
        "\n",
        "def status(x):\n",
        "    if x > 0.5:\n",
        "        print(\"Unhealthy\")\n",
        "    else:\n",
        "        print(\"Healthy\")\n",
        "# Example usage:\n",
        "\n",
        "sample_file_path = \"/content/drive/MyDrive/d_data_test/preprocessed_d_605916.csv\"\n",
        "seq_length = 200\n",
        "\n",
        "X_sample = preprocess_single_file(sample_file_path, seq_length)\n",
        "\n",
        "# Predict on the sample file\n",
        "y_sample_pred = model.predict(X_sample)\n",
        "print(y_sample_pred[0])\n",
        "\n",
        "# Print the result\n",
        "status(y_sample_pred[0])"
      ],
      "metadata": {
        "id": "8MRm_GBznlIC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Example usage:\n",
        "\n",
        "sample_file_path = \"/content/drive/MyDrive/n_data_test/preprocessed_n_851866.csv\"\n",
        "seq_length = 200\n",
        "\n",
        "X_sample = preprocess_single_file(sample_file_path, seq_length)\n",
        "\n",
        "# Predict on the sample file\n",
        "y_sample_pred = model.predict(X_sample)\n",
        "\n",
        "# Print the result\n",
        "print(y_sample_pred[0])\n",
        "\n",
        "status(y_sample_pred[0])\n"
      ],
      "metadata": {
        "id": "q_cvlCSlnlFq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(model.summary())"
      ],
      "metadata": {
        "id": "eYyLDdygnlCu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from keras.utils import plot_model\n",
        "\n",
        "# Assuming you have a trained LSTM model called 'model'\n",
        "plot_model(model, to_file='model_architecture.png', show_shapes=True)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 644
        },
        "id": "pURaBSirnk6g",
        "outputId": "298ea4f7-dfe0-420f-bad7-6559b85f976b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Check class distribution\n",
        "unique_train, counts_train = np.unique(y_train, return_counts=True)\n",
        "unique_test, counts_test = np.unique(y_test, return_counts=True)\n",
        "\n",
        "print(\"Class distribution in training set:\", dict(zip(unique_train, counts_train)))\n",
        "print(\"Class distribution in test set:\", dict(zip(unique_test, counts_test)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UnctauVoowXt",
        "outputId": "8c244253-0fe7-477b-8cfe-de6dac8ba38b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Class distribution in training set: {0.0: 3456, 1.0: 3652}\n",
            "Class distribution in test set: {0.0: 854, 1.0: 924}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import classification_report\n",
        "\n",
        "# Predict the test labels\n",
        "y_pred = model.predict(X_test)\n",
        "y_pred_classes = (y_pred > 0.5).astype(int)\n",
        "\n",
        "# Calculate and print the classification report\n",
        "report = classification_report(y_test, y_pred_classes, target_names=['Healthy', 'Diseased'])\n",
        "print(report)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z2pY7To0owVD",
        "outputId": "00f60c4f-4e99-4726-e01c-541808a480cf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "56/56 [==============================] - 3s 51ms/step\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "     Healthy       0.99      1.00      1.00       854\n",
            "    Diseased       1.00      0.99      1.00       924\n",
            "\n",
            "    accuracy                           1.00      1778\n",
            "   macro avg       1.00      1.00      1.00      1778\n",
            "weighted avg       1.00      1.00      1.00      1778\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "dQZvHlx2owRL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.model_selection import KFold\n",
        "from keras.models import clone_model\n",
        "\n",
        "def train_and_evaluate_model(X_train, y_train, X_val, y_val):\n",
        "    # Create and compile a new instance of the model\n",
        "    model = Sequential()\n",
        "    model.add(LSTM(10, input_shape=(X_train.shape[1], X_train.shape[2]), return_sequences=True))\n",
        "    model.add(Dropout(0.4))\n",
        "    model.add(LSTM(10))\n",
        "    model.add(Dropout(0.4))\n",
        "    model.add(Dense(1, activation='sigmoid'))\n",
        "    model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])\n",
        "\n",
        "    # Train the model\n",
        "    early_stopping = EarlyStopping(monitor='val_loss', patience=5)\n",
        "    model.fit(X_train, y_train, validation_data=(X_val, y_val), epochs=10, batch_size=32, callbacks=[early_stopping], verbose=0)\n",
        "\n",
        "    # Evaluate the model\n",
        "    loss, accuracy = model.evaluate(X_val, y_val, verbose=0)\n",
        "    return accuracy\n",
        "\n",
        "# Combine the train and test sets for cross-validation\n",
        "X = np.concatenate((X_train, X_test), axis=0)\n",
        "y = np.concatenate((y_train, y_test), axis=0)\n",
        "\n",
        "# Define the number of folds for cross-validation\n",
        "num_folds = 5\n",
        "kfold = KFold(n_splits=num_folds, shuffle=True, random_state=42)\n",
        "\n",
        "# Run cross-validation\n",
        "cv_accuracies = []\n",
        "for train_index, val_index in kfold.split(X, y):\n",
        "    X_train_fold, X_val_fold = X[train_index], X[val_index]\n",
        "    y_train_fold, y_val_fold = y[train_index], y[val_index]\n",
        "\n",
        "    fold_accuracy = train_and_evaluate_model(X_train_fold, y_train_fold, X_val_fold, y_val_fold)\n",
        "    cv_accuracies.append(fold_accuracy)\n",
        "\n",
        "# Calculate and print the average accuracy across all folds\n",
        "avg_accuracy = np.mean(cv_accuracies)\n",
        "print(f\"Average accuracy across {num_folds}-fold cross-validation: {avg_accuracy}\")\n",
        "print(f\"5 accuracies: {cv_accuracies}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MThmAXuIowMq",
        "outputId": "8a5aa51c-f6b9-4592-9d79-70afa280fc76"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Average accuracy across 5-fold cross-validation: 0.9148028135299683\n",
            "5 accuracies: [0.976940393447876, 1.0, 0.626899242401123, 0.9966235160827637, 0.9735509157180786]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "s19RubKCnkvl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Data Augmentation [Windowing technique]\n",
        "from keras.preprocessing.sequence import TimeseriesGenerator\n",
        "\n",
        "# Define window size and stride\n",
        "window_size = 10\n",
        "stride = 1 \n",
        "\n",
        "# Create TimeseriesGenerator for training data\n",
        "train_generator = TimeseriesGenerator(train_features_X, train_labels_y, length=window_size, stride=stride)\n",
        "\n",
        "# Generate input sequences and corresponding labels for training data\n",
        "X_train_sequences, y_train_labels = train_generator[0]\n",
        "\n",
        "# Create TimeseriesGenerator for testing data\n",
        "test_generator = TimeseriesGenerator(test_features_X, test_labels_y, length=window_size, stride=stride)\n",
        "\n",
        "# Generate input sequences and corresponding labels for testing data\n",
        "X_test_sequences, y_test_labels = test_generator[0]\n"
      ],
      "metadata": {
        "id": "FtFl_SqmnYKU"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}