Prolongation - Deep Learning.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "d4512109-72c3-4639-9f84-c4ded9559659",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import os\n",
    "import librosa\n",
    "import librosa.display\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import sklearn.preprocessing\n",
    "from scipy.signal import lfilter\n",
    "from joblib import Parallel, delayed\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "import parselmouth\n",
    "from sklearn.decomposition import PCA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e26e9fbd-fd8d-4a1b-8dc3-d9a68e8ffbb8",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(r\"C:\\Users\\jmdgo\\Downloads\\binary_labeled_dataset.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "82127c18-f3c7-4c59-91e1-96ea6e2d7acf",
   "metadata": {},
   "outputs": [],
   "source": [
    "clip_path = r\"C:\\Users\\jmdgo\\Downloads\\extracted_clips\\extracted_clips\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c8e02825-5606-4530-ae17-0e5eea811e28",
   "metadata": {},
   "outputs": [],
   "source": [
    "audio_paths = []\n",
    "for folder in os.listdir(clip_path):\n",
    "    folder_path = os.path.join(clip_path, folder)\n",
    "    #episode_paths = []\n",
    "    for episode in os.listdir(folder_path):\n",
    "        episode_path = os.path.join(folder_path, episode)\n",
    "        for wav in os.listdir(episode_path):\n",
    "            wav_path = os.path.join(episode_path, wav)\n",
    "            audio_paths.append(wav_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "cded2107-5a65-41cc-80fd-7862a35a912a",
   "metadata": {},
   "outputs": [],
   "source": [
    "df['audio_path'] = ['default'] * len(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "49178e08-ce96-4858-97fa-387a1c7106f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "for path in audio_paths:\n",
    "    filename = os.path.basename(path)\n",
    "    parts = filename.split('_')\n",
    "    podcast_name = parts[0]\n",
    "    episode_number = int(parts[1])\n",
    "    clip_number = int(parts[2].split('.')[0]) \n",
    "\n",
    "    match_row = df[(df['Show'] == podcast_name) & (df['EpId'] == episode_number) & (df['ClipId'] == clip_number)]\n",
    "    if not match_row.empty:\n",
    "        match_index = match_row.index[0]\n",
    "        df.at[match_index, 'audio_path'] = path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "1a039cfe-617b-4fab-9f73-9cf73262b00a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    60.677123\n",
      "1    39.322877\n",
      "Name: Stutter, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "value_counts = df['Stutter'].value_counts()\n",
    "total_rows = df.shape[0]\n",
    "\n",
    "percentage_per_class = (value_counts / total_rows) * 100\n",
    "\n",
    "print(percentage_per_class)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "99d679ea-5661-4f3d-912c-f8bcec07633e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_mfcc(audio_file, num_mfcc=40):\n",
    "    audio, sr = librosa.load(audio_file, sr=None)\n",
    "    mfccs = librosa.feature.mfcc(y=audio, sr=sr, n_mfcc=num_mfcc)\n",
    "    mfccs_flat = mfccs.T.flatten()\n",
    "    return mfccs_flat\n",
    "\n",
    "def extract_zcr(audio_file, frame_length=2048, hop_length=512):\n",
    "    audio, sr = librosa.load(audio_file, sr=None)\n",
    "    zcr = librosa.feature.zero_crossing_rate(audio, frame_length=frame_length, hop_length=hop_length)\n",
    "    return zcr.flatten()\n",
    "\n",
    "def extract_jitter_shimmer(audio_file):\n",
    "    sound = parselmouth.Sound(audio_file)\n",
    "    pitch = sound.to_pitch()\n",
    "    pulses = parselmouth.praat.call([sound, pitch], \"To PointProcess (cc)\")\n",
    "    jitter = parselmouth.praat.call(pulses, \"Get jitter (local)\", 0, 0, 0.0001, 0.02, 1.3)\n",
    "    shimmer = parselmouth.praat.call([sound, pulses], \"Get shimmer (local)\", 0, 0, 0.0001, 0.02, 1.3, 1.6)\n",
    "    return jitter, shimmer\n",
    "\n",
    "def extract_all_features(audio_file, num_mfcc=40, frame_length=2048, hop_length=512):\n",
    "    mfcc_features = extract_mfcc(audio_file, num_mfcc)\n",
    "    zcr_features = extract_zcr(audio_file, frame_length, hop_length)\n",
    "    jitter, shimmer = extract_jitter_shimmer(audio_file)\n",
    "    return np.concatenate([mfcc_features, zcr_features, [jitter, shimmer]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "1986acfd-999f-4b6d-a5ef-83c4283fa41e",
   "metadata": {},
   "outputs": [],
   "source": [
    "audio_files = df['audio_path'] \n",
    "labels = df['Prolongation']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f18f0517-edf7-48ac-beb9-455c724add88",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_prolongation = df[['audio_path', 'Prolongation']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "6a98512a-db92-42d3-be8d-7faf74367b19",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_prolongation_1 = df_prolongation[df_prolongation['Prolongation']==1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "4f4f7e7f-0148-4642-be12-1366c45aa674",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_prolongation_0 = df[(df['Prolongation']==0) & \n",
    "                        (df['Block']==0) & \n",
    "                        (df['Interjection']==0) & \n",
    "                        (df['WordRep']==0) & \n",
    "                        (df['SoundRep']==0) &\n",
    "                        (df['NoStutteredWords']==1)]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "58215a72-ffed-45fc-a98d-c83c3d79b42a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2065, 2)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_prolongation_1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "77dfe2ad-b0ed-4291-93b1-c79b1719201c",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_prolongation_0_sampled = df_prolongation_0.sample(2065)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "695a90ae-1f44-43a7-bdd2-5bdde9340ee5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2065, 17)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_prolongation_0_sampled.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "ce16530e-e3c0-4322-a556-bc0eadab17ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_prolongation_data = pd.concat([df_prolongation_0_sampled, df_prolongation_1], ignore_index=True, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "e76bd344-df9c-4b5c-a4d6-7992f5e2aece",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4130, 17)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_prolongation_data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "91a4fd62-172b-416e-8c72-b2b942c8dc22",
   "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>audio_path</th>\n",
       "      <th>Prolongation</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>C:\\Users\\jmdgo\\Downloads\\extracted_clips\\extra...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>C:\\Users\\jmdgo\\Downloads\\extracted_clips\\extra...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                          audio_path  Prolongation\n",
       "0  C:\\Users\\jmdgo\\Downloads\\extracted_clips\\extra...             0\n",
       "1  C:\\Users\\jmdgo\\Downloads\\extracted_clips\\extra...             0"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_prolongation.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "659f2a48-a4ec-4b22-ab53-0439f4bea6a3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    50.0\n",
      "1    50.0\n",
      "Name: Prolongation, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "value_counts = df_prolongation_data['Prolongation'].value_counts()\n",
    "total_rows = df_prolongation_data.shape[0]\n",
    "\n",
    "percentage_per_class = (value_counts / total_rows) * 100\n",
    "\n",
    "print(percentage_per_class)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "6ac7b6a0-0b0b-4eb1-92b2-6d4b834e12aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.array(df_prolongation_data['audio_path'])\n",
    "y = np.array(df_prolongation_data['Prolongation'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "02ad3a9a-237b-4e62-8d65-506c7ad0472f",
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=40, stratify = y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "30457ffd-8255-4ebc-974d-38f33db7afcb",
   "metadata": {},
   "outputs": [],
   "source": [
    "mfcc_features_train = Parallel(n_jobs=-1)(delayed(extract_mfcc)(audio_file) for audio_file in X_train)\n",
    "mfcc_features_test = Parallel(n_jobs=-1)(delayed(extract_mfcc)(audio_file) for audio_file in X_test)\n",
    "zcr_features_train = Parallel(n_jobs=-1)(delayed(extract_zcr)(audio_file) for audio_file in X_train)\n",
    "zcr_features_test = Parallel(n_jobs=-1)(delayed(extract_zcr)(audio_file) for audio_file in X_test)\n",
    "\n",
    "jitter_shimmer_train = Parallel(n_jobs=-1)(delayed(extract_jitter_shimmer)(audio_file) for audio_file in X_train)\n",
    "jitter_shimmer_test = Parallel(n_jobs=-1)(delayed(extract_jitter_shimmer)(audio_file) for audio_file in X_test)\n",
    "\n",
    "jitter_train, shimmer_train = zip(*jitter_shimmer_train)\n",
    "jitter_test, shimmer_test = zip(*jitter_shimmer_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6973590c-5fc5-40f4-a7fb-10d05dd9df47",
   "metadata": {},
   "source": [
    "zcr_features_train = Parallel(n_jobs=-1)(delayed(extract_zcr)(audio_file) for audio_file in X_train)\n",
    "zcr_features_test = Parallel(n_jobs=-1)(delayed(extract_zcr)(audio_file) for audio_file in X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "660938cb-e39a-450a-9061-6c24c02bd983",
   "metadata": {},
   "source": [
    "features_train = np.array([np.hstack((mfcc, zcr)) for mfcc, zcr in zip(mfcc_features_train, zcr_features_train)])\n",
    "features_test = np.array([np.hstack((mfcc, zcr)) for mfcc, zcr in zip(mfcc_features_test, zcr_features_test)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "ef378e5f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2891, 3856)\n",
      "(1239, 3856)\n"
     ]
    }
   ],
   "source": [
    "merged_features_train = np.column_stack((mfcc_features_train, zcr_features_train, jitter_train, shimmer_train))\n",
    "merged_features_test = np.column_stack((mfcc_features_test, zcr_features_test, jitter_test, shimmer_test))\n",
    "\n",
    "print(merged_features_train.shape)\n",
    "print(merged_features_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "edabd8ce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((2891,), (1239,), (2891,), (1239,))"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape,X_test.shape,y_train.shape,y_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "b0716fea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NaN values found in training data at indices: [[2506 3854]\n",
      " [2506 3855]\n",
      " [2604 3854]\n",
      " [2604 3855]\n",
      " [2799 3854]\n",
      " [2799 3855]]\n",
      "No NaN values found in testing data\n"
     ]
    }
   ],
   "source": [
    "nan_indices_train = np.argwhere(np.isnan(merged_features_train))\n",
    "if len(nan_indices_train) > 0:\n",
    "    print(\"NaN values found in training data at indices:\", nan_indices_train)\n",
    "else:\n",
    "    print(\"No NaN values found in training data\")\n",
    "\n",
    "# Check for NaN values in testing data\n",
    "nan_indices_test = np.argwhere(np.isnan(merged_features_test))\n",
    "if len(nan_indices_test) > 0:\n",
    "    print(\"NaN values found in testing data at indices:\", nan_indices_test)\n",
    "else:\n",
    "    print(\"No NaN values found in testing data\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "d47130de",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No NaN values found in imputed training data\n",
      "No NaN values found in imputed testing data\n"
     ]
    }
   ],
   "source": [
    "from sklearn.impute import KNNImputer\n",
    "# KNN imputation\n",
    "imputer = KNNImputer(n_neighbors=5)  # You can adjust the number of neighbors as needed\n",
    "\n",
    "# Fit imputer on training data and transform both training and testing data\n",
    "merged_features_train = imputer.fit_transform(merged_features_train)\n",
    "merged_features_test = imputer.transform(merged_features_test)\n",
    "\n",
    "# Check if any NaN values remain after imputation\n",
    "nan_indices_train = np.argwhere(np.isnan(merged_features_train))\n",
    "if len(nan_indices_train) > 0:\n",
    "    print(\"NaN values still present in imputed training data at indices:\", nan_indices_train)\n",
    "else:\n",
    "    print(\"No NaN values found in imputed training data\")\n",
    "\n",
    "nan_indices_test = np.argwhere(np.isnan(merged_features_test))\n",
    "if len(nan_indices_test) > 0:\n",
    "    print(\"NaN values still present in imputed testing data at indices:\", nan_indices_test)\n",
    "else:\n",
    "    print(\"No NaN values found in imputed testing data\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "814849c2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Explained variance ratio: [0.23752044 0.16494374 0.04871912 0.03939321 0.03542037 0.03207223\n",
      " 0.03117927 0.02073781 0.01916248 0.01698106 0.01481102 0.01251656\n",
      " 0.01121389 0.00915949 0.00871063 0.00848164 0.00708747 0.00697615\n",
      " 0.00658917 0.00606463 0.00551531 0.0054587  0.00541356 0.00499439\n",
      " 0.00455259 0.00419883 0.00411399 0.00389106 0.00375998 0.00372442\n",
      " 0.00359807 0.00346636 0.00330063 0.00320057 0.00307761 0.0029373\n",
      " 0.00288572 0.00282483 0.00274999 0.00264881 0.00260665 0.00257116\n",
      " 0.00244398 0.00232947 0.00223247 0.00219124 0.00214265 0.00208467\n",
      " 0.00205736 0.0019603 ]\n"
     ]
    }
   ],
   "source": [
    "from sklearn.decomposition import PCA\n",
    "\n",
    "# Assuming merged_features_train and merged_features_test are your feature arrays\n",
    "\n",
    "# Merge the training and testing data\n",
    "merged_data = np.concatenate((merged_features_train, merged_features_test), axis=0)\n",
    "\n",
    "# Apply PCA\n",
    "pca = PCA(n_components=50)  # You can specify the number of principal components as needed\n",
    "transformed_data = pca.fit_transform(merged_data)\n",
    "\n",
    "# Print the explained variance ratio\n",
    "print(\"Explained variance ratio:\", pca.explained_variance_ratio_)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "3f94b2af-6ef7-4b4c-bb18-f970a4e39fda",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Distribution of 0s and 1s in y_train:\n",
      "1    1446\n",
      "0    1445\n",
      "dtype: int64\n",
      "\n",
      "Distribution of 0s and 1s in y_test:\n",
      "0    620\n",
      "1    619\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "y_train_series = pd.Series(y_train)\n",
    "y_test_series = pd.Series(y_test)\n",
    "\n",
    "# Count the occurrences of each unique value in y_train\n",
    "train_distribution = y_train_series.value_counts()\n",
    "\n",
    "# Count the occurrences of each unique value in y_test\n",
    "test_distribution = y_test_series.value_counts()\n",
    "\n",
    "print(\"Distribution of 0s and 1s in y_train:\")\n",
    "print(train_distribution)\n",
    "\n",
    "print(\"\\nDistribution of 0s and 1s in y_test:\")\n",
    "print(test_distribution)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "890da51e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "91/91 [==============================] - 10s 100ms/step - loss: 17.5028 - accuracy: 0.5189 - val_loss: 0.7247 - val_accuracy: 0.5157\n",
      "Epoch 2/10\n",
      "91/91 [==============================] - 9s 100ms/step - loss: 0.6963 - accuracy: 0.5711 - val_loss: 0.6835 - val_accuracy: 0.5674\n",
      "Epoch 3/10\n",
      "91/91 [==============================] - 9s 100ms/step - loss: 0.6626 - accuracy: 0.6230 - val_loss: 0.7082 - val_accuracy: 0.5803\n",
      "Epoch 4/10\n",
      "91/91 [==============================] - 9s 100ms/step - loss: 0.6403 - accuracy: 0.6596 - val_loss: 0.6889 - val_accuracy: 0.5787\n",
      "Epoch 5/10\n",
      "91/91 [==============================] - 9s 100ms/step - loss: 0.6067 - accuracy: 0.6880 - val_loss: 0.6791 - val_accuracy: 0.6182\n",
      "Epoch 6/10\n",
      "91/91 [==============================] - 9s 101ms/step - loss: 0.5491 - accuracy: 0.7606 - val_loss: 0.7088 - val_accuracy: 0.6077\n",
      "Epoch 7/10\n",
      "91/91 [==============================] - 9s 100ms/step - loss: 0.5601 - accuracy: 0.7949 - val_loss: 0.7595 - val_accuracy: 0.6174\n",
      "Epoch 8/10\n",
      "91/91 [==============================] - 9s 99ms/step - loss: 0.4728 - accuracy: 0.8426 - val_loss: 0.7534 - val_accuracy: 0.6037\n",
      "Epoch 9/10\n",
      "91/91 [==============================] - 9s 99ms/step - loss: 0.3534 - accuracy: 0.8900 - val_loss: 0.7778 - val_accuracy: 0.6094\n",
      "Epoch 10/10\n",
      "91/91 [==============================] - 9s 101ms/step - loss: 0.2783 - accuracy: 0.9242 - val_loss: 0.9616 - val_accuracy: 0.5851\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.src.callbacks.History at 0x1bc2513c9d0>"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "from sklearn.model_selection import train_test_split\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Conv1D, MaxPooling1D, Flatten, Dense\n",
    "from tensorflow.keras.utils import to_categorical\n",
    "\n",
    "X_train = np.array(merged_features_train)\n",
    "X_test = np.array(merged_features_test)\n",
    "y_train = np.array(y_train)\n",
    "y_test = np.array(y_test)\n",
    "\n",
    "# Convert labels to categorical\n",
    "y_train_categorical = to_categorical(y_train, num_classes=2)\n",
    "y_test_categorical = to_categorical(y_test, num_classes=2)\n",
    "\n",
    "# Reshape features for Conv1D input shape\n",
    "X_train = X_train.reshape(X_train.shape[0], X_train.shape[1], 1)\n",
    "X_test = X_test.reshape(X_test.shape[0], X_test.shape[1], 1)\n",
    "\n",
    "# Define the CNN model\n",
    "model = Sequential()\n",
    "model.add(Conv1D(32, 3, activation='relu', input_shape=(X_train.shape[1], 1)))\n",
    "model.add(MaxPooling1D(pool_size=2))\n",
    "model.add(Conv1D(64, 3, activation='relu'))\n",
    "model.add(MaxPooling1D(pool_size=2))\n",
    "model.add(Flatten())\n",
    "model.add(Dense(128, activation='relu'))\n",
    "model.add(Dense(2, activation='sigmoid'))  # Output layer with sigmoid activation for binary classification\n",
    "\n",
    "# Compile the model\n",
    "model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])\n",
    "\n",
    "# Train the model\n",
    "model.fit(X_train, y_train_categorical, epochs=10, batch_size=32, validation_data=(X_test, y_test_categorical))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "ed530069",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "91/91 [==============================] - 11s 103ms/step - loss: 20.1623 - accuracy: 0.5105 - val_loss: 0.8753 - val_accuracy: 0.5617\n",
      "Epoch 2/10\n",
      "91/91 [==============================] - 9s 103ms/step - loss: 0.6918 - accuracy: 0.6621 - val_loss: 1.0606 - val_accuracy: 0.5303\n",
      "Epoch 3/10\n",
      "91/91 [==============================] - 9s 101ms/step - loss: 0.5249 - accuracy: 0.7551 - val_loss: 1.0449 - val_accuracy: 0.5432\n",
      "Epoch 4/10\n",
      "91/91 [==============================] - 9s 101ms/step - loss: 0.4031 - accuracy: 0.8433 - val_loss: 0.8239 - val_accuracy: 0.5940\n",
      "Epoch 5/10\n",
      "91/91 [==============================] - 9s 102ms/step - loss: 0.2926 - accuracy: 0.8990 - val_loss: 0.8225 - val_accuracy: 0.6053\n",
      "Epoch 6/10\n",
      "91/91 [==============================] - 9s 100ms/step - loss: 0.1755 - accuracy: 0.9606 - val_loss: 0.9136 - val_accuracy: 0.6118\n",
      "Epoch 7/10\n",
      "91/91 [==============================] - 9s 100ms/step - loss: 0.1054 - accuracy: 0.9882 - val_loss: 0.9939 - val_accuracy: 0.6061\n",
      "Epoch 8/10\n",
      "91/91 [==============================] - 9s 101ms/step - loss: 0.0567 - accuracy: 0.9979 - val_loss: 1.0613 - val_accuracy: 0.6029\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from sklearn.model_selection import train_test_split\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Conv1D, MaxPooling1D, Flatten, Dense\n",
    "from tensorflow.keras.utils import to_categorical\n",
    "\n",
    "# Assuming merged_features_train contains merged features for training data\n",
    "# Assuming merged_features_test contains merged features for test data\n",
    "# Assuming y_train contains labels for training data\n",
    "# Assuming y_test contains labels for test data\n",
    "\n",
    "# Convert lists to numpy arrays\n",
    "X_train = np.array(merged_features_train)\n",
    "X_test = np.array(merged_features_test)\n",
    "y_train = np.array(y_train)\n",
    "y_test = np.array(y_test)\n",
    "\n",
    "# Convert labels to categorical\n",
    "y_train_categorical = to_categorical(y_train, num_classes=2)\n",
    "y_test_categorical = to_categorical(y_test, num_classes=2)\n",
    "\n",
    "# Reshape features for Conv1D input shape\n",
    "X_train = X_train.reshape(X_train.shape[0], X_train.shape[1], 1)\n",
    "X_test = X_test.reshape(X_test.shape[0], X_test.shape[1], 1)\n",
    "\n",
    "# Define the CNN model\n",
    "model = Sequential()\n",
    "model.add(Conv1D(32, 3, activation='relu', input_shape=(X_train.shape[1], 1)))\n",
    "model.add(MaxPooling1D(pool_size=2))\n",
    "model.add(Conv1D(64, 3, activation='relu'))\n",
    "model.add(MaxPooling1D(pool_size=2))\n",
    "model.add(Flatten())\n",
    "model.add(Dense(128, activation='relu'))\n",
    "model.add(Dense(2, activation='softmax'))  # Output layer with softmax activation for binary classification\n",
    "\n",
    "# Compile the model\n",
    "model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])\n",
    "\n",
    "from tensorflow.keras.callbacks import EarlyStopping\n",
    "\n",
    "# Define early stopping callback\n",
    "early_stopping = EarlyStopping(monitor='val_loss', patience=3, restore_best_weights=True)\n",
    "\n",
    "# Train the model with early stopping\n",
    "history = model.fit(X_train, y_train_categorical, epochs=10, batch_size=32, \n",
    "                    validation_data=(X_test, y_test_categorical), callbacks=[early_stopping])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "ddc3bc8a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['loss', 'accuracy', 'val_loss', 'val_accuracy'])\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "# Print the keys of the history\n",
    "print(history.history.keys())\n",
    "\n",
    "# Summarize history for accuracy\n",
    "plt.plot(history.history['accuracy'])\n",
    "plt.plot(history.history['val_accuracy'])\n",
    "plt.title('Model Accuracy')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(['Train', 'Validation'], loc='upper left')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "89d8bb59",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model saved successfully to: C:\\Users\\jmdgo\\Downloads\n"
     ]
    }
   ],
   "source": [
    "model_file_path = r'C:\\Users\\jmdgo\\Downloads'\n",
    "model.save(\"prolongation_mzjs_model.h5\")\n",
    "print(\"Model saved successfully to:\", model_file_path)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}