spectro-cnn-experiments.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from loader.data_loader import PMEmoDataset\n",
    "import torch.utils.data as torchData\n",
    "from model import spectroCnnVanilla\n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.metrics import root_mean_squared_error, r2_score\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO normalize spectrograms\n",
    "# TODO save model weights\n",
    "# TODO split model into distinct valence and arousal models, because combining them into a single model might affect the other, causing the unstable r2 scores, losses, rsme values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "root_dir = \"dataset\"\n",
    "dataset = PMEmoDataset(root_dir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Train-test split\n",
    "train_size = int(0.8 * len(dataset))\n",
    "test_size = len(dataset) - train_size\n",
    "train_dataset, test_dataset = torch.utils.data.random_split(dataset, [train_size, test_size])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset size: 7670\n",
      "Train dataset size: 6136\n",
      "Test dataset size: 1534\n",
      "Spectrogram: torch.Size([1, 369, 496])\n",
      "EDA: torch.Size([1, 896])\n",
      "Arousal: torch.Size([1])\n",
      "Valence: torch.Size([1])\n",
      "Music vector: torch.Size([319])\n"
     ]
    }
   ],
   "source": [
    "print(f'Dataset size: {len(dataset)}')\n",
    "print(f'Train dataset size: {len(train_dataset)}')\n",
    "print(f'Test dataset size: {len(test_dataset)}')  # 767 613 154\n",
    "print(f'Spectrogram: {dataset[0][0].shape}')\n",
    "print(f'EDA: {dataset[0][1].shape}')\n",
    "print(f'Arousal: {dataset[0][2].shape}')\n",
    "print(f'Valence: {dataset[0][3].shape}')\n",
    "print(f'Music vector: {dataset[0][4].shape}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[[  0.,   0.,   0.,  ...,  16.,  32.,  31.],\n",
      "         [  0.,   0.,   0.,  ...,  16.,  32.,  31.],\n",
      "         [  0.,   3.,   0.,  ...,  38.,  47.,  50.],\n",
      "         ...,\n",
      "         [ 43.,  95., 105.,  ...,  76.,  66.,  72.],\n",
      "         [ 43.,  95., 105.,  ...,  76.,  66.,  72.],\n",
      "         [ 43.,  95., 105.,  ...,  76.,  66.,  72.]]])\n"
     ]
    }
   ],
   "source": [
    "print(dataset[0][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 16\n",
    "\n",
    "\n",
    "train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size,\n",
    "                                          shuffle=True, num_workers=8)\n",
    "\n",
    "test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size,\n",
    "                                         shuffle=False, num_workers=8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Instantiate the model\n",
    "usesSpectrogram = True\n",
    "usesEDA = True\n",
    "usesMusic = True\n",
    "predictsArousal = True\n",
    "predictsValence = True\n",
    "usesMusicLSTM = False\n",
    "\n",
    "# Ensure that predictArousal and predictValence are not both False\n",
    "assert predictsArousal or predictsValence\n",
    "# Ensure that at least one of usesSpectrogram, usesEDA, and usesMusic is True\n",
    "assert usesSpectrogram or usesEDA or usesMusic\n",
    "\n",
    "model = spectroCnnVanilla.SpectroNet(usesSpectrogram,\n",
    "                                    usesEDA,\n",
    "                                    usesMusic,\n",
    "                                    predictsArousal,\n",
    "                                    predictsValence,\n",
    "                                    usesMusicLSTM)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SpectroNet(\n",
      "  (spec_cnn): Sequential(\n",
      "    (0): Conv2d(1, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (1): ReLU()\n",
      "    (2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "    (4): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (5): ReLU()\n",
      "    (6): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (7): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "    (8): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (9): ReLU()\n",
      "    (10): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (11): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "    (12): AdaptiveAvgPool2d(output_size=(1, 1))\n",
      "    (13): Flatten(start_dim=1, end_dim=-1)\n",
      "  )\n",
      "  (output): Sequential(\n",
      "    (0): Linear(in_features=128, out_features=64, bias=True)\n",
      "    (1): Dropout(p=0.1, inplace=False)\n",
      "    (2): Linear(in_features=64, out_features=32, bias=True)\n",
      "    (3): ReLU(inplace=True)\n",
      "    (4): Linear(in_features=32, out_features=2, bias=True)\n",
      "    (5): ReLU(inplace=True)\n",
      "  )\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "print(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of parameters in the model: 233,122\n"
     ]
    }
   ],
   "source": [
    "num_params = 0\n",
    "for x in model.parameters():\n",
    "  num_params += len(torch.flatten(x))\n",
    "\n",
    "print(f'Number of parameters in the model: {num_params:,}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "# Define loss function and optimizer\n",
    "criterion = nn.MSELoss()\n",
    "optimizer = optim.Adam(model.parameters(), lr=0.0001)\n",
    "# optimizer = optim.SGD(model.parameters(), lr=0.001)\n",
    "\n",
    "# Training loop\n",
    "num_epochs = 3\n",
    "device = torch.device(\"mps\" if torch.backends.mps.is_available() else \"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "model.to(device)\n",
    "print(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def memory_stats():\n",
    "    print(torch.cuda.memory_allocated()/1024**2)\n",
    "    print(torch.cuda.memory_reserved()/1024**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "31.0693359375\n",
      "5162.0\n"
     ]
    }
   ],
   "source": [
    "memory_stats()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# if device == 'cuda':\n",
    "#     torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def unpack_data(data):\n",
    "    spectrogram, eda_data, arousal_label, valence_label, music_vector = data\n",
    "    spectrogram = spectrogram.to(device)\n",
    "    eda_data = eda_data.to(device)\n",
    "    arousal_label = arousal_label.to(device)\n",
    "    valence_label = valence_label.to(device)\n",
    "    music_vector = music_vector.to(device=device, dtype=torch.float32)\n",
    "    return spectrogram, eda_data, arousal_label, valence_label, music_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Train epoch 1: 100%|██████████| 384/384 [00:44<00:00,  8.65batch/s, Running loss: 0.038752615716172535]\n",
      "Validate epoch 1: 100%|██████████| 96/96 [00:04<00:00, 23.33batch/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [1/3], Train Loss: 0.0388, Val Loss: 0.0002, Arousal RMSE: 0.1981, Valence RMSE: 0.2083, Arousal R2: 0.3069, Valence R2: 0.2435\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "Train epoch 2: 100%|██████████| 384/384 [00:44<00:00,  8.63batch/s, Running loss: 0.03844560854001126] \n",
      "Validate epoch 2: 100%|██████████| 96/96 [00:04<00:00, 23.55batch/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [2/3], Train Loss: 0.0384, Val Loss: 0.0003, Arousal RMSE: 0.1944, Valence RMSE: 0.2153, Arousal R2: 0.3326, Valence R2: 0.1922\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "Train epoch 3: 100%|██████████| 384/384 [00:45<00:00,  8.53batch/s, Running loss: 0.03788489866322683] \n",
      "Validate epoch 3: 100%|██████████| 96/96 [00:04<00:00, 23.30batch/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [3/3], Train Loss: 0.0379, Val Loss: 0.0003, Arousal RMSE: 0.1984, Valence RMSE: 0.2039, Arousal R2: 0.3050, Valence R2: 0.2751\n",
      "Training finished.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# Training loop\n",
    "for epoch in range(num_epochs):\n",
    "    running_loss = 0.0\n",
    "    model.train()\n",
    "    pbar_train = tqdm(enumerate(train_loader, 0), unit=\"batch\", total=len(train_loader), desc=f'Train epoch {str(epoch + 1)}')\n",
    "    for i, data in pbar_train:\n",
    "        spectrogram, eda_data, arousal_label, valence_label, music_vector = unpack_data(data)\n",
    "\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        # # Print shapes of all inputs\n",
    "        # print(\"--------------\")\n",
    "        # print(f\"Spectrogram shape: {spectrogram.shape}\")\n",
    "        # print(f\"EDA data shape: {eda_data.shape}\")\n",
    "        # print(f\"Arousal label shape: {arousal_label.shape}\")\n",
    "        # print(f\"Valence label shape: {valence_label.shape}\")\n",
    "        # print(f\"Music vector shape: {music_vector.shape}\")\n",
    "\n",
    "        output = model(spectrogram, eda_data, music_vector)\n",
    "        labels = torch.cat((arousal_label, valence_label), -1)\n",
    "\n",
    "        # print(f'Output: {output.shape}')\n",
    "        # print(f'Labels: {labels.shape}')\n",
    "        \n",
    "        loss = criterion(output, labels)\n",
    "\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        running_loss += loss.item()\n",
    "        \n",
    "        pbar_train.set_postfix_str(f'Running loss: {running_loss / (i + 1)}')\n",
    "\n",
    "    # Evaluate on the validation set\n",
    "    model.eval()\n",
    "    val_loss = 0.0\n",
    "    arousal_preds = []\n",
    "    valence_preds = []\n",
    "    arousal_labels = []\n",
    "    valence_labels = []\n",
    "\n",
    "    with torch.no_grad():\n",
    "        pbar_test = tqdm(enumerate(test_loader, 0), unit=\"batch\", total=len(test_loader), desc=f'Validate epoch {str(epoch + 1)}')\n",
    "        for i, data in pbar_test:\n",
    "            spectrogram, eda_data, arousal_label, valence_label, music_vector = unpack_data(data)\n",
    "\n",
    "            output = model(spectrogram, eda_data, music_vector)\n",
    "            # print(output.shape)\n",
    "            labels = torch.cat((arousal_label, valence_label), -1)\n",
    "            val_loss = criterion(output, labels)\n",
    "            arousal_output = output[:,0:1]\n",
    "            valence_output = output[:,1:]\n",
    "            arousal_preds.extend(arousal_output.cpu().numpy())\n",
    "            valence_preds.extend(valence_output.cpu().numpy())\n",
    "            arousal_labels.extend(arousal_label.cpu().numpy())\n",
    "            valence_labels.extend(valence_label.cpu().numpy())\n",
    "\n",
    "        # Calculate and print losses and metrics\n",
    "        arousal_mse = root_mean_squared_error(arousal_labels, arousal_preds)\n",
    "        valence_mse = root_mean_squared_error(valence_labels, valence_preds)\n",
    "        arousal_r2 = r2_score(arousal_labels, arousal_preds)\n",
    "        valence_r2 = r2_score(valence_labels, valence_preds)\n",
    "\n",
    "        print(f\"Epoch [{epoch + 1}/{num_epochs}], \"\n",
    "                f\"Train Loss: {running_loss / len(train_loader):.4f}, \"\n",
    "                f\"Val Loss: {val_loss / len(test_loader):.4f}, \"\n",
    "                f\"Arousal RMSE: {arousal_mse:.4f}, \"\n",
    "                f\"Valence RMSE: {valence_mse:.4f}, \"\n",
    "                f\"Arousal R2: {arousal_r2:.4f}, \"\n",
    "                f\"Valence R2: {valence_r2:.4f}\")\n",
    "\n",
    "print(\"Training finished.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model weights saved to: ./weights/spectroCnnVanilla-24-04-15-2327.pt\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "t = time.localtime()\n",
    "current_time = time.strftime(\"%y-%m-%d-%H%M\", t)\n",
    "\n",
    "PATH = './weights/spectroCnnVanilla-'+current_time+'.pt'\n",
    "torch.save(model.state_dict(), PATH)\n",
    "print(f'Model weights saved to: {PATH}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Validate epoch 3:   0%|          | 0/96 [00:00<?, ?batch/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0.7792, 0.7200],\n",
      "        [0.7519, 0.5550],\n",
      "        [0.4594, 0.3992],\n",
      "        [0.4240, 0.3996],\n",
      "        [0.5784, 0.5206],\n",
      "        [0.5798, 0.5611],\n",
      "        [0.6537, 0.6022],\n",
      "        [0.4993, 0.4615],\n",
      "        [0.4272, 0.3848],\n",
      "        [0.4642, 0.4486],\n",
      "        [0.7218, 0.6360],\n",
      "        [0.5926, 0.4925],\n",
      "        [0.6584, 0.6110],\n",
      "        [0.6414, 0.7035],\n",
      "        [0.6535, 0.6232],\n",
      "        [0.7218, 0.5208]], device='cuda:0')\n"
     ]
    },
    {
     "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"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Validate epoch 3:   0%|          | 0/96 [00:00<?, ?batch/s]\n"
     ]
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "with torch.no_grad():\n",
    "    pbar_test = tqdm(enumerate(test_loader, 0), unit=\"batch\", total=len(test_loader), desc=f'Validate epoch {str(epoch + 1)}')\n",
    "    for i, data in pbar_test:\n",
    "        spectrogram, eda_data, arousal_label, valence_label, music_vector = unpack_data(data)\n",
    "\n",
    "        output = model(spectrogram, eda_data, music_vector)\n",
    "        print(output)\n",
    "        arousal_output = output[:,0:1]\n",
    "        valence_output = output[:,1:]\n",
    "        outputs = torch.cat((arousal_output, valence_output), -1)\n",
    "        labels = torch.cat((arousal_label, valence_label), -1)\n",
    "        # print(outputs)\n",
    "        # print(labels)\n",
    "    \n",
    "        t = list(outputs.T[0].cpu())\n",
    "        t_2 = list(labels.T[0].cpu())\n",
    "\n",
    "        n=batch_size\n",
    "        r = np.arange(n) \n",
    "        width = 0.35\n",
    "        \n",
    "        plt.bar(r, t, color = 'b', \n",
    "                width = width,\n",
    "                label='Pred') \n",
    "        plt.bar(r + width, t_2, color = 'r', \n",
    "                width = width,\n",
    "                label='Label')\n",
    "\n",
    "        plt.xlabel('Datapoints')\n",
    "        plt.title('Arousal Comparison')\n",
    "        plt.legend()\n",
    "        plt.show()\n",
    "\n",
    "\n",
    "        t = list(outputs.T[1].cpu())\n",
    "        t_2 = list(labels.T[1].cpu())\n",
    "\n",
    "        n=16\n",
    "        r = np.arange(n) \n",
    "        width = 0.35\n",
    "        \n",
    "        plt.bar(r, t, color = 'b', \n",
    "                width = width,\n",
    "                label='Pred') \n",
    "        plt.bar(r + width, t_2, color = 'r', \n",
    "                width = width,\n",
    "                label='Label')\n",
    "\n",
    "        plt.xlabel('Datapoints')\n",
    "        plt.title('Valence Comparison')\n",
    "        plt.legend()\n",
    "        plt.show()\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# with torch.no_grad():\n",
    "#     pbar_test = tqdm(enumerate(test_loader, 0), unit=\"batch\", total=len(test_loader), desc=f'Validate epoch {str(epoch + 1)}')\n",
    "#     for i, data in pbar_test:\n",
    "#         spectrogram, eda_data, arousal_label, valence_label, music_vector = unpack_data(data)\n",
    "\n",
    "#         output = model(spectrogram, eda_data, music_vector)\n",
    "#         arousal_output = output[:,0:1]\n",
    "#         valence_output = output[:,1:]\n",
    "#         outputs = torch.cat((arousal_output, valence_output), -1)\n",
    "#         labels = torch.cat((arousal_label, valence_label), -1)\n",
    "#         print(arousal_output, valence_output)\n",
    "#         print(labels)\n",
    "#         break\n",
    "\n",
    "# import torch\n",
    "# import matplotlib.pyplot as plt\n",
    "\n",
    "# t = torch.tensor([0., 0., 1., 1., 0., 1., 1., 0., 0., 0.])\n",
    "# hist = torch.histc(t, bins = 2, min = 0, max = 1)\n",
    "\n",
    "# bins = 2\n",
    "# x = range(bins)\n",
    "# plt.bar(x, hist, align='center')\n",
    "# plt.xlabel('Bins')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}