train copy 3.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           frame_path  left_state  left_hold_duration  right_state   \n",
      "0  frames/frame_0.jpg           0                 0.0            0  \\\n",
      "1  frames/frame_1.jpg           0                 0.0            0   \n",
      "2  frames/frame_2.jpg           0                 0.0            0   \n",
      "3  frames/frame_3.jpg           0                 0.0            0   \n",
      "4  frames/frame_4.jpg           0                 0.0            0   \n",
      "\n",
      "   right_hold_duration  \n",
      "0                  0.0  \n",
      "1                  0.0  \n",
      "2                  0.0  \n",
      "3                  0.0  \n",
      "4                  0.0  \n"
     ]
    }
   ],
   "source": [
    "df = pd.read_csv(\"dataset.csv\")\n",
    "# Display the first few rows of the DataFrame\n",
    "print(df.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the image data\n",
    "\n",
    "from PIL import Image\n",
    "import numpy as np\n",
    "df['frame_path'] = df['frame_path'].apply(lambda x: np.array(Image.open(x)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# normalize the image data\n",
    "df['frame_path'] = df['frame_path'].apply(lambda x: x/255)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                          frame_path  left_state  right_state\n",
      "0  [[[0.9215686274509803, 0.9176470588235294, 0.9...           0            0\n",
      "1  [[[0.2, 0.5764705882352941, 0.7647058823529411...           0            0\n",
      "2  [[[0.9686274509803922, 0.9450980392156862, 0.9...           0            0\n",
      "3  [[[0.0392156862745098, 0.03529411764705882, 0....           0            0\n",
      "4  [[[0.9294117647058824, 0.9254901960784314, 0.9...           0            0\n"
     ]
    }
   ],
   "source": [
    "# Columns to be dropped\n",
    "drop_columns = [\n",
    "                'left_hold_duration',\n",
    "                'right_hold_duration']\n",
    "\n",
    "# Drop the columns\n",
    "df = df.drop(columns=drop_columns)\n",
    "\n",
    "print(df.head())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                          frame_path  left_state  right_state   \n",
      "0  [[[0.9215686274509803, 0.9176470588235294, 0.9...           0            0  \\\n",
      "1  [[[0.2, 0.5764705882352941, 0.7647058823529411...           0            0   \n",
      "2  [[[0.9686274509803922, 0.9450980392156862, 0.9...           0            0   \n",
      "3  [[[0.0392156862745098, 0.03529411764705882, 0....           0            0   \n",
      "4  [[[0.9294117647058824, 0.9254901960784314, 0.9...           0            0   \n",
      "\n",
      "   empty_state  \n",
      "0            1  \n",
      "1            1  \n",
      "2            1  \n",
      "3            1  \n",
      "4            1  \n"
     ]
    }
   ],
   "source": [
    "# Create a new column 'empty_state' initialized with zeros\n",
    "df['empty_state'] = 0\n",
    "\n",
    "# Iterate through rows\n",
    "for i in range(len(df)):\n",
    "    # If 'left' and 'right' are the same\n",
    "    if df.loc[i, 'left_state'] == df.loc[i, 'right_state']:\n",
    "        # Replace 'left' and 'right' with 0\n",
    "        df.loc[i, 'left_state'] = 0\n",
    "        df.loc[i, 'left_state'] = 0\n",
    "        # Assign 'empty_state' to 1\n",
    "        df.loc[i, 'empty_state'] = 1\n",
    "    \n",
    "    # else assign 'empty_state' to 0\n",
    "    else:\n",
    "        df.loc[i, 'empty_state'] = 0\n",
    "\n",
    "# Display the first few rows of the DataFrame\n",
    "print(df.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>left_state</th>\n",
       "      <th>right_state</th>\n",
       "      <th>empty_state</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>10263.000000</td>\n",
       "      <td>10263.000000</td>\n",
       "      <td>10263.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>0.110104</td>\n",
       "      <td>0.247978</td>\n",
       "      <td>0.641918</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>0.313035</td>\n",
       "      <td>0.431860</td>\n",
       "      <td>0.479460</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         left_state   right_state   empty_state\n",
       "count  10263.000000  10263.000000  10263.000000\n",
       "mean       0.110104      0.247978      0.641918\n",
       "std        0.313035      0.431860      0.479460\n",
       "min        0.000000      0.000000      0.000000\n",
       "25%        0.000000      0.000000      0.000000\n",
       "50%        0.000000      0.000000      1.000000\n",
       "75%        0.000000      0.000000      1.000000\n",
       "max        1.000000      1.000000      1.000000"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "train_data, test_data = train_test_split(df, test_size=0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>left_state</th>\n",
       "      <th>right_state</th>\n",
       "      <th>empty_state</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>8210.000000</td>\n",
       "      <td>8210.000000</td>\n",
       "      <td>8210.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>0.110719</td>\n",
       "      <td>0.246894</td>\n",
       "      <td>0.642387</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>0.313803</td>\n",
       "      <td>0.431231</td>\n",
       "      <td>0.479326</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        left_state  right_state  empty_state\n",
       "count  8210.000000  8210.000000  8210.000000\n",
       "mean      0.110719     0.246894     0.642387\n",
       "std       0.313803     0.431231     0.479326\n",
       "min       0.000000     0.000000     0.000000\n",
       "25%       0.000000     0.000000     0.000000\n",
       "50%       0.000000     0.000000     1.000000\n",
       "75%       0.000000     0.000000     1.000000\n",
       "max       1.000000     1.000000     1.000000"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check train minotiry class\n",
    "train_data.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>left_state</th>\n",
       "      <th>right_state</th>\n",
       "      <th>empty_state</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>6182.000000</td>\n",
       "      <td>6182.000000</td>\n",
       "      <td>6182.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>0.330799</td>\n",
       "      <td>0.327887</td>\n",
       "      <td>0.341313</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>0.470539</td>\n",
       "      <td>0.469482</td>\n",
       "      <td>0.474189</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        left_state  right_state  empty_state\n",
       "count  6182.000000  6182.000000  6182.000000\n",
       "mean      0.330799     0.327887     0.341313\n",
       "std       0.470539     0.469482     0.474189\n",
       "min       0.000000     0.000000     0.000000\n",
       "25%       0.000000     0.000000     0.000000\n",
       "50%       0.000000     0.000000     0.000000\n",
       "75%       1.000000     1.000000     1.000000\n",
       "max       1.000000     1.000000     1.000000"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Randomly remove 50% of the empty state data to balance the dataset\n",
    "train_data = train_data.drop(train_data[train_data['empty_state'] == 1].sample(frac=0.6).index)\n",
    "\n",
    "# Randomly increase the left state data to balance the dataset\n",
    "train_data = pd.concat([train_data, train_data[train_data['left_state'] == 1].sample(frac=1.25, replace=True)])\n",
    "\n",
    "# Check the minority class in the train_data\n",
    "train_data.describe()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define features (X) and labels (Y) for training set\n",
    "X_train = train_data['frame_path']\n",
    "Y_train = train_data.drop('frame_path', axis=1)\n",
    "\n",
    "# Define features (X) and labels (Y) for testing set\n",
    "X_test = test_data['frame_path']\n",
    "Y_test = test_data.drop('frame_path', axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train = np.stack(train_data['frame_path'])\n",
    "X_test = np.stack(test_data['frame_path'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Conv2D, MaxPooling2D, Dropout, Flatten, Dense\n",
    "\n",
    "# Define the model architecture\n",
    "model = Sequential([\n",
    "    Conv2D(32, (3, 3), activation='relu', input_shape=(X_train.shape[1:])),\n",
    "    MaxPooling2D(pool_size=(2, 2)),\n",
    "    Dropout(0.25),\n",
    "    \n",
    "    Conv2D(64, (3, 3), activation='relu'),\n",
    "    MaxPooling2D(pool_size=(2, 2)),\n",
    "    Dropout(0.25),\n",
    "    \n",
    "    Conv2D(128, (3, 3), activation='relu'),\n",
    "    MaxPooling2D(pool_size=(2, 2)),\n",
    "    Dropout(0.25),\n",
    "\n",
    "    Conv2D(128, (3, 3), activation='relu'),\n",
    "    MaxPooling2D(pool_size=(2, 2)),\n",
    "    Dropout(0.25),\n",
    "\n",
    "    Flatten(),    # Flattening the 3D outputs of the previous layer\n",
    "    \n",
    "    Dense(512, activation='relu'),\n",
    "    Dropout(0.5),\n",
    "\n",
    "    Dense (256, activation='relu'),\n",
    "    Dropout(0.5),\n",
    "    \n",
    "    Dense (256, activation='relu'),\n",
    "    Dropout(0.5),\n",
    "\n",
    "    Dense(Y_train.shape[1], activation='sigmoid')   # number of output neurons equals to number of key states\n",
    "])\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " conv2d (Conv2D)             (None, 238, 318, 32)      896       \n",
      "                                                                 \n",
      " max_pooling2d (MaxPooling2D  (None, 119, 159, 32)     0         \n",
      " )                                                               \n",
      "                                                                 \n",
      " dropout (Dropout)           (None, 119, 159, 32)      0         \n",
      "                                                                 \n",
      " conv2d_1 (Conv2D)           (None, 117, 157, 64)      18496     \n",
      "                                                                 \n",
      " max_pooling2d_1 (MaxPooling  (None, 58, 78, 64)       0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " dropout_1 (Dropout)         (None, 58, 78, 64)        0         \n",
      "                                                                 \n",
      " conv2d_2 (Conv2D)           (None, 56, 76, 128)       73856     \n",
      "                                                                 \n",
      " max_pooling2d_2 (MaxPooling  (None, 28, 38, 128)      0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " dropout_2 (Dropout)         (None, 28, 38, 128)       0         \n",
      "                                                                 \n",
      " conv2d_3 (Conv2D)           (None, 26, 36, 128)       147584    \n",
      "                                                                 \n",
      " max_pooling2d_3 (MaxPooling  (None, 13, 18, 128)      0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " dropout_3 (Dropout)         (None, 13, 18, 128)       0         \n",
      "                                                                 \n",
      " flatten (Flatten)           (None, 29952)             0         \n",
      "                                                                 \n",
      " dense (Dense)               (None, 512)               15335936  \n",
      "                                                                 \n",
      " dropout_4 (Dropout)         (None, 512)               0         \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 256)               131328    \n",
      "                                                                 \n",
      " dropout_5 (Dropout)         (None, 256)               0         \n",
      "                                                                 \n",
      " dense_2 (Dense)             (None, 256)               65792     \n",
      "                                                                 \n",
      " dropout_6 (Dropout)         (None, 256)               0         \n",
      "                                                                 \n",
      " dense_3 (Dense)             (None, 3)                 771       \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 15,774,659\n",
      "Trainable params: 15,774,659\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# Compile the model\n",
    "model.compile(optimizer='adam', \n",
    "              loss='binary_crossentropy',   # use binary_crossentropy for multi-label classification\n",
    "              metrics=['accuracy'])\n",
    "\n",
    "# Print a summary of the model's architecture\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/25\n",
      "310/310 [==============================] - 17s 34ms/step - loss: 0.5936 - accuracy: 0.4554 - val_loss: 0.8405 - val_accuracy: 0.0420\n",
      "Epoch 2/25\n",
      "310/310 [==============================] - 9s 28ms/step - loss: 0.5187 - accuracy: 0.5717 - val_loss: 0.5059 - val_accuracy: 0.5934\n",
      "Epoch 3/25\n",
      "310/310 [==============================] - 9s 28ms/step - loss: 0.4646 - accuracy: 0.6392 - val_loss: 0.5315 - val_accuracy: 0.6265\n",
      "Epoch 4/25\n",
      "310/310 [==============================] - 9s 28ms/step - loss: 0.4402 - accuracy: 0.6651 - val_loss: 0.4285 - val_accuracy: 0.7130\n",
      "Epoch 5/25\n",
      "310/310 [==============================] - 9s 28ms/step - loss: 0.4113 - accuracy: 0.6965 - val_loss: 0.3556 - val_accuracy: 0.8254\n",
      "Epoch 6/25\n",
      "310/310 [==============================] - 9s 28ms/step - loss: 0.3938 - accuracy: 0.7090 - val_loss: 0.3358 - val_accuracy: 0.8270\n",
      "Epoch 7/25\n",
      "310/310 [==============================] - 9s 28ms/step - loss: 0.3851 - accuracy: 0.7092 - val_loss: 0.3482 - val_accuracy: 0.8577\n",
      "Epoch 8/25\n",
      "310/310 [==============================] - 9s 28ms/step - loss: 0.3735 - accuracy: 0.7270 - val_loss: 0.3380 - val_accuracy: 0.8173\n",
      "Epoch 9/25\n",
      "310/310 [==============================] - 9s 28ms/step - loss: 0.3638 - accuracy: 0.7373 - val_loss: 0.2909 - val_accuracy: 0.8755\n",
      "Epoch 10/25\n",
      "310/310 [==============================] - 8s 27ms/step - loss: 0.3529 - accuracy: 0.7474 - val_loss: 0.2363 - val_accuracy: 0.8698\n",
      "Epoch 11/25\n",
      "310/310 [==============================] - 9s 28ms/step - loss: 0.3498 - accuracy: 0.7464 - val_loss: 0.2594 - val_accuracy: 0.8698\n",
      "Epoch 12/25\n",
      "310/310 [==============================] - 9s 28ms/step - loss: 0.3428 - accuracy: 0.7557 - val_loss: 0.2454 - val_accuracy: 0.8545\n",
      "Epoch 13/25\n",
      "310/310 [==============================] - 9s 27ms/step - loss: 0.3278 - accuracy: 0.7683 - val_loss: 0.2244 - val_accuracy: 0.8771\n",
      "Epoch 14/25\n",
      "310/310 [==============================] - 8s 27ms/step - loss: 0.3149 - accuracy: 0.7830 - val_loss: 0.2687 - val_accuracy: 0.8561\n",
      "Epoch 15/25\n",
      "310/310 [==============================] - 8s 27ms/step - loss: 0.3112 - accuracy: 0.7820 - val_loss: 0.1801 - val_accuracy: 0.9030\n",
      "Epoch 16/25\n",
      "310/310 [==============================] - 8s 27ms/step - loss: 0.2976 - accuracy: 0.8044 - val_loss: 0.1635 - val_accuracy: 0.8973\n",
      "Epoch 17/25\n",
      "310/310 [==============================] - 8s 27ms/step - loss: 0.2890 - accuracy: 0.8016 - val_loss: 0.1790 - val_accuracy: 0.8860\n",
      "Epoch 18/25\n",
      "310/310 [==============================] - 9s 27ms/step - loss: 0.2809 - accuracy: 0.8101 - val_loss: 0.1725 - val_accuracy: 0.8989\n",
      "Epoch 19/25\n",
      "310/310 [==============================] - 9s 27ms/step - loss: 0.2894 - accuracy: 0.8010 - val_loss: 0.1584 - val_accuracy: 0.9095\n",
      "Epoch 20/25\n",
      "310/310 [==============================] - 8s 27ms/step - loss: 0.2641 - accuracy: 0.8224 - val_loss: 0.1186 - val_accuracy: 0.9434\n",
      "Epoch 21/25\n",
      "310/310 [==============================] - 8s 27ms/step - loss: 0.2586 - accuracy: 0.8315 - val_loss: 0.1056 - val_accuracy: 0.9337\n",
      "Epoch 22/25\n",
      "310/310 [==============================] - 9s 28ms/step - loss: 0.2446 - accuracy: 0.8354 - val_loss: 0.1156 - val_accuracy: 0.9256\n",
      "Epoch 23/25\n",
      "310/310 [==============================] - 9s 27ms/step - loss: 0.2414 - accuracy: 0.8356 - val_loss: 0.1422 - val_accuracy: 0.9272\n",
      "Epoch 24/25\n",
      "310/310 [==============================] - 9s 28ms/step - loss: 0.2266 - accuracy: 0.8540 - val_loss: 0.1021 - val_accuracy: 0.9418\n",
      "Epoch 25/25\n",
      "310/310 [==============================] - 9s 28ms/step - loss: 0.2207 - accuracy: 0.8599 - val_loss: 0.1145 - val_accuracy: 0.9305\n"
     ]
    }
   ],
   "source": [
    "# Train the model\n",
    "history = model.fit(X_train, Y_train, validation_split=0.2, epochs=25, batch_size=16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.save('model4.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test loss: 0.34957054257392883\n"
     ]
    }
   ],
   "source": [
    "# evaluate the model\n",
    "score = model.evaluate(X_test, Y_test, verbose=0)\n",
    "print('Test loss:', score[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test accuracy: 0.7705796360969543\n"
     ]
    }
   ],
   "source": [
    "# calculate accuracy\n",
    "print('Test accuracy:', score[1])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ai",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.16"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}