Final_Model.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1AHs9mcVQpEh"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import os\n",
        "from torch import nn\n",
        "from torch.utils.data import DataLoader\n",
        "from torchvision.transforms import ToTensor\n",
        "from torch.utils.data import Dataset\n",
        "import torchvision.models as models\n",
        "\n",
        "\n",
        "import pandas as pd\n",
        "import torchaudio\n",
        "import pickle\n",
        "import numpy as np\n",
        "from tqdm.auto import tqdm"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y6OygEc_UgnK"
      },
      "source": [
        "# DataLoader"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FGOz1E0UtNRp",
        "outputId": "18a338ec-168b-4ea6-9f4e-c49d9326f5c8"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/gdrive\n"
          ]
        }
      ],
      "source": [
        "#import zipfile\n",
        "from google.colab import drive\n",
        "drive.mount('/content/gdrive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tgdtPV2-3o1R",
        "outputId": "fb0f7ee1-fe92-497d-a264-bd963b5b5403"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting patool\n",
            "  Downloading patool-1.12-py2.py3-none-any.whl (77 kB)\n",
            "\u001b[K     |████████████████████████████████| 77 kB 3.2 MB/s \n",
            "\u001b[?25hInstalling collected packages: patool\n",
            "Successfully installed patool-1.12\n",
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting pyunpack\n",
            "  Downloading pyunpack-0.3-py2.py3-none-any.whl (4.1 kB)\n",
            "Collecting entrypoint2\n",
            "  Downloading entrypoint2-1.1-py2.py3-none-any.whl (9.9 kB)\n",
            "Collecting easyprocess\n",
            "  Downloading EasyProcess-1.1-py3-none-any.whl (8.7 kB)\n",
            "Installing collected packages: entrypoint2, easyprocess, pyunpack\n",
            "Successfully installed easyprocess-1.1 entrypoint2-1.1 pyunpack-0.3\n"
          ]
        }
      ],
      "source": [
        "!pip install patool\n",
        "!pip install pyunpack\n",
        "from pyunpack import Archive\n",
        "Archive(\"/content/gdrive/MyDrive/AI/wav.rar\").extractall(\"/content/\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "GkFzAgE8uv1A"
      },
      "outputs": [],
      "source": [
        "classmap=[\"C\",\"C#\",\"D\",\"D#\",\"E\",\"F\",\"F#\",\"G\",\"G#\",\"A\",\"A#\",\"B\"]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "oy3pkUUvYEFU"
      },
      "outputs": [],
      "source": [
        "#df = pd.read_csv(\"/content/gdrive/MyDrive/AI/labels.csv\")\n",
        "#from sklearn.model_selection import train_test_split\n",
        "#train_df, test_df = train_test_split(df, test_size=0.2)\n",
        "train_df = pd.read_csv(\"/content/gdrive/MyDrive/AI/train.csv\")\n",
        "test_df = pd.read_csv(\"/content/gdrive/MyDrive/AI/test.csv\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0skXnvx9bL0q"
      },
      "outputs": [],
      "source": [
        "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
        "\n",
        "target_sample_rate=16000.0\n",
        "mel_spectrogram = torchaudio.transforms.MelSpectrogram(\n",
        "    sample_rate=34624,\n",
        "    n_mels=128,\n",
        "    n_fft=2048,\n",
        "    hop_length=512\n",
        ")\n",
        "mel_spectrogram.to(device)\n",
        "\n",
        "def resample_if_necessary(signal, sr):\n",
        "  if sr != target_sample_rate:\n",
        "      resampler = torchaudio.transforms.Resample(sr, target_sample_rate)\n",
        "      signal = resampler(signal)\n",
        "  return signal\n",
        "\n",
        "def mix_down_if_necessary(signal):\n",
        "  if signal.shape[0] > 1:\n",
        "      signal = torch.mean(signal, dim=0, keepdim=True)\n",
        "  return signal\n",
        "\n",
        "def transformation(signal):\n",
        "  mel_spectrogram"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wU4DS4YJwPaS"
      },
      "outputs": [],
      "source": [
        "class CustomTrainDataset(Dataset):\n",
        "    def __init__(self, feat_path=train_df[\"wav_path\"], transform=None, target_transform=None):\n",
        "        self.label = train_df[\"label\"]\n",
        "        self.feat_path = feat_path\n",
        "        self.path = \"/content/wav/\"\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.label)\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        path = self.path +self.feat_path[idx]+'.wav'\n",
        "        signal, sr = torchaudio.load(path)\n",
        "        signal = resample_if_necessary(signal, sr)\n",
        "        signal = mix_down_if_necessary(signal)\n",
        "        data = mel_spectrogram(signal)\n",
        "        data = data[0]\n",
        "        label = classmap.index(self.label[idx])\n",
        "        return data, label\n",
        "\n",
        "class CustomTestDataset(Dataset):\n",
        "    def __init__(self, feat_path=test_df[\"wav_path\"] , transform=None, target_transform=None):\n",
        "        self.label = test_df[\"label\"]\n",
        "        self.feat_path = feat_path \n",
        "        self.path = \"/content/wav/\"\n",
        "\n",
        "    def __len__(self):\n",
        "      return len(self.label)\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        path = self.path +self.feat_path[idx]+'.wav'\n",
        "        signal, sr = torchaudio.load(path)\n",
        "        signal = resample_if_necessary(signal, sr)\n",
        "        signal = mix_down_if_necessary(signal)\n",
        "        data = mel_spectrogram(signal)\n",
        "        data = data[0]\n",
        "        label = classmap.index(self.label[idx])\n",
        "        return data, label\n",
        "\n",
        "train_dataset=CustomTrainDataset()\n",
        "test_dataset=CustomTestDataset()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hXMirgfe0ZRG"
      },
      "source": [
        "#Model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "eW8fVK_BzFaH"
      },
      "outputs": [],
      "source": [
        "class Model(nn.Module):\n",
        "    def __init__(self, feat_dim=256):\n",
        "        super(Model, self).__init__()\n",
        "        # wav2letter architecture\n",
        "        self.convo1 = self._get_conv_block(128, 256, 7)\n",
        "        self.convo2 = self._get_conv_block(256, 256, 7)\n",
        "        self.convo3 = self._get_conv_block(256, 512, 7)\n",
        "        self.flatten = nn.Flatten()\n",
        "        self.linear = nn.Linear(512* 50, 12)\n",
        "\n",
        "    def _get_activation(self, name):\n",
        "      if name == \"relu\":\n",
        "        return nn.ReLU()\n",
        "      elif name == \"sigmoid\":\n",
        "        return nn.Sigmoid()\n",
        "\n",
        "    def _get_conv_block(self, in_channel, out_channel, kernel_size, activation=\"relu\"):\n",
        "      return nn.Sequential(\n",
        "          nn.Conv1d(in_channel, out_channel, kernel_size, padding=\"same\"),\n",
        "          nn.BatchNorm1d(out_channel),\n",
        "          self._get_activation(activation)\n",
        "      )\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.convo1(x)\n",
        "        x = self.convo2(x)\n",
        "        x = self.convo3(x)\n",
        "        x = self.flatten(x)\n",
        "        x = self.linear(x)\n",
        "        return x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "F39K46Ly4-c_"
      },
      "outputs": [],
      "source": [
        "model = Model()\n",
        "model = model.to(device)\n",
        "optimizer = torch.optim.Adam(model.parameters(), 3e-4)\n",
        "\n",
        "checkpoint = { \n",
        "    'model': model.state_dict(),\n",
        "    'optimizer': optimizer.state_dict(),\n",
        "}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HzS7UjeK0xkO"
      },
      "outputs": [],
      "source": [
        "def save(train_losses,metrics_train,test_losses,metrics_test,i):\n",
        "    loss_log_test=[]\n",
        "    acc_log_test=[]\n",
        "    loss_log_train=[]\n",
        "    acc_log_train=[]\n",
        "    \n",
        "    path='/content/gdrive/MyDrive/AI/weight/con/'+str(i)+'/checkpoint.pth'\n",
        "    path_log='/content/gdrive/MyDrive/AI/weight/con/'+str(i)\n",
        "    path_old='/content/gdrive/MyDrive/AI/weight/con/'+str(i-1)\n",
        "    torch.save(checkpoint, path)\n",
        "    torch.save(model.state_dict(), '/content/gdrive/MyDrive/AI/weight/con/'+str(i)+'/model_weight.pth')\n",
        "\n",
        "    if(i>1):\n",
        "      with open(path_old+'/loss_log_test.pkl', 'rb') as f:\n",
        "          loss_log_test = pickle.load(f)\n",
        "      with open(path_old+'/acc_log_test.pkl', 'rb') as f:\n",
        "          acc_log_test = pickle.load(f)  \n",
        "      with open(path_old+'/loss_log_train.pkl', 'rb') as f:\n",
        "          loss_log_train = pickle.load(f)\n",
        "      with open(path_old+'/acc_log_train.pkl', 'rb') as f:\n",
        "          acc_log_train = pickle.load(f)    \n",
        "\n",
        "    for k in test_losses :\n",
        "        loss_log_test.append(k)\n",
        "    acc_log_test = acc_log_test + metrics_test\n",
        "\n",
        "    for k in train_losses :\n",
        "        loss_log_train.append(k)\n",
        "    acc_log_train = acc_log_train + metrics_train\n",
        "\n",
        "    with open(path_log+'/loss_log_train.pkl', 'wb') as f:\n",
        "        pickle.dump(loss_log_train, f)\n",
        "    with open(path_log+'/acc_log_train.pkl', 'wb') as f:\n",
        "        pickle.dump(acc_log_train, f)\n",
        "    with open(path_log+'/loss_log_test.pkl', 'wb') as f:\n",
        "        pickle.dump(loss_log_test, f)\n",
        "    with open(path_log+'/acc_log_test.pkl', 'wb') as f:\n",
        "        pickle.dump(acc_log_test, f)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Vaic96DF1PwO"
      },
      "outputs": [],
      "source": [
        "from sklearn.metrics import confusion_matrix, precision_score,accuracy_score\n",
        "\n",
        "loss_fn = nn.CrossEntropyLoss()\n",
        "def M_loss_func(pred, target):\n",
        "  return loss_fn(pred,target)\n",
        "\n",
        "def M_accuracy(pred,target):\n",
        "  pred = pred.argmax(dim=1).detach().numpy()\n",
        "  return accuracy_score(target, pred)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bDjCUl0uJJe7"
      },
      "source": [
        "# Training loop"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pwgmk_IHUfjk"
      },
      "outputs": [],
      "source": [
        "batch_size = 128\n",
        "epochs = 10\n",
        "lr = 3e-4\n",
        "device = 'cuda' if torch.cuda.is_available() else 'cpu'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "t9F85zTY0oI2"
      },
      "outputs": [],
      "source": [
        "def get_epoch(k, train_dataloader, val_dataloader, batch_size,st,ed):\n",
        "    print(\"epoch\",\"\\t train loss \\t accuracy \\t\\t val loss \\t\\t val accuracy\")\n",
        "    train_loss ,train_acc, val_loss=0,0,0\n",
        "    for i in range(st,ed+1) :\n",
        "        train_epoch(i, train_dataloader, val_dataloader, batch_size)\n",
        "\n",
        "def train_epoch(k, train_dataloader, val_dataloader, batch_size):\n",
        "    model.train()\n",
        "    train_batch_loss = []\n",
        "    train_batch_acc = []\n",
        "    for batch in tqdm(train_dataloader):\n",
        "        xb, yb = batch\n",
        "        xb = xb.to(device)\n",
        "        yb = yb.to(device)\n",
        "\n",
        "        optimizer.zero_grad()\n",
        "        yhatb = model(xb)\n",
        "\n",
        "        loss = M_loss_func(yhatb, yb)\n",
        "        acc = M_accuracy(yhatb, yb)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "        train_batch_loss.append(loss.detach().cpu().numpy())\n",
        "        train_batch_acc.append(acc)\n",
        "\n",
        "    train_loss = np.mean(train_batch_loss)\n",
        "    train_acc = np.mean(train_batch_acc)\n",
        "\n",
        "    val_batch_loss = []\n",
        "    losses=[]\n",
        "    metrics=[]\n",
        "    for batch in tqdm(val_dataloader):\n",
        "        x, y = batch\n",
        "        x = x.to(device)\n",
        "        y = y.to(device)\n",
        "\n",
        "        with torch.no_grad():\n",
        "            yhatb = model(x)\n",
        "            loss = M_loss_func(yhatb, y)\n",
        "            acc = M_accuracy(yhatb, y)\n",
        "            losses.append(loss.detach().cpu())\n",
        "            metrics.append(acc)\n",
        "        val_batch_loss.append(loss.cpu().numpy())\n",
        "    val_loss = np.mean(val_batch_loss)\n",
        "    val_acc = np.mean(metrics)\n",
        "    save(train_batch_loss,train_batch_acc, losses,metrics,k)\n",
        "    print(k, \"\\t\", train_loss , \"\\t\", train_acc*100,\"\\t\", val_loss, \"\\t\" , val_acc*100)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 49,
          "referenced_widgets": [
            "40ae4c0811754738970b5480fac732e0",
            "e97373649063425c927c4a3aa8b71475",
            "93c435a101d04ba59776c3bf008bd453",
            "3dd57961bed748258bf7d251ac4e5490",
            "0ca683fae9904b9eb2d72d5c22016fa3",
            "ff21f5c5cddb4e7da6101fb9db595f4f",
            "832f3a613f594c95946937b548000ec3",
            "9f7c446f43ed4edfa2c5ec70c928776c",
            "2096b7ea7b79402cb3ebbb11b8524f1b",
            "92df0c95d2604e04b9aecf27eb872b16",
            "62ae240abaf4438d9fb98c2907cfba3f"
          ]
        },
        "id": "rvu5THXtw-vX",
        "outputId": "df8668ff-d7f2-4ec2-93e7-8ae76d3c82c0"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/42 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "40ae4c0811754738970b5480fac732e0"
            }
          },
          "metadata": {}
        }
      ],
      "source": [
        "#train_dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
        "val_dataloader = DataLoader(test_dataset, batch_size=batch_size)\n",
        "for batch in tqdm(val_dataloader):\n",
        "    xb, yb = batch\n",
        "    break"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZN9q26-Q3YtT"
      },
      "outputs": [],
      "source": [
        "model = Model()\n",
        "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
        "optimizer = torch.optim.Adam(model.parameters(), 3e-4)\n",
        "i=0\n",
        "if(i):\n",
        "  model.load_state_dict(torch.load('/content/gdrive/MyDrive/AI/weight/con/'+str(i)+'/model_weight.pth'))\n",
        "  model = model.to(device)\n",
        "  model.train()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kughl24z3QHu"
      },
      "outputs": [],
      "source": [
        "train_dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, pin_memory=True, num_workers=0)\n",
        "test_dataloader = DataLoader(test_dataset, batch_size=batch_size, pin_memory=True, num_workers=0)\n",
        "get_epoch(15, train_dataloader, test_dataloader, batch_size,21,25)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m-5Jpk2_d1kg"
      },
      "source": [
        "# Graph"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2GCv4GVtd32I"
      },
      "outputs": [],
      "source": [
        "loss_log=[]\n",
        "acc_log=[]\n",
        "i=15\n",
        "\n",
        "path='/content/gdrive/MyDrive/AI/weight/con_wev/'+str(i-1)+'/checkpoint.pth'\n",
        "path_log='/content/gdrive/MyDrive/AI/weight/con_wev/'+str(i)\n",
        "path_old='/content/gdrive/MyDrive/AI/weight/con_wev/'+str(i-1)\n",
        "\n",
        "with open(path_log+'/loss_log_train.pkl', 'rb') as f:\n",
        "    loss_log_train = pickle.load(f)\n",
        "with open(path_log+'/acc_log_train.pkl', 'rb') as f:\n",
        "    acc_log_train = pickle.load(f)\n",
        "with open(path_log+'/loss_log_test.pkl', 'rb') as f:\n",
        "    loss_log_test = pickle.load(f)\n",
        "with open(path_log+'/acc_log_test.pkl', 'rb') as f:\n",
        "    acc_log_test = pickle.load(f)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OTdS2oLYeOBQ",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 537
        },
        "outputId": "a92912ba-db8d-408e-f3da-fe862d7a4675"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 648x648 with 4 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "t = torch.arange(len(loss_log_train)).numpy()\n",
        "k = torch.arange(len(loss_log_test)).numpy()\n",
        "\n",
        "fig,ax = plt.subplots(4,1,figsize=(9, 9))\n",
        "ax[0].plot(t, loss_log_train, label=\"Loss train\")\n",
        "ax[1].plot(k, loss_log_test, label=\"Loss test\", color=\"y\")\n",
        "ax[2].plot(t, acc_log_train, label=\"Acc train\")\n",
        "ax[3].plot(k, acc_log_test, label=\"Acc test\", color=\"y\")\n",
        "\n",
        "for i in range(4):\n",
        "  ax[i].legend()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0I0v14qrbrqr"
      },
      "source": [
        "# Predict\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DAF3YUZ8POYz"
      },
      "outputs": [],
      "source": [
        "model = Model()\n",
        "model = model.to(device)\n",
        "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
        "optimizer = torch.optim.Adam(model.parameters(), 3e-4)\n",
        "i=3\n",
        "path='/content/gdrive/MyDrive/AI/weight/con_wev/'+str(i)+'/checkpoint.pth'\n",
        "\n",
        "checkpoint = { \n",
        "    'model': model.state_dict(),\n",
        "    'optimizer': optimizer.state_dict(),\n",
        "}\n",
        "\n",
        "checkpoint = torch.load(path)\n",
        "model.load_state_dict(checkpoint['model'])\n",
        "optimizer.load_state_dict(checkpoint['optimizer'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bXOZFEY05cpm"
      },
      "outputs": [],
      "source": [
        "modelt = Model()\n",
        "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
        "optimizer = torch.optim.Adam(modelt.parameters(), 3e-4)\n",
        "i=15\n",
        "modelt.load_state_dict(torch.load('/content/gdrive/MyDrive/AI/weight/con/'+str(i)+'/model_weight.pth'))\n",
        "modelt = modelt.to(device)\n",
        "modelt.eval()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gp9cn1MLeMP1"
      },
      "outputs": [],
      "source": [
        "def predict(model, input, target, class_mapping) :\n",
        "  with torch.no_grad():\n",
        "    pred = model(input)\n",
        "    pred_index = (pred.argmax(dim=1)).to(dtype=int)\n",
        "    preds=[]\n",
        "    expected=[]\n",
        "    print(f\"Accuracy : {M_accuracy(pred,target)*100}\")\n",
        "    for i in range(len(pred_index)) :\n",
        "      preds.append(class_mapping[pred_index[i]])\n",
        "      expected.append(class_mapping[target[i]])\n",
        "  return preds, expected"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hwQc30L9buls",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 413,
          "referenced_widgets": [
            "f6da008e570e4d019433243a20a0eb0b",
            "3d2af676721a4d048cadba6f7eb0138d",
            "d0443f48241e44ebb4999195d87e484f",
            "3fa568ea7b7049ca9e53de55e8724b4f",
            "7d0dc860e7f349e58790202c1c37921d",
            "581cc5f9edc5459faeea108ce2ca7557",
            "7cd5534111e94beb9ff86f96aea77998",
            "db7d2ad4378c4c2bb79cb46ce83c1ee8",
            "154b00d92d7b4b9f85b9ccdf943ef54d",
            "78585096f1c84737b8de3f9629a8212e",
            "d58def506d924698acf646dc3664d536"
          ]
        },
        "outputId": "abe8d7c6-a6b3-427a-f654-2e47b3e3a7a1"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/42 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "f6da008e570e4d019433243a20a0eb0b"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy : 97.65625\n",
            "Predicted: 'F#', expected: 'F#'\n",
            "Predicted: 'A#', expected: 'A#'\n",
            "Predicted: 'B', expected: 'B'\n",
            "Predicted: 'C', expected: 'C'\n",
            "Predicted: 'B', expected: 'B'\n",
            "Predicted: 'F', expected: 'F'\n",
            "Predicted: 'F#', expected: 'F#'\n",
            "Predicted: 'A#', expected: 'A#'\n",
            "Predicted: 'A', expected: 'A'\n",
            "Predicted: 'B', expected: 'B'\n",
            "Predicted: 'F', expected: 'F'\n",
            "Predicted: 'F#', expected: 'F#'\n",
            "Predicted: 'G', expected: 'G'\n",
            "Predicted: 'C', expected: 'C'\n",
            "Predicted: 'F', expected: 'F'\n",
            "Predicted: 'D', expected: 'D'\n",
            "Predicted: 'B', expected: 'B'\n",
            "Predicted: 'F', expected: 'F'\n",
            "Predicted: 'C', expected: 'C'\n",
            "Predicted: 'E', expected: 'E'\n"
          ]
        }
      ],
      "source": [
        "from sys import breakpointhook\n",
        "\n",
        "batch_size=128\n",
        "validation=DataLoader(test_dataset, batch_size=batch_size)\n",
        "for batch in tqdm(validation):\n",
        "    xb, yb = batch\n",
        "    break\n",
        "  \n",
        "predicted, expected = predict(modelt, xb, yb, classmap)\n",
        "for i in range(20) :\n",
        "    print(f\"Predicted: '{predicted[i]}', expected: '{expected[i]}'\")"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import pickle\n",
        "pickle.dump(modelt, open(\"notemodel.pkl\", 'wb'))"
      ],
      "metadata": {
        "id": "xIuRbvEKbhT6"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "name": "Feat_Model.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    },
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "40ae4c0811754738970b5480fac732e0": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_e97373649063425c927c4a3aa8b71475",
              "IPY_MODEL_93c435a101d04ba59776c3bf008bd453",
              "IPY_MODEL_3dd57961bed748258bf7d251ac4e5490"
            ],
            "layout": "IPY_MODEL_0ca683fae9904b9eb2d72d5c22016fa3"
          }
        },
        "e97373649063425c927c4a3aa8b71475": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_ff21f5c5cddb4e7da6101fb9db595f4f",
            "placeholder": "​",
            "style": "IPY_MODEL_832f3a613f594c95946937b548000ec3",
            "value": "  0%"
          }
        },
        "93c435a101d04ba59776c3bf008bd453": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "danger",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_9f7c446f43ed4edfa2c5ec70c928776c",
            "max": 42,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_2096b7ea7b79402cb3ebbb11b8524f1b",
            "value": 0
          }
        },
        "3dd57961bed748258bf7d251ac4e5490": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_92df0c95d2604e04b9aecf27eb872b16",
            "placeholder": "​",
            "style": "IPY_MODEL_62ae240abaf4438d9fb98c2907cfba3f",
            "value": " 0/42 [00:06&lt;?, ?it/s]"
          }
        },
        "0ca683fae9904b9eb2d72d5c22016fa3": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "ff21f5c5cddb4e7da6101fb9db595f4f": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "832f3a613f594c95946937b548000ec3": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "9f7c446f43ed4edfa2c5ec70c928776c": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "2096b7ea7b79402cb3ebbb11b8524f1b": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "92df0c95d2604e04b9aecf27eb872b16": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "62ae240abaf4438d9fb98c2907cfba3f": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "f6da008e570e4d019433243a20a0eb0b": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_3d2af676721a4d048cadba6f7eb0138d",
              "IPY_MODEL_d0443f48241e44ebb4999195d87e484f",
              "IPY_MODEL_3fa568ea7b7049ca9e53de55e8724b4f"
            ],
            "layout": "IPY_MODEL_7d0dc860e7f349e58790202c1c37921d"
          }
        },
        "3d2af676721a4d048cadba6f7eb0138d": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_581cc5f9edc5459faeea108ce2ca7557",
            "placeholder": "​",
            "style": "IPY_MODEL_7cd5534111e94beb9ff86f96aea77998",
            "value": "  0%"
          }
        },
        "d0443f48241e44ebb4999195d87e484f": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "danger",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_db7d2ad4378c4c2bb79cb46ce83c1ee8",
            "max": 42,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_154b00d92d7b4b9f85b9ccdf943ef54d",
            "value": 0
          }
        },
        "3fa568ea7b7049ca9e53de55e8724b4f": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_78585096f1c84737b8de3f9629a8212e",
            "placeholder": "​",
            "style": "IPY_MODEL_d58def506d924698acf646dc3664d536",
            "value": " 0/42 [00:06&lt;?, ?it/s]"
          }
        },
        "7d0dc860e7f349e58790202c1c37921d": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "581cc5f9edc5459faeea108ce2ca7557": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "7cd5534111e94beb9ff86f96aea77998": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "db7d2ad4378c4c2bb79cb46ce83c1ee8": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "154b00d92d7b4b9f85b9ccdf943ef54d": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "78585096f1c84737b8de3f9629a8212e": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "d58def506d924698acf646dc3664d536": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        }
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}