torch_transformer_classification.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-10T17:24:36.056435Z",
     "start_time": "2021-04-10T17:24:32.230066Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\lejuj\\Anaconda3\\envs\\torchaudio\\lib\\site-packages\\torchaudio\\extension\\extension.py:13: UserWarning: torchaudio C++ extension is not available.\n",
      "  warnings.warn('torchaudio C++ extension is not available.')\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.8.1\n",
      "0.8.1\n"
     ]
    }
   ],
   "source": [
    "# import time\n",
    "import os\n",
    "from os import path\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.preprocessing import MultiLabelBinarizer, LabelEncoder, LabelBinarizer, StandardScaler\n",
    "import matplotlib.pyplot as plt\n",
    "from IPython.display import Audio, display\n",
    "#from pydub import AudioSegment\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "import torchaudio\n",
    "\n",
    "from torchaudio import transforms\n",
    "from torchvision import transforms as T\n",
    "import torchvision.models as models\n",
    "from torchsummary import summary\n",
    "\n",
    "from pytorch_pretrained_vit import ViT\n",
    "from pytorch_pretrained_vit.configs import PRETRAINED_MODELS\n",
    "\n",
    "import soundfile as sf\n",
    "import librosa\n",
    "from tqdm.notebook import tqdm\n",
    "\n",
    "from utils import * \n",
    "\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(torch.__version__)\n",
    "print(torchaudio.__version__)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-10T17:24:36.181480Z",
     "start_time": "2021-04-10T17:24:36.100437Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sat Apr 10 19:24:36 2021       \n",
      "+-----------------------------------------------------------------------------+\n",
      "| NVIDIA-SMI 452.06       Driver Version: 452.06       CUDA Version: 11.0     |\n",
      "|-------------------------------+----------------------+----------------------+\n",
      "| GPU  Name            TCC/WDDM | Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
      "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
      "|===============================+======================+======================|\n",
      "|   0  GeForce RTX 2060   WDDM  | 00000000:01:00.0  On |                  N/A |\n",
      "| N/A   55C    P8     9W /  N/A |    725MiB /  6144MiB |      9%      Default |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "                                                                               \n",
      "+-----------------------------------------------------------------------------+\n",
      "| Processes:                                                                  |\n",
      "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
      "|        ID   ID                                                   Usage      |\n",
      "|=============================================================================|\n",
      "|    0   N/A  N/A      1720    C+G   Insufficient Permissions        N/A      |\n",
      "|    0   N/A  N/A      6132    C+G   ...lPanel\\SystemSettings.exe    N/A      |\n",
      "|    0   N/A  N/A      7376    C+G   ...wekyb3d8bbwe\\Video.UI.exe    N/A      |\n",
      "|    0   N/A  N/A     10100    C+G   C:\\Windows\\explorer.exe         N/A      |\n",
      "|    0   N/A  N/A     11456    C+G   ...es.TextInput.InputApp.exe    N/A      |\n",
      "|    0   N/A  N/A     11484    C+G   ...artMenuExperienceHost.exe    N/A      |\n",
      "|    0   N/A  N/A     12136    C+G   ...w5n1h2txyewy\\SearchUI.exe    N/A      |\n",
      "|    0   N/A  N/A     12836    C+G   ...p-2.7.2\\GitHubDesktop.exe    N/A      |\n",
      "|    0   N/A  N/A     12904    C+G   ...cw5n1h2txyewy\\LockApp.exe    N/A      |\n",
      "|    0   N/A  N/A     13348    C+G   ...y\\ShellExperienceHost.exe    N/A      |\n",
      "|    0   N/A  N/A     13804    C+G   ...ekyb3d8bbwe\\YourPhone.exe    N/A      |\n",
      "|    0   N/A  N/A     14168    C+G   ...s (x86)\\Origin\\Origin.exe    N/A      |\n",
      "|    0   N/A  N/A     14320    C+G   ...8wekyb3d8bbwe\\GameBar.exe    N/A      |\n",
      "|    0   N/A  N/A     14632    C+G   ...perience\\NVIDIA Share.exe    N/A      |\n",
      "|    0   N/A  N/A     16272    C+G   ...me\\Application\\chrome.exe    N/A      |\n",
      "|    0   N/A  N/A     17288    C+G   ...b3d8bbwe\\WinStore.App.exe    N/A      |\n",
      "+-----------------------------------------------------------------------------+\n"
     ]
    }
   ],
   "source": [
    "!nvidia-smi "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# panda time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-10T17:24:38.144478Z",
     "start_time": "2021-04-10T17:24:36.220447Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "tracks = pd.read_csv('data/fma_metadata/tracks.csv', index_col=0, header=[0, 1])\n",
    "subset=tracks.index[tracks['set', 'subset'] == 'small']\n",
    "tracks=tracks.loc[subset]\n",
    "tracks;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## split dataset (train, test) + preprocess mono/multi classification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-10T17:24:38.394480Z",
     "start_time": "2021-04-10T17:24:38.359440Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6400 training examples, 800 validation examples, 1600 testing examples\n",
      "Top genres (8): ['Electronic', 'Experimental', 'Folk', 'Hip-Hop', 'Instrumental', 'International', 'Pop', 'Rock']\n",
      "indice data corrupted = 3530\n",
      "indice data corrupted = 3896\n",
      "indice data corrupted = 5609\n"
     ]
    }
   ],
   "source": [
    "# train => track_id train \n",
    "# data => track_id + label\n",
    "train_index = tracks.index[tracks['set', 'split'] == 'training']\n",
    "val_index = tracks.index[tracks['set', 'split'] == 'validation']\n",
    "test_index = tracks.index[(tracks['set', 'split'] == 'test' )| (tracks['set', 'split']=='validation') ]\n",
    "print('{} training examples, {} validation examples, {} testing examples'.format(*map(len, [train_index, val_index, test_index])))\n",
    "genres = list(LabelEncoder().fit(tracks['track', 'genre_top']).classes_)\n",
    "print('Top genres ({}): {}'.format(len(genres), genres))\n",
    "data=tracks['track', 'genre_top']\n",
    "# data,train_index[0], data.loc[train_index[0]] # (2, 'Hip-Hop')\n",
    "# pour multi classifier\n",
    "multi_classifier=False\n",
    "if multi_classifier:\n",
    "    enc = MultiLabelBinarizer()\n",
    "    labels = tracks['track', 'genres_all']\n",
    "    test_multi_index = tracks.index[(tracks['set', 'split'] == 'test' ) ]\n",
    "\n",
    "    # Split in training, validation and testing sets.\n",
    "    y_train = enc.fit_transform(labels[train_index])\n",
    "    y_val = enc.transform(labels[val_index])\n",
    "    y_test = enc.transform(labels[test_index])\n",
    "    \n",
    "# /!\\ data corrupted delete them : \"099134.mp3\" \"108925.mp3\" \"133297.mp3\" use cell below    \n",
    "flag=len(train_index)\n",
    "for i in range(len(train_index)):\n",
    "    if flag==i:\n",
    "        break\n",
    "    if str(train_index[i])==\"99134\" or str(train_index[i])==\"108925\" or str(train_index[i])==\"133297\":\n",
    "        print(\"indice data corrupted =\",i)\n",
    "        train_index=train_index.delete(i)\n",
    "        if multi_classifier:\n",
    "            y_train=np.delete(y_train, i,axis=0)\n",
    "\n",
    "        flag=flag-1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-27T09:35:43.630461Z",
     "start_time": "2021-03-27T09:35:43.626599Z"
    }
   },
   "source": [
    "## (use one time) to convert all mp3 to wav (speed load mp3 << speed load wav) with downsample from 44100 to 22050 Hz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-27T09:27:52.750234Z",
     "start_time": "2021-03-27T09:27:52.284935Z"
    },
    "scrolled": false
   },
   "source": [
    "#!mkdir \"data_proces/fma_small/\"\n",
    "path1=\"data/fma_small/\"\n",
    "path_stockage=\"data_proces/fma_small/\"\n",
    "count=0\n",
    "for root, dirs, files in os.walk(path1):\n",
    "    for name in files:\n",
    "        if name.endswith(\".mp3\"):\n",
    "            if not(path.exists(path_stockage+name[:-4]+'.wav')):\n",
    "                try:\n",
    "                    waveform, sample_rate=librosa.load(root+\"/\"+name,duration=15,sr=22050)\n",
    "                    sf.write(path_stockage+name[:-4]+'.wav', waveform, sample_rate)\n",
    "                    count+=1\n",
    "                except:\n",
    "                    print(\"audio :\"+root+\"/\"+name+\"  is corrupted\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# transformer\n",
    "https://colab.research.google.com/drive/1muZ4QFgVfwALgqmrfOkp7trAvqDemckO?usp=sharing#scrollTo=sb13T_M0yFb1\n",
    "https://colab.research.google.com/github/ra1ph2/Vision-Transformer/blob/main/VisionTransformer.ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-10T17:24:38.628439Z",
     "start_time": "2021-04-10T17:24:38.625476Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#!pip install --upgrade pytorch-pretrained-vit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-10T17:24:38.854437Z",
     "start_time": "2021-04-10T17:24:38.850481Z"
    }
   },
   "outputs": [],
   "source": [
    "#Pretrained on ImageNet-21k and fine tune on ImageNet-1k \n",
    "model_name = 'B_16_imagenet1k' #86859496\n",
    "model_name = \"B_32_imagenet1k\" #88297192\n",
    "model_name = \"B_32_imagenet1k\" #88297192\n",
    "model_name =\"L_16_imagenet1k\" #304 715 752\n",
    "model_name =\"L_32_imagenet1k\" #306 632 680\n",
    "# just trained on ImageNet-21k\n",
    "model_name =\"L_32\" #327 899 475\n",
    "model_name =\"B_16\" #102 595 923\n",
    "model_name =\"B_32\" #104 252 499\n",
    "model_name =\"L_16\" # pretraine param not avaiable\n",
    "model_name =\"L_32\" #327 899 475\n",
    "# count_parameters(model)\n",
    "all_model_pretrained=['B_16', 'B_32', 'L_32', 'B_16_imagenet1k', 'B_32_imagenet1k', 'L_16_imagenet1k', 'L_32_imagenet1k']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-10T17:24:39.150507Z",
     "start_time": "2021-04-10T17:24:39.131485Z"
    }
   },
   "outputs": [],
   "source": [
    "from model import *\n",
    "\n",
    "class Perso_ViT(nn.Module):\n",
    "    def __init__(self,name_model=\"B_16_imagenet1k\",PRETRAINED_MODELS=PRETRAINED_MODELS,Number_block=None):\n",
    "        super(Perso_ViT, self).__init__()\n",
    "        self.name_model=name_model\n",
    "        self.Number_block=Number_block\n",
    "        self.best_model=40 #a modif\n",
    "        if Number_block:\n",
    "            PRETRAINED_MODELS[name_model]['config']['num_layers']=Number_block\n",
    "        dim_out=PRETRAINED_MODELS[name_model][\"config\"][\"dim\"]\n",
    "        self.model= ViT(\"B_16_imagenet1k\", pretrained=True)\n",
    "        self.model.fc=nn.Identity()\n",
    "        self.last_layer=nn.Sequential(nn.Linear(dim_out,1024),nn.ReLU(),nn.Linear(1024,512),nn.ReLU(),nn.Linear(512,8))\n",
    "        self.model_freeze=True\n",
    "        \n",
    "        self.criterion = nn.CrossEntropyLoss()\n",
    "        self.Train_loss=[]\n",
    "        self.Test_loss=[]\n",
    "        self.Train_correct=[]\n",
    "        self.Test_correct=[]\n",
    "        \n",
    "    def freeze(self,all_layer=True):\n",
    "        if all_layer:\n",
    "            self.model_freeze=True\n",
    "        else:\n",
    "            self.model_freeze=False\n",
    "            for param in self.model.transformer.parameters():\n",
    "                param.requires_grad = False\n",
    "            # freeze or not the first conv\n",
    "            for param in self.model.patch_embedding.parameters(): #activate training on first conv\n",
    "                param.requires_grad = True\n",
    "            for param in self.model.fc.parameters():\n",
    "                param.require_grad = True\n",
    "\n",
    "        \n",
    "    def unfreeze(self):\n",
    "        self.model_freeze=False\n",
    "        for param in self.parameters():\n",
    "            param.requires_grad = True\n",
    "\n",
    "    def fit(self,epochs,optimizer,device,trainloader,all_spectro,max_lr=1e-5,use_amp=False,grad_clip=0.2):\n",
    "        scheduler = torch.optim.lr_scheduler.OneCycleLR(optimizer, max_lr, steps_per_epoch=len(trainloader), epochs=epochs)\n",
    "        for epoch in range(1, epochs + 1):\n",
    "            train_loss,correct_train=train(self.model, device, trainloader, self.criterion, optimizer, epoch,scheduler,all_spectro,transform_train_db,use_amp,grad_clip)\n",
    "            test_loss,correct_test=test(self.model, device, testloader,self.criterion,all_spectro,transform_test_db)\n",
    "            self.Train_loss.append(train_loss)\n",
    "            self.Test_loss.append(test_loss)\n",
    "            self.Train_correct.append(correct_train)\n",
    "            self.Test_correct.append(correct_test)\n",
    "            print(optimizer.param_groups[0]['lr'])\n",
    "            if correct_test>self.best_model:\n",
    "                self.best_model=correct_test\n",
    "                if self.Number_block:\n",
    "                    path=\"model_save/ViT_\"+self.name_model+str(self.Number_block)+\"_spec.pth\"\n",
    "                else:\n",
    "                    path=\"model_save/ViT_\"+self.name_model+\"_spec.pth\"\n",
    "                torch.save(model.state_dict(), path)\n",
    "        plt.plot(self.Train_loss)\n",
    "        plt.plot(self.Test_loss)\n",
    "        plt.legend([\"train\",\"test\"])\n",
    "        plt.title(\"CrossEntropyLoss \"+self.name_model)\n",
    "        plt.xlabel(\"epochs\")\n",
    "        plt.savefig('loss_'+self.name_model+' _spectro_all_spectr.png')\n",
    "        plt.show()\n",
    "\n",
    "        plt.plot(self.Train_correct)\n",
    "        plt.plot(self.Test_correct)\n",
    "        plt.legend([\"train\",\"test\"])\n",
    "        plt.title(self.name_model+ \" accuracy % , max acc = \"+str(max(self.Test_correct)))\n",
    "        plt.xlabel(\"epochs\")\n",
    "        plt.savefig('accuracy_ '+self.name_model+' _spectro_all_spectr.png')\n",
    "        plt.show()\n",
    "    def configure_optimizers(self):\n",
    "        optimizer = torch.optim.Adam(self.parameters(), lr=1e-3)\n",
    "        return optimizer\n",
    "    def forward(self, x):\n",
    "        if self.model_freeze:\n",
    "            with torch.no_grad():\n",
    "                x=self.model(x)\n",
    "        else:\n",
    "            x=self.model(x)\n",
    "        x=self.last_layer(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-10T17:24:42.108480Z",
     "start_time": "2021-04-10T17:24:39.376436Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Missing keys when loading pretrained weights: []\n",
      "Unexpected keys when loading pretrained weights: ['transformer.blocks.6.attn.proj_q.weight', 'transformer.blocks.6.attn.proj_q.bias', 'transformer.blocks.6.attn.proj_k.weight', 'transformer.blocks.6.attn.proj_k.bias', 'transformer.blocks.6.attn.proj_v.weight', 'transformer.blocks.6.attn.proj_v.bias', 'transformer.blocks.6.proj.weight', 'transformer.blocks.6.proj.bias', 'transformer.blocks.6.norm1.weight', 'transformer.blocks.6.norm1.bias', 'transformer.blocks.6.pwff.fc1.weight', 'transformer.blocks.6.pwff.fc1.bias', 'transformer.blocks.6.pwff.fc2.weight', 'transformer.blocks.6.pwff.fc2.bias', 'transformer.blocks.6.norm2.weight', 'transformer.blocks.6.norm2.bias', 'transformer.blocks.7.attn.proj_q.weight', 'transformer.blocks.7.attn.proj_q.bias', 'transformer.blocks.7.attn.proj_k.weight', 'transformer.blocks.7.attn.proj_k.bias', 'transformer.blocks.7.attn.proj_v.weight', 'transformer.blocks.7.attn.proj_v.bias', 'transformer.blocks.7.proj.weight', 'transformer.blocks.7.proj.bias', 'transformer.blocks.7.norm1.weight', 'transformer.blocks.7.norm1.bias', 'transformer.blocks.7.pwff.fc1.weight', 'transformer.blocks.7.pwff.fc1.bias', 'transformer.blocks.7.pwff.fc2.weight', 'transformer.blocks.7.pwff.fc2.bias', 'transformer.blocks.7.norm2.weight', 'transformer.blocks.7.norm2.bias', 'transformer.blocks.8.attn.proj_q.weight', 'transformer.blocks.8.attn.proj_q.bias', 'transformer.blocks.8.attn.proj_k.weight', 'transformer.blocks.8.attn.proj_k.bias', 'transformer.blocks.8.attn.proj_v.weight', 'transformer.blocks.8.attn.proj_v.bias', 'transformer.blocks.8.proj.weight', 'transformer.blocks.8.proj.bias', 'transformer.blocks.8.norm1.weight', 'transformer.blocks.8.norm1.bias', 'transformer.blocks.8.pwff.fc1.weight', 'transformer.blocks.8.pwff.fc1.bias', 'transformer.blocks.8.pwff.fc2.weight', 'transformer.blocks.8.pwff.fc2.bias', 'transformer.blocks.8.norm2.weight', 'transformer.blocks.8.norm2.bias', 'transformer.blocks.9.attn.proj_q.weight', 'transformer.blocks.9.attn.proj_q.bias', 'transformer.blocks.9.attn.proj_k.weight', 'transformer.blocks.9.attn.proj_k.bias', 'transformer.blocks.9.attn.proj_v.weight', 'transformer.blocks.9.attn.proj_v.bias', 'transformer.blocks.9.proj.weight', 'transformer.blocks.9.proj.bias', 'transformer.blocks.9.norm1.weight', 'transformer.blocks.9.norm1.bias', 'transformer.blocks.9.pwff.fc1.weight', 'transformer.blocks.9.pwff.fc1.bias', 'transformer.blocks.9.pwff.fc2.weight', 'transformer.blocks.9.pwff.fc2.bias', 'transformer.blocks.9.norm2.weight', 'transformer.blocks.9.norm2.bias', 'transformer.blocks.10.attn.proj_q.weight', 'transformer.blocks.10.attn.proj_q.bias', 'transformer.blocks.10.attn.proj_k.weight', 'transformer.blocks.10.attn.proj_k.bias', 'transformer.blocks.10.attn.proj_v.weight', 'transformer.blocks.10.attn.proj_v.bias', 'transformer.blocks.10.proj.weight', 'transformer.blocks.10.proj.bias', 'transformer.blocks.10.norm1.weight', 'transformer.blocks.10.norm1.bias', 'transformer.blocks.10.pwff.fc1.weight', 'transformer.blocks.10.pwff.fc1.bias', 'transformer.blocks.10.pwff.fc2.weight', 'transformer.blocks.10.pwff.fc2.bias', 'transformer.blocks.10.norm2.weight', 'transformer.blocks.10.norm2.bias', 'transformer.blocks.11.attn.proj_q.weight', 'transformer.blocks.11.attn.proj_q.bias', 'transformer.blocks.11.attn.proj_k.weight', 'transformer.blocks.11.attn.proj_k.bias', 'transformer.blocks.11.attn.proj_v.weight', 'transformer.blocks.11.attn.proj_v.bias', 'transformer.blocks.11.proj.weight', 'transformer.blocks.11.proj.bias', 'transformer.blocks.11.norm1.weight', 'transformer.blocks.11.norm1.bias', 'transformer.blocks.11.pwff.fc1.weight', 'transformer.blocks.11.pwff.fc1.bias', 'transformer.blocks.11.pwff.fc2.weight', 'transformer.blocks.11.pwff.fc2.bias', 'transformer.blocks.11.norm2.weight', 'transformer.blocks.11.norm2.bias']\n"
     ]
    }
   ],
   "source": [
    "model=Perso_ViT(Number_block=6).to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-10T17:24:42.358472Z",
     "start_time": "2021-04-10T17:24:42.330437Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "384\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\lejuj\\Anaconda3\\envs\\torchaudio\\lib\\site-packages\\torchaudio\\functional\\functional.py:358: UserWarning: At least one mel filterbank has all zero values. The value for `n_mels` (512) may be set too high. Or, the value for `n_freqs` (1025) may be set too low.\n",
      "  \"At least one mel filterbank has all zero values. \"\n",
      "C:\\Users\\lejuj\\Anaconda3\\envs\\torchaudio\\lib\\site-packages\\torchaudio\\functional\\functional.py:358: UserWarning: At least one mel filterbank has all zero values. The value for `n_mels` (384) may be set too high. Or, the value for `n_freqs` (1025) may be set too low.\n",
      "  \"At least one mel filterbank has all zero values. \"\n"
     ]
    }
   ],
   "source": [
    "amp_db=transforms.AmplitudeToDB().to(device)\n",
    "bs=5\n",
    "normalize_spec_db, all_spectro, trainloader, testloader=init_param(model,train_index,test_index,data,bs,label_dic)\n",
    "\n",
    "transform_train_db = T.Compose([amp_db, normalize_spec_db,\n",
    "         # transforms.TimeStretch(fixed_rate =1.2),\n",
    "        #transforms.TimeMasking(time_mask_param=20),\n",
    "        #transforms.FrequencyMasking(freq_mask_param=30),\n",
    "        #T.RandomHorizontalFlip(),\n",
    "        #T.Resize((image_size,image_size))\n",
    "         ])\n",
    "\n",
    "transform_test_db = T.Compose([amp_db,           \n",
    "        normalize_spec_db])\n",
    "\n",
    "torch.cuda.empty_cache()\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "weight_decay = 1e-6\n",
    "\n",
    "optimizer = optim.Adam(model.parameters(), lr=0.001,weight_decay=0)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-10T18:13:04.413303Z",
     "start_time": "2021-04-10T17:24:42.621436Z"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "435aef4b4377490cba7f8733f1459a30",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/1280 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Epoch: 1  \tLoss: 1.546699   Accuracy: 1661/6397 (26%\n",
      "\n",
      "Test set: Average loss: 0.3080, Accuracy: 751/1600 (47%)\n",
      "\n",
      "8.110598554243549e-06\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1359cf5456ad448897c553547050b789",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/1280 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Epoch: 2  \tLoss: 2.386219   Accuracy: 3026/6397 (47%\n",
      "\n",
      "Test set: Average loss: 0.2925, Accuracy: 829/1600 (52%)\n",
      "\n",
      "4.768354952660993e-11\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"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "14ef37e1442c407b9b783049297be54c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/1280 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Epoch: 1  \tLoss: 0.926001   Accuracy: 3149/6397 (49%\n",
      "\n",
      "Test set: Average loss: 0.2943, Accuracy: 825/1600 (52%)\n",
      "\n",
      "8.110598554243549e-06\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a7ee368676f447b6bbcda971ee25c016",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/1280 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Epoch: 2  \tLoss: 0.749160   Accuracy: 3177/6397 (50%\n",
      "\n",
      "Test set: Average loss: 0.2919, Accuracy: 832/1600 (52%)\n",
      "\n",
      "4.768354952660993e-11\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"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8d92814462c74daf806d2076212f7fc0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/1280 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Epoch: 1  \tLoss: 1.026115   Accuracy: 3184/6397 (50%\n",
      "\n",
      "Test set: Average loss: 0.3005, Accuracy: 793/1600 (50%)\n",
      "\n",
      "8.110598554243549e-06\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0d42210bba1c4b9dae3a0f7da8525abc",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/1280 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Epoch: 2  \tLoss: 2.862520   Accuracy: 3449/6397 (54%\n",
      "\n",
      "Test set: Average loss: 0.2908, Accuracy: 829/1600 (52%)\n",
      "\n",
      "4.768354952660993e-11\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"
    },
    {
     "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": [
    "epochs=2\n",
    "model.freeze()\n",
    "model.fit(epochs,optimizer,device,trainloader,all_spectro,max_lr=1e-5)\n",
    "model.freeze(False)\n",
    "model.fit(epochs,optimizer,device,trainloader,all_spectro,max_lr=1e-5)\n",
    "model.unfreeze()\n",
    "model.fit(epochs,optimizer,device,trainloader,all_spectro,max_lr=1e-5)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "# draft"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-10T15:34:23.690880Z",
     "start_time": "2021-04-10T15:34:23.685880Z"
    },
    "hidden": true
   },
   "outputs": [],
   "source": [
    "amp_db=transforms.AmplitudeToDB().to(device)\n",
    "# index = 1\n",
    "bs=2\n",
    "normalize_spec_db, all_spectro, trainloader, testloader=init_param(model,train_index,test_index,data,bs,label_dic)\n",
    "\n",
    "\n",
    "transform_train_db = T.Compose([amp_db, normalize_spec_db,\n",
    "         # transforms.TimeStretch(fixed_rate =1.2),\n",
    "        #transforms.TimeMasking(time_mask_param=20),\n",
    "        #transforms.FrequencyMasking(freq_mask_param=30),\n",
    "        #T.RandomHorizontalFlip(),\n",
    "        #T.Resize((image_size,image_size))\n",
    "         ])\n",
    "transform_test_db = T.Compose([amp_db,           \n",
    "        normalize_spec_db])\n",
    "\n",
    "torch.cuda.empty_cache()\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "grad_clip = 0.2\n",
    "weight_decay = 1e-6\n",
    "#post_transf=nn.Sequential(nn.Linear(21843,512),nn.ReLU(),nn.Linear(512,8)).to(device)\n",
    "# TRY\n",
    "# post_transf=nn.Sequential(nn.Linear(768,512),nn.ReLU(),nn.Linear(512,8)).to(device)\n",
    "\n",
    "optimizer = optim.Adam(model.parameters(), lr=0.001,weight_decay=0)\n",
    "epochs=20\n",
    "scheduler = torch.optim.lr_scheduler.OneCycleLR(optimizer, max_lr=1e-10, steps_per_epoch=len(trainloader), epochs=epochs)\n",
    "\n",
    "Train_loss=[]\n",
    "Test_loss=[]\n",
    "Train_correct=[]\n",
    "Test_correct=[]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-04T10:56:25.794390Z",
     "start_time": "2021-04-04T10:56:25.790389Z"
    },
    "hidden": true
   },
   "outputs": [],
   "source": [
    "class Mish(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Mish, self).__init__()\n",
    "    def forward(self, input):\n",
    "        return input * torch.tanh(F.softplus(input))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "TO TRY:\n",
    "   - raw input in one or all layer \n",
    "   - every transformer layer\n",
    "   - more complex feature extractor like spectrogram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def count_parameters(model):\n",
    "    return sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
    "count_parameters(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "## draft for google cloud computing v100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-05T11:01:46.887492Z",
     "start_time": "2021-04-05T11:01:46.883492Z"
    },
    "hidden": true
   },
   "outputs": [],
   "source": [
    "all_model_pretrained=['B_16', 'B_32', 'L_32', 'B_16_imagenet1k', 'B_32_imagenet1k', 'L_16_imagenet1k', 'L_32_imagenet1k']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-05T09:48:39.056716Z",
     "start_time": "2021-04-05T09:48:37.603768Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "224\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'train_transf' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-47-78ca2c224f20>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     33\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mepoch\u001b[0m\u001b[1;33m==\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     34\u001b[0m             \u001b[0mnormal_ViT\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0munfreeze\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 35\u001b[1;33m         \u001b[0mtrain_loss\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mcorrect_train\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtrain_transf\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdevice\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtrainloader\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcriterion\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0moptimizer\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mepoch\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mscheduler\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mall_spectro\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mtransform_train_db\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtransform_train_db\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mlog_interval\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m100\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mgrad_clip\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mgrad_clip\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mUse_waveform\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mFalse\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     36\u001b[0m         \u001b[0mtest_loss\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mcorrect_test\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtest_transf\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdevice\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtestloader\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mcriterion\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mall_spectro\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mtransform_test_db\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mUse_waveform\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mFalse\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     37\u001b[0m         \u001b[0mTrain_loss\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtrain_loss\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'train_transf' is not defined"
     ]
    }
   ],
   "source": [
    "criterion = nn.CrossEntropyLoss()\n",
    "grad_clip = 0.2\n",
    "amp_db=transforms.AmplitudeToDB().to(device)\n",
    "\n",
    "# weight_decay = 1e-6\n",
    "for model_name in all_model_pretrained:\n",
    "    torch.cuda.empty_cache()\n",
    "    #init model\n",
    "    model = ViT(model_name, pretrained=False).to(device)\n",
    "    dim_out=PRETRAINED_MODELS[model_name][\"config\"][\"dim\"]\n",
    "\n",
    "    normalize_spec_db, all_spectro, trainloader, testloader=init_param(model)\n",
    "\n",
    "    transform_train_db = T.Compose([ amp_db,     \n",
    "                                    normalize_spec_db,])\n",
    "\n",
    "    transform_test_db = T.Compose([amp_db,           \n",
    "            normalize_spec_db])\n",
    "\n",
    "    model.fc=nn.Sequential(nn.Linear(dim_out, 1024),nn.ReLU(),nn.Linear(1024, 8)).to(device)\n",
    "    normal_ViT=Normal_ViT(model).to(device)\n",
    "    optimizer = optim.Adam(normal_ViT.parameters(), lr=0.001,weight_decay=0)\n",
    "    #init list\n",
    "    Train_loss=[]\n",
    "    Test_loss=[]\n",
    "    Train_correct=[]\n",
    "    Test_correct=[]\n",
    "    best_model=45\n",
    "    epochs=2\n",
    "    normal_ViT.freeze()\n",
    "    scheduler = torch.optim.lr_scheduler.OneCycleLR(optimizer, max_lr=1e-5, steps_per_epoch=len(trainloader), epochs=epochs)\n",
    "    for epoch in range(1, epochs + 1):\n",
    "        if epoch==2:\n",
    "            normal_ViT.unfreeze()\n",
    "        train_loss,correct_train=train_transf(model, device, trainloader, criterion, optimizer, epoch,scheduler,all_spectro,transform_train_db=transform_train_db,log_interval=100,grad_clip=grad_clip,Use_waveform=False)\n",
    "        test_loss,correct_test=test_transf(model, device, testloader,criterion,all_spectro,transform_test_db,Use_waveform=False)\n",
    "        Train_loss.append(train_loss)\n",
    "        Test_loss.append(test_loss)\n",
    "        Train_correct.append(correct_train)\n",
    "        Test_correct.append(correct_test)\n",
    "        print(\"lr = \",optimizer.param_groups[0]['lr'])\n",
    "        if correct_test>best_model:\n",
    "            best_model=correct_test\n",
    "            path=\"model_save/Normal_ViT_\"+model_name+\"_spec.pth\"\n",
    "            torch.save(model.state_dict(), path)\n",
    "    plt.plot(Train_loss)\n",
    "    plt.plot(Test_loss)\n",
    "    plt.legend([\"train\",\"test\"])\n",
    "    plt.title(\"CrossEntropyLoss \"+model_name)\n",
    "    plt.xlabel(\"epochs\")\n",
    "    plt.savefig('loss_'+model_name+' _spectro_all_spectr.png')\n",
    "    plt.show()\n",
    "                                                \n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.13"
  },
  "notify_time": "5",
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": false,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "756.961px",
    "left": "2405.72px",
    "top": "200.352px",
    "width": "267.891px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "position": {
    "height": "319px",
    "left": "1550px",
    "right": "20px",
    "top": "120px",
    "width": "350px"
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}