Automatic Language Identification - v1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:root:Setting up a new session...\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "import os\n",
    "import pathlib\n",
    "import random\n",
    "from datetime import datetime\n",
    "\n",
    "import cv2\n",
    "import IPython.display as ipd\n",
    "import librosa\n",
    "import librosa.display\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data import DataLoader, Dataset, SubsetRandomSampler\n",
    "\n",
    "from helpers import Compose\n",
    "from visualizations import Visualizations\n",
    "\n",
    "# from torchvision import transforms\n",
    "\n",
    "vis = Visualizations()\n",
    "\n",
    "# setting reprodutibilitty\n",
    "# torch.manual_seed(0)\n",
    "# np.random.seed(0)\n",
    "\n",
    "# from fastai.vision import Image\n",
    "# import torchaudio\n",
    "# import matplotlib.pyplot as plt\n",
    "# import pyrubberband as pyrb\n",
    "# from torchsummary import summary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def languageToLabel(language):\n",
    "    '''Troca a representação em string da classe para uma representação em int\n",
    "    \n",
    "        language: string\n",
    "    '''\n",
    "\n",
    "    if language == 'alemao':\n",
    "        return 0\n",
    "    elif language == 'ingles':\n",
    "        return 1\n",
    "    elif language == 'espanhol':\n",
    "        return 2\n",
    "\n",
    "tempo_inicio_treino = datetime.now()\n",
    "def save_model(name):\n",
    "    '''Pode ser usado para salvar parâmetros a cada epoch.'''\n",
    "    \n",
    "    tempo_formatado = tempo_inicio_treino.strftime(\"%d-%m-%Y-%H:%M:%S\")\n",
    "    folder_path = F'./data/pth_checkpoints/{tempo_formatado}'\n",
    "    pathlib.Path(folder_path).mkdir(parents=True, exist_ok=True)\n",
    "    \n",
    "    # somente os parâmetros\n",
    "    save_path = folder_path + F'/{name}.pth'\n",
    "    checkpoint = {\n",
    "        'state_dict': model.state_dict(),\n",
    "        'optimizer': optimizer.state_dict(),\n",
    "    }\n",
    "    torch.save(checkpoint, save_path)\n",
    "\n",
    "    # todo o modelo\n",
    "    save_path_full = folder_path + F'/{name}_full.pth'\n",
    "    torch.save(model, save_path_full)\n",
    "    \n",
    "def load_model(model, optimizer, full_path):\n",
    "    \n",
    "    checkpoint = torch.load(full_path)\n",
    "    model.load_state_dict(checkpoint['state_dict'])\n",
    "    optimizer.load_state_dict(checkpoint['optimizer'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MeuDataset(Dataset):\n",
    "    '''Inicialização\n",
    "\n",
    "    Nota que devemos croppar para 220500 p/ aumentar o batch size.\n",
    "    '''\n",
    "    def __init__(self, rootPath, csvPath, transform=None):\n",
    "        self.csvData = pd.read_csv(csvPath, delimiter=';')\n",
    "        self.rootPath = rootPath\n",
    "        self.list_IDs = self.csvData.iloc[:, 0]\n",
    "        self.labels = self.csvData.iloc[:, 1]\n",
    "        self.transform = transform\n",
    "\n",
    "    def __len__(self):\n",
    "        '''Número total de amostras'''\n",
    "        return self.csvData.shape[0]\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        'Gera uma amostra da lista'\n",
    "        # Carrega a amostra e pega a label\n",
    "        X = librosa.load(self.rootPath + self.list_IDs[index])\n",
    "        y = languageToLabel(self.labels[index])\n",
    "\n",
    "        audio_sample = {}\n",
    "        audio_sample['sample_array'], audio_sample['sample_rate'] = X\n",
    "\n",
    "        # croppamos os que não estão no padrão\n",
    "        audio_sample['sample_array'] = audio_sample['sample_array'][:220500]\n",
    "\n",
    "        if self.transform:\n",
    "            X = self.transform(audio_sample)\n",
    "\n",
    "        return X, y\n",
    "\n",
    "    @staticmethod\n",
    "    def get_mean_std(dataloader):\n",
    "        '''\n",
    "        Iterates through batches and extract its mean and std dev.\n",
    "        This is supposed to run only once, and then hard code the results into the normalization step.\n",
    "        \n",
    "        Params:\n",
    "            loader: Dataloader object\n",
    "        \n",
    "        Returns:\n",
    "            tuple of mean and standard deviation of all examples in dataloader\n",
    "        \n",
    "        '''\n",
    "\n",
    "        mu = 0\n",
    "        sigma = 0\n",
    "        nb_samples = 0\n",
    "        current_batch = 1\n",
    "        for images_list, labels in dataloader:\n",
    "\n",
    "            batch_samples = images_list.size(0)\n",
    "            #             print(images_list.size())\n",
    "\n",
    "            flatenned_spectrograms = images_list.view(batch_samples,\n",
    "                                                      images_list.size(1), -1)\n",
    "            #             print(flatenned_spectrograms.size())\n",
    "\n",
    "            mu += flatenned_spectrograms.mean(2).sum(0)\n",
    "            sigma += flatenned_spectrograms.std(2).sum(0)\n",
    "\n",
    "            #             print(mu.size())\n",
    "            #             print(sigma.size())\n",
    "\n",
    "            nb_samples += batch_samples\n",
    "            current_batch += 1\n",
    "            print(current_batch)\n",
    "\n",
    "        mu = mu / nb_samples\n",
    "        sigma = sigma / nb_samples\n",
    "\n",
    "        return mu, sigma\n",
    "\n",
    "    @property\n",
    "    def classes(self):\n",
    "        return self.labels.unique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# transformations\n",
    "class ToSpectrogram(object):\n",
    "    '''Convert audio sample to Mel-Spectrogram and resize it, multiplying its size to a number'''\n",
    "    def __init__(self, multiply_by):\n",
    "        '''Multiply spectrogram size by number\n",
    "\n",
    "        multiply_by: int\n",
    "\n",
    "        '''\n",
    "\n",
    "        self.multiply_by = multiply_by\n",
    "\n",
    "    def __call__(self, audio_sample):\n",
    "        '''Convert audio to mel-spectrogram and then resizes it'''\n",
    "\n",
    "        audio_sample_array, sample_rate = audio_sample[\n",
    "            'sample_array'], audio_sample['sample_rate']\n",
    "\n",
    "        # setar para escala mel\n",
    "        S = librosa.feature.melspectrogram(audio_sample_array,\n",
    "                                           sr=sample_rate,\n",
    "                                           n_mels=128,\n",
    "                                           n_fft=1024,\n",
    "                                           hop_length=256,\n",
    "                                           fmin=0.0,\n",
    "                                           fmax=None)\n",
    "\n",
    "        # arrumar amplitude\n",
    "        S = librosa.amplitude_to_db(S, ref=np.min, amin=1e-05, top_db=120.0)\n",
    "\n",
    "        new_H = S.shape[0] * self.multiply_by\n",
    "        new_W = S.shape[1] * self.multiply_by\n",
    "\n",
    "        resized_spectrogram = cv2.resize(S,\n",
    "                                         dsize=(new_W, new_H),\n",
    "                                         interpolation=cv2.INTER_CUBIC)\n",
    "\n",
    "        return resized_spectrogram\n",
    "\n",
    "\n",
    "class ToTensor(object):\n",
    "    \"\"\"Convert ndarrays in sample to Tensors.\n",
    "\n",
    "    object: np.array\n",
    "    \"\"\"\n",
    "    def __call__(self, spectrogram):\n",
    "        '''Insert dimension of size one at first position'''\n",
    "\n",
    "        # swap color axis because\n",
    "        # numpy image: H x W x C\n",
    "        # torch image: C X H X W\n",
    "\n",
    "        return torch.from_numpy(spectrogram).unsqueeze(0)\n",
    "\n",
    "\n",
    "class Normalize(object):\n",
    "    '''Normalizes tensors by subtracting by its mean, and dividing by the std deviation\n",
    "    \n",
    "    object: tensor\n",
    "    '''\n",
    "    def __init__(self, stats):\n",
    "        '''\n",
    "        stats: tuple with (mean, std_dev)\n",
    "        '''\n",
    "\n",
    "        self.mean, self.std_dev = stats\n",
    "\n",
    "    def __call__(self, tensor):\n",
    "\n",
    "        return (tensor - self.mean) / self.std_dev"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def init_weights(m):\n",
    "    '''Initializing weights as described by Kaiming et al. '''\n",
    "    if type(m) == nn.Linear:\n",
    "        torch.nn.init.kaiming_uniform_(m.weight)\n",
    "        m.bias.data.fill_(0.01)\n",
    "\n",
    "\n",
    "class CRNN(nn.Module):\n",
    "    '''Teste'''\n",
    "    def __init__(self, H_W, nb_classes):\n",
    "        '''H_W: tuple'''\n",
    "        super(CRNN, self).__init__()\n",
    "\n",
    "        self.H, self.W = H_W\n",
    "\n",
    "        # time feature extraction\n",
    "        self.conv1_time = nn.Conv2d(1,\n",
    "                                    out_channels=32,\n",
    "                                    kernel_size=(6, self.W - 1),\n",
    "                                    padding=(0, 428),\n",
    "                                    bias=False)\n",
    "        self.bn1_time = nn.BatchNorm2d(32)\n",
    "        self.relu1_time = nn.LeakyReLU(negative_slope=1e-2)\n",
    "        self.maxpool_time = nn.MaxPool2d((8, 16))\n",
    "\n",
    "        # frequency feature extraction\n",
    "        self.conv1_freq = nn.Conv2d(1,\n",
    "                                    out_channels=32,\n",
    "                                    kernel_size=(self.H, 5),\n",
    "                                    padding=(61, 0),\n",
    "                                    bias=False)\n",
    "        self.bn1_freq = nn.BatchNorm2d(32)\n",
    "        self.relu1_freq = nn.LeakyReLU(negative_slope=1e-2)\n",
    "        self.maxpool_freq = nn.MaxPool2d((8, 16))\n",
    "\n",
    "        self.dense_layer = nn.Linear(64 * 15 * 53, nb_classes)\n",
    "        # self.dense_layer = nn.Linear(64 * 61 * 429, nb_classes)\n",
    "        # self.dense_layer = nn.Linear(32 * 125 * 1, nb_classes)\n",
    "\n",
    "    def forward(self, x):\n",
    "        '''Here we forward the spectrogram two times to a first-layer, then we concat\n",
    "        these two first layers and we go through the forward propagation.\n",
    "\n",
    "        '''\n",
    "\n",
    "        x1 = x\n",
    "        x2 = x\n",
    "\n",
    "        x1 = self.conv1_time(x1)\n",
    "        x1 = self.bn1_time(x1)\n",
    "        x1 = self.relu1_time(x1)\n",
    "        x1 = self.maxpool_time(x1)\n",
    "\n",
    "        x2 = self.conv1_freq(x2)\n",
    "        x2 = self.bn1_freq(x2)\n",
    "        x2 = self.relu1_freq(x2)\n",
    "        x2 = self.maxpool_freq(x2)\n",
    "\n",
    "        # print(\"x1 shape: \", x1.shape)\n",
    "        # print(\"x2 shape: \", x2.shape)\n",
    "\n",
    "        x = torch.cat((x1, x2), dim=1)\n",
    "        # print(\"after concat: \", x.shape)\n",
    "\n",
    "        # flatten\n",
    "        x = x.view(x.size(0), -1)\n",
    "\n",
    "        #         print(\"after flatten: \", x.shape)\n",
    "\n",
    "        x = self.dense_layer(x)\n",
    "        x = F.log_softmax(x, dim=1)\n",
    "\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_dataloader(dataset,\n",
    "                    training_percentage,\n",
    "                    batch_size,\n",
    "                    debug=False,\n",
    "                    debug_size=0.02):\n",
    "    '''Split dataset into training_set and test_set\n",
    "    \n",
    "    Params:\n",
    "        dataset: dataset\n",
    "        training_percentage: float number between [0, 1] to split train/test set.\n",
    "        \n",
    "    Returns:\n",
    "        training_loader, test_loader: DataLoader objects\n",
    "    '''\n",
    "\n",
    "    DEBUG_PERCENT_SIZE = debug_size\n",
    "\n",
    "    dataset_length = len(dataset) if not debug else math.floor(\n",
    "        len(dataset) * DEBUG_PERCENT_SIZE)\n",
    "    training_set_size = math.floor(dataset_length * training_percentage)\n",
    "    test_set_size = dataset_length - training_set_size\n",
    "\n",
    "    if debug:\n",
    "        print(F\"Debug: {debug}\\n\"\n",
    "              F\"Dataset Length: {dataset_length}\\n\"\n",
    "              F\"Training Set Size: {training_set_size}\\n\"\n",
    "              F\"Test Set Size: {test_set_size}\\n\"\n",
    "              F\"Sanity Check: {training_set_size + test_set_size}\")\n",
    "\n",
    "    indices = np.random.permutation(len(dataset))\n",
    "    training_idxs = indices[:training_set_size]\n",
    "    test_idxs = indices[training_set_size:training_set_size + test_set_size]\n",
    "\n",
    "    training_sampler = SubsetRandomSampler(training_idxs)\n",
    "    test_sampler = SubsetRandomSampler(test_idxs)\n",
    "\n",
    "    training_loader = DataLoader(dataset,\n",
    "                                 batch_size=batch_size,\n",
    "                                 num_workers=2,\n",
    "                                 sampler=training_sampler,\n",
    "                                 # pin_memory=True,\n",
    "                                 drop_last=True)\n",
    "\n",
    "    test_loader = DataLoader(\n",
    "        dataset,\n",
    "        batch_size=batch_size,\n",
    "        num_workers=2,\n",
    "        sampler=test_sampler,\n",
    "        # pin_memory=True,\n",
    "        drop_last=True)\n",
    "    \n",
    "\n",
    "    return training_loader, test_loader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "composed = Compose(\n",
    "    [ToSpectrogram(1),\n",
    "     ToTensor(), Normalize((35.8871, 23.5386))])\n",
    "\n",
    "# (tensor([35.8871]), tensor([23.5386]))\n",
    "\n",
    "dataset_training = MeuDataset(\n",
    "    \"./data/\", \"./data/spoken-language-identification/training.csv\", composed)\n",
    "\n",
    "dataset_test = MeuDataset(\"./data/\",\n",
    "                          \"./data/spoken-language-identification/test.csv\",\n",
    "                          composed)\n",
    "\n",
    "# librosa.display.specshow(a, y_axis='mel', fmax=8000, x_axis='time')\n",
    "# Image.show(a, figsize=(20, 5), cmap=None, hide_axis=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GPU is available\n"
     ]
    }
   ],
   "source": [
    "# torch.cuda.is_available() checks and returns a Boolean True if a GPU is available, else it'll return False\n",
    "is_cuda = torch.cuda.is_available()\n",
    "# is_cuda = 0\n",
    "\n",
    "# If we have a GPU available, we'll set our device to GPU. We'll use this device variable later in our code.\n",
    "if is_cuda:\n",
    "    device = torch.device(\"cuda\")\n",
    "    print(\"GPU is available\")\n",
    "else:\n",
    "    device = torch.device(\"cpu\")\n",
    "    print(\"GPU not available, CPU used\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model, dataloader, debug=False):\n",
    "    '''\n",
    "    \n",
    "    '''\n",
    "\n",
    "    model.train()\n",
    "    vis.operation = 'Training'\n",
    "\n",
    "    loss_history = []\n",
    "\n",
    "    # step = # batch\n",
    "    # data = batch contents\n",
    "    # data[0] = tensors\n",
    "    # data[1] = labels\n",
    "\n",
    "    # running_loss = 0.0\n",
    "    for step, data in enumerate(dataloader):\n",
    "\n",
    "        # zero grad\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        # loading from data, and assigning to cuda\n",
    "        inputs, labels = data\n",
    "        if is_cuda:\n",
    "            inputs = inputs.to(device)\n",
    "            labels = labels.to(device)\n",
    "\n",
    "        outputs = model(inputs).to(device)\n",
    "        # print(\"outputs size:\", outputs.shape)\n",
    "\n",
    "        loss = loss_fn(outputs, labels)\n",
    "\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        # statistics\n",
    "        # running_loss += loss.item()\n",
    "        loss_history.append(loss.item())\n",
    "\n",
    "        vis.plot_current_batch(step, batch_size, len(dataloader) * batch_size)\n",
    "        vis.update_elapsed_time()\n",
    "\n",
    "        if step % 10 == 0:\n",
    "            vis.plot_loss(np.mean(loss_history[-10:]), step, F\"epoch_{epoch}\")\n",
    "            if debug:\n",
    "                print(F'\\nEpoch: {epoch}')\n",
    "                print(\n",
    "                    F'Samples: {step * batch_size} of {len(dataloader) * batch_size}'\n",
    "                )\n",
    "                print(F'Loss: {loss_history[-1]}\\n')\n",
    "\n",
    "    return loss_history\n",
    "\n",
    "\n",
    "def evaluate(model, dataloader, debug=False):\n",
    "\n",
    "    model.eval()\n",
    "    vis.operation = 'Evaluation'\n",
    "\n",
    "    correct = 0\n",
    "    total = 0\n",
    "    class_correct = [x for x in range(3)]\n",
    "    class_total = [x for x in range(3)]\n",
    "\n",
    "    labels_numpy = np.array([])\n",
    "    predicted_numpy = np.array([])\n",
    "\n",
    "    with torch.no_grad():\n",
    "\n",
    "        for step, data in enumerate(dataloader):\n",
    "\n",
    "            inputs, labels = data\n",
    "\n",
    "            if is_cuda:\n",
    "                inputs = inputs.to(device)\n",
    "                labels = labels.to(device)\n",
    "\n",
    "            outputs = model(inputs)\n",
    "\n",
    "            _, predicted = torch.max(outputs.data, 1)\n",
    "\n",
    "            total += labels.size(0)\n",
    "            correct += (predicted == labels).sum().item()\n",
    "            c = (predicted == labels).squeeze()\n",
    "\n",
    "            # statistics\n",
    "            vis.plot_current_batch(step, batch_size,\n",
    "                                   len(dataloader) * batch_size)\n",
    "            vis.update_elapsed_time()\n",
    "\n",
    "            #for i in range(batch_size):\n",
    "            #label = labels[i]\n",
    "            #class_correct[label] += c[i].item()\n",
    "            #class_total[label] += 1\n",
    "\n",
    "            if debug:\n",
    "                print(F\"\\nTotal Examples: {len(dataloader) * batch_size}\\n\"\n",
    "                      F\"Correct: {correct} of {total}\\n\"\n",
    "                      F\"Labels: {labels}\\n\"\n",
    "                      F\"Predicted: {predicted}\\n\"\n",
    "                      F\"Classes Correct: {class_correct}\"\n",
    "                      F\"Classes Total: {class_total}\")\n",
    "\n",
    "            labels_numpy = np.append(labels_numpy, labels.cpu().numpy())\n",
    "            predicted_numpy = np.append(predicted_numpy,\n",
    "                                        predicted.cpu().numpy())\n",
    "\n",
    "    return labels_numpy, predicted_numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 32\n",
    "nb_classes = 3\n",
    "nb_epochs = 10\n",
    "\n",
    "eval_first = False\n",
    "\n",
    "# training_loader, test_loader = make_dataloader(dataset_completo,\n",
    "#                                      1.0,\n",
    "#                                      batch_size,\n",
    "#                                      debug=False,\n",
    "#                                      debug_size=0.02)\n",
    "\n",
    "training_loader, _ = make_dataloader(dataset_training,\n",
    "                                     1.0,\n",
    "                                     batch_size,\n",
    "                                     debug=False,\n",
    "                                     debug_size=0.01)\n",
    "\n",
    "test_loader, _ = make_dataloader(dataset_test,\n",
    "                                 1.0,\n",
    "                                 batch_size,\n",
    "                                 debug=False,\n",
    "                                 debug_size=0.5)\n",
    "\n",
    "model = CRNN((128, 862), nb_classes)\n",
    "model.apply(init_weights)\n",
    "learning_rate = 1e-3\n",
    "\n",
    "if is_cuda:\n",
    "    torch.cuda.empty_cache()\n",
    "    model.cuda()\n",
    "\n",
    "loss_fn = nn.NLLLoss()  #.cuda()\n",
    "optimizer = torch.optim.AdamW(model.parameters(), lr=learning_rate)\n",
    "\n",
    "# load_model(model, optimizer, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normalized confusion matrix\n",
      "[[0.40116279 0.54069767 0.05813953]\n",
      " [0.         0.96449704 0.03550296]\n",
      " [0.         0.         1.        ]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/martin/Documentos/PythonEnvironments/tcc-py3.7/lib/python3.7/site-packages/torch/serialization.py:256: UserWarning: Couldn't retrieve source code for container of type CRNN. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normalized confusion matrix\n",
      "[[0.87058824 0.08823529 0.04117647]\n",
      " [0.05882353 0.91176471 0.02941176]\n",
      " [0.14534884 0.01162791 0.84302326]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/martin/Documentos/PythonEnvironments/tcc-py3.7/lib/python3.7/site-packages/torch/serialization.py:256: UserWarning: Couldn't retrieve source code for container of type CRNN. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normalized confusion matrix\n",
      "[[0.81065089 0.03550296 0.15384615]\n",
      " [0.10059172 0.76331361 0.13609467]\n",
      " [0.02873563 0.         0.97126437]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/martin/Documentos/PythonEnvironments/tcc-py3.7/lib/python3.7/site-packages/torch/serialization.py:256: UserWarning: Couldn't retrieve source code for container of type CRNN. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normalized confusion matrix\n",
      "[[0.38596491 0.33918129 0.2748538 ]\n",
      " [0.00584795 0.91812865 0.07602339]\n",
      " [0.         0.02352941 0.97647059]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/martin/Documentos/PythonEnvironments/tcc-py3.7/lib/python3.7/site-packages/torch/serialization.py:256: UserWarning: Couldn't retrieve source code for container of type CRNN. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normalized confusion matrix\n",
      "[[0.85714286 0.03571429 0.10714286]\n",
      " [0.         0.95953757 0.04046243]\n",
      " [0.04093567 0.01169591 0.94736842]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/martin/Documentos/PythonEnvironments/tcc-py3.7/lib/python3.7/site-packages/torch/serialization.py:256: UserWarning: Couldn't retrieve source code for container of type CRNN. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normalized confusion matrix\n",
      "[[0.88757396 0.04733728 0.06508876]\n",
      " [0.04093567 0.94736842 0.01169591]\n",
      " [0.10465116 0.02325581 0.87209302]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/martin/Documentos/PythonEnvironments/tcc-py3.7/lib/python3.7/site-packages/torch/serialization.py:256: UserWarning: Couldn't retrieve source code for container of type CRNN. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normalized confusion matrix\n",
      "[[0.92771084 0.02409639 0.04819277]\n",
      " [0.00578035 0.89595376 0.0982659 ]\n",
      " [0.02312139 0.         0.97687861]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/martin/Documentos/PythonEnvironments/tcc-py3.7/lib/python3.7/site-packages/torch/serialization.py:256: UserWarning: Couldn't retrieve source code for container of type CRNN. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normalized confusion matrix\n",
      "[[0.97674419 0.00581395 0.01744186]\n",
      " [0.0295858  0.9408284  0.0295858 ]\n",
      " [0.06432749 0.03508772 0.9005848 ]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/martin/Documentos/PythonEnvironments/tcc-py3.7/lib/python3.7/site-packages/torch/serialization.py:256: UserWarning: Couldn't retrieve source code for container of type CRNN. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normalized confusion matrix\n",
      "[[0.99408284 0.         0.00591716]\n",
      " [0.05813953 0.93023256 0.01162791]\n",
      " [0.20467836 0.01754386 0.77777778]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/martin/Documentos/PythonEnvironments/tcc-py3.7/lib/python3.7/site-packages/torch/serialization.py:256: UserWarning: Couldn't retrieve source code for container of type CRNN. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normalized confusion matrix\n",
      "[[0.98224852 0.00591716 0.01183432]\n",
      " [0.03550296 0.8816568  0.08284024]\n",
      " [0.09770115 0.00574713 0.89655172]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/martin/Documentos/PythonEnvironments/tcc-py3.7/lib/python3.7/site-packages/torch/serialization.py:256: UserWarning: Couldn't retrieve source code for container of type CRNN. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n"
     ]
    }
   ],
   "source": [
    "#summary(model, (1, 128, 862))\n",
    "epoch_loss_history = []\n",
    "epoch_eval_history = []\n",
    "vis.epoch_total = nb_epochs\n",
    "\n",
    "for epoch in range(nb_epochs):\n",
    "\n",
    "    # stats\n",
    "    vis.epoch_current += 1\n",
    "\n",
    "    if not eval_first or epoch > 0:\n",
    "        loss_history = train(model, dataloader=training_loader, debug=False)\n",
    "        epoch_loss_history.append(loss_history)\n",
    "        vis.plot_epoch_loss(epoch_loss_history)\n",
    "\n",
    "    true_labels, predicted_labels = evaluate(model,\n",
    "                                             dataloader=test_loader,\n",
    "                                             debug=False)\n",
    "    epoch_eval_history.append((true_labels, predicted_labels))\n",
    "\n",
    "    # stats\n",
    "    vis.plot_confusion_matrix(true_labels, predicted_labels)\n",
    "    vis.plot_roc_auc_score(true_labels, predicted_labels, epoch)\n",
    "    \n",
    "    # save after each epoch\n",
    "    save_model(F'epoch_{epoch + 1}')\n",
    "\n",
    "vis.update_elapsed_time(isFinished=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import roc_curve, roc_auc_score, auc, precision_recall_fscore_support\n",
    "from sklearn.preprocessing import LabelBinarizer, label_binarize\n",
    "from itertools import cycle\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "label_real = epoch_eval_history[9][0][:]\n",
    "label_pred = epoch_eval_history[9][1][:]\n",
    "\n",
    "lb = LabelBinarizer()\n",
    "lb.fit(label_real)\n",
    "\n",
    "label_real_binarizado = lb.transform(label_real)\n",
    "label_pred_binarizado = lb.transform(label_pred)\n",
    "n_classes = 3\n",
    "\n",
    "fpr = dict()\n",
    "tpr = dict()\n",
    "roc_auc = dict()\n",
    "f1_score_list = list()\n",
    "for i in range(nb_classes):\n",
    "    fpr[i], tpr[i], threshold = roc_curve(label_real_binarizado[:, i],\n",
    "                                          label_pred_binarizado[:, i])\n",
    "    roc_auc[i] = auc(fpr[i], tpr[i])\n",
    "    f1_score_list.append(\n",
    "        precision_recall_fscore_support(label_real_binarizado[:, i],\n",
    "                                        label_pred_binarizado[:, i],\n",
    "                                        average='macro'))\n",
    "\n",
    "roc_auc_score(label_real_binarizado, label_pred_binarizado, average=\"macro\")\n",
    "\n",
    "# funcao plot roc\n",
    "# Compute macro-average ROC curve and ROC area\n",
    "\n",
    "# First aggregate all false positive rates\n",
    "all_fpr = np.unique(np.concatenate([fpr[i] for i in range(n_classes)]))\n",
    "\n",
    "# Then interpolate all ROC curves at this points\n",
    "mean_tpr = np.zeros_like(all_fpr)\n",
    "for i in range(n_classes):\n",
    "    mean_tpr += np.interp(all_fpr, fpr[i], tpr[i])\n",
    "\n",
    "# Finally average it and compute AUC\n",
    "mean_tpr /= n_classes\n",
    "\n",
    "fpr[\"macro\"] = all_fpr\n",
    "tpr[\"macro\"] = mean_tpr\n",
    "roc_auc[\"macro\"] = auc(fpr[\"macro\"], tpr[\"macro\"])\n",
    "\n",
    "# Plot all ROC curves\n",
    "plt.figure(figsize=(10, 8))\n",
    "# plt.plot(fpr[\"micro\"],\n",
    "#          tpr[\"micro\"],\n",
    "#          label='micro-average ROC curve (area = {0:0.2f})'\n",
    "#          ''.format(roc_auc[\"micro\"]),\n",
    "#          color='deeppink',\n",
    "#          linestyle=':',\n",
    "#          linewidth=4)\n",
    "\n",
    "lw = 3\n",
    "\n",
    "plt.plot(fpr[\"macro\"],\n",
    "         tpr[\"macro\"],\n",
    "         label='macro-average ROC curve (area = {0:0.2f})'\n",
    "         ''.format(roc_auc[\"macro\"]),\n",
    "         color='navy',\n",
    "         linestyle=':',\n",
    "         linewidth=4)\n",
    "\n",
    "colors = cycle(['aqua', 'darkorange', 'cornflowerblue'])\n",
    "for i, color in zip(range(n_classes), colors):\n",
    "    plt.plot(fpr[i],\n",
    "             tpr[i],\n",
    "             color=color,\n",
    "             lw=lw,\n",
    "             label='ROC curve of class {0} (area = {1:0.2f})'\n",
    "             ''.format(i, roc_auc[i]))\n",
    "\n",
    "plt.plot([0, 1], [0, 1], 'k--', lw=lw)\n",
    "plt.xlim([0.0, 1.0])\n",
    "plt.ylim([0.0, 1.05])\n",
    "plt.xlabel('Taxa Falsos Positivos')\n",
    "plt.ylabel('Taxa Verdadeiros Positivos')\n",
    "plt.title('Extensão de Curva COR em Multi-Classe')\n",
    "plt.legend(loc=\"lower right\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "# save_model('epoch_10')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.9270177838577291, 0.9246072230157111, 0.925793305710437, None)"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "precision_recall_fscore_support(label_real_binarizado[:, 2], label_pred_binarizado[:, 2], average='macro')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9246072230157111"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "roc_auc[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------------------------------------------------------------\n",
      "        Layer (type)               Output Shape         Param #\n",
      "================================================================\n",
      "            Conv2d-1         [-1, 32, 123, 858]         165,312\n",
      "       BatchNorm2d-2         [-1, 32, 123, 858]              64\n",
      "         LeakyReLU-3         [-1, 32, 123, 858]               0\n",
      "         MaxPool2d-4           [-1, 32, 15, 53]               0\n",
      "            Conv2d-5         [-1, 32, 123, 858]          20,480\n",
      "       BatchNorm2d-6         [-1, 32, 123, 858]              64\n",
      "         LeakyReLU-7         [-1, 32, 123, 858]               0\n",
      "         MaxPool2d-8           [-1, 32, 15, 53]               0\n",
      "            Linear-9                    [-1, 3]         152,643\n",
      "================================================================\n",
      "Total params: 338,563\n",
      "Trainable params: 338,563\n",
      "Non-trainable params: 0\n",
      "----------------------------------------------------------------\n",
      "Input size (MB): 0.42\n",
      "Forward/backward pass size (MB): 154.98\n",
      "Params size (MB): 1.29\n",
      "Estimated Total Size (MB): 156.69\n",
      "----------------------------------------------------------------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "ERROR:visdom:Connection is already closed.\n",
      "ERROR:visdom:[Errno 111] Connection refused\n",
      "ERROR:visdom:[Errno 111] Connection refused\n",
      "ERROR:visdom:[Errno 111] Connection refused\n",
      "ERROR:visdom:[Errno 111] Connection refused\n",
      "ERROR:visdom:[Errno 111] Connection refused\n",
      "ERROR:visdom:[Errno 111] Connection refused\n",
      "ERROR:visdom:[Errno 111] Connection refused\n",
      "ERROR:visdom:[Errno 111] Connection refused\n"
     ]
    }
   ],
   "source": [
    "# from torchsummary import summary\n",
    "# summary(model, (1, 128, 862))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# np.pad(array, (0, 150000), 'constant', constant_values=0)[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# x = pyrb.pitch_shift(array, rate, -2.25)\n",
    "# ipd.Audio(a, rate=rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# teste.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# D.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}