SoundRep - 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['SoundRep']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f18f0517-edf7-48ac-beb9-455c724add88",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_SoundRep = df[['audio_path', 'SoundRep']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "6a98512a-db92-42d3-be8d-7faf74367b19",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_SoundRep_1 = df_SoundRep[df_SoundRep['SoundRep']==1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "4f4f7e7f-0148-4642-be12-1366c45aa674",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_SoundRep_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": [
       "(1950, 2)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_SoundRep_1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "77dfe2ad-b0ed-4291-93b1-c79b1719201c",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_SoundRep_0_sampled = df_SoundRep_0.sample(1950)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "695a90ae-1f44-43a7-bdd2-5bdde9340ee5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1950, 17)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_SoundRep_0_sampled.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "ce16530e-e3c0-4322-a556-bc0eadab17ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_SoundRep_data = pd.concat([df_SoundRep_0_sampled, df_SoundRep_1], ignore_index=True, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "e76bd344-df9c-4b5c-a4d6-7992f5e2aece",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3900, 17)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_SoundRep_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>SoundRep</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  SoundRep\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_SoundRep.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: SoundRep, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "value_counts = df_SoundRep_data['SoundRep'].value_counts()\n",
    "total_rows = df_SoundRep_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_SoundRep_data['audio_path'])\n",
    "y = np.array(df_SoundRep_data['SoundRep'])"
   ]
  },
  {
   "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": [
      "(2730, 3856)\n",
      "(1170, 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": [
       "((2730,), (1170,), (2730,), (1170,))"
      ]
     },
     "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: [[ 147 3854]\n",
      " [ 147 3855]\n",
      " [ 325 3855]\n",
      " [1870 3854]\n",
      " [1870 3855]\n",
      " [2060 3854]\n",
      " [2060 3855]]\n",
      "NaN values found in testing data at indices: [[ 138 3854]\n",
      " [ 138 3855]\n",
      " [ 140 3854]\n",
      " [ 140 3855]\n",
      " [ 161 3854]\n",
      " [ 161 3855]\n",
      " [ 605 3854]\n",
      " [ 605 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": 27,
   "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": 29,
   "id": "ab2ae65f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Explained variance ratio: [0.23046092 0.1690381  0.05182512 0.03873228 0.03267255 0.03213632\n",
      " 0.03040406 0.01967926 0.01881117 0.01597497 0.01437103 0.01180179\n",
      " 0.01135941 0.01020829 0.00928691 0.00887731 0.00776032 0.00679666\n",
      " 0.00657214 0.00648516 0.00598973 0.00572877 0.00556341 0.0049202\n",
      " 0.00474634 0.00465325 0.00444663 0.00401209 0.00388667 0.00380322\n",
      " 0.00367577 0.00361095 0.00345658 0.00316666 0.00307042 0.00297792\n",
      " 0.00292586 0.00288976 0.00276818 0.00265818 0.00263326 0.00248504\n",
      " 0.00245014 0.00236614 0.00228997 0.00225381 0.0022253  0.00220008\n",
      " 0.00202645 0.00197055]\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": 30,
   "id": "3f94b2af-6ef7-4b4c-bb18-f970a4e39fda",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Distribution of 0s and 1s in y_train:\n",
      "1    1365\n",
      "0    1365\n",
      "dtype: int64\n",
      "\n",
      "Distribution of 0s and 1s in y_test:\n",
      "0    585\n",
      "1    585\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": 31,
   "id": "890da51e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "86/86 [==============================] - 9s 99ms/step - loss: 18.9509 - accuracy: 0.5524 - val_loss: 0.7147 - val_accuracy: 0.5966\n",
      "Epoch 2/10\n",
      "86/86 [==============================] - 8s 94ms/step - loss: 0.6035 - accuracy: 0.6905 - val_loss: 0.6925 - val_accuracy: 0.6120\n",
      "Epoch 3/10\n",
      "86/86 [==============================] - 8s 94ms/step - loss: 0.4626 - accuracy: 0.7916 - val_loss: 0.7216 - val_accuracy: 0.6137\n",
      "Epoch 4/10\n",
      "86/86 [==============================] - 8s 92ms/step - loss: 0.3684 - accuracy: 0.8502 - val_loss: 0.8918 - val_accuracy: 0.5863\n",
      "Epoch 5/10\n",
      "86/86 [==============================] - 8s 94ms/step - loss: 0.2461 - accuracy: 0.9190 - val_loss: 0.8337 - val_accuracy: 0.6026\n",
      "Epoch 6/10\n",
      "86/86 [==============================] - 8s 92ms/step - loss: 0.1465 - accuracy: 0.9674 - val_loss: 0.8887 - val_accuracy: 0.6000\n",
      "Epoch 7/10\n",
      "86/86 [==============================] - 8s 93ms/step - loss: 0.0811 - accuracy: 0.9901 - val_loss: 1.0207 - val_accuracy: 0.6068\n",
      "Epoch 8/10\n",
      "86/86 [==============================] - 8s 92ms/step - loss: 0.0490 - accuracy: 0.9974 - val_loss: 1.0908 - val_accuracy: 0.5957\n",
      "Epoch 9/10\n",
      "86/86 [==============================] - 8s 92ms/step - loss: 0.0274 - accuracy: 0.9993 - val_loss: 1.2084 - val_accuracy: 0.5991\n",
      "Epoch 10/10\n",
      "86/86 [==============================] - 8s 92ms/step - loss: 0.0161 - accuracy: 1.0000 - val_loss: 1.2317 - val_accuracy: 0.5974\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.src.callbacks.History at 0x2add0b564d0>"
      ]
     },
     "execution_count": 31,
     "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": 35,
   "id": "ed530069",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "86/86 [==============================] - 9s 96ms/step - loss: 14.9529 - accuracy: 0.5513 - val_loss: 0.7588 - val_accuracy: 0.5607\n",
      "Epoch 2/10\n",
      "86/86 [==============================] - 8s 94ms/step - loss: 0.5402 - accuracy: 0.7374 - val_loss: 0.6884 - val_accuracy: 0.6077\n",
      "Epoch 3/10\n",
      "86/86 [==============================] - 8s 94ms/step - loss: 0.3890 - accuracy: 0.8421 - val_loss: 0.7183 - val_accuracy: 0.6120\n",
      "Epoch 4/10\n",
      "86/86 [==============================] - 8s 94ms/step - loss: 0.2228 - accuracy: 0.9330 - val_loss: 0.7829 - val_accuracy: 0.6197\n",
      "Epoch 5/10\n",
      "86/86 [==============================] - 8s 94ms/step - loss: 0.1110 - accuracy: 0.9839 - val_loss: 0.9572 - val_accuracy: 0.6162\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": 36,
   "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": 37,
   "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(\"SoundRep_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
}