extract_cqtnet.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import torch\n",
    "from torch.utils.data import DataLoader\n",
    "import torchvision.transforms as transforms\n",
    "from torchnet import meter\n",
    "from tqdm import tqdm\n",
    "import numpy as np\n",
    "import time\n",
    "import torch.nn.functional as F\n",
    "import torch.nn as nn\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from cqt_loader_setlist import CQT\n",
    "from models import CQTNet\n",
    "from config import DefaultConfig\n",
    "from utility import calc_MAP, norm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Set Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.cuda.is_available()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.cuda.is_available() True\n",
      "use_gpu True\n",
      "cuda:0\n"
     ]
    }
   ],
   "source": [
    "modelname = 'CQTNet'\n",
    "load_latest = True\n",
    "load_model_path = 'check_points/CQTNet.pth'\n",
    "model_save_path = 'finetuning'\n",
    "\n",
    "load_latest=True \n",
    "\n",
    "parallel=True\n",
    "\n",
    "opt = DefaultConfig(load_model_path=load_model_path, \n",
    "                    notes=model_save_path,\n",
    "                    batch_sz=32,\n",
    "                    max_epoch=50, \n",
    "                    lr=0.001, \n",
    "                    lr_decay=0.8, \n",
    "                    weight_decay=1e-5, \n",
    "                    use_gpu=True, \n",
    "                    num_workers=4, \n",
    "                    parallel=parallel, \n",
    "                    load_latest=load_latest,\n",
    "                    gpu_device=\"cuda:0\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'NVIDIA GeForce RTX 3090'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.cuda.get_device_name(device=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#root = \"/Users/dirceusilva/Documents/BancoDados/setlist_all/setlist_65k/features_develop/universe_develop\"\n",
    "root = '/mnt/dataset/dataset_cover/universe_develop'\n",
    "train_data_path = os.path.join(root, \"universe_train\")\n",
    "val_data_path = os.path.join(root, \"universe_val\")\n",
    "test_data_path = os.path.join(root, \"universe_test\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# step 1: Build DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#######################################################\n",
    "#                  Create Dataset\n",
    "#######################################################\n",
    "train_dataset0 = CQT(train_data_path, mode=\"train\", out_length=200, num_workers=opt.num_workers)\n",
    "train_dataset1 = CQT(train_data_path, mode=\"train\", out_length=300, num_workers=opt.num_workers)\n",
    "train_dataset2 = CQT(train_data_path, mode=\"train\", out_length=400, num_workers=opt.num_workers)\n",
    "\n",
    "valid_dataset = CQT(val_data_path, mode=\"valid\", out_length=None, num_workers=1) \n",
    "test_dataset = CQT(test_data_path, mode=\"test\", out_length=None, num_workers=1)\n",
    "\n",
    "#######################################################\n",
    "#                  Define Dataloaders\n",
    "#######################################################\n",
    "\n",
    "train_dataloader0 = DataLoader(train_dataset0, batch_size=opt.batch_size, shuffle=True, generator=torch.Generator(device='cuda:0'))\n",
    "train_dataloader1 = DataLoader(train_dataset1, batch_size=opt.batch_size, shuffle=True, generator=torch.Generator(device='cuda:0'))\n",
    "train_dataloader2 = DataLoader(train_dataset2, batch_size=opt.batch_size, shuffle=True, generator=torch.Generator(device='cuda:0'))\n",
    "\n",
    "val_dataloader = DataLoader(valid_dataset, batch_size=1, shuffle=False, generator=torch.Generator(device='cuda:0'))\n",
    "test_dataloader = DataLoader(test_dataset, batch_size=1, shuffle=False, generator=torch.Generator(device='cuda:0'))\n",
    "\n",
    "loaders = {'train': train_dataloader0, 'valid': val_dataloader, 'test': test_dataloader}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# step 2: configure model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CQTNet(\n",
      "  (features): Sequential(\n",
      "    (conv0): Conv2d(1, 32, kernel_size=(12, 3), stride=(1, 1), padding=(6, 0), bias=False)\n",
      "    (norm0): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (relu0): ReLU(inplace=True)\n",
      "    (conv1): Conv2d(32, 64, kernel_size=(13, 3), stride=(1, 1), dilation=(1, 2), bias=False)\n",
      "    (norm1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (relu1): ReLU(inplace=True)\n",
      "    (pool1): MaxPool2d(kernel_size=(1, 2), stride=(1, 2), padding=(0, 1), dilation=1, ceil_mode=False)\n",
      "    (conv2): Conv2d(64, 64, kernel_size=(13, 3), stride=(1, 1), bias=False)\n",
      "    (norm2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (relu2): ReLU(inplace=True)\n",
      "    (conv3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), dilation=(1, 2), bias=False)\n",
      "    (norm3): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (relu3): ReLU(inplace=True)\n",
      "    (pool3): MaxPool2d(kernel_size=(1, 2), stride=(1, 2), padding=(0, 1), dilation=1, ceil_mode=False)\n",
      "    (conv4): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), bias=False)\n",
      "    (norm4): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (relu4): ReLU(inplace=True)\n",
      "    (conv5): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), dilation=(1, 2), bias=False)\n",
      "    (norm5): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (relu5): ReLU(inplace=True)\n",
      "    (pool5): MaxPool2d(kernel_size=(1, 2), stride=(1, 2), padding=(0, 1), dilation=1, ceil_mode=False)\n",
      "    (conv6): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), bias=False)\n",
      "    (norm6): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (relu6): ReLU(inplace=True)\n",
      "    (conv7): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), dilation=(1, 2), bias=False)\n",
      "    (norm7): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (relu7): ReLU(inplace=True)\n",
      "    (pool7): MaxPool2d(kernel_size=(1, 2), stride=(1, 2), padding=(0, 1), dilation=1, ceil_mode=False)\n",
      "    (conv8): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), bias=False)\n",
      "    (norm8): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (relu8): ReLU(inplace=True)\n",
      "    (conv9): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), dilation=(1, 2), bias=False)\n",
      "    (norm9): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (relu9): ReLU(inplace=True)\n",
      "  )\n",
      "  (pool): AdaptiveMaxPool2d(output_size=(1, 1))\n",
      "  (fc0): Linear(in_features=512, out_features=300, bias=True)\n",
      "  (fc1): Linear(in_features=300, out_features=10000, bias=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "\n",
    "#opt._parse(kwargs)\n",
    "\n",
    "model = CQTNet.CQTNet()\n",
    "model.load_state_dict(torch.load(load_model_path, map_location=opt.device))\n",
    "\n",
    "print(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = CQTNet.CQTNetSetlist(original_model=model, num_classes=train_dataset0.get_nr_classes())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "for p in model.features.parameters():\n",
    "    p.requires_grad = True\n",
    "\n",
    "for p in model.fc0.parameters():\n",
    "    p.requires_grad = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "features.conv0.weight True\n",
      "features.norm0.weight True\n",
      "features.norm0.bias True\n",
      "features.conv1.weight True\n",
      "features.norm1.weight True\n",
      "features.norm1.bias True\n",
      "features.conv2.weight True\n",
      "features.norm2.weight True\n",
      "features.norm2.bias True\n",
      "features.conv3.weight True\n",
      "features.norm3.weight True\n",
      "features.norm3.bias True\n",
      "features.conv4.weight True\n",
      "features.norm4.weight True\n",
      "features.norm4.bias True\n",
      "features.conv5.weight True\n",
      "features.norm5.weight True\n",
      "features.norm5.bias True\n",
      "features.conv6.weight True\n",
      "features.norm6.weight True\n",
      "features.norm6.bias True\n",
      "features.conv7.weight True\n",
      "features.norm7.weight True\n",
      "features.norm7.bias True\n",
      "features.conv8.weight True\n",
      "features.norm8.weight True\n",
      "features.norm8.bias True\n",
      "features.conv9.weight True\n",
      "features.norm9.weight True\n",
      "features.norm9.bias True\n",
      "fc0.weight True\n",
      "fc0.bias True\n",
      "fc1.weight True\n",
      "fc1.bias True\n"
     ]
    }
   ],
   "source": [
    "for name, param in model.named_parameters():\n",
    "    print(name, param.requires_grad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "check_points/<class 'models.CQTNet.CQTNetSetlist'>finetuning/latest.pth\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "DataParallel(\n",
       "  (module): CQTNetSetlist(\n",
       "    (features): Sequential(\n",
       "      (conv0): Conv2d(1, 32, kernel_size=(12, 3), stride=(1, 1), padding=(6, 0), bias=False)\n",
       "      (norm0): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu0): ReLU(inplace=True)\n",
       "      (conv1): Conv2d(32, 64, kernel_size=(13, 3), stride=(1, 1), dilation=(1, 2), bias=False)\n",
       "      (norm1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu1): ReLU(inplace=True)\n",
       "      (pool1): MaxPool2d(kernel_size=(1, 2), stride=(1, 2), padding=(0, 1), dilation=1, ceil_mode=False)\n",
       "      (conv2): Conv2d(64, 64, kernel_size=(13, 3), stride=(1, 1), bias=False)\n",
       "      (norm2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu2): ReLU(inplace=True)\n",
       "      (conv3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), dilation=(1, 2), bias=False)\n",
       "      (norm3): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu3): ReLU(inplace=True)\n",
       "      (pool3): MaxPool2d(kernel_size=(1, 2), stride=(1, 2), padding=(0, 1), dilation=1, ceil_mode=False)\n",
       "      (conv4): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), bias=False)\n",
       "      (norm4): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu4): ReLU(inplace=True)\n",
       "      (conv5): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), dilation=(1, 2), bias=False)\n",
       "      (norm5): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu5): ReLU(inplace=True)\n",
       "      (pool5): MaxPool2d(kernel_size=(1, 2), stride=(1, 2), padding=(0, 1), dilation=1, ceil_mode=False)\n",
       "      (conv6): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), bias=False)\n",
       "      (norm6): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu6): ReLU(inplace=True)\n",
       "      (conv7): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), dilation=(1, 2), bias=False)\n",
       "      (norm7): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu7): ReLU(inplace=True)\n",
       "      (pool7): MaxPool2d(kernel_size=(1, 2), stride=(1, 2), padding=(0, 1), dilation=1, ceil_mode=False)\n",
       "      (conv8): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), bias=False)\n",
       "      (norm8): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu8): ReLU(inplace=True)\n",
       "      (conv9): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), dilation=(1, 2), bias=False)\n",
       "      (norm9): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu9): ReLU(inplace=True)\n",
       "    )\n",
       "    (pool): AdaptiveMaxPool2d(output_size=(1, 1))\n",
       "    (fc0): Linear(in_features=512, out_features=300, bias=True)\n",
       "    (fc1): Linear(in_features=300, out_features=6191, bias=True)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "if parallel is True: \n",
    "        model = torch.nn.DataParallel(model, device_ids=[0])\n",
    "\n",
    "if parallel is True:\n",
    "    if opt.load_latest is True:\n",
    "        #model.load_state_dict(torch.load(os.path.join(\"check_points\",opt.notes)), strict=False)\n",
    "        model.module.load_latest(opt.notes)\n",
    "    elif opt.load_model_path:\n",
    "        model.module.load(opt.load_model_path)\n",
    "else:\n",
    "    if opt.load_latest is True:\n",
    "        model.load_latest(opt.notes)\n",
    "    elif opt.load_model_path:\n",
    "        model.load(opt.load_model_path)\n",
    "model.to(opt.device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# To device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DataParallel(\n",
      "  (module): CQTNetSetlist(\n",
      "    (features): Sequential(\n",
      "      (conv0): Conv2d(1, 32, kernel_size=(12, 3), stride=(1, 1), padding=(6, 0), bias=False)\n",
      "      (norm0): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu0): ReLU(inplace=True)\n",
      "      (conv1): Conv2d(32, 64, kernel_size=(13, 3), stride=(1, 1), dilation=(1, 2), bias=False)\n",
      "      (norm1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu1): ReLU(inplace=True)\n",
      "      (pool1): MaxPool2d(kernel_size=(1, 2), stride=(1, 2), padding=(0, 1), dilation=1, ceil_mode=False)\n",
      "      (conv2): Conv2d(64, 64, kernel_size=(13, 3), stride=(1, 1), bias=False)\n",
      "      (norm2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu2): ReLU(inplace=True)\n",
      "      (conv3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), dilation=(1, 2), bias=False)\n",
      "      (norm3): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu3): ReLU(inplace=True)\n",
      "      (pool3): MaxPool2d(kernel_size=(1, 2), stride=(1, 2), padding=(0, 1), dilation=1, ceil_mode=False)\n",
      "      (conv4): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), bias=False)\n",
      "      (norm4): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu4): ReLU(inplace=True)\n",
      "      (conv5): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), dilation=(1, 2), bias=False)\n",
      "      (norm5): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu5): ReLU(inplace=True)\n",
      "      (pool5): MaxPool2d(kernel_size=(1, 2), stride=(1, 2), padding=(0, 1), dilation=1, ceil_mode=False)\n",
      "      (conv6): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), bias=False)\n",
      "      (norm6): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu6): ReLU(inplace=True)\n",
      "      (conv7): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), dilation=(1, 2), bias=False)\n",
      "      (norm7): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu7): ReLU(inplace=True)\n",
      "      (pool7): MaxPool2d(kernel_size=(1, 2), stride=(1, 2), padding=(0, 1), dilation=1, ceil_mode=False)\n",
      "      (conv8): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), bias=False)\n",
      "      (norm8): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu8): ReLU(inplace=True)\n",
      "      (conv9): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), dilation=(1, 2), bias=False)\n",
      "      (norm9): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu9): ReLU(inplace=True)\n",
      "    )\n",
      "    (pool): AdaptiveMaxPool2d(output_size=(1, 1))\n",
      "    (fc0): Linear(in_features=512, out_features=300, bias=True)\n",
      "    (fc1): Linear(in_features=300, out_features=6191, bias=True)\n",
      "  )\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "model.to(opt.device)\n",
    "print(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  step 3: criterion and optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = torch.nn.CrossEntropyLoss()\n",
    "lr = opt.lr\n",
    "#if opt.parallel is True:\n",
    "#    optimizer = torch.optim.Adam(model.module.parameters(), lr=lr, weight_decay=opt.weight_decay)\n",
    "#else:\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=opt.weight_decay)\n",
    "    \n",
    "scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(\n",
    "    optimizer, mode='min', factor=opt.lr_decay, patience=2, min_lr=5e-6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# step 4: Train"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Validation Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "@torch.no_grad()\n",
    "def val_slow(model, dataloader, epoch):\n",
    "    \n",
    "    model.eval()\n",
    "    total, correct = 0, 0\n",
    "    labels, features = None, None\n",
    "\n",
    "    for ii, (data, label) in enumerate(dataloader):\n",
    "        input_data = data.to(opt.device)\n",
    "        #print(input.shape)\n",
    "        score, feature = model(input_data)\n",
    "        feature = feature.data.cpu().numpy()\n",
    "        label = label.data.cpu().numpy()\n",
    "        if features is not None:\n",
    "            features = np.concatenate((features, feature), axis=0)\n",
    "            labels = np.concatenate((labels,label))\n",
    "        else:\n",
    "            features = feature\n",
    "            labels = label\n",
    "    features = norm(features)\n",
    "\n",
    "    dis2d = -np.matmul(features, features.T) # [-1,1] Because normalized, so mutmul is equal to ED\n",
    "    np.save('dis.npy',dis2d)\n",
    "    np.save('label.npy',labels)\n",
    "\n",
    "    MAP, top10, rank1 = calc_MAP(dis2d, labels)\n",
    "\n",
    "    print(epoch, MAP, top10, rank1 )\n",
    "    \n",
    "    model.train()\n",
    "    \n",
    "    return MAP"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1 0.885741948128748 0.1830084235860409 33.35643802647413\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.885741948128748"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "best_MAP=0\n",
    "    \n",
    "val_slow(model, val_dataloader, -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0it [00:00, ?it/s]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:32,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.04845547107165218\n",
      "model name 0515_23:55:06.pth\n",
      "0 0.8959867525726601 0.18456077015643804 37.63790613718412\n",
      "*****************BEST*****************\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:30,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.021686241091678635\n",
      "model name 0516_00:11:34.pth\n",
      "1 0.8945765534066048 0.18400722021660648 34.38688327316486\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:32,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.01788341089733189\n",
      "model name 0516_00:28:06.pth\n",
      "2 0.8978840278480384 0.18471720818291215 37.41925391095066\n",
      "*****************BEST*****************\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:30,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.01652729404235408\n",
      "model name 0516_00:44:36.pth\n",
      "3 0.8936143779414447 0.18406738868832734 34.14777376654633\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:31,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.014805727773217581\n",
      "model name 0516_01:01:07.pth\n",
      "4 0.886697372086821 0.18293622141997595 39.037906137184116\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:30,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.014173093404431337\n",
      "model name 0516_01:17:37.pth\n",
      "5 0.8948960276598023 0.18457280385078217 34.68760529482551\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:30,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.013553052089752122\n",
      "model name 0516_01:34:06.pth\n",
      "6 0.8949162528699103 0.18439229843561972 32.54476534296029\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:31,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.012684913771885001\n",
      "model name 0516_01:50:36.pth\n",
      "7 0.8961970900040772 0.1843080625752106 35.001925391095064\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:30,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.012548397507735096\n",
      "model name 0516_02:07:06.pth\n",
      "8 0.8948004640543107 0.18433212996389892 33.415042117930206\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:30,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.012233268506946515\n",
      "model name 0516_02:23:36.pth\n",
      "9 0.8926226082726599 0.18405535499398315 35.5531889290012\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:31,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0117982409301616\n",
      "model name 0516_02:40:05.pth\n",
      "10 0.8876905253794132 0.18339350180505415 39.123225030084235\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:30,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.011598009375077883\n",
      "model name 0516_02:56:33.pth\n",
      "11 0.8911567738289452 0.18400722021660648 35.478941034897716\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:31,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.011236734268900669\n",
      "model name 0516_03:13:03.pth\n",
      "12 0.8927252929390198 0.18409145607701566 35.17882069795427\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:30,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.011146824651425302\n",
      "model name 0516_03:29:33.pth\n",
      "13 0.8924428922391396 0.18424789410348977 34.28748495788207\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:30,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.010930902450113848\n",
      "model name 0516_03:46:01.pth\n",
      "14 0.8925693305474112 0.18418772563176894 32.33020457280385\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:30,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.010991937233049302\n",
      "model name 0516_04:02:32.pth\n",
      "15 0.8895791187860893 0.18377858002406738 35.171480144404335\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:31,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.010756190248728956\n",
      "model name 0516_04:19:01.pth\n",
      "16 0.893441251597018 0.18452466907340553 36.09602888086643\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:35,  1.45it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.010614079175320656\n",
      "model name 0516_04:35:34.pth\n",
      "17 0.8892046200466249 0.1838748495788207 34.90758122743682\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:29,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.010452472546702656\n",
      "model name 0516_04:52:01.pth\n",
      "18 0.8930485971313826 0.18401925391095067 36.26690734055355\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:29,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.010371498122831148\n",
      "model name 0516_05:08:29.pth\n",
      "19 0.8932416289271591 0.18422382671480145 33.145968712394705\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:30,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.010446166653580294\n",
      "model name 0516_05:24:58.pth\n",
      "20 0.8941942702289314 0.18407942238267147 38.29614921780987\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:31,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.010166942460282435\n",
      "model name 0516_05:41:28.pth\n",
      "21 0.8908055758938438 0.18399518652226235 36.11239470517449\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:31,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.010301354018543308\n",
      "model name 0516_05:57:59.pth\n",
      "22 0.8916457287243019 0.18376654632972322 37.19903730445247\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:31,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.010185980253133614\n",
      "model name 0516_06:14:29.pth\n",
      "23 0.8936369116104991 0.18439229843561972 37.88567990373045\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:31,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.00997421593756195\n",
      "model name 0516_06:30:59.pth\n",
      "24 0.8957947981417832 0.18478941034897714 37.46257521058965\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:30,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.009876566628559541\n",
      "model name 0516_06:47:27.pth\n",
      "25 0.891167358135727 0.1838146811070999 36.5560770156438\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:30,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.00989069150567212\n",
      "model name 0516_07:03:57.pth\n",
      "26 0.8968833399406149 0.18488567990373045 36.65439229843562\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:27,  1.47it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.009855488163593974\n",
      "model name 0516_07:20:23.pth\n",
      "27 0.8900141390537771 0.18379061371841154 35.461371841155234\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:29,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.009542039914847474\n",
      "model name 0516_07:36:50.pth\n",
      "28 0.8964817881306759 0.18458483754512636 34.2280385078219\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:30,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.009932783809547823\n",
      "model name 0516_07:53:20.pth\n",
      "29 0.8945762704240414 0.18445246690734057 36.5503008423586\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:26,  1.47it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.009714642579956247\n",
      "model name 0516_08:09:45.pth\n",
      "30 0.891201646808425 0.18362214199759325 34.28026474127557\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:26,  1.47it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.009677785515673639\n",
      "model name 0516_08:26:09.pth\n",
      "31 0.8957246103289289 0.18460890493381468 35.04055354993983\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:30,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.007503828593526991\n",
      "model name 0516_08:42:36.pth\n",
      "32 0.8942203732596277 0.18425992779783393 36.45006016847172\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:29,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.007108400487113127\n",
      "model name 0516_08:59:04.pth\n",
      "33 0.8961634301014342 0.18466907340553548 32.85932611311673\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:27,  1.47it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0070489642059185665\n",
      "model name 0516_09:15:31.pth\n",
      "34 0.8925399809824247 0.18392298435619736 32.96883273164862\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:29,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.007334433473183297\n",
      "model name 0516_09:31:59.pth\n",
      "35 0.8884408011078043 0.18358604091456077 35.567870036101084\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:27,  1.47it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.007216434289699641\n",
      "model name 0516_09:48:26.pth\n",
      "36 0.8913438628834325 0.18377858002406738 35.41540312876053\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:27,  1.47it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.007227118000587542\n",
      "model name 0516_10:04:53.pth\n",
      "37 0.8941526546823053 0.18399518652226235 33.6208182912154\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:29,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.005924634554841754\n",
      "model name 0516_10:21:20.pth\n",
      "38 0.890856101013247 0.18386281588447653 34.24344163658243\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:28,  1.47it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.005604849152871419\n",
      "model name 0516_10:37:45.pth\n",
      "39 0.8923300836754 0.1844765342960289 33.25944645006017\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:27,  1.47it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.005773904246960418\n",
      "model name 0516_10:54:10.pth\n",
      "40 0.8908733597339801 0.18421179302045726 35.19338146811071\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:30,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.005768796773691854\n",
      "model name 0516_11:10:39.pth\n",
      "41 0.8938409299078944 0.18457280385078217 34.31263537906137\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:28,  1.47it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.005870562084660963\n",
      "model name 0516_11:27:06.pth\n",
      "42 0.893816049741361 0.18439229843561972 33.52611311672683\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:28,  1.47it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.004565184309032536\n",
      "model name 0516_11:43:32.pth\n",
      "43 0.8883185443769749 0.18382671480144402 32.043561973525875\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:28,  1.47it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.004821226228742124\n",
      "model name 0516_11:59:59.pth\n",
      "44 0.8905749160041627 0.18364620938628157 32.55475330926595\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:28,  1.47it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.004423532431932555\n",
      "model name 0516_12:16:25.pth\n",
      "45 0.8933473489506127 0.18441636582430807 30.151985559566786\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:27,  1.47it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.004694014283256642\n",
      "model name 0516_12:32:50.pth\n",
      "46 0.8888697959876874 0.1838748495788207 33.471961492178096\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:29,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.004528028591133716\n",
      "model name 0516_12:49:17.pth\n",
      "47 0.8946125950218352 0.18452466907340553 33.02635379061372\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:29,  1.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.004587180139367258\n",
      "model name 0516_13:05:44.pth\n",
      "48 0.8979962095564893 0.18523465703971118 32.58146811070999\n",
      "*****************BEST*****************\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1273it [14:28,  1.47it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.003742056920366177\n",
      "model name 0516_13:22:10.pth\n",
      "49 0.8921344339553335 0.18422382671480145 34.11347773766546\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\n",
    "for epoch in range(opt.max_epoch):\n",
    "    running_loss = 0\n",
    "    num = 0\n",
    "    for (data0, label0),(data1, label1),(data2, label2) in tqdm(zip(train_dataloader0, train_dataloader1, train_dataloader2)):\n",
    "        for flag in range(3):\n",
    "            if flag==0:\n",
    "                data=data0\n",
    "                label=label0\n",
    "            elif flag==1:\n",
    "                data=data1\n",
    "                label=label1\n",
    "            else:\n",
    "                data=data2\n",
    "                label=label2\n",
    "            # train model\n",
    "            input_data = data.requires_grad_()\n",
    "            input_data = input_data.to(opt.device)\n",
    "            \n",
    "            target = label.to(opt.device)\n",
    "\n",
    "            optimizer.zero_grad()\n",
    "            score, _ = model(input_data)\n",
    "            loss = criterion(score, target)\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "\n",
    "            running_loss += loss.item()\n",
    "            num += target.shape[0]\n",
    "        \n",
    "    running_loss /= num \n",
    "    \n",
    "    print(running_loss)\n",
    "    \n",
    "    if opt.parallel is True:\n",
    "        model.module.save(opt.notes)\n",
    "    else:\n",
    "        model.save(opt.notes)\n",
    "    \n",
    "    # update learning rate\n",
    "    scheduler.step(running_loss) \n",
    "    \n",
    "    # validate\n",
    "    MAP=0\n",
    "    MAP += val_slow(model, val_dataloader, epoch)\n",
    "            \n",
    "    if MAP>best_MAP:\n",
    "        best_MAP=MAP\n",
    "        print('*****************BEST*****************')\n",
    "    print('')\n",
    "    model.train()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "opt.notes='experiment0'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# step 5: Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test(**kwargs):\n",
    "    opt.batch_size=1\n",
    "    opt.num_workers=1\n",
    "    opt.model = 'CQTNet'\n",
    "    opt.load_latest = False\n",
    "    opt.load_model_path = 'check_points/CQTNet.pth'\n",
    "    opt._parse(kwargs)\n",
    "    \n",
    "    model = getattr(models, opt.model)() \n",
    "    #print(model)\n",
    "    if opt.load_latest is True:\n",
    "        model.load_latest(opt.notes)\n",
    "    elif opt.load_model_path:\n",
    "        model.load(opt.load_model_path)\n",
    "    model.to(opt.device)\n",
    "\n",
    "    val_data = CQT('val', out_length=None)\n",
    "    test_data = CQT('test', out_length=None)\n",
    "    val_dataloader = DataLoader(val_data, 1, shuffle=False,num_workers=1)\n",
    "    test_dataloader = DataLoader(test_data, 1, shuffle=False,num_workers=1)\n",
    "    \n",
    "    val_slow(model, val_dataloader, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1 0.900768927377684 0.0933318161128812 111.79449248975877\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.900768927377684"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "val_slow(model, test_dataloader, -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}