WordRep - 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": 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['WordRep']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f18f0517-edf7-48ac-beb9-455c724add88",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_WordRep = df[['audio_path', 'WordRep']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "6a98512a-db92-42d3-be8d-7faf74367b19",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_WordRep_1 = df_WordRep[df_WordRep['WordRep']==1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "4f4f7e7f-0148-4642-be12-1366c45aa674",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_WordRep_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": [
       "(2358, 2)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_WordRep_1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "77dfe2ad-b0ed-4291-93b1-c79b1719201c",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_WordRep_0_sampled = df_WordRep_0.sample(2358)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "695a90ae-1f44-43a7-bdd2-5bdde9340ee5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2358, 17)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_WordRep_0_sampled.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "ce16530e-e3c0-4322-a556-bc0eadab17ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_WordRep_data = pd.concat([df_WordRep_0_sampled, df_WordRep_1], ignore_index=True, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "e76bd344-df9c-4b5c-a4d6-7992f5e2aece",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4716, 17)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_WordRep_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>WordRep</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  WordRep\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_WordRep.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: WordRep, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "value_counts = df_WordRep_data['WordRep'].value_counts()\n",
    "total_rows = df_WordRep_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_WordRep_data['audio_path'])\n",
    "y = np.array(df_WordRep_data['WordRep'])"
   ]
  },
  {
   "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": [
      "(3301, 3856)\n",
      "(1415, 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": [
       "((3301,), (1415,), (3301,), (1415,))"
      ]
     },
     "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: [[  96 3854]\n",
      " [  96 3855]\n",
      " [1100 3855]\n",
      " [1496 3854]\n",
      " [1496 3855]\n",
      " [2520 3854]\n",
      " [2520 3855]]\n",
      "NaN values found in testing data at indices: [[ 589 3854]\n",
      " [ 589 3855]\n",
      " [ 614 3854]\n",
      " [ 614 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": 30,
   "id": "ab2ae65f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Explained variance ratio: [0.24778653 0.15632687 0.04659932 0.03814196 0.03333837 0.0299441\n",
      " 0.0278395  0.01992707 0.01829503 0.01710236 0.01471269 0.01259337\n",
      " 0.01109808 0.01105278 0.00942105 0.00850567 0.0083739  0.00720376\n",
      " 0.00638069 0.006122   0.00581438 0.0056173  0.00542596 0.00520031\n",
      " 0.00464309 0.00440965 0.00424653 0.00408088 0.00395583 0.00368943\n",
      " 0.00366224 0.00354939 0.00344957 0.00311403 0.00306417 0.00293423\n",
      " 0.00285715 0.00275122 0.00269917 0.00259841 0.00254493 0.00249555\n",
      " 0.00235417 0.00230372 0.00229554 0.00220197 0.00213064 0.00209418\n",
      " 0.0020142  0.00196921]\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": 31,
   "id": "3f94b2af-6ef7-4b4c-bb18-f970a4e39fda",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Distribution of 0s and 1s in y_train:\n",
      "1    1651\n",
      "0    1650\n",
      "dtype: int64\n",
      "\n",
      "Distribution of 0s and 1s in y_test:\n",
      "0    708\n",
      "1    707\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": 32,
   "id": "890da51e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "104/104 [==============================] - 10s 93ms/step - loss: 12.1015 - accuracy: 0.5338 - val_loss: 0.7845 - val_accuracy: 0.5845\n",
      "Epoch 2/10\n",
      "104/104 [==============================] - 10s 92ms/step - loss: 0.6080 - accuracy: 0.6871 - val_loss: 0.6952 - val_accuracy: 0.6092\n",
      "Epoch 3/10\n",
      "104/104 [==============================] - 9s 91ms/step - loss: 0.4433 - accuracy: 0.8207 - val_loss: 0.7501 - val_accuracy: 0.6106\n",
      "Epoch 4/10\n",
      "104/104 [==============================] - 10s 92ms/step - loss: 0.2989 - accuracy: 0.9006 - val_loss: 0.8258 - val_accuracy: 0.5951\n",
      "Epoch 5/10\n",
      "104/104 [==============================] - 10s 92ms/step - loss: 0.1583 - accuracy: 0.9621 - val_loss: 0.9792 - val_accuracy: 0.5816\n",
      "Epoch 6/10\n",
      "104/104 [==============================] - 10s 95ms/step - loss: 0.0864 - accuracy: 0.9870 - val_loss: 1.1257 - val_accuracy: 0.5837\n",
      "Epoch 7/10\n",
      "104/104 [==============================] - 10s 94ms/step - loss: 0.0430 - accuracy: 0.9973 - val_loss: 1.2844 - val_accuracy: 0.5830\n",
      "Epoch 8/10\n",
      "104/104 [==============================] - 10s 93ms/step - loss: 0.0186 - accuracy: 0.9994 - val_loss: 1.4938 - val_accuracy: 0.5682\n",
      "Epoch 9/10\n",
      "104/104 [==============================] - 10s 92ms/step - loss: 0.0094 - accuracy: 1.0000 - val_loss: 1.5207 - val_accuracy: 0.5795\n",
      "Epoch 10/10\n",
      "104/104 [==============================] - 10s 93ms/step - loss: 0.0049 - accuracy: 1.0000 - val_loss: 1.6116 - val_accuracy: 0.5788\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.src.callbacks.History at 0x1cb1d078bd0>"
      ]
     },
     "execution_count": 32,
     "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": 37,
   "id": "ed530069",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "104/104 [==============================] - 11s 95ms/step - loss: 16.1136 - accuracy: 0.5183 - val_loss: 4.1389 - val_accuracy: 0.4996\n",
      "Epoch 2/10\n",
      "104/104 [==============================] - 10s 97ms/step - loss: 1.1178 - accuracy: 0.6122 - val_loss: 0.7899 - val_accuracy: 0.5633\n",
      "Epoch 3/10\n",
      "104/104 [==============================] - 10s 92ms/step - loss: 0.4696 - accuracy: 0.7776 - val_loss: 0.7654 - val_accuracy: 0.5753\n",
      "Epoch 4/10\n",
      "104/104 [==============================] - 10s 92ms/step - loss: 0.3207 - accuracy: 0.8812 - val_loss: 0.8578 - val_accuracy: 0.5682\n",
      "Epoch 5/10\n",
      "104/104 [==============================] - 10s 95ms/step - loss: 0.2096 - accuracy: 0.9400 - val_loss: 1.1416 - val_accuracy: 0.5576\n",
      "Epoch 6/10\n",
      "104/104 [==============================] - 10s 94ms/step - loss: 0.1408 - accuracy: 0.9670 - val_loss: 1.0305 - val_accuracy: 0.5625\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 sigmoid 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": 38,
   "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": 39,
   "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(\"WordRep_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
}