main_music.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Music-selectivity in DNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x7f2a6ca3e130>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Common\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import os; cwd = os.getcwd()\n",
    "import os.path as osp\n",
    "from argparse import Namespace\n",
    "from tqdm.notebook import tqdm\n",
    "import random\n",
    "import seaborn as sns\n",
    "import numpy.matlib\n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "import os.path as osp\n",
    "import pickle\n",
    "plt.rcParams['svg.fonttype'] = 'none'\n",
    "\n",
    "# Torch\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from torch.nn.utils.rnn import pad_sequence\n",
    "from torch.utils.data import DataLoader, random_split, Dataset\n",
    "import torchaudio as ta\n",
    "\n",
    "# etc\n",
    "from audioset import AudioSet, AudioSet2, AudioSet_shuffle\n",
    "from imresize import *\n",
    "\n",
    "# sklearn\n",
    "from sklearn import metrics\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.datasets import make_classification\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.svm import LinearSVC\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.manifold import TSNE\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.pipeline import make_pipeline\n",
    "from sklearn.metrics import average_precision_score, brier_score_loss, \\\n",
    "    log_loss, roc_auc_score\n",
    "from sklearn.metrics import explained_variance_score, mean_absolute_error, \\\n",
    "    mean_squared_error, median_absolute_error, r2_score\n",
    "\n",
    "use_cuda = torch.cuda.is_available()\n",
    "torch.manual_seed(7)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "opt = Namespace()\n",
    "opt.batch_size = 32\n",
    "opt.epochs = 30\n",
    "opt.lr = 0.001 # 0.001\n",
    "opt.device = torch.device(\"cuda\" if use_cuda else \"cpu\")\n",
    "opt.name = 'cnn_audioset_nomusic'\n",
    "dr = 0.2 # dropout rate\n",
    "\n",
    "datadir = '/home/kgspiano/Music_selectivity/data/AudioSet'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def binarizer(idx):\n",
    "    tmp = torch.zeros(num_class)\n",
    "    tmp[idx] = 1\n",
    "    return tmp\n",
    "def collate_fn(batch):\n",
    "    waveforms = pad_sequence(\n",
    "        [torch.from_numpy(b[0]).float() for b in batch], \n",
    "        batch_first=True)\n",
    "    waveforms = waveforms.reshape(waveforms.shape[0], 1, -1)\n",
    "    targets = torch.stack([binarizer(b[1]) for b in batch])\n",
    "    return waveforms, targets\n",
    "def cm2inch(*tupl):\n",
    "    inch = 2.54\n",
    "    if isinstance(tupl[0], tuple):\n",
    "        return tuple(i/inch for i in tupl[0])\n",
    "    else:\n",
    "        return tuple(i/inch for i in tupl)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Loading data for training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "tmpset = AudioSet(datadir, train=False)\n",
    "classes = tmpset.idx2class\n",
    "reverse_dict= dict(map(reversed,classes.items()))\n",
    "\n",
    "## music categories in Music hierarchy  \n",
    "Musicrelatedind = []\n",
    "Omittedclasses = []\n",
    "Music_categories = np.load('Music_categories.npy').tolist()\n",
    "for key1 in Music_categories:\n",
    "    if key1 in reverse_dict:\n",
    "        Musicrelatedind.append(reverse_dict[key1])\n",
    "    else:\n",
    "        Omittedclasses.append(key1)\n",
    "\n",
    "        \n",
    "        \n",
    "## Music categories in Human Voice hierarchy \n",
    "HV_categories = ['Singing','Humming', 'Yodeling', 'Chant', 'Male singing', 'Female singing', 'Child singing', 'Synthetic singing', 'Rapping']\n",
    "\n",
    "HVrelatedind = []\n",
    "for key1 in HV_categories:\n",
    "    if key1 in reverse_dict:\n",
    "        HVrelatedind.append(reverse_dict[key1])\n",
    "    else:\n",
    "        Omittedclasses.append(key1)                \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Manual check of the presence of music\n",
    "import pandas as pd\n",
    "import openpyxl\n",
    "df = pd.read_excel('filenames.xlsx', usecols = [0])\n",
    "val_list = df.values.tolist()\n",
    "name_err = []\n",
    "name_err.append(df.columns.tolist()[0][6:] + '.gz')\n",
    "for i,tmp in enumerate(val_list):\n",
    "    if i<4:\n",
    "        name_err.append(tmp[0][6:] + '.gz')\n",
    "    else:\n",
    "        name_err.append(tmp[0] + '.gz')\n",
    "\n",
    "deleteid = name_err"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Loading data without music\n",
    "A = HVrelatedind\n",
    "# A = ['Singing','Humming', 'yodeling', 'chant', 'Male singing', 'Female singing', 'Child singing', 'Synthetic singing', 'Rapping']\n",
    "B = Musicrelatedind\n",
    "Musicrelatedind_all = list(set(A) | set(B))\n",
    "\n",
    "torch.manual_seed(0)\n",
    "deleteidx = np.array(Musicrelatedind_all)\n",
    "\n",
    "# testset = AudioSet2('data/AudioSet/', train=False, deleteidx= deleteidx, deleteid = deleteid)\n",
    "# dataset = AudioSet2('data/AudioSet/', train=True, deleteidx= deleteidx, deleteid = deleteid)\n",
    "testset = AudioSet2(datadir, train=False, deleteidx= deleteidx, deleteid = deleteid)\n",
    "dataset = AudioSet2(datadir, train=True, deleteidx= deleteidx, deleteid = deleteid)\n",
    "trainset, validset = random_split(dataset, [round(len(dataset)*.9), round(len(dataset)*.1)])\n",
    "num_class = testset.n_class\n",
    "bs = opt.batch_size\n",
    "n_workers = 0\n",
    "isshufflelabel = 0\n",
    "\n",
    "\n",
    "val_loader = torch.utils.data.DataLoader(\n",
    "    validset,\n",
    "    batch_size=bs, shuffle=True, collate_fn=collate_fn,\n",
    "    num_workers=n_workers, pin_memory=False)\n",
    "train_loader = torch.utils.data.DataLoader(\n",
    "    trainset,\n",
    "    batch_size=bs, shuffle=True, collate_fn=collate_fn,\n",
    "    num_workers=n_workers, pin_memory=False)\n",
    "\n",
    "test_loader = torch.utils.data.DataLoader(\n",
    "    testset,\n",
    "    batch_size=bs, shuffle=True, collate_fn=collate_fn,\n",
    "    num_workers=n_workers, pin_memory=False)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataiter = iter(val_loader)\n",
    "wavtmp, labels = dataiter.next()\n",
    "samplingrate = wavtmp.shape[2]/10 # samplingrate, total 10 s\n",
    "winlen = int(np.round(samplingrate*1/40))\n",
    "\n",
    "mel_spectrogram = nn.Sequential(\n",
    "    ta.transforms.MelSpectrogram(n_mels=64, sample_rate = samplingrate, win_length = winlen, n_fft = winlen, f_min = 0, f_max = 8000, normalized=False),\n",
    "    ta.transforms.AmplitudeToDB()\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### CNN model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "class AudioCNN(nn.Module):\n",
    "    def __init__(self, num_class):\n",
    "        super(AudioCNN,self).__init__()\n",
    "\n",
    "        self.spec = mel_spectrogram\n",
    "        self.conv1 = nn.Sequential(\n",
    "            nn.Conv2d(in_channels=1, out_channels=32, kernel_size=5, stride=(2, 4), bias = False),\n",
    "            nn.BatchNorm2d(32),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.MaxPool2d(kernel_size=2, stride=2),\n",
    "            nn.Dropout(dr),\n",
    "        )\n",
    "\n",
    "        self.conv2 = nn.Sequential(\n",
    "            nn.Conv2d(in_channels=32, out_channels=64,kernel_size=5,stride=1, bias = False),\n",
    "            nn.BatchNorm2d(64), \n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.MaxPool2d(kernel_size=2, stride=1),\n",
    "            nn.Conv2d(in_channels=64, out_channels=128,kernel_size=5,stride=1, bias = False),\n",
    "            nn.BatchNorm2d(128),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.MaxPool2d(kernel_size=2, stride=1),\n",
    "            nn.Dropout(dr),\n",
    "        )\n",
    "            \n",
    "        self.conv3 = nn.Sequential(\n",
    "            nn.Conv2d(in_channels=128, out_channels=256, kernel_size=5, stride=1, bias=False),\n",
    "            nn.BatchNorm2d(256),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Dropout(dr),\n",
    "        )\n",
    "        \n",
    "        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))\n",
    "        \n",
    "        self.fc1 = nn.Sequential(\n",
    "            nn.Linear(256, 256),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Dropout(dr),\n",
    "        )\n",
    "        \n",
    "        self.fc2 = nn.Linear(256, num_class)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = self.spec(x)\n",
    "        x = self.conv1(x)\n",
    "        x = self.conv2(x)\n",
    "        x = self.conv3(x)\n",
    "        x = torch.flatten(self.avgpool(x), 1)\n",
    "        x = self.fc1(x)\n",
    "        x = self.fc2(x)\n",
    "\n",
    "        return x \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Network training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(opt, model, train_loader, optim, scheduler, criterion, epoch):\n",
    "    \n",
    "    model.train()\n",
    "    train_loss = 0; total = 0; total_correct = 0\n",
    "    for inputs, targets in train_loader:\n",
    "        inputs,targets = inputs.to(opt.device), targets.to(opt.device)\n",
    "        optim.zero_grad()\n",
    "        outputs = model(inputs)\n",
    "        loss = criterion(outputs, targets)\n",
    "        loss.backward()\n",
    "        optim.step()\n",
    "        scheduler.step()\n",
    "        train_loss += loss.item()\n",
    "        total += targets.size(0)\n",
    "    \n",
    "        outputs = torch.sigmoid(outputs)\n",
    "\n",
    "        with torch.no_grad():\n",
    "            target = targets.cpu().detach().numpy().flatten()\n",
    "            output = outputs.cpu().detach().numpy().flatten()\n",
    "            total_correct += metrics.average_precision_score(target, output, average='micro')\n",
    "\n",
    "    acc = 100. * total_correct/ len(train_loader) #total\n",
    "    accuracies_tr.append(acc)\n",
    "\n",
    "#     print(\"Train Epoch: [{}]  loss: [{:.2f}] Accuracy [{:.2f}] \".format(epoch+1, train_loss/len(train_loader), acc))\n",
    "\n",
    "\n",
    "    \n",
    "def validate(opt, model, test_loader, criterion, epoch):\n",
    "    global best_acc\n",
    "    model.eval()\n",
    "    test_loss, total, total_correct, = 0,0,0\n",
    "    \n",
    "    for inputs, targets in test_loader:\n",
    "        inputs, targets = inputs.to(opt.device), targets.to(opt.device)\n",
    "        outputs = model(inputs)\n",
    "        loss = criterion(outputs, targets)\n",
    "        test_loss += loss.item()\n",
    "        total += targets.size(0)\n",
    "        outputs = torch.sigmoid(outputs)\n",
    "        with torch.no_grad():\n",
    "            target = targets.cpu().detach().numpy().flatten()\n",
    "            output = outputs.cpu().detach().numpy().flatten()\n",
    "            total_correct += metrics.average_precision_score(target, output, average='micro')\n",
    "    # Save checkpoint when best model\n",
    "    acc = 100. * total_correct / len(test_loader) #total\n",
    "    accuracies_val.append(acc)\n",
    "   \n",
    "    print(\"Validation Epoch: [{}]  loss: [{:.2f}] Accuracy [{:.2f}] \".format(epoch+1, test_loss/len(test_loader), acc))\n",
    "    \n",
    "\n",
    "    if acc > best_acc:\n",
    "        if isinstance(model, torch.nn.DataParallel):\n",
    "            print('Saving Best model...\\t\\t\\tTop1 = %.2f%%' %(acc))\n",
    "            state = {\n",
    "                'model':model.module.state_dict(),\n",
    "                'model1': model.state_dict(),\n",
    "                'model2': model,\n",
    "                'acc':acc,\n",
    "                'epoch':epoch,\n",
    "                'loss':loss,\n",
    "            }\n",
    "        \n",
    "        else:\n",
    "            print('Saving Best model...\\t\\t\\tTop1 = %.2f%%' %(acc))\n",
    "            state = {\n",
    "                    'model':model,\n",
    "                    'acc':acc,\n",
    "                    'epoch':epoch,\n",
    "                    }      \n",
    "            \n",
    "        if not osp.isdir('checkpoint'):\n",
    "            os.mkdir('checkpoint')\n",
    "        save_point = './checkpoint/'\n",
    "        if not os.path.isdir(save_point):\n",
    "            os.mkdir(save_point)\n",
    "        torch.save(state, save_point + opt.name + '.t7')\n",
    "        best_acc = acc\n",
    "    return best_acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Save random model\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "228e8cfbb6af4c36af1f16197fdcd49e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/30 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation Epoch: [1]  loss: [0.03] Accuracy [8.40] \n",
      "Saving Best model...\t\t\tTop1 = 8.40%\n",
      "Validation Epoch: [2]  loss: [0.02] Accuracy [10.66] \n",
      "Saving Best model...\t\t\tTop1 = 10.66%\n",
      "Validation Epoch: [3]  loss: [0.02] Accuracy [11.56] \n",
      "Saving Best model...\t\t\tTop1 = 11.56%\n",
      "Validation Epoch: [4]  loss: [0.02] Accuracy [11.89] \n",
      "Saving Best model...\t\t\tTop1 = 11.89%\n",
      "Validation Epoch: [5]  loss: [0.02] Accuracy [8.80] \n",
      "Validation Epoch: [6]  loss: [0.02] Accuracy [9.70] \n",
      "Validation Epoch: [7]  loss: [0.02] Accuracy [12.86] \n",
      "Saving Best model...\t\t\tTop1 = 12.86%\n",
      "Validation Epoch: [8]  loss: [0.02] Accuracy [15.28] \n",
      "Saving Best model...\t\t\tTop1 = 15.28%\n",
      "Validation Epoch: [9]  loss: [0.02] Accuracy [13.22] \n",
      "Validation Epoch: [10]  loss: [0.02] Accuracy [14.74] \n",
      "Validation Epoch: [11]  loss: [0.02] Accuracy [14.14] \n",
      "Validation Epoch: [12]  loss: [0.02] Accuracy [13.59] \n",
      "Validation Epoch: [13]  loss: [0.02] Accuracy [17.17] \n",
      "Saving Best model...\t\t\tTop1 = 17.17%\n",
      "Validation Epoch: [14]  loss: [0.02] Accuracy [15.28] \n",
      "Validation Epoch: [15]  loss: [0.02] Accuracy [18.74] \n",
      "Saving Best model...\t\t\tTop1 = 18.74%\n",
      "Validation Epoch: [16]  loss: [0.02] Accuracy [18.82] \n",
      "Saving Best model...\t\t\tTop1 = 18.82%\n",
      "Validation Epoch: [17]  loss: [0.02] Accuracy [12.68] \n",
      "Validation Epoch: [18]  loss: [0.02] Accuracy [19.13] \n",
      "Saving Best model...\t\t\tTop1 = 19.13%\n",
      "Validation Epoch: [19]  loss: [0.02] Accuracy [19.56] \n",
      "Saving Best model...\t\t\tTop1 = 19.56%\n",
      "Validation Epoch: [20]  loss: [0.02] Accuracy [22.15] \n",
      "Saving Best model...\t\t\tTop1 = 22.15%\n",
      "Validation Epoch: [21]  loss: [0.02] Accuracy [20.33] \n",
      "Validation Epoch: [22]  loss: [0.02] Accuracy [18.42] \n",
      "Validation Epoch: [23]  loss: [0.02] Accuracy [17.09] \n",
      "Validation Epoch: [24]  loss: [0.02] Accuracy [23.58] \n",
      "Saving Best model...\t\t\tTop1 = 23.58%\n",
      "Validation Epoch: [25]  loss: [0.02] Accuracy [23.36] \n",
      "Validation Epoch: [26]  loss: [0.02] Accuracy [19.19] \n",
      "Validation Epoch: [27]  loss: [0.02] Accuracy [25.91] \n",
      "Saving Best model...\t\t\tTop1 = 25.91%\n",
      "Validation Epoch: [28]  loss: [0.02] Accuracy [24.62] \n",
      "Validation Epoch: [29]  loss: [0.02] Accuracy [26.10] \n",
      "Saving Best model...\t\t\tTop1 = 26.10%\n",
      "Validation Epoch: [30]  loss: [0.02] Accuracy [26.73] \n",
      "Saving Best model...\t\t\tTop1 = 26.73%\n"
     ]
    }
   ],
   "source": [
    "iterind = 0\n",
    "np.seterr(divide='ignore', invalid='ignore')\n",
    "torch.manual_seed(iterind)\n",
    "best_acc = 0\n",
    "accuracies_tr = []\n",
    "accuracies_val = []\n",
    "model = AudioCNN(num_class)\n",
    "model = model.to(opt.device)\n",
    "\n",
    "if isinstance(model, torch.nn.DataParallel):\n",
    "    print('Save random model')\n",
    "    state = {\n",
    "        'model':model.module.state_dict(),\n",
    "        'model1': model.state_dict(),\n",
    "        'model2': model,\n",
    "    }\n",
    "else:\n",
    "    print('Save random model')\n",
    "    state = {\n",
    "            'model':model,\n",
    "            }      \n",
    "\n",
    "if not osp.isdir('checkpoint'):\n",
    "    os.mkdir('checkpoint')\n",
    "save_point = './checkpoint/'\n",
    "if not os.path.isdir(save_point):\n",
    "    os.mkdir(save_point)\n",
    "torch.save(state, save_point + opt.name + 'rand.t7')\n",
    "criterion = nn.BCEWithLogitsLoss()\n",
    "optimizer = torch.optim.AdamW(model.parameters(), lr=opt.lr)\n",
    "scheduler = torch.optim.lr_scheduler.OneCycleLR(optimizer, max_lr=0.001,\n",
    "                                              steps_per_epoch=int(len(train_loader)),\n",
    "                                              epochs=opt.epochs,\n",
    "                                              anneal_strategy='linear')\n",
    "for epoch in tqdm(range(opt.epochs)):\n",
    "    train(opt, model, train_loader, optimizer, scheduler, criterion, epoch)\n",
    "    best_acc = validate(opt, model, val_loader, criterion, epoch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Loading Data for testing music-selectivity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "testset = AudioSet(datadir, train=False)\n",
    "dataset = AudioSet(datadir, train=True)\n",
    "trainset, validset = random_split(dataset, [round(len(dataset)*.9), round(len(dataset)*.1)])\n",
    "num_class = testset.n_class\n",
    "bs = opt.batch_size\n",
    "n_workers = 0\n",
    "\n",
    "val_loader = torch.utils.data.DataLoader(\n",
    "    validset,\n",
    "    batch_size=bs, shuffle=False, collate_fn=collate_fn,\n",
    "    num_workers=n_workers, pin_memory=False)\n",
    "train_loader = torch.utils.data.DataLoader(\n",
    "    trainset,\n",
    "    batch_size=bs, shuffle=False, collate_fn=collate_fn,\n",
    "    num_workers=n_workers, pin_memory=False)\n",
    "test_loader = torch.utils.data.DataLoader(\n",
    "    testset,\n",
    "    batch_size=bs, shuffle=False, collate_fn=collate_fn,\n",
    "    num_workers=n_workers, pin_memory=False)\n",
    "\n",
    "labelismusic = np.array([True if i in Musicrelatedind else False for i in range(527)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Testing natural sound recognition performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Evaluator(object):\n",
    "    def __init__(self, model):\n",
    "\n",
    "        self.model = model\n",
    "        \n",
    "    def evaluate(self, data_loader):\n",
    "\n",
    "        clipwise_output = []\n",
    "        target = []\n",
    "\n",
    "        for inputs, targets in data_loader:\n",
    "            inputs, targets = inputs.to(opt.device), targets.to(opt.device)\n",
    "            outputs = self.model(inputs)\n",
    "            outputs = torch.sigmoid(outputs)\n",
    "            if len(clipwise_output) ==0:\n",
    "                clipwise_output = outputs\n",
    "                target = targets\n",
    "            else:\n",
    "                clipwise_output = torch.cat((clipwise_output, outputs), dim=0)\n",
    "                target = torch.cat((target, targets), dim=0)\n",
    "        clipwise_output = clipwise_output.cpu()\n",
    "        target = target.cpu()\n",
    "        average_precision = metrics.average_precision_score(\n",
    "            target, clipwise_output, average=None)\n",
    "    \n",
    "        statistics = {'average_precision': average_precision, 'output':clipwise_output}\n",
    "\n",
    "        return statistics\n",
    "    \n",
    "    def evaluate_chance(self, data_loader):\n",
    "        clipwise_output = []\n",
    "        target = []\n",
    "\n",
    "        for inputs, targets in data_loader:\n",
    "            inputs, targets = inputs.to(opt.device), targets.to(opt.device)\n",
    "            outputs = self.model(inputs)\n",
    "            outputs = torch.sigmoid(outputs)\n",
    "            if len(clipwise_output) ==0:\n",
    "                clipwise_output = outputs\n",
    "                target = targets\n",
    "            else:\n",
    "                clipwise_output = torch.cat((clipwise_output, outputs), dim=0)\n",
    "                target = torch.cat((target, targets), dim=0)\n",
    "        clipwise_output = clipwise_output.cpu()*0+1\n",
    "        \n",
    "        target = target.cpu()\n",
    "        average_precision = metrics.average_precision_score(\n",
    "            target, clipwise_output, average=None)\n",
    "\n",
    "        statistics = {'average_precision': average_precision, 'output':clipwise_output}\n",
    "\n",
    "        return statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Net:trained without music, nonmusic detection performance\n",
      "mean±std: mean average precision = 0.10923704147650512\n",
      "chance mAP = 0.004525523132575321\n",
      "Net:trained without music, music detection performance\n",
      "mean±std: mean average precision = 0.007335318346331586\n",
      "chance mAP = 0.00564257252448516\n",
      "CPU times: user 7min 31s, sys: 5.81 s, total: 7min 37s\n",
      "Wall time: 3min 14s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "checkpoint = torch.load('checkpoint/' + 'cnn_audioset_nomusic' + '.t7')\n",
    "model = checkpoint['model']\n",
    "model.eval() # evaluation mode\n",
    "\n",
    "# Get test statistics\n",
    "evaluator = Evaluator(model=model)\n",
    "with torch.no_grad():\n",
    "    test_statistics = evaluator.evaluate(test_loader)\n",
    "# chance\n",
    "evaluator = Evaluator(model=model)\n",
    "with torch.no_grad():\n",
    "    test_statistics_chance = evaluator.evaluate_chance(test_loader)\n",
    "\n",
    "print('Net:trained without music, nonmusic detection performance')\n",
    "print('mean'+ u\"\\u00B1\" + 'std: mean average precision = ' + str(np.mean(test_statistics['average_precision'][~labelismusic]))) \n",
    "print('chance mAP = ' + str(np.mean(test_statistics_chance['average_precision'][~labelismusic])))\n",
    "\n",
    "print('Net:trained without music, music detection performance')\n",
    "print('mean'+ u\"\\u00B1\" + 'std: mean average precision = ' + str(np.mean(test_statistics['average_precision'][labelismusic]))) \n",
    "print('chance mAP = ' + str(np.mean(test_statistics_chance['average_precision'][labelismusic])))\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### Extracting feature vectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "\n",
    "LOI = 'avgpool' # feature extraction layer\n",
    "def get_module(model, name):\n",
    "    sub_module = model\n",
    "    for n in name.split('.'):\n",
    "        sub_module = sub_module._modules[n]\n",
    "    return sub_module\n",
    "\n",
    "# get feature vectors from trained/random network\n",
    "def get_feature(model, data_loader):\n",
    "    with torch.no_grad():\n",
    "        ismusiclabel = []\n",
    "        isnonmusiclabel = []\n",
    "\n",
    "        featuretmp = []\n",
    "        for inputs, targets in data_loader:\n",
    "            for i in np.arange(targets.shape[0]):\n",
    "                ismusiclabel.append(not any(np.logical_not([x in Musicrelatedind for x in np.where(targets[i, :])[0]])))\n",
    "                isnonmusiclabel.append(not any(([x in Musicrelatedind for x in np.where(targets[i, :])[0]])))\n",
    "                \n",
    "            x = inputs[:,:,:].float().to(opt.device)\n",
    "            features_blobs = {}\n",
    "            hooks = []\n",
    "            layers = [LOI]\n",
    "            for layer in layers:\n",
    "                m = get_module(model, layer)\n",
    "                def hook_feature(layer):\n",
    "                    def _hook(module, input, output):\n",
    "                        features_blobs[layer] = output.detach().cpu().numpy()\n",
    "                    return _hook\n",
    "                hooks.append(m.register_forward_hook(hook_feature(layer)))\n",
    "\n",
    "            with torch.no_grad():\n",
    "                model(x)\n",
    "                for hook in hooks:\n",
    "                    hook.remove()\n",
    "            fvtmp = features_blobs[LOI] # Activation\n",
    "            if len(featuretmp)==0:\n",
    "                featuretmp = fvtmp\n",
    "            else:    \n",
    "                featuretmp = np.concatenate((featuretmp, fvtmp), axis = 0)\n",
    "        featuretmp = np.squeeze(featuretmp)\n",
    "        ismusic = np.array(ismusiclabel) \n",
    "        isnonmusic = np.array(isnonmusiclabel)\n",
    "        fv = {}\n",
    "        fv['fv'] = featuretmp\n",
    "        fv['ismusic'] = ismusic\n",
    "        fv['isnonmusic'] = isnonmusic\n",
    "\n",
    "        return fv    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Defining Segregation Index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "## Analysis of tSNE space\n",
    "isBC = True \n",
    "def getMSI(points, ismusic, isnonmusic, BC = False):\n",
    "    nbin = 64\n",
    "    xs = points[:,0]\n",
    "    ys = points[:,1]\n",
    "    xmin = np.min(xs)\n",
    "    xmax = np.max(xs)\n",
    "    ymin = np.min(ys)\n",
    "    ymax = np.max(ys)\n",
    "    rg = [[xmin, xmax], [ymin, ymax]]\n",
    "    Hmusic, xedges, yedges = np.histogram2d(xs[ismusic], ys[ismusic], bins = nbin, density = True)\n",
    "    Hnonmusic, xedges, yedges = np.histogram2d(xs[isnonmusic], ys[isnonmusic], bins = nbin, density = True)\n",
    "    Hmusic = Hmusic/np.sum(Hmusic)\n",
    "    Hnonmusic = Hnonmusic/np.sum(Hnonmusic)\n",
    "    BC = (np.sum(np.sqrt(Hmusic*Hnonmusic)))\n",
    "    SI = 1-BC\n",
    "    return SI\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Visualizing tSNE embedding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Visualization of tSNE embedding: music vs nonmusic\n",
    "bline = 0.1\n",
    "cherry = np.array([139, 0, 0, 255*bline])/255 # actually dark red\n",
    "sapphire = np.array([0, 0,128, 255*bline])/255 # navy\n",
    "import matplotlib.patches as  mpatches\n",
    "def tSNE_visualization(name, isA, isnonA, isscatter = False, label1 = 'Music', label2 = 'Non-music'):\n",
    "\n",
    "    fv = featurevectors[name]['fv']\n",
    "    ismusic = isA\n",
    "    isnonmusic = isnonA\n",
    "    points = embeddings['method:TSNE, ' + name]\n",
    "    xs = points[:,0]\n",
    "    ys = points[:,1]\n",
    "    \n",
    "    fig = plt.figure() #(figsize = cm2inch(4.2, 4.2))\n",
    "    levels = np.array([0.2, 0.4, 0.6, 0.8])\n",
    "    for level in levels:\n",
    "        sns.kdeplot(x=xs[ismusic], y=ys[ismusic], shade=False, bw_adjust=1, levels = [level], color = level*np.array([0,0,0,1-bline])+cherry)\n",
    "        sns.kdeplot(x=xs[isnonmusic], y=ys[isnonmusic], shade=False, bw_adjust=1, levels = [level], color = level*np.array([0,0,0,1-bline])+sapphire)\n",
    "\n",
    "    handles = [mpatches.Patch(facecolor=np.array([139, 0, 0, 180])/255, label=label1),\n",
    "       mpatches.Patch(facecolor=np.array([0, 0,128, 180])/255, label=label2)]\n",
    "#     plt.legend(handles=handles, bbox_to_anchor=(0.95, 0.95, 0.3, 0.2), loc='upper right')\n",
    "    plt.legend(handles=handles)\n",
    "#         plt.xticks(fontsize = 6)\n",
    "#         plt.yticks(fontsize = 6)\n",
    "    plt.xticks(np.arange(-50, 51, 50), labels=['-50', '0', '50'])\n",
    "    plt.yticks(np.arange(-50, 51, 50), labels=['-50', '0', '50'])\n",
    "\n",
    "    SI = getMSI(points, ismusic, isnonmusic, BC = isBC)\n",
    "    print('SI = ' + str(SI))\n",
    "    return SI\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 7min 43s, sys: 27.4 s, total: 8min 10s\n",
      "Wall time: 4min 52s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "checkpoint = torch.load('checkpoint/' + 'cnn_audioset_nomusic' + '.t7')\n",
    "model = checkpoint['model']\n",
    "model.eval() # evaluation mode\n",
    "featurevectors = {} \n",
    "key_test = 'data:test, net:trained_nomusic'\n",
    "key_train = 'data:train, net:trained_nomusic'\n",
    "featurevectors[key_test] = get_feature(model, test_loader) # tuple: fv, ismusic, isnonmusic, isspeech\n",
    "featurevectors[key_train] = get_feature(model, train_loader) # tuple: fv, ismusic, isnonmusic, isspeech\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SI = 0.6715967413731515\n",
      "CPU times: user 9min 39s, sys: 528 ms, total: 9min 40s\n",
      "Wall time: 4min 7s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%time\n",
    "ismusic = featurevectors[key_test]['ismusic']\n",
    "isnonmusic = featurevectors[key_test]['isnonmusic']\n",
    "ismusic_tr = featurevectors[key_train]['ismusic']\n",
    "isnonmusic_tr = featurevectors[key_train]['isnonmusic']\n",
    "\n",
    "embeddings = {}\n",
    "SIstmp = []\n",
    "fv = featurevectors[key_test]['fv']\n",
    "tSNE = Pipeline([('scaling', StandardScaler()), ('tSNE', TSNE(n_components=2))])\n",
    "points = tSNE.fit_transform(fv)\n",
    "embeddings['method:TSNE, ' + key_test] = points\n",
    "\n",
    "SI = tSNE_visualization(key_test, ismusic, isnonmusic)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### tSNE embedding of testset (Checking Music/nonmusic clustering)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "fv = featurevectors[key_test];\n",
    "tmp1 = np.mean(fv['fv'][ismusic, :], axis = 1).flatten()\n",
    "tmp2 = np.mean(fv['fv'][isnonmusic, :], axis=1).flatten()\n",
    "plt.hist(tmp2, alpha = 0.6, label = 'Nonmusic', weights=np.ones(len(tmp2)) / len(tmp2), bins = np.arange(0,1,0.04), color = 'lightblue')\n",
    "plt.hist(tmp1, alpha = 0.6, label = 'Music', weights=np.ones(len(tmp1)) / len(tmp1), bins = np.arange(0,1,0.04), color = 'pink')\n",
    "plt.xlabel('Average response')\n",
    "plt.ylabel('Portion')\n",
    "plt.plot([np.mean(tmp1), np.mean(tmp1)], [0, 0.2], color='red')\n",
    "plt.plot([np.mean(tmp2), np.mean(tmp2)], [0, 0.2], color='blue')\n",
    "plt.legend()\n",
    "plt.yticks(np.arange(0, 0.21,0.05))  \n",
    "plt.xticks(np.arange(0, 1.1, 0.2))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "fv = featurevectors[key_train]\n",
    "featuretmp = fv['fv']\n",
    "ind1 = ismusic_tr; ind2 = isnonmusic_tr\n",
    "d1 = featuretmp[ind1, :]; d2 = featuretmp[ind2, :]\n",
    "m1 = np.mean(d1, axis=0); m2 = np.mean(d2, axis = 0)\n",
    "s1 = np.std(d1, axis=0); s2 = np.std(d2, axis=0)\n",
    "t = (m1-m2)/np.sqrt(np.square(s1)/d1.shape[0] + np.square(s2)/d2.shape[0])\n",
    "# t = (m1-m2)/np.sqrt(np.square(s1) + np.square(s2))\n",
    "fv['t'] = t\n",
    "MSI_order = np.argsort(-t)\n",
    "fv['MSI_order'] = MSI_order\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get music selectivity \n",
    "def getMS(fv, ind1, ind2, drawfig, MSI_ind = None):\n",
    "    featuretmp = fv['fv']\n",
    "        \n",
    "    d1 = featuretmp[ind1]; d2 = featuretmp[ind2]\n",
    "    m1 = np.mean(d1, axis=0); m2 = np.mean(d2, axis = 0)\n",
    "    s1 = np.std(d1, axis=0); s2 = np.std(d2, axis=0)\n",
    "    t = (m1-m2)/np.sqrt(np.square(s1)/d1.shape[0] + np.square(s2)/d2.shape[0] )\n",
    "    fv['t'] = t\n",
    "    MSI_order = np.argsort(-t)\n",
    "    fv['MSI_order'] = MSI_order\n",
    "    if MSI_ind is None:\n",
    "        MSI_ind = MSI_order[0:32]\n",
    "    \n",
    "    fvtmp = np.mean(featuretmp[:,MSI_ind], axis=1)\n",
    "    data = [fvtmp[ind1], fvtmp[ind2]]\n",
    "    if drawfig:        \n",
    "        xlabels = ['Music', 'Nonmusic']\n",
    "        fig, ax1 = plt.subplots(nrows=1, ncols=1, figsize=(9, 4))\n",
    "        bplot1 = ax1.boxplot(data,\n",
    "                             sym='',\n",
    "                             vert=True,  # vertical box alignment\n",
    "                             patch_artist=True,  # fill with color\n",
    "                             labels=xlabels)  # will be used to label x-ticks\n",
    "        ax1.set_title('Rectangular box plot');plt.ylabel('Response');plt.xlabel('Input data')\n",
    "        colors = ['pink', 'lightblue', 'lightgreen']\n",
    "        for patch, color in zip(bplot1['boxes'], colors):\n",
    "            patch.set_facecolor(color)\n",
    "    return t, MSI_order, data\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/kgspiano/.miniconda3/envs/music/lib/python3.7/site-packages/numpy/core/_asarray.py:102: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  return array(a, dtype, copy=False, order=order)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "drawfig = False\n",
    "fv = featurevectors[key_train]; ind1 = fv['ismusic']; ind2 = fv['isnonmusic']\n",
    "t, MSI_order, data2 = getMS(fv, ind1, ind2, drawfig)    \n",
    "MSI_ind = MSI_order[0:32]\n",
    "\n",
    "fv = featurevectors[key_test]; ind1 = fv['ismusic']; ind2 = fv['isnonmusic']\n",
    "t, MSI_order, data1 = getMS(fv, ind1, ind2, drawfig,  MSI_ind = MSI_ind)     \n",
    "\n",
    "data = [data1[0], data2[0], data1[1], data2[1]]\n",
    "xlabels = ['Music \\n (train)', 'Music \\n (test)', 'Nonmusic \\n (train)', 'Nonmusic \\n (test)']\n",
    "fig, ax1 = plt.subplots(nrows=1, ncols=1)\n",
    "bplot1 = ax1.boxplot(data,\n",
    "                     sym='',\n",
    "                     vert=True,  # vertical box alignment\n",
    "                     patch_artist=True,  # fill with color\n",
    "                     labels=xlabels)  # will be used to label x-ticks\n",
    "ax1.set_xticklabels(xlabels)  \n",
    "plt.yticks(np.arange(0, 1.9, 0.5))\n",
    "plt.ylabel('Response');plt.xlabel('Input data')\n",
    "colors = ['pink', 'pink','lightblue','lightblue']\n",
    "for patch, color in zip(bplot1['boxes'], colors):\n",
    "    patch.set_facecolor(color)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Linear Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "unitN = 256 # 256 units\n",
    "names = list(featurevectors.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "aptmp = np.zeros(8)\n",
    "\n",
    "fv_tr = featurevectors[key_train]['fv']\n",
    "fv = featurevectors[key_test]['fv']\n",
    "MSI_order = featurevectors[key_test]['MSI_order']\n",
    "usedind_tr = ismusic_tr+isnonmusic_tr\n",
    "usedind = ismusic+isnonmusic\n",
    "\n",
    "for ii in np.arange(8):\n",
    "    k = ii*32\n",
    "    indrange = np.arange(k, k+32)\n",
    "    X = fv_tr[:, MSI_order[indrange]][usedind_tr, :]\n",
    "    y = ismusic_tr[usedind_tr]\n",
    "    clf = make_pipeline(StandardScaler(),\n",
    "                        LinearRegression())\n",
    "    clf.fit(X, y)\n",
    "    \n",
    "    X2 = fv[:, MSI_order[indrange]][usedind, :]\n",
    "    y2 = ismusic[usedind]\n",
    "    y_test = y2\n",
    "    y_score = clf.predict(X2)\n",
    "\n",
    "    ap = average_precision_score(y_test, y_score)\n",
    "    aptmp[ii] = ap\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "data = [aptmp[0], aptmp[1], aptmp[2], aptmp[3]]#, AP\n",
    "datalabel = ['Top 12.5%', '- 25%', '-37.5%', '-50%']#, '-67.5%', '-75%', '-87.5%', '-100%']\n",
    "datamean = [np.mean(d) for d in data]\n",
    "datastd = [np.std(d) for d in data]\n",
    "fig, ax = plt.subplots()\n",
    "x_pos = np.arange(len(datamean))\n",
    "ax.bar(x_pos, datamean, align='center', alpha=0.5, ecolor='black', capsize=5)\n",
    "ax.set_ylabel('Average precision')\n",
    "ax.set_xticks(x_pos)\n",
    "plt.yticks([0, 0.2, 0.4, 0.6, 0.8, 1.0])\n",
    "ax.set_xticklabels(datalabel)\n",
    "ax.yaxis.grid(True)\n",
    "plt.tight_layout()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sound quilt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "win_ms = 25 # 25 ms\n",
    "segment_size_in_win = 16\n",
    "win_length_smp = floor(win_ms/1000*samplingrate) # win length in sampling number\n",
    "olap_pts = win_length_smp\n",
    "max_shift = int(np.floor(win_length_smp/2))\n",
    "n_seg_total = floor(220500/win_length_smp/segment_size_in_win)\n",
    "half_olap = int(np.floor(win_length_smp/2))\n",
    "half_olap_2 = int(olap_pts-half_olap)\n",
    "hop_pts = win_length_smp*segment_size_in_win # size of segment (30xN)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reorder_segs(d, hop_pts, order, olap_pts, max_shift):\n",
    "    shifts = np.zeros((len(order)))\n",
    "\n",
    "    # pre-initialize output, including overlap beyond end\n",
    "    y = np.zeros((hop_pts*len(order)+half_olap_2))\n",
    "\n",
    "    # actual window is the non-overlapping part, plus half an overlap at each end\n",
    "\n",
    "    win = np.hstack((0.5*(1-np.cos(np.pi*np.arange(olap_pts)/olap_pts)), np.squeeze(np.ones((1, hop_pts-olap_pts))), 0.5*(np.cos(np.pi*np.arange(olap_pts)/olap_pts)+1))) \n",
    "\n",
    "    # ramping, plus cross-correlation optimization of alignment\n",
    "\n",
    "    # We construct the output frame by frame\n",
    "    # We choose the precise alignment of the next frame by\n",
    "    # cross-correlating in the overlap region\n",
    "\n",
    "    # Seed with the first window\n",
    "    # starting point of frame requested by <order>\n",
    "    dbase = (order[0])*hop_pts;\n",
    "    threeqwinix = np.arange(hop_pts+half_olap_2)\n",
    "    y[threeqwinix] = d[dbase + threeqwinix-1]* win[half_olap+threeqwinix]\n",
    "    \n",
    "    # indices of overlap region, relative to first \"real\" point\n",
    "    olap_ix = np.arange(-half_olap, half_olap_2)\n",
    "    # indices of full window, relative to first \"real\" point\n",
    "    win_ix  = np.arange(-half_olap, hop_pts+half_olap_2)\n",
    "\n",
    "    for f in np.arange(1,len(order)):\n",
    "\n",
    "        # starting point of frame requested by <order>\n",
    "        dbase = (order[f])*hop_pts;\n",
    "        # starting point of where it's going to go (ignoring overlap)\n",
    "        ybase = (f)*hop_pts;\n",
    "        olap_region = y[ybase+olap_ix];\n",
    "        # apply second window (that will be applied to final overlap choice)\n",
    "        olap_region = olap_region*win[0:len(olap_region)];\n",
    "        # cross-correlate\n",
    "        # what is the block of candidate overlap points from original signal?\n",
    "\n",
    "        cand_block = d[dbase+ np.arange((-half_olap-max_shift),(half_olap_2+max_shift))];\n",
    "        xc = np.convolve(cand_block, np.flipud(olap_region))#/np.sqrt(sum(np.square(olap_region)));  # normalize in case we want to plot\n",
    "\n",
    "        # Instead, first trim off the ends...\n",
    "        xc = xc[len(olap_region)+np.arange(0, (1+2*max_shift))];\n",
    "        # ... then find shift in that part only\n",
    "        shift = np.where(xc==np.max(xc))[0][0]-max_shift;\n",
    "\n",
    "        # overlap-add at that point\n",
    "        op_range = ybase + win_ix;\n",
    "        overlap_part = win * d[dbase +shift+win_ix]\n",
    "        y[op_range] = y[op_range] + overlap_part\n",
    "        shifts[f] = shift\n",
    "    y = y[0:(len(y)-half_olap_2)]\n",
    "    return y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Define mel spectrogram\n",
    "samplingrate = iter(val_loader).next()[0].shape[2]/10 # samplingrate, total 10 s\n",
    "winlen = int(np.round(samplingrate*1/40)) # winlen: 25 ms, hoplen: 25 ms\n",
    "mel_spectrogram2 = nn.Sequential(\n",
    "    ta.transforms.MelSpectrogram(n_mels=64, sample_rate = samplingrate, win_length = winlen, hop_length = winlen, n_fft = winlen, f_min = 0, f_max = 8000, normalized=False),\n",
    "    ta.transforms.AmplitudeToDB()\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "win_ms = 25 # 25 ms\n",
    "win_length_smp = floor(win_ms/1000*samplingrate) # win length in sampling number\n",
    "olap_pts = win_length_smp\n",
    "max_shift = int(np.floor(win_length_smp/2))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get order\n",
    "def get_feature_soundquilt(model, data_loader, segment_size_in_win):\n",
    "    with torch.no_grad():\n",
    "        featuretmp = []\n",
    "        for inputs, targets in tqdm(data_loader):\n",
    "\n",
    "            data_torch = inputs[:,:,:].float().to(opt.device)\n",
    "            outputtmp2 = mel_spectrogram2(inputs.float()).cpu().numpy() # mel-spectrogram data (no modulation)\n",
    "\n",
    "            if segment_size_in_win !=0:\n",
    "                \n",
    "                n_seg_total = floor(220500/win_length_smp/segment_size_in_win)\n",
    "                half_olap = int(np.floor(win_length_smp/2))\n",
    "                half_olap_2 = int(olap_pts-half_olap)\n",
    "                hop_pts = win_length_smp*segment_size_in_win \n",
    "                deltacalsize = 2 \n",
    "                seg_length_smp = hop_pts\n",
    "                \n",
    "                for i in np.arange(targets.shape[0]):\n",
    "                    source_s = data_torch.cpu().numpy()[i,0,:]\n",
    "                    meltmp = outputtmp2[i, 0, :, :] \n",
    "                    deltas = []\n",
    "                    for j in np.arange(n_seg_total-1):\n",
    "                        # calculate delta\n",
    "                        segtmp1 = meltmp[:, (j*segment_size_in_win):((j+1)*segment_size_in_win)] # jth segment of melspectrogram\n",
    "                        segtmp2 = meltmp[:, ((j+1)*segment_size_in_win):((j+2)*segment_size_in_win)] # j+1th segment of melspectrogram\n",
    "                        deltatmp = segtmp1[:,(segment_size_in_win-deltacalsize):segment_size_in_win] - \\\n",
    "                        segtmp2[:, 0:deltacalsize]\n",
    "                        deltas.append(np.sum(deltatmp*deltatmp))\n",
    "\n",
    "                    soundsample = data_torch[i,0,:].cpu().numpy()\n",
    "                    s_segments = []  # list of wav segments\n",
    "                    for k in np.arange(n_seg_total-1):\n",
    "                        if k ==0:\n",
    "                            initint = np.random.randint(len(deltas))\n",
    "                            order = []\n",
    "                            order.append(initint)\n",
    "                            delt = np.array(deltas) # delta\n",
    "                            delk = delt[initint]\n",
    "                            delt[initint] = np.nan\n",
    "\n",
    "                        else:\n",
    "                            tmp = abs(delt - delk) # find idx of similar delta\n",
    "                            tmp = np.nanargmin(tmp)\n",
    "                            order.append(tmp)\n",
    "                            delk = delt[tmp]\n",
    "                            delt[tmp] = np.nan\n",
    "                    quilted_s = reorder_segs(source_s, hop_pts, order,  olap_pts, max_shift)\n",
    "                    datatmp = np.zeros((data_torch.shape[2]))\n",
    "                    datatmp[0:quilted_s.shape[0]] = quilted_s\n",
    "                    datatmp[int(220500*0.8):data_torch.shape[2]] = 0\n",
    "                    data_torch[i,0,:] = torch.from_numpy(datatmp)\n",
    "            else:\n",
    "                data_torch[:,:,int(220500*0.8):data_torch.shape[2]] = 0\n",
    "            x = data_torch.float().to(opt.device)\n",
    "            features_blobs = {}\n",
    "            hooks = []\n",
    "            layers = [LOI]\n",
    "            for layer in layers:\n",
    "                m = get_module(model, layer)\n",
    "                def hook_feature(layer):\n",
    "                    def _hook(module, input, output):\n",
    "                        features_blobs[layer] = output.detach().cpu().numpy()\n",
    "                    return _hook\n",
    "                hooks.append(m.register_forward_hook(hook_feature(layer)))\n",
    "\n",
    "            with torch.no_grad():\n",
    "                model(x)\n",
    "                for hook in hooks:\n",
    "                    hook.remove()\n",
    "            activ = features_blobs[LOI] \n",
    "            if len(featuretmp)==0:\n",
    "                featuretmp = activ\n",
    "            else:    \n",
    "                featuretmp = np.concatenate((featuretmp, activ), axis = 0)\n",
    "        featuretmp = np.squeeze(featuretmp)\n",
    "        fv = {}\n",
    "        fv['fv'] = featuretmp\n",
    "        return fv\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "78119194c50649438908ffd8a0130931",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/550 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "dbbe4ef22c604c599349b2c05bfa622a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/550 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "bf5a7962b3524443bfb8e7486a1aceb9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/550 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d729ecde39e148fb8387f19251856fc7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/550 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0f864f8afdfd414da7a16a339a4bf43b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/550 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "88d2ff6224324df48f9c2637d96bf5ac",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/550 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4ae04218b3294c62bafe066d3cd34c00",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/550 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 4h 27min 19s, sys: 2min 17s, total: 4h 29min 37s\n",
      "Wall time: 50min 57s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "MSI_inds = []\n",
    "seg_sizes = [0, 2, 4, 8, 16, 32, 64]\n",
    "y_preds = np.zeros((len(seg_sizes), len(ismusic_tr)))\n",
    "resptmp2 = np.zeros((len(seg_sizes), len(ismusic_tr), 256))\n",
    "for ss, segment_size_in_win in enumerate(seg_sizes):\n",
    "\n",
    "    fv = get_feature_soundquilt(model, train_loader, segment_size_in_win)\n",
    "    X2 = fv['fv']\n",
    "    y = ismusic_tr\n",
    "    resptmp2[ss, :,:] = X2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "resp_to_music = resptmp2[:,ismusic_tr, :]\n",
    "resp_to_nonmusic = resptmp2[:,isnonmusic_tr, :]\n",
    "resps = np.zeros((4, len(seg_sizes)))\n",
    "\n",
    "name = key_test\n",
    "MSI_order = featurevectors[name]['MSI_order']\n",
    "MSI_ind = MSI_order[0:32]\n",
    "tmp = resp_to_music\n",
    "tmp = tmp[:,:,MSI_ind]\n",
    "tmp = np.mean(tmp, axis=1)\n",
    "tmp = np.mean(tmp, axis=1)\n",
    "resps[0, :] = tmp\n",
    "\n",
    "tmp = resp_to_nonmusic\n",
    "tmp = tmp[:,:,MSI_ind]\n",
    "tmp = np.mean(tmp, axis=1)\n",
    "tmp = np.mean(tmp, axis=1)\n",
    "resps[1, :] = tmp\n",
    "\n",
    "MSI_ind = MSI_order[-32:]\n",
    "tmp = resp_to_music[:,:,:]\n",
    "tmp = tmp[:,:,MSI_ind]\n",
    "tmp = np.mean(tmp, axis=1)\n",
    "tmp = np.mean(tmp, axis=1)\n",
    "resps[2, :] = tmp\n",
    "\n",
    "tmp = resp_to_nonmusic[:,:,:]\n",
    "tmp = tmp[:,:,MSI_ind]\n",
    "tmp = np.mean(tmp, axis=1)\n",
    "tmp = np.mean(tmp, axis=1)\n",
    "resps[3, :] = tmp\n",
    "resp_quilt_dict = {}\n",
    "resp_quilt_dict['trained_nomusic'] = resps\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "cherryfull = [0.54509804, 0.        , 0.        , 1      ]\n",
    "sapphirefull = [0.        , 0.        , 0.50196078, 1      ]\n",
    "\n",
    "plt.figure(figsize = (8,4))\n",
    "plt.subplot(1,2,1)\n",
    "xrange = np.arange(1,7,1)\n",
    "xticklabels = (np.array(seg_sizes)[xrange]*25).tolist()\n",
    "xticklabels.append('Original')\n",
    "xrangeplot = np.arange(1,8,1)\n",
    "resptmp = resps[0,:] #np.mean(resptmp2, axis=0)\n",
    "plt.errorbar(xrange, resptmp[xrange], color = cherryfull, fmt='-', label='Music')\n",
    "\n",
    "plt.xticks(xrangeplot, xticklabels)\n",
    "plt.xlabel('Segment size [ms]')\n",
    "plt.ylabel('Average response')\n",
    "plt.errorbar(7, resptmp[0], color = cherryfull, fmt='.')\n",
    "\n",
    "resptmp = resps[1,:] #np.mean(resptmp2, axis=0)\n",
    "plt.errorbar(xrange, resptmp[xrange], color = sapphirefull, fmt='-', label='Non-music')\n",
    "\n",
    "plt.xlabel('Segment size [ms]')\n",
    "plt.ylabel('Average response')\n",
    "plt.errorbar(7, resptmp[0], color = sapphirefull, fmt='.')\n",
    "plt.xticks(xrangeplot, xticklabels)\n",
    "# plt.title('Sound quilt of non-music')\n",
    "plt.ylim(0, 1.0)\n",
    "plt.legend()\n",
    "# plt.show()\n",
    "\n",
    "plt.subplot(1,2,2)\n",
    "xticklabels = (np.array(seg_sizes)[xrange]*25).tolist()\n",
    "xticklabels.append('Original')\n",
    "xrangeplot = np.arange(1,8,1)\n",
    "resptmp = resps[2,:] \n",
    "plt.errorbar(xrange, resptmp[xrange], color = cherryfull, fmt='-', label='Music')\n",
    "plt.errorbar(7, resptmp[0], color = cherryfull, fmt='.')\n",
    "\n",
    "resptmp = resps[3,:]\n",
    "plt.errorbar(xrange, resptmp[xrange], color = sapphirefull, fmt='-', label='Non-music')\n",
    "plt.xlabel('Segment size [ms]')\n",
    "plt.ylabel('Average response')\n",
    "plt.errorbar(7, resptmp[0], color = sapphirefull, fmt='.')\n",
    "plt.xticks(xrangeplot, xticklabels)\n",
    "plt.ylim(0, 1.0)\n",
    "plt.legend()\n",
    "plt.tight_layout()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ablation test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Ablation_test(modelused, data_loader, idx_ablation=None): # output: average precision & auc of each class\n",
    "    if idx_ablation is None:\n",
    "\n",
    "        evaluator = Evaluator(model=modelused)\n",
    "        with torch.no_grad():\n",
    "            test_statistics = evaluator.evaluate(data_loader)\n",
    "    else:\n",
    "        hooks = []\n",
    "        layers = [LOI] # Layers of interest\n",
    "        for layer in layers:\n",
    "            m = get_module(modelused, layer)\n",
    "            def hook_ablation(layer):\n",
    "                def _hook(module, input, output):\n",
    "                    output[:, idx_ablation, 0,0] = 0\n",
    "                return _hook\n",
    "            hooks.append(m.register_forward_hook(hook_ablation(layer)))\n",
    "        \n",
    "        # evaluation of MAP & MAUC\n",
    "        evaluator = Evaluator(modelused)\n",
    "        with torch.no_grad():\n",
    "            test_statistics = evaluator.evaluate(data_loader)\n",
    "        # removehook\n",
    "            for hook in hooks:\n",
    "                hook.remove()\n",
    "    print('MAP = ' + str(test_statistics['average_precision'].mean()))\n",
    "\n",
    "    return test_statistics #[test_statistics['average_precision'][label_used].mean(), test_statistics['auc'][label_used].mean()], test_statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MAP = 0.08023275595558287\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/kgspiano/.miniconda3/envs/music/lib/python3.7/site-packages/ipykernel_launcher.py:17: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MAP = 0.07639079519771176\n",
      "MAP = 0.06703086724707905\n",
      "MAP = 0.07812563367308414\n",
      "MAP = 0.06965564878160552\n",
      "CPU times: user 18min 49s, sys: 15.6 s, total: 19min 4s\n",
      "Wall time: 8min 5s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "Accuracy = {}\n",
    "N_ablation = 32\n",
    "\n",
    "name = key_test\n",
    "if not (name in Accuracy):\n",
    "    Accuracy[name] = {}\n",
    "    \n",
    "# Baseline\n",
    "Accuracy[name]['Baseline'] = Ablation_test(model, test_loader)\n",
    "\n",
    "# Ablation based on MSI\n",
    "fv = featurevectors[name]; \n",
    "t = fv['t']\n",
    "tt = np.argsort(t)\n",
    "samplingrange_top = np.arange(unitN-1-N_ablation, unitN-1); \n",
    "samplingrange_bottom = np.arange(0, N_ablation); \n",
    "samplingrange_middle = np.arange((np.int(unitN/2)-np.int(N_ablation/2)), (np.int(unitN/2)+np.int(N_ablation/2)))\n",
    "\n",
    "Accuracy[name]['MSI bottom '+str(100*N_ablation/256) +'%'] = Ablation_test(model, test_loader, idx_ablation = tt[samplingrange_bottom])\n",
    "Accuracy[name]['MSI top '+str(100*N_ablation/256) +'%'] = Ablation_test(model, test_loader, idx_ablation = tt[samplingrange_top])\n",
    "Accuracy[name]['MSI middle '+str(100*N_ablation/256) +'%'] = Ablation_test(model, test_loader, idx_ablation = tt[samplingrange_middle])\n",
    "\n",
    "# Ablation based on L1norm\n",
    "n = 1\n",
    "Lnnorm = np.mean(np.power(abs(featurevectors[name]['fv']), n), axis=0)\n",
    "tt = np.argsort(Lnnorm) \n",
    "samplingrange_top = np.arange(unitN-1-N_ablation, unitN-1); \n",
    "Accuracy[name]['L' +str(n) +'norm, top '+str(100*N_ablation/256) +'%'] = Ablation_test(model, test_loader, idx_ablation = tt[samplingrange_top])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "averageprecisions = np.zeros((len(list(Accuracy[name].keys())), labelismusic.shape[0])) # iteration x 527 classes\n",
    "D = Accuracy[name]\n",
    "for i, key in enumerate(list(D.keys())):\n",
    "    averageprecisions[i, :] = D[key]['average_precision']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5,)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AP = np.mean(averageprecisions[:,~labelismusic], axis=1)\n",
    "AP.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "# APs\n",
    "AP = np.mean(averageprecisions[:,~labelismusic], axis=1)\n",
    "data = [AP[0], AP[1],AP[2],AP[3],AP[4]]#, AP\n",
    "datalabel = ['Baseline',\n",
    " 'MSI \\n bot. 12.5%',\n",
    " 'MSI \\n top 12.5%',\n",
    " 'MSI \\n mid. 12.5%',\n",
    " 'L1norm \\n top 12.5%']\n",
    "datamean = [np.mean(d) for d in data]\n",
    "datastd = [np.std(d) for d in data]\n",
    "fig, ax = plt.subplots()\n",
    "x_pos = np.arange(len(datamean))\n",
    "ax.bar(x_pos, datamean, align='center', alpha=0.5, ecolor='black', capsize=5)\n",
    "ax.set_ylabel('Average precision')\n",
    "ax.set_xticks(x_pos)\n",
    "ax.set_xticklabels(datalabel)\n",
    "ax.set_yticks(np.arange(0.05, 0.131, 0.03))\n",
    "plt.ylim([0.05, 0.13])\n",
    "plt.tight_layout()\n",
    "\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "music",
   "language": "python",
   "name": "music"
  },
  "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.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}