cnn_classifier.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Binary classification with DeepCNN\n",
    "\n",
    "The paths utilized are defiend in the `path_module.py`\n",
    "\n",
    "Before this, the data must be processed. \n",
    "- `data_processing` notebook loads raw data and prepares training,validation and test dataset\n",
    "\n",
    "### 1. Import libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from modules.path_module import *\n",
    "from modules.utils_module import *\n",
    "import os\n",
    "import joblib\n",
    "import torch\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Load data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data=joblib.load(os.path.join(processed_datapath,\"train_data.joblib\"))\n",
    "test_data=joblib.load(os.path.join(processed_datapath,\"test_data.joblib\"))\n",
    "val_data=joblib.load(os.path.join(processed_datapath,\"val_data.joblib\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Prepare data \n",
    "- We train using the training set and save the model that gives the best performance on the validation set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_sigdata,train_label=prepare_cnn_data(train_data)\n",
    "val_sigdata,val_label=prepare_cnn_data(val_data)\n",
    "test_sigdata,test_label=prepare_cnn_data(test_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. DeepCNN model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Paper: https://link.springer.com/article/10.1007/s00521-018-3689-5\n",
    "\n",
    "Architecture: https://link.springer.com/article/10.1007/s00521-018-3689-5/tables/1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Layers | Layer name    | Kernel size | No. of filters | Stride | Output shape | No. of trainable parameters | Regularization  |\n",
    "|--------|---------------|-------------|----------------|--------|--------------|-----------------------------|-----------------|\n",
    "| 0      | Input         | –           | –              | –      | 2500 x 59    | 0                           | –               |\n",
    "| 1      | 1D convolution| 20 x 1      | 5              | 1      | 2481 x 5     | 6000                        | –               |\n",
    "| 2      | Max-pooling   | 2 x 1       | 5              | 2      | 1240 x 5     | 0                           | –               |\n",
    "| 3      | 1D convolution| 10 x 1      | 10             | 1      | 1231 x 10    | 5000                        | –               |\n",
    "| 4      | Max-pooling   | 2 x 1       | 10             | 2      | 615 x 10     | 0                           | –               |\n",
    "| 5      | 1D convolution| 10 x 1      | 10             | 1      | 606 x 10     | 10000                       | –               |\n",
    "| 6      | Max-pooling   | 2 x 1       | 10             | 2      | 303 x 10     | 0                           | –               |\n",
    "| 7      | 1D convolution| 5 x 1       | 15             | 1      | 299 x 15     | 7500                        | –               |\n",
    "| 8      | Max-pooling   | 2 x 1       | 15             | 2      | 149 x 15     | 0                           | –               |\n",
    "| 10     | Dense         | –           | –              | –      | 20           | 44800                       | Dropout (0.5)   |\n",
    "| 12     | Dense         | –           | –              | –      | 10           | 210                         | Dropout (0.5)   |\n",
    "| 13     | Dense         | –           | –              | –      | 2            | 22                          | –               |\n",
    "|        | Total         |             |                |        |              | 68332                       |                 |\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "class CNN_Model(nn.Module):\n",
    "    def __init__(self,chan_total,signal_length):\n",
    "        super(CNN_Model, self).__init__()\n",
    "        self.conv1 = nn.Conv1d(in_channels=chan_total, out_channels=5, kernel_size=20, stride=1,padding=0)\n",
    "        self.pool = nn.AvgPool1d(kernel_size=2)\n",
    "        self.conv2=nn.Conv1d(in_channels=5, out_channels=10, kernel_size=10, stride=1,padding=0)\n",
    "        self.conv3=nn.Conv1d(in_channels=10, out_channels=10, kernel_size=10, stride=1,padding=0)\n",
    "        self.conv4=nn.Conv1d(in_channels=10, out_channels=15, kernel_size=5, stride=1,padding=0)\n",
    "        self.fc1 = nn.Linear(int(149*15), 20)\n",
    "        self.fc2 = nn.Linear(20, 10)\n",
    "        self.fc3 = nn.Linear(10, 2)\n",
    "        self.dropout = nn.Dropout(0.5)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.conv1(x)) # layer 1\n",
    "        x = self.pool(x) # layer 2\n",
    "        x=F.relu(self.conv2(x)) # layer 3\n",
    "        x = self.pool(x) # layer 4\n",
    "        x=F.relu(self.conv3(x)) # layer 5\n",
    "        x = self.pool(x) # layer 6\n",
    "        x=F.relu(self.conv4(x)) # layer 7\n",
    "        x = self.pool(x) # layer 8\n",
    "        x = x.view(-1, int(149*15)) \n",
    "        x = self.dropout(x) # layer 9\n",
    "        x=self.fc1(x) # layer 10\n",
    "        x = self.dropout(x) # layer 11\n",
    "        x=self.fc2(x) # layer 12\n",
    "        x=self.fc3(x) # layer 13\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. Initialize model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running on: cpu\n",
      "Model created\n"
     ]
    }
   ],
   "source": [
    "import torch.optim as optim\n",
    "from torch import cuda\n",
    "\n",
    "# Set the random seed for reproducibility\n",
    "random_seed = 42\n",
    "random.seed(random_seed)\n",
    "torch.manual_seed(random_seed)\n",
    "torch.cuda.manual_seed(random_seed)\n",
    "np.random.seed(random_seed)\n",
    "\n",
    "# use GPU\n",
    "device='cpu'#'cuda' if cuda.is_available() else 'cpu'\n",
    "print(\"Running on: \"+device)\n",
    "cuda.empty_cache()\n",
    "\n",
    "# initialize model\n",
    "n_chan=train_data[0].data.shape[1]\n",
    "n_datalength=train_data[0].data.shape[0]\n",
    "model = CNN_Model(n_chan,n_datalength)\n",
    "model.to(device)\n",
    "print('Model created')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. Configure Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 16#1 # could not find\n",
    "#num_epochs = 64\n",
    "num_epochs = 70 # from paper\n",
    "lrate=1e-4 #from paper\n",
    "patience=80 # no early stopping from paper\n",
    "# Define loss function and optimizer\n",
    "criterion = nn.BCELoss()\n",
    "optimizer = optim.Adam(model.parameters(), lr=lrate)\n",
    "cnn_modelfullpath=os.path.join(cnn_modelpath,'cnn.pt')\n",
    "\n",
    "training_arg={\n",
    "    'modelfullpath': cnn_modelfullpath,\n",
    "    'criterion': criterion,\n",
    "    'optimizer': optimizer,\n",
    "    'epochs': num_epochs,\n",
    "    'patience': patience,\n",
    "    'seed': random_seed\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7. Prepare data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.utils.data import DataLoader, TensorDataset\n",
    "\n",
    "train_dataset = TensorDataset(torch.stack(train_sigdata), torch.stack(train_label))\n",
    "val_dataset = TensorDataset(torch.stack(val_sigdata), torch.stack(val_label))\n",
    "test_dataset = TensorDataset(torch.stack(test_sigdata), torch.stack(test_label))\n",
    "\n",
    "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
    "val_loader = DataLoader(val_dataset, batch_size=1, shuffle=False)\n",
    "test_loader = DataLoader(test_dataset, batch_size=1, shuffle=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8. Train model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1/70: 100%|██████████| 21/21 [00:02<00:00,  8.89it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model state saved with validation accuracy: 51.4493\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2/70: 100%|██████████| 21/21 [00:00<00:00, 27.95it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model state saved with validation accuracy: 56.5217\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3/70: 100%|██████████| 21/21 [00:00<00:00, 30.03it/s]\n",
      "Epoch 4/70: 100%|██████████| 21/21 [00:00<00:00, 26.50it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model state saved with validation accuracy: 58.6957\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5/70: 100%|██████████| 21/21 [00:00<00:00, 27.65it/s]\n",
      "Epoch 6/70: 100%|██████████| 21/21 [00:00<00:00, 30.08it/s]\n",
      "Epoch 7/70: 100%|██████████| 21/21 [00:00<00:00, 29.96it/s]\n",
      "Epoch 8/70: 100%|██████████| 21/21 [00:00<00:00, 30.77it/s]\n",
      "Epoch 9/70: 100%|██████████| 21/21 [00:00<00:00, 30.59it/s]\n",
      "Epoch 10/70: 100%|██████████| 21/21 [00:00<00:00, 30.65it/s]\n",
      "Epoch 11/70: 100%|██████████| 21/21 [00:00<00:00, 30.21it/s]\n",
      "Epoch 12/70: 100%|██████████| 21/21 [00:00<00:00, 29.95it/s]\n",
      "Epoch 13/70: 100%|██████████| 21/21 [00:00<00:00, 29.73it/s]\n",
      "Epoch 14/70: 100%|██████████| 21/21 [00:00<00:00, 29.98it/s]\n",
      "Epoch 15/70: 100%|██████████| 21/21 [00:00<00:00, 30.25it/s]\n",
      "Epoch 16/70: 100%|██████████| 21/21 [00:00<00:00, 30.59it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model state saved with validation accuracy: 59.4203\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 17/70: 100%|██████████| 21/21 [00:00<00:00, 27.68it/s]\n",
      "Epoch 18/70: 100%|██████████| 21/21 [00:00<00:00, 30.28it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model state saved with validation accuracy: 60.1449\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 19/70: 100%|██████████| 21/21 [00:00<00:00, 29.48it/s]\n",
      "Epoch 20/70: 100%|██████████| 21/21 [00:00<00:00, 30.39it/s]\n",
      "Epoch 21/70: 100%|██████████| 21/21 [00:00<00:00, 30.72it/s]\n",
      "Epoch 22/70: 100%|██████████| 21/21 [00:00<00:00, 31.24it/s]\n",
      "Epoch 23/70: 100%|██████████| 21/21 [00:00<00:00, 29.93it/s]\n",
      "Epoch 24/70: 100%|██████████| 21/21 [00:00<00:00, 31.08it/s]\n",
      "Epoch 25/70: 100%|██████████| 21/21 [00:00<00:00, 30.43it/s]\n",
      "Epoch 26/70: 100%|██████████| 21/21 [00:00<00:00, 31.39it/s]\n",
      "Epoch 27/70: 100%|██████████| 21/21 [00:00<00:00, 31.80it/s]\n",
      "Epoch 28/70: 100%|██████████| 21/21 [00:00<00:00, 31.02it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model state saved with validation accuracy: 61.5942\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 29/70: 100%|██████████| 21/21 [00:00<00:00, 31.15it/s]\n",
      "Epoch 30/70: 100%|██████████| 21/21 [00:00<00:00, 30.44it/s]\n",
      "Epoch 31/70: 100%|██████████| 21/21 [00:00<00:00, 31.15it/s]\n",
      "Epoch 32/70: 100%|██████████| 21/21 [00:00<00:00, 31.29it/s]\n",
      "Epoch 33/70: 100%|██████████| 21/21 [00:00<00:00, 31.30it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model state saved with validation accuracy: 66.6667\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 34/70: 100%|██████████| 21/21 [00:00<00:00, 29.04it/s]\n",
      "Epoch 35/70: 100%|██████████| 21/21 [00:00<00:00, 28.99it/s]\n",
      "Epoch 36/70: 100%|██████████| 21/21 [00:00<00:00, 30.89it/s]\n",
      "Epoch 37/70: 100%|██████████| 21/21 [00:00<00:00, 30.67it/s]\n",
      "Epoch 38/70: 100%|██████████| 21/21 [00:00<00:00, 29.43it/s]\n",
      "Epoch 39/70: 100%|██████████| 21/21 [00:00<00:00, 31.84it/s]\n",
      "Epoch 40/70: 100%|██████████| 21/21 [00:00<00:00, 31.63it/s]\n",
      "Epoch 41/70: 100%|██████████| 21/21 [00:00<00:00, 29.53it/s]\n",
      "Epoch 42/70: 100%|██████████| 21/21 [00:00<00:00, 29.37it/s]\n",
      "Epoch 43/70: 100%|██████████| 21/21 [00:00<00:00, 29.40it/s]\n",
      "Epoch 44/70: 100%|██████████| 21/21 [00:00<00:00, 31.58it/s]\n",
      "Epoch 45/70: 100%|██████████| 21/21 [00:00<00:00, 32.04it/s]\n",
      "Epoch 46/70: 100%|██████████| 21/21 [00:00<00:00, 31.74it/s]\n",
      "Epoch 47/70: 100%|██████████| 21/21 [00:00<00:00, 31.01it/s]\n",
      "Epoch 48/70: 100%|██████████| 21/21 [00:00<00:00, 30.12it/s]\n",
      "Epoch 49/70: 100%|██████████| 21/21 [00:00<00:00, 32.33it/s]\n",
      "Epoch 50/70: 100%|██████████| 21/21 [00:00<00:00, 32.11it/s]\n",
      "Epoch 51/70: 100%|██████████| 21/21 [00:00<00:00, 31.24it/s]\n",
      "Epoch 52/70: 100%|██████████| 21/21 [00:00<00:00, 31.20it/s]\n",
      "Epoch 53/70: 100%|██████████| 21/21 [00:00<00:00, 31.69it/s]\n",
      "Epoch 54/70: 100%|██████████| 21/21 [00:00<00:00, 32.06it/s]\n",
      "Epoch 55/70: 100%|██████████| 21/21 [00:00<00:00, 31.85it/s]\n",
      "Epoch 56/70: 100%|██████████| 21/21 [00:00<00:00, 31.51it/s]\n",
      "Epoch 57/70: 100%|██████████| 21/21 [00:00<00:00, 31.10it/s]\n",
      "Epoch 58/70: 100%|██████████| 21/21 [00:00<00:00, 30.95it/s]\n",
      "Epoch 59/70: 100%|██████████| 21/21 [00:00<00:00, 31.67it/s]\n",
      "Epoch 60/70: 100%|██████████| 21/21 [00:00<00:00, 31.32it/s]\n",
      "Epoch 61/70: 100%|██████████| 21/21 [00:00<00:00, 31.71it/s]\n",
      "Epoch 62/70: 100%|██████████| 21/21 [00:00<00:00, 29.54it/s]\n",
      "Epoch 63/70: 100%|██████████| 21/21 [00:00<00:00, 35.58it/s]\n",
      "Epoch 64/70: 100%|██████████| 21/21 [00:00<00:00, 35.53it/s]\n",
      "Epoch 65/70: 100%|██████████| 21/21 [00:00<00:00, 34.93it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model state saved with validation accuracy: 68.1159\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 66/70: 100%|██████████| 21/21 [00:00<00:00, 32.39it/s]\n",
      "Epoch 67/70: 100%|██████████| 21/21 [00:00<00:00, 33.65it/s]\n",
      "Epoch 68/70: 100%|██████████| 21/21 [00:00<00:00, 33.38it/s]\n",
      "Epoch 69/70: 100%|██████████| 21/21 [00:00<00:00, 33.40it/s]\n",
      "Epoch 70/70: 100%|██████████| 21/21 [00:00<00:00, 34.73it/s]\n"
     ]
    }
   ],
   "source": [
    "results= model_trainer(model,train_loader,val_loader,training_arg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9. Inspect training process"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.plot(results['epoch_loss'])\n",
    "plt.xlabel('epoch')\n",
    "plt.ylabel('Avg loss')\n",
    "plt.show()\n",
    "\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(results['training_acc'],label='Training data')\n",
    "plt.plot(results['validation_acc'],label='Validation data')\n",
    "plt.legend()\n",
    "plt.xlabel('epoch')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 10. Evaluate model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fine tune model loaded\n",
      "Train Binary Accuracy: 93.1677\n",
      "Confusion Matrix:\n",
      "[[168   0]\n",
      " [ 22 132]]\n",
      "Accuracy: 93.16770186335404\n",
      "Precision: 100.0\n",
      "Sensitivity (Recall): 85.71428571428571\n",
      "Specificity: 100.0\n",
      "F1 Score: 0.923076923076923\n",
      "AUC Score: 0.9969465058750774\n",
      "\n",
      "\n",
      "Validation Binary Accuracy: 68.1159\n",
      "Confusion Matrix:\n",
      "[[62 10]\n",
      " [34 32]]\n",
      "Accuracy: 68.11594202898551\n",
      "Precision: 76.19047619047619\n",
      "Sensitivity (Recall): 48.484848484848484\n",
      "Specificity: 86.11111111111111\n",
      "F1 Score: 0.5925925925925926\n",
      "AUC Score: 0.6616161616161615\n",
      "\n",
      "\n",
      "Test Binary Accuracy: 58.6957\n",
      "Confusion Matrix:\n",
      "[[36 12]\n",
      " [26 18]]\n",
      "Accuracy: 58.69565217391305\n",
      "Precision: 60.0\n",
      "Sensitivity (Recall): 40.909090909090914\n",
      "Specificity: 75.0\n",
      "F1 Score: 0.4864864864864865\n",
      "AUC Score: 0.6287878787878788\n",
      "Completed\n"
     ]
    }
   ],
   "source": [
    "best_model_state=torch.load(cnn_modelfullpath, map_location=device)\n",
    "model.load_state_dict(best_model_state,strict=True)\n",
    "model.eval()\n",
    "print('Fine tune model loaded')\n",
    "\n",
    "tr_accuracy, tr_est,tr_labels,tr_scores= evaluate_binary_accuracy(model, train_loader)\n",
    "print(f'Train Binary Accuracy: {tr_accuracy:.4f}')\n",
    "perf_metrics(tr_labels, tr_est,tr_scores)\n",
    "print('\\n')\n",
    "v_accuracy,val_est,val_labels, val_scores = evaluate_binary_accuracy(model, val_loader)\n",
    "print(f'Validation Binary Accuracy: {v_accuracy:.4f}')\n",
    "perf_metrics(val_labels, val_est,val_scores)\n",
    "print('\\n')\n",
    "test_accuracy,test_est,test_labels, test_scores = evaluate_binary_accuracy(model, test_loader)\n",
    "print(f'Test Binary Accuracy: {test_accuracy:.4f}')\n",
    "perf_metrics(test_labels, test_est,test_scores)\n",
    "\n",
    "print('Completed')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model Details"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model param total: 53142\n",
      "CNN_Model(\n",
      "  (conv1): Conv1d(59, 5, kernel_size=(20,), stride=(1,))\n",
      "  (pool): AvgPool1d(kernel_size=(2,), stride=(2,), padding=(0,))\n",
      "  (conv2): Conv1d(5, 10, kernel_size=(10,), stride=(1,))\n",
      "  (conv3): Conv1d(10, 10, kernel_size=(10,), stride=(1,))\n",
      "  (conv4): Conv1d(10, 15, kernel_size=(5,), stride=(1,))\n",
      "  (fc1): Linear(in_features=2235, out_features=20, bias=True)\n",
      "  (fc2): Linear(in_features=20, out_features=10, bias=True)\n",
      "  (fc3): Linear(in_features=10, out_features=2, bias=True)\n",
      "  (dropout): Dropout(p=0.5, inplace=False)\n",
      ")\n",
      "Output shape: torch.Size([1, 2])\n",
      "----------------------------------------------------------------\n",
      "        Layer (type)               Output Shape         Param #\n",
      "================================================================\n",
      "            Conv1d-1              [-1, 5, 2481]           5,905\n",
      "         AvgPool1d-2              [-1, 5, 1240]               0\n",
      "            Conv1d-3             [-1, 10, 1231]             510\n",
      "         AvgPool1d-4              [-1, 10, 615]               0\n",
      "            Conv1d-5              [-1, 10, 606]           1,010\n",
      "         AvgPool1d-6              [-1, 10, 303]               0\n",
      "            Conv1d-7              [-1, 15, 299]             765\n",
      "         AvgPool1d-8              [-1, 15, 149]               0\n",
      "           Dropout-9                 [-1, 2235]               0\n",
      "           Linear-10                   [-1, 20]          44,720\n",
      "          Dropout-11                   [-1, 20]               0\n",
      "           Linear-12                   [-1, 10]             210\n",
      "           Linear-13                    [-1, 2]              22\n",
      "================================================================\n",
      "Total params: 53,142\n",
      "Trainable params: 53,142\n",
      "Non-trainable params: 0\n",
      "----------------------------------------------------------------\n",
      "Input size (MB): 0.56\n",
      "Forward/backward pass size (MB): 0.42\n",
      "Params size (MB): 0.20\n",
      "Estimated Total Size (MB): 1.19\n",
      "----------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "from torchsummary import summary\n",
    "\n",
    "model_params = sum(p.numel() for p in model.parameters())\n",
    "print(f'Model param total: {model_params}')\n",
    "print(model)\n",
    "\n",
    "dummy_input = torch.randn(1, 59, 2500)  # Batch size of 1\n",
    "output = model(dummy_input)\n",
    "print(f\"Output shape: {output.shape}\")\n",
    "\n",
    "summary(model, input_size=(59, 2500), device=device)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "mybertV2",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}