Interjection - Deep Learning.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "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": 2,
   "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": 3,
   "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": 4,
   "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": 5,
   "id": "cded2107-5a65-41cc-80fd-7862a35a912a",
   "metadata": {},
   "outputs": [],
   "source": [
    "df['audio_path'] = ['default'] * len(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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": 7,
   "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": 8,
   "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": 9,
   "id": "1986acfd-999f-4b6d-a5ef-83c4283fa41e",
   "metadata": {},
   "outputs": [],
   "source": [
    "audio_files = df['audio_path'] \n",
    "labels = df['Interjection']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f18f0517-edf7-48ac-beb9-455c724add88",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_Interjection = df[['audio_path', 'Interjection']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "6a98512a-db92-42d3-be8d-7faf74367b19",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_Interjection_1 = df_Interjection[df_Interjection['Interjection']==1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "4f4f7e7f-0148-4642-be12-1366c45aa674",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_Interjection_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": 13,
   "id": "58215a72-ffed-45fc-a98d-c83c3d79b42a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4836, 2)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_Interjection_1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "77dfe2ad-b0ed-4291-93b1-c79b1719201c",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_Interjection_0_sampled = df_Interjection_0.sample(4836)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "695a90ae-1f44-43a7-bdd2-5bdde9340ee5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4836, 17)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_Interjection_0_sampled.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "ce16530e-e3c0-4322-a556-bc0eadab17ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_Interjection_data = pd.concat([df_Interjection_0_sampled, df_Interjection_1], ignore_index=True, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "e76bd344-df9c-4b5c-a4d6-7992f5e2aece",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(9672, 17)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_Interjection_data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "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>Interjection</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  Interjection\n",
       "0  C:\\Users\\jmdgo\\Downloads\\extracted_clips\\extra...             0\n",
       "1  C:\\Users\\jmdgo\\Downloads\\extracted_clips\\extra...             0"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_Interjection.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "659f2a48-a4ec-4b22-ab53-0439f4bea6a3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    50.0\n",
      "1    50.0\n",
      "Name: Interjection, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "value_counts = df_Interjection_data['Interjection'].value_counts()\n",
    "total_rows = df_Interjection_data.shape[0]\n",
    "\n",
    "percentage_per_class = (value_counts / total_rows) * 100\n",
    "\n",
    "print(percentage_per_class)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "6ac7b6a0-0b0b-4eb1-92b2-6d4b834e12aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.array(df_Interjection_data['audio_path'])\n",
    "y = np.array(df_Interjection_data['Interjection'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "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": 24,
   "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": 25,
   "id": "ef378e5f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(6770, 3856)\n",
      "(2902, 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": 26,
   "id": "edabd8ce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((6770,), (2902,), (6770,), (2902,))"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape,X_test.shape,y_train.shape,y_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "b0716fea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NaN values found in training data at indices: [[1709 3854]\n",
      " [1709 3855]\n",
      " [2683 3854]\n",
      " [2683 3855]\n",
      " [3318 3854]\n",
      " [3318 3855]\n",
      " [3983 3855]\n",
      " [5907 3854]\n",
      " [5907 3855]]\n",
      "NaN values found in testing data at indices: [[1429 3854]\n",
      " [1429 3855]]\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": 28,
   "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": 31,
   "id": "ab2ae65f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Explained variance ratio: [0.24535217 0.15974216 0.04872017 0.03948037 0.03389454 0.03217935\n",
      " 0.0308984  0.02110615 0.01733706 0.01695509 0.01463326 0.01192235\n",
      " 0.01065615 0.00991996 0.00890294 0.00825575 0.00787611 0.00680049\n",
      " 0.00599704 0.00598058 0.00571532 0.00535166 0.0052643  0.00451284\n",
      " 0.00438078 0.00422555 0.00398242 0.00391104 0.00369522 0.00362139\n",
      " 0.00348156 0.00327542 0.00322576 0.0029611  0.00292022 0.00279547\n",
      " 0.00278059 0.00274154 0.00271298 0.00250157 0.00247134 0.00243278\n",
      " 0.00234928 0.00229588 0.00217007 0.0021121  0.002096   0.00201872\n",
      " 0.00197486 0.00192207]\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": 32,
   "id": "3f94b2af-6ef7-4b4c-bb18-f970a4e39fda",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Distribution of 0s and 1s in y_train:\n",
      "0    3385\n",
      "1    3385\n",
      "dtype: int64\n",
      "\n",
      "Distribution of 0s and 1s in y_test:\n",
      "1    1451\n",
      "0    1451\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": 34,
   "id": "890da51e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "212/212 [==============================] - 21s 95ms/step - loss: 9.4362 - accuracy: 0.5598 - val_loss: 0.6640 - val_accuracy: 0.6141\n",
      "Epoch 2/10\n",
      "212/212 [==============================] - 20s 96ms/step - loss: 0.5908 - accuracy: 0.6818 - val_loss: 0.6601 - val_accuracy: 0.6220\n",
      "Epoch 3/10\n",
      "212/212 [==============================] - 20s 96ms/step - loss: 0.4838 - accuracy: 0.7725 - val_loss: 0.7158 - val_accuracy: 0.6096\n",
      "Epoch 4/10\n",
      "212/212 [==============================] - 20s 95ms/step - loss: 0.3655 - accuracy: 0.8476 - val_loss: 0.7151 - val_accuracy: 0.6389\n",
      "Epoch 5/10\n",
      "212/212 [==============================] - 20s 95ms/step - loss: 0.2456 - accuracy: 0.9097 - val_loss: 0.8403 - val_accuracy: 0.6079\n",
      "Epoch 6/10\n",
      "212/212 [==============================] - 20s 95ms/step - loss: 0.1576 - accuracy: 0.9496 - val_loss: 1.1630 - val_accuracy: 0.6041\n",
      "Epoch 7/10\n",
      "212/212 [==============================] - 20s 95ms/step - loss: 0.0848 - accuracy: 0.9798 - val_loss: 1.1304 - val_accuracy: 0.6220\n",
      "Epoch 8/10\n",
      "212/212 [==============================] - 20s 95ms/step - loss: 0.0426 - accuracy: 0.9941 - val_loss: 1.3230 - val_accuracy: 0.6182\n",
      "Epoch 9/10\n",
      "212/212 [==============================] - 20s 96ms/step - loss: 0.0204 - accuracy: 0.9991 - val_loss: 1.4078 - val_accuracy: 0.6268\n",
      "Epoch 10/10\n",
      "212/212 [==============================] - 20s 95ms/step - loss: 0.0101 - accuracy: 1.0000 - val_loss: 1.4914 - val_accuracy: 0.6368\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.src.callbacks.History at 0x2f6a09bd7d0>"
      ]
     },
     "execution_count": 34,
     "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": 38,
   "id": "ed530069",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "212/212 [==============================] - 21s 96ms/step - loss: 6.2326 - accuracy: 0.5712 - val_loss: 0.6740 - val_accuracy: 0.6165\n",
      "Epoch 2/10\n",
      "212/212 [==============================] - 20s 94ms/step - loss: 0.5788 - accuracy: 0.6991 - val_loss: 0.6822 - val_accuracy: 0.6172\n",
      "Epoch 3/10\n",
      "212/212 [==============================] - 20s 95ms/step - loss: 0.4612 - accuracy: 0.7851 - val_loss: 0.6952 - val_accuracy: 0.6254\n",
      "Epoch 4/10\n",
      "212/212 [==============================] - 21s 97ms/step - loss: 0.3205 - accuracy: 0.8715 - val_loss: 0.7839 - val_accuracy: 0.6061\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='sigmoid'))  # 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": 39,
   "id": "0d06238d",
   "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": 40,
   "id": "387b3171",
   "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(\"interjection_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
}