2022-hw4-simple.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b06e65f8",
   "metadata": {
    "id": "C_jdZ5vHJ4A9",
    "papermill": {
     "duration": 0.016937,
     "end_time": "2022-03-25T04:49:08.874336",
     "exception": false,
     "start_time": "2022-03-25T04:49:08.857399",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Task description\n",
    "- Classify the speakers of given features.\n",
    "- Main goal: Learn how to use transformer.\n",
    "- Baselines:\n",
    "  - Easy: Run sample code and know how to use transformer.\n",
    "  - Medium: Know how to adjust parameters of transformer.\n",
    "  - Strong: Construct [conformer](https://arxiv.org/abs/2005.08100) which is a variety of transformer. \n",
    "  - Boss: Implement [Self-Attention Pooling](https://arxiv.org/pdf/2008.01077v1.pdf) & [Additive Margin Softmax](https://arxiv.org/pdf/1801.05599.pdf) to further boost the performance.\n",
    "\n",
    "- Other links\n",
    "  - Kaggle: [link](https://www.kaggle.com/t/ac77388c90204a4c8daebeddd40ff916)\n",
    "  - Slide: [link](https://docs.google.com/presentation/d/1HLAj7UUIjZOycDe7DaVLSwJfXVd3bXPOyzSb6Zk3hYU/edit?usp=sharing)\n",
    "  - Data: [link](https://github.com/MachineLearningHW/ML_HW4_Dataset)\n",
    "\n",
    "# Download dataset\n",
    "- Data is [here](https://github.com/MachineLearningHW/ML_HW4_Dataset)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a621c4dd",
   "metadata": {
    "id": "LhLNWB-AK2Z5",
    "papermill": {
     "duration": 0.015366,
     "end_time": "2022-03-25T04:49:08.906440",
     "exception": false,
     "start_time": "2022-03-25T04:49:08.891074",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "\"\"\"\n",
    "If the links below become inaccessible, please connect TAs.\n",
    "\"\"\"\n",
    "\n",
    "!wget https://github.com/MachineLearningHW/ML_HW4_Dataset/raw/0.0.1/Dataset.tar.gz.partaa\n",
    "!wget https://github.com/MachineLearningHW/ML_HW4_Dataset/raw/0.0.1/Dataset.tar.gz.partab\n",
    "!wget https://github.com/MachineLearningHW/ML_HW4_Dataset/raw/0.0.1/Dataset.tar.gz.partac\n",
    "!wget https://github.com/MachineLearningHW/ML_HW4_Dataset/raw/0.0.1/Dataset.tar.gz.partad\n",
    "\n",
    "!cat Dataset.tar.gz.parta* > Dataset.tar.gz\n",
    "\n",
    "!tar zxvf Dataset.tar.gz"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36230f1a",
   "metadata": {
    "id": "ENWVAUDVJtVY",
    "papermill": {
     "duration": 0.015209,
     "end_time": "2022-03-25T04:49:08.937102",
     "exception": false,
     "start_time": "2022-03-25T04:49:08.921893",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Fix Random Seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "51703be6",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-03-25T04:49:08.979268Z",
     "iopub.status.busy": "2022-03-25T04:49:08.978324Z",
     "iopub.status.idle": "2022-03-25T04:49:10.431200Z",
     "shell.execute_reply": "2022-03-25T04:49:10.430488Z",
     "shell.execute_reply.started": "2022-03-25T04:13:46.689273Z"
    },
    "id": "E6burzCXIyuA",
    "papermill": {
     "duration": 1.478999,
     "end_time": "2022-03-25T04:49:10.431376",
     "exception": false,
     "start_time": "2022-03-25T04:49:08.952377",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import torch\n",
    "import random\n",
    "\n",
    "def set_seed(seed):\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    torch.manual_seed(seed)\n",
    "    if torch.cuda.is_available():\n",
    "        torch.cuda.manual_seed(seed)\n",
    "        torch.cuda.manual_seed_all(seed)\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "\n",
    "set_seed(87)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5e38a98",
   "metadata": {
    "id": "k7dVbxW2LASN",
    "papermill": {
     "duration": 0.015588,
     "end_time": "2022-03-25T04:49:10.462819",
     "exception": false,
     "start_time": "2022-03-25T04:49:10.447231",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Data\n",
    "\n",
    "## Dataset\n",
    "- Original dataset is [Voxceleb2](https://www.robots.ox.ac.uk/~vgg/data/voxceleb/vox2.html).\n",
    "- The [license](https://creativecommons.org/licenses/by/4.0/) and [complete version](https://www.robots.ox.ac.uk/~vgg/data/voxceleb/files/license.txt) of Voxceleb2.\n",
    "- We randomly select 600 speakers from Voxceleb2.\n",
    "- Then preprocess the raw waveforms into mel-spectrograms.\n",
    "\n",
    "- Args:\n",
    "  - data_dir: The path to the data directory.\n",
    "  - metadata_path: The path to the metadata.\n",
    "  - segment_len: The length of audio segment for training. \n",
    "- The architecture of data directory \\\\\n",
    "  - data directory \\\\\n",
    "  |---- metadata.json \\\\\n",
    "  |---- testdata.json \\\\\n",
    "  |---- mapping.json \\\\\n",
    "  |---- uttr-{random string}.pt \\\\\n",
    "\n",
    "- The information in metadata\n",
    "  - \"n_mels\": The dimention of mel-spectrogram.\n",
    "  - \"speakers\": A dictionary. \n",
    "    - Key: speaker ids.\n",
    "    - value: \"feature_path\" and \"mel_len\"\n",
    "\n",
    "\n",
    "For efficiency, we segment the mel-spectrograms into segments in the traing step."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "47b09b1d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-03-25T04:49:10.505170Z",
     "iopub.status.busy": "2022-03-25T04:49:10.504447Z",
     "iopub.status.idle": "2022-03-25T04:49:10.506992Z",
     "shell.execute_reply": "2022-03-25T04:49:10.506593Z",
     "shell.execute_reply.started": "2022-03-25T04:13:48.055005Z"
    },
    "id": "KpuGxl4CI2pr",
    "papermill": {
     "duration": 0.028928,
     "end_time": "2022-03-25T04:49:10.507123",
     "exception": false,
     "start_time": "2022-03-25T04:49:10.478195",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import json\n",
    "import torch\n",
    "import random\n",
    "from pathlib import Path\n",
    "from torch.utils.data import Dataset\n",
    "from torch.nn.utils.rnn import pad_sequence\n",
    " \n",
    " \n",
    "class myDataset(Dataset):\n",
    "\tdef __init__(self, data_dir, segment_len=128):\n",
    "\t\tself.data_dir = data_dir\n",
    "\t\tself.segment_len = segment_len\n",
    "\t\n",
    "\t\t# Load the mapping from speaker neme to their corresponding id. \n",
    "\t\tmapping_path = Path(data_dir) / \"mapping.json\"\n",
    "\t\tmapping = json.load(mapping_path.open())\n",
    "\t\tself.speaker2id = mapping[\"speaker2id\"]\n",
    "\t\n",
    "\t\t# Load metadata of training data.\n",
    "\t\tmetadata_path = Path(data_dir) / \"metadata.json\"\n",
    "\t\tmetadata = json.load(open(metadata_path))[\"speakers\"]\n",
    "\t\n",
    "\t\t# Get the total number of speaker.\n",
    "\t\tself.speaker_num = len(metadata.keys())\n",
    "\t\tself.data = []\n",
    "\t\tfor speaker in metadata.keys():\n",
    "\t\t\tfor utterances in metadata[speaker]:\n",
    "\t\t\t\tself.data.append([utterances[\"feature_path\"], self.speaker2id[speaker]])\n",
    " \n",
    "\tdef __len__(self):\n",
    "\t\t\treturn len(self.data)\n",
    " \n",
    "\tdef __getitem__(self, index):\n",
    "\t\tfeat_path, speaker = self.data[index]\n",
    "\t\t# Load preprocessed mel-spectrogram.\n",
    "\t\tmel = torch.load(os.path.join(self.data_dir, feat_path))\n",
    "\n",
    "\t\t# Segmemt mel-spectrogram into \"segment_len\" frames.\n",
    "\t\tif len(mel) > self.segment_len:\n",
    "\t\t\t# Randomly get the starting point of the segment.\n",
    "\t\t\tstart = random.randint(0, len(mel) - self.segment_len)\n",
    "\t\t\t# Get a segment with \"segment_len\" frames.\n",
    "\t\t\tmel = torch.FloatTensor(mel[start:start+self.segment_len])\n",
    "\t\telse:\n",
    "\t\t\tmel = torch.FloatTensor(mel)\n",
    "\t\t# Turn the speaker id into long for computing loss later.\n",
    "\t\tspeaker = torch.FloatTensor([speaker]).long()\n",
    "\t\treturn mel, speaker\n",
    " \n",
    "\tdef get_speaker_number(self):\n",
    "\t\treturn self.speaker_num"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad81f8b8",
   "metadata": {
    "id": "668hverTMlGN",
    "papermill": {
     "duration": 0.015137,
     "end_time": "2022-03-25T04:49:10.537589",
     "exception": false,
     "start_time": "2022-03-25T04:49:10.522452",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Dataloader\n",
    "- Split dataset into training dataset(90%) and validation dataset(10%).\n",
    "- Create dataloader to iterate the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e64a23d5",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-03-25T04:49:10.577014Z",
     "iopub.status.busy": "2022-03-25T04:49:10.576225Z",
     "iopub.status.idle": "2022-03-25T04:49:10.578710Z",
     "shell.execute_reply": "2022-03-25T04:49:10.578254Z",
     "shell.execute_reply.started": "2022-03-25T04:13:48.069526Z"
    },
    "id": "B7c2gZYoJDRS",
    "papermill": {
     "duration": 0.025913,
     "end_time": "2022-03-25T04:49:10.578822",
     "exception": false,
     "start_time": "2022-03-25T04:49:10.552909",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch.utils.data import DataLoader, random_split\n",
    "from torch.nn.utils.rnn import pad_sequence\n",
    "\n",
    "\n",
    "def collate_batch(batch):\n",
    "\t# Process features within a batch.\n",
    "\t\"\"\"Collate a batch of data.\"\"\"\n",
    "\tmel, speaker = zip(*batch)\n",
    "\t# Because we train the model batch by batch, we need to pad the features in the same batch to make their lengths the same.\n",
    "\tmel = pad_sequence(mel, batch_first=True, padding_value=-20)    # pad log 10^(-20) which is very small value.\n",
    "\t# mel: (batch size, length, 40)\n",
    "\treturn mel, torch.FloatTensor(speaker).long()\n",
    "\n",
    "\n",
    "def get_dataloader(data_dir, batch_size, n_workers):\n",
    "\t\"\"\"Generate dataloader\"\"\"\n",
    "\tdataset = myDataset(data_dir)\n",
    "\tspeaker_num = dataset.get_speaker_number()\n",
    "\t# Split dataset into training dataset and validation dataset\n",
    "\ttrainlen = int(0.9 * len(dataset))\n",
    "\tlengths = [trainlen, len(dataset) - trainlen]\n",
    "\ttrainset, validset = random_split(dataset, lengths)\n",
    "\n",
    "\ttrain_loader = DataLoader(\n",
    "\t\ttrainset,\n",
    "\t\tbatch_size=batch_size,\n",
    "\t\tshuffle=True,\n",
    "\t\tdrop_last=True,\n",
    "\t\tnum_workers=n_workers,\n",
    "\t\tpin_memory=True,\n",
    "\t\tcollate_fn=collate_batch,\n",
    "\t)\n",
    "\tvalid_loader = DataLoader(\n",
    "\t\tvalidset,\n",
    "\t\tbatch_size=batch_size,\n",
    "\t\tnum_workers=n_workers,\n",
    "\t\tdrop_last=True,\n",
    "\t\tpin_memory=True,\n",
    "\t\tcollate_fn=collate_batch,\n",
    "\t)\n",
    "\n",
    "\treturn train_loader, valid_loader, speaker_num"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b463d53e",
   "metadata": {
    "id": "5FOSZYxrMqhc",
    "papermill": {
     "duration": 0.015152,
     "end_time": "2022-03-25T04:49:10.609752",
     "exception": false,
     "start_time": "2022-03-25T04:49:10.594600",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Model\n",
    "- TransformerEncoderLayer:\n",
    "  - Base transformer encoder layer in [Attention Is All You Need](https://arxiv.org/abs/1706.03762)\n",
    "  - Parameters:\n",
    "    - d_model: the number of expected features of the input (required).\n",
    "\n",
    "    - nhead: the number of heads of the multiheadattention models (required).\n",
    "\n",
    "    - dim_feedforward: the dimension of the feedforward network model (default=2048).\n",
    "\n",
    "    - dropout: the dropout value (default=0.1).\n",
    "\n",
    "    - activation: the activation function of intermediate layer, relu or gelu (default=relu).\n",
    "\n",
    "- TransformerEncoder:\n",
    "  - TransformerEncoder is a stack of N transformer encoder layers\n",
    "  - Parameters:\n",
    "    - encoder_layer: an instance of the TransformerEncoderLayer() class (required).\n",
    "\n",
    "    - num_layers: the number of sub-encoder-layers in the encoder (required).\n",
    "\n",
    "    - norm: the layer normalization component (optional)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "fb4bfbed",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-03-25T04:49:10.649034Z",
     "iopub.status.busy": "2022-03-25T04:49:10.648316Z",
     "iopub.status.idle": "2022-03-25T04:49:10.650648Z",
     "shell.execute_reply": "2022-03-25T04:49:10.650260Z",
     "shell.execute_reply.started": "2022-03-25T04:13:48.082941Z"
    },
    "id": "iXZ5B0EKJGs8",
    "papermill": {
     "duration": 0.02546,
     "end_time": "2022-03-25T04:49:10.650756",
     "exception": false,
     "start_time": "2022-03-25T04:49:10.625296",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "\n",
    "class Classifier(nn.Module):\n",
    "\tdef __init__(self, d_model=80, n_spks=600, dropout=0.1):\n",
    "\t\tsuper().__init__()\n",
    "\t\t# Project the dimension of features from that of input into d_model.\n",
    "\t\tself.prenet = nn.Linear(40, d_model)\n",
    "\t\t# TODO:\n",
    "\t\t#   Change Transformer to Conformer.\n",
    "\t\t#   https://arxiv.org/abs/2005.08100\n",
    "\t\tself.encoder_layer = nn.TransformerEncoderLayer(\n",
    "\t\t\td_model=d_model, dim_feedforward=256, nhead=2\n",
    "\t\t)\n",
    "\t\tself.encoder = nn.TransformerEncoder(self.encoder_layer, num_layers=2)\n",
    "\n",
    "\t\t# Project the the dimension of features from d_model into speaker nums.\n",
    "\t\tself.pred_layer = nn.Sequential(\n",
    "\t\t\tnn.Linear(d_model, d_model),\n",
    "\t\t\tnn.ReLU(),\n",
    "\t\t\tnn.Linear(d_model, n_spks),\n",
    "\t\t)\n",
    "\n",
    "\tdef forward(self, mels):\n",
    "\t\t\"\"\"\n",
    "\t\targs:\n",
    "\t\t\tmels: (batch size, length, 40)\n",
    "\t\treturn:\n",
    "\t\t\tout: (batch size, n_spks)\n",
    "\t\t\"\"\"\n",
    "\t\t# out: (batch size, length, d_model)\n",
    "\t\tout = self.prenet(mels)\n",
    "\t\t# out: (length, batch size, d_model)\n",
    "\t\tout = out.permute(1, 0, 2)\n",
    "\t\t# The encoder layer expect features in the shape of (length, batch size, d_model).\n",
    "\t\tout = self.encoder(out)\n",
    "\t\t# out: (batch size, length, d_model)\n",
    "\t\tout = out.transpose(0, 1)\n",
    "\t\t# mean pooling\n",
    "\t\tstats = out.mean(dim=1)\n",
    "\n",
    "\t\t# out: (batch, n_spks)\n",
    "\t\tout = self.pred_layer(stats)\n",
    "\t\treturn out"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28b70544",
   "metadata": {
    "id": "W7yX8JinM5Ly",
    "papermill": {
     "duration": 0.015531,
     "end_time": "2022-03-25T04:49:10.681597",
     "exception": false,
     "start_time": "2022-03-25T04:49:10.666066",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Learning rate schedule\n",
    "- For transformer architecture, the design of learning rate schedule is different from that of CNN.\n",
    "- Previous works show that the warmup of learning rate is useful for training models with transformer architectures.\n",
    "- The warmup schedule\n",
    "  - Set learning rate to 0 in the beginning.\n",
    "  - The learning rate increases linearly from 0 to initial learning rate during warmup period."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "cf2176cd",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-03-25T04:49:10.719847Z",
     "iopub.status.busy": "2022-03-25T04:49:10.719168Z",
     "iopub.status.idle": "2022-03-25T04:49:10.721315Z",
     "shell.execute_reply": "2022-03-25T04:49:10.721740Z",
     "shell.execute_reply.started": "2022-03-25T04:13:48.095418Z"
    },
    "id": "ykt0N1nVJJi2",
    "papermill": {
     "duration": 0.02493,
     "end_time": "2022-03-25T04:49:10.721849",
     "exception": false,
     "start_time": "2022-03-25T04:49:10.696919",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "import torch\n",
    "from torch.optim import Optimizer\n",
    "from torch.optim.lr_scheduler import LambdaLR\n",
    "\n",
    "\n",
    "def get_cosine_schedule_with_warmup(\n",
    "\toptimizer: Optimizer,\n",
    "\tnum_warmup_steps: int,\n",
    "\tnum_training_steps: int,\n",
    "\tnum_cycles: float = 0.5,\n",
    "\tlast_epoch: int = -1,\n",
    "):\n",
    "\t\"\"\"\n",
    "\tCreate a schedule with a learning rate that decreases following the values of the cosine function between the\n",
    "\tinitial lr set in the optimizer to 0, after a warmup period during which it increases linearly between 0 and the\n",
    "\tinitial lr set in the optimizer.\n",
    "\n",
    "\tArgs:\n",
    "\t\toptimizer (:class:`~torch.optim.Optimizer`):\n",
    "\t\tThe optimizer for which to schedule the learning rate.\n",
    "\t\tnum_warmup_steps (:obj:`int`):\n",
    "\t\tThe number of steps for the warmup phase.\n",
    "\t\tnum_training_steps (:obj:`int`):\n",
    "\t\tThe total number of training steps.\n",
    "\t\tnum_cycles (:obj:`float`, `optional`, defaults to 0.5):\n",
    "\t\tThe number of waves in the cosine schedule (the defaults is to just decrease from the max value to 0\n",
    "\t\tfollowing a half-cosine).\n",
    "\t\tlast_epoch (:obj:`int`, `optional`, defaults to -1):\n",
    "\t\tThe index of the last epoch when resuming training.\n",
    "\n",
    "\tReturn:\n",
    "\t\t:obj:`torch.optim.lr_scheduler.LambdaLR` with the appropriate schedule.\n",
    "\t\"\"\"\n",
    "\tdef lr_lambda(current_step):\n",
    "\t\t# Warmup\n",
    "\t\tif current_step < num_warmup_steps:\n",
    "\t\t\treturn float(current_step) / float(max(1, num_warmup_steps))\n",
    "\t\t# decadence\n",
    "\t\tprogress = float(current_step - num_warmup_steps) / float(\n",
    "\t\t\tmax(1, num_training_steps - num_warmup_steps)\n",
    "\t\t)\n",
    "\t\treturn max(\n",
    "\t\t\t0.0, 0.5 * (1.0 + math.cos(math.pi * float(num_cycles) * 2.0 * progress))\n",
    "\t\t)\n",
    "\n",
    "\treturn LambdaLR(optimizer, lr_lambda, last_epoch)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06d787f3",
   "metadata": {
    "id": "-LN2XkteM_uH",
    "papermill": {
     "duration": 0.015737,
     "end_time": "2022-03-25T04:49:10.754243",
     "exception": false,
     "start_time": "2022-03-25T04:49:10.738506",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Model Function\n",
    "- Model forward function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "7427da90",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-03-25T04:49:10.790710Z",
     "iopub.status.busy": "2022-03-25T04:49:10.789913Z",
     "iopub.status.idle": "2022-03-25T04:49:10.791809Z",
     "shell.execute_reply": "2022-03-25T04:49:10.792202Z",
     "shell.execute_reply.started": "2022-03-25T04:13:48.107482Z"
    },
    "id": "N-rr8529JMz0",
    "papermill": {
     "duration": 0.022539,
     "end_time": "2022-03-25T04:49:10.792329",
     "exception": false,
     "start_time": "2022-03-25T04:49:10.769790",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "\n",
    "\n",
    "def model_fn(batch, model, criterion, device):\n",
    "\t\"\"\"Forward a batch through the model.\"\"\"\n",
    "\n",
    "\tmels, labels = batch\n",
    "\tmels = mels.to(device)\n",
    "\tlabels = labels.to(device)\n",
    "\n",
    "\touts = model(mels)\n",
    "\n",
    "\tloss = criterion(outs, labels)\n",
    "\n",
    "\t# Get the speaker id with highest probability.\n",
    "\tpreds = outs.argmax(1)\n",
    "\t# Compute accuracy.\n",
    "\taccuracy = torch.mean((preds == labels).float())\n",
    "\n",
    "\treturn loss, accuracy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86a3f0f6",
   "metadata": {
    "id": "cwM_xyOtNCI2",
    "papermill": {
     "duration": 0.015311,
     "end_time": "2022-03-25T04:49:10.822892",
     "exception": false,
     "start_time": "2022-03-25T04:49:10.807581",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Validate\n",
    "- Calculate accuracy of the validation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2804f647",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-03-25T04:49:10.856527Z",
     "iopub.status.busy": "2022-03-25T04:49:10.855755Z",
     "iopub.status.idle": "2022-03-25T04:49:10.863246Z",
     "shell.execute_reply": "2022-03-25T04:49:10.862827Z",
     "shell.execute_reply.started": "2022-03-25T04:13:48.11875Z"
    },
    "id": "YAiv6kpdJRTJ",
    "papermill": {
     "duration": 0.024941,
     "end_time": "2022-03-25T04:49:10.863354",
     "exception": false,
     "start_time": "2022-03-25T04:49:10.838413",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "from tqdm import tqdm\n",
    "import torch\n",
    "\n",
    "\n",
    "def valid(dataloader, model, criterion, device): \n",
    "\t\"\"\"Validate on validation set.\"\"\"\n",
    "\n",
    "\tmodel.eval()\n",
    "\trunning_loss = 0.0\n",
    "\trunning_accuracy = 0.0\n",
    "\tpbar = tqdm(total=len(dataloader.dataset), ncols=0, desc=\"Valid\", unit=\" uttr\")\n",
    "\n",
    "\tfor i, batch in enumerate(dataloader):\n",
    "\t\twith torch.no_grad():\n",
    "\t\t\tloss, accuracy = model_fn(batch, model, criterion, device)\n",
    "\t\t\trunning_loss += loss.item()\n",
    "\t\t\trunning_accuracy += accuracy.item()\n",
    "\n",
    "\t\tpbar.update(dataloader.batch_size)\n",
    "\t\tpbar.set_postfix(\n",
    "\t\t\tloss=f\"{running_loss / (i+1):.2f}\",\n",
    "\t\t\taccuracy=f\"{running_accuracy / (i+1):.2f}\",\n",
    "\t\t)\n",
    "\n",
    "\tpbar.close()\n",
    "\tmodel.train()\n",
    "\n",
    "\treturn running_accuracy / len(dataloader)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd772863",
   "metadata": {
    "id": "g6ne9G-eNEdG",
    "papermill": {
     "duration": 0.015155,
     "end_time": "2022-03-25T04:49:10.893761",
     "exception": false,
     "start_time": "2022-03-25T04:49:10.878606",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Main function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "3187fa82",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-03-25T04:49:10.939908Z",
     "iopub.status.busy": "2022-03-25T04:49:10.939309Z",
     "iopub.status.idle": "2022-03-25T05:17:45.086536Z",
     "shell.execute_reply": "2022-03-25T05:17:45.086932Z",
     "shell.execute_reply.started": "2022-03-25T04:13:48.128799Z"
    },
    "id": "Usv9s-CuJSG7",
    "papermill": {
     "duration": 1714.177688,
     "end_time": "2022-03-25T05:17:45.087151",
     "exception": false,
     "start_time": "2022-03-25T04:49:10.909463",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Info]: Use cuda now!\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/lib/python3.7/site-packages/torch/utils/data/dataloader.py:481: UserWarning: This DataLoader will create 8 worker processes in total. Our suggested max number of worker in current system is 2, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n",
      "  cpuset_checked))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Info]: Finish loading data!\n",
      "[Info]: Finish creating model!\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Train: 100% 2000/2000 [00:54<00:00, 36.72 step/s, accuracy=0.12, loss=3.93, step=2000]\n",
      "Valid: 100% 5664/5667 [00:06<00:00, 870.19 uttr/s, accuracy=0.16, loss=4.04] \n",
      "Train: 100% 2000/2000 [00:44<00:00, 44.85 step/s, accuracy=0.19, loss=3.38, step=4000]\n",
      "Valid: 100% 5664/5667 [00:03<00:00, 1841.07 uttr/s, accuracy=0.27, loss=3.38]\n",
      "Train: 100% 2000/2000 [00:44<00:00, 44.78 step/s, accuracy=0.44, loss=2.40, step=6000]\n",
      "Valid: 100% 5664/5667 [00:02<00:00, 1906.77 uttr/s, accuracy=0.38, loss=2.79]\n",
      "Train: 100% 2000/2000 [00:48<00:00, 41.49 step/s, accuracy=0.59, loss=2.06, step=8000]\n",
      "Valid: 100% 5664/5667 [00:03<00:00, 1480.08 uttr/s, accuracy=0.41, loss=2.62]\n",
      "Train: 100% 2000/2000 [00:46<00:00, 43.42 step/s, accuracy=0.31, loss=2.75, step=1e+4]\n",
      "Valid: 100% 5664/5667 [00:03<00:00, 1752.25 uttr/s, accuracy=0.44, loss=2.49]\n",
      "Train:   0% 7/2000 [00:00<00:43, 45.75 step/s, accuracy=0.44, loss=2.58, step=1e+4]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Step 10000, best model saved. (accuracy=0.4449)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Train: 100% 2000/2000 [00:43<00:00, 45.60 step/s, accuracy=0.38, loss=2.57, step=12000]\n",
      "Valid: 100% 5664/5667 [00:02<00:00, 1965.75 uttr/s, accuracy=0.50, loss=2.22]\n",
      "Train: 100% 2000/2000 [00:47<00:00, 41.96 step/s, accuracy=0.38, loss=1.99, step=14000]\n",
      "Valid: 100% 5664/5667 [00:02<00:00, 2011.26 uttr/s, accuracy=0.51, loss=2.16]\n",
      "Train: 100% 2000/2000 [00:49<00:00, 40.66 step/s, accuracy=0.44, loss=2.41, step=16000]\n",
      "Valid: 100% 5664/5667 [00:03<00:00, 1729.24 uttr/s, accuracy=0.54, loss=2.03]\n",
      "Train: 100% 2000/2000 [00:42<00:00, 46.51 step/s, accuracy=0.69, loss=1.64, step=18000]\n",
      "Valid: 100% 5664/5667 [00:02<00:00, 1986.30 uttr/s, accuracy=0.55, loss=1.94]\n",
      "Train: 100% 2000/2000 [00:43<00:00, 46.02 step/s, accuracy=0.69, loss=1.35, step=2e+4]\n",
      "Valid: 100% 5664/5667 [00:02<00:00, 2011.16 uttr/s, accuracy=0.57, loss=1.86]\n",
      "Train:   0% 10/2000 [00:00<00:40, 49.50 step/s, accuracy=0.84, loss=0.99, step=2e+4]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Step 20000, best model saved. (accuracy=0.5749)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Train: 100% 2000/2000 [00:49<00:00, 40.50 step/s, accuracy=0.66, loss=1.53, step=22000]\n",
      "Valid: 100% 5664/5667 [00:02<00:00, 1984.89 uttr/s, accuracy=0.58, loss=1.83]\n",
      "Train: 100% 2000/2000 [00:43<00:00, 46.02 step/s, accuracy=0.62, loss=1.45, step=24000]\n",
      "Valid: 100% 5664/5667 [00:02<00:00, 2015.94 uttr/s, accuracy=0.60, loss=1.77]\n",
      "Train: 100% 2000/2000 [00:42<00:00, 46.66 step/s, accuracy=0.62, loss=1.45, step=26000]\n",
      "Valid: 100% 5664/5667 [00:02<00:00, 1980.89 uttr/s, accuracy=0.61, loss=1.68]\n",
      "Train: 100% 2000/2000 [00:52<00:00, 38.27 step/s, accuracy=0.69, loss=0.92, step=28000]\n",
      "Valid: 100% 5664/5667 [00:02<00:00, 2010.50 uttr/s, accuracy=0.61, loss=1.67]\n",
      "Train: 100% 2000/2000 [00:43<00:00, 46.29 step/s, accuracy=0.59, loss=1.51, step=3e+4]\n",
      "Valid: 100% 5664/5667 [00:02<00:00, 1958.17 uttr/s, accuracy=0.63, loss=1.62]\n",
      "Train:   0% 7/2000 [00:00<01:05, 30.47 step/s, accuracy=0.75, loss=1.34, step=3e+4]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Step 30000, best model saved. (accuracy=0.6296)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Train: 100% 2000/2000 [00:43<00:00, 46.10 step/s, accuracy=0.81, loss=0.66, step=32000]\n",
      "Valid: 100% 5664/5667 [00:03<00:00, 1509.12 uttr/s, accuracy=0.65, loss=1.54]\n",
      "Train: 100% 2000/2000 [00:53<00:00, 37.50 step/s, accuracy=0.59, loss=1.61, step=34000]\n",
      "Valid: 100% 5664/5667 [00:02<00:00, 1965.61 uttr/s, accuracy=0.65, loss=1.52]\n",
      "Train: 100% 2000/2000 [00:43<00:00, 45.96 step/s, accuracy=0.75, loss=1.09, step=36000]\n",
      "Valid: 100% 5664/5667 [00:02<00:00, 1997.34 uttr/s, accuracy=0.66, loss=1.46]\n",
      "Train: 100% 2000/2000 [00:43<00:00, 46.48 step/s, accuracy=0.84, loss=0.82, step=38000]\n",
      "Valid: 100% 5664/5667 [00:02<00:00, 1999.44 uttr/s, accuracy=0.66, loss=1.44]\n",
      "Train: 100% 2000/2000 [00:43<00:00, 46.40 step/s, accuracy=0.72, loss=1.10, step=4e+4]\n",
      "Valid: 100% 5664/5667 [00:02<00:00, 1944.79 uttr/s, accuracy=0.67, loss=1.41]\n",
      "Train:   0% 8/2000 [00:00<00:44, 45.05 step/s, accuracy=0.88, loss=0.59, step=4e+4]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Step 40000, best model saved. (accuracy=0.6744)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Train: 100% 2000/2000 [00:43<00:00, 46.01 step/s, accuracy=0.78, loss=0.80, step=42000]\n",
      "Valid: 100% 5664/5667 [00:03<00:00, 1794.08 uttr/s, accuracy=0.68, loss=1.36]\n",
      "Train: 100% 2000/2000 [00:42<00:00, 46.79 step/s, accuracy=0.69, loss=0.92, step=44000]\n",
      "Valid: 100% 5664/5667 [00:03<00:00, 1503.97 uttr/s, accuracy=0.68, loss=1.37]\n",
      "Train: 100% 2000/2000 [00:56<00:00, 35.34 step/s, accuracy=0.75, loss=0.91, step=46000]\n",
      "Valid: 100% 5664/5667 [00:02<00:00, 2009.71 uttr/s, accuracy=0.69, loss=1.33]\n",
      "Train: 100% 2000/2000 [00:42<00:00, 46.59 step/s, accuracy=0.78, loss=0.63, step=48000]\n",
      "Valid: 100% 5664/5667 [00:02<00:00, 1940.80 uttr/s, accuracy=0.70, loss=1.31]\n",
      "Train: 100% 2000/2000 [00:42<00:00, 46.75 step/s, accuracy=0.81, loss=0.50, step=5e+4]\n",
      "Valid: 100% 5664/5667 [00:03<00:00, 1832.74 uttr/s, accuracy=0.72, loss=1.24]\n",
      "Train:   0% 10/2000 [00:00<00:41, 48.47 step/s, accuracy=0.81, loss=0.83, step=5e+4]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Step 50000, best model saved. (accuracy=0.7159)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Train: 100% 2000/2000 [00:43<00:00, 45.80 step/s, accuracy=0.91, loss=0.46, step=52000]\n",
      "Valid: 100% 5664/5667 [00:03<00:00, 1472.86 uttr/s, accuracy=0.71, loss=1.25]\n",
      "Train: 100% 2000/2000 [00:43<00:00, 46.35 step/s, accuracy=0.78, loss=1.08, step=54000]\n",
      "Valid: 100% 5664/5667 [00:02<00:00, 2040.31 uttr/s, accuracy=0.72, loss=1.22]\n",
      "Train: 100% 2000/2000 [00:43<00:00, 46.01 step/s, accuracy=0.72, loss=0.85, step=56000]\n",
      "Valid: 100% 5664/5667 [00:04<00:00, 1187.31 uttr/s, accuracy=0.71, loss=1.23]\n",
      "Train: 100% 2000/2000 [00:59<00:00, 33.85 step/s, accuracy=0.91, loss=0.49, step=58000]\n",
      "Valid: 100% 5664/5667 [00:02<00:00, 2030.19 uttr/s, accuracy=0.73, loss=1.17]\n",
      "Train: 100% 2000/2000 [00:42<00:00, 46.94 step/s, accuracy=0.69, loss=1.23, step=6e+4]\n",
      "Valid: 100% 5664/5667 [00:02<00:00, 2018.07 uttr/s, accuracy=0.73, loss=1.21]\n",
      "Train:   0% 10/2000 [00:00<00:41, 47.61 step/s, accuracy=0.81, loss=0.49, step=6e+4]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Step 60000, best model saved. (accuracy=0.7290)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Train: 100% 2000/2000 [00:43<00:00, 46.11 step/s, accuracy=0.91, loss=0.37, step=62000]\n",
      "Valid: 100% 5664/5667 [00:03<00:00, 1843.34 uttr/s, accuracy=0.73, loss=1.15]\n",
      "Train: 100% 2000/2000 [00:42<00:00, 46.61 step/s, accuracy=0.97, loss=0.35, step=64000]\n",
      "Valid: 100% 5664/5667 [00:03<00:00, 1801.99 uttr/s, accuracy=0.73, loss=1.17]\n",
      "Train: 100% 2000/2000 [00:43<00:00, 45.98 step/s, accuracy=0.91, loss=0.52, step=66000]\n",
      "Valid: 100% 5664/5667 [00:02<00:00, 1982.80 uttr/s, accuracy=0.73, loss=1.18]\n",
      "Train: 100% 2000/2000 [00:42<00:00, 46.70 step/s, accuracy=0.91, loss=0.52, step=68000]\n",
      "Valid: 100% 5664/5667 [00:02<00:00, 2020.12 uttr/s, accuracy=0.73, loss=1.18]\n",
      "Train: 100% 2000/2000 [00:42<00:00, 46.79 step/s, accuracy=0.84, loss=0.63, step=7e+4]\n",
      "Valid: 100% 5664/5667 [00:03<00:00, 1855.86 uttr/s, accuracy=0.73, loss=1.18]\n",
      "Train:   0% 0/2000 [00:00<?, ? step/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Step 70000, best model saved. (accuracy=0.7343)\n"
     ]
    }
   ],
   "source": [
    "from tqdm import tqdm\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.optim import AdamW\n",
    "from torch.utils.data import DataLoader, random_split\n",
    "\n",
    "\n",
    "def parse_args():\n",
    "\t\"\"\"arguments\"\"\"\n",
    "\tconfig = {\n",
    "\t\t\"data_dir\": \"../input/ml2022spring-hw4/Dataset\",\n",
    "\t\t\"save_path\": \"model.ckpt\",\n",
    "\t\t\"batch_size\": 32,\n",
    "\t\t\"n_workers\": 8,\n",
    "\t\t\"valid_steps\": 2000,\n",
    "\t\t\"warmup_steps\": 1000,\n",
    "\t\t\"save_steps\": 10000,\n",
    "\t\t\"total_steps\": 70000,\n",
    "\t}\n",
    "\n",
    "\treturn config\n",
    "\n",
    "\n",
    "def main(\n",
    "\tdata_dir,\n",
    "\tsave_path,\n",
    "\tbatch_size,\n",
    "\tn_workers,\n",
    "\tvalid_steps,\n",
    "\twarmup_steps,\n",
    "\ttotal_steps,\n",
    "\tsave_steps,\n",
    "):\n",
    "\t\"\"\"Main function.\"\"\"\n",
    "\tdevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\tprint(f\"[Info]: Use {device} now!\")\n",
    "\n",
    "\ttrain_loader, valid_loader, speaker_num = get_dataloader(data_dir, batch_size, n_workers)\n",
    "\ttrain_iterator = iter(train_loader)\n",
    "\tprint(f\"[Info]: Finish loading data!\",flush = True)\n",
    "\n",
    "\tmodel = Classifier(n_spks=speaker_num).to(device)\n",
    "\tcriterion = nn.CrossEntropyLoss()\n",
    "\toptimizer = AdamW(model.parameters(), lr=1e-3)\n",
    "\tscheduler = get_cosine_schedule_with_warmup(optimizer, warmup_steps, total_steps)\n",
    "\tprint(f\"[Info]: Finish creating model!\",flush = True)\n",
    "\n",
    "\tbest_accuracy = -1.0\n",
    "\tbest_state_dict = None\n",
    "\n",
    "\tpbar = tqdm(total=valid_steps, ncols=0, desc=\"Train\", unit=\" step\")\n",
    "\n",
    "\tfor step in range(total_steps):\n",
    "\t\t# Get data\n",
    "\t\ttry:\n",
    "\t\t\tbatch = next(train_iterator)\n",
    "\t\texcept StopIteration:\n",
    "\t\t\ttrain_iterator = iter(train_loader)\n",
    "\t\t\tbatch = next(train_iterator)\n",
    "\n",
    "\t\tloss, accuracy = model_fn(batch, model, criterion, device)\n",
    "\t\tbatch_loss = loss.item()\n",
    "\t\tbatch_accuracy = accuracy.item()\n",
    "\n",
    "\t\t# Updata model\n",
    "\t\tloss.backward()\n",
    "\t\toptimizer.step()\n",
    "\t\tscheduler.step()\n",
    "\t\toptimizer.zero_grad()\n",
    "\n",
    "\t\t# Log\n",
    "\t\tpbar.update()\n",
    "\t\tpbar.set_postfix(\n",
    "\t\t\tloss=f\"{batch_loss:.2f}\",\n",
    "\t\t\taccuracy=f\"{batch_accuracy:.2f}\",\n",
    "\t\t\tstep=step + 1,\n",
    "\t\t)\n",
    "\n",
    "\t\t# Do validation\n",
    "\t\tif (step + 1) % valid_steps == 0:\n",
    "\t\t\tpbar.close()\n",
    "\n",
    "\t\t\tvalid_accuracy = valid(valid_loader, model, criterion, device)\n",
    "\n",
    "\t\t\t# keep the best model\n",
    "\t\t\tif valid_accuracy > best_accuracy:\n",
    "\t\t\t\tbest_accuracy = valid_accuracy\n",
    "\t\t\t\tbest_state_dict = model.state_dict()\n",
    "\n",
    "\t\t\tpbar = tqdm(total=valid_steps, ncols=0, desc=\"Train\", unit=\" step\")\n",
    "\n",
    "\t\t# Save the best model so far.\n",
    "\t\tif (step + 1) % save_steps == 0 and best_state_dict is not None:\n",
    "\t\t\ttorch.save(best_state_dict, save_path)\n",
    "\t\t\tpbar.write(f\"Step {step + 1}, best model saved. (accuracy={best_accuracy:.4f})\")\n",
    "\n",
    "\tpbar.close()\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "\tmain(**parse_args())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae9c3a09",
   "metadata": {
    "id": "NLatBYAhNNMx",
    "papermill": {
     "duration": 29.407624,
     "end_time": "2022-03-25T05:18:43.989344",
     "exception": false,
     "start_time": "2022-03-25T05:18:14.581720",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Inference\n",
    "\n",
    "## Dataset of inference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "9535edb9",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-03-25T05:19:42.593631Z",
     "iopub.status.busy": "2022-03-25T05:19:42.592771Z",
     "iopub.status.idle": "2022-03-25T05:19:42.594621Z",
     "shell.execute_reply": "2022-03-25T05:19:42.595025Z",
     "shell.execute_reply.started": "2022-03-25T04:37:32.972635Z"
    },
    "id": "efS4pCmAJXJH",
    "papermill": {
     "duration": 29.331191,
     "end_time": "2022-03-25T05:19:42.595174",
     "exception": false,
     "start_time": "2022-03-25T05:19:13.263983",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import json\n",
    "import torch\n",
    "from pathlib import Path\n",
    "from torch.utils.data import Dataset\n",
    "\n",
    "\n",
    "class InferenceDataset(Dataset):\n",
    "\tdef __init__(self, data_dir):\n",
    "\t\ttestdata_path = Path(data_dir) / \"testdata.json\"\n",
    "\t\tmetadata = json.load(testdata_path.open())\n",
    "\t\tself.data_dir = data_dir\n",
    "\t\tself.data = metadata[\"utterances\"]\n",
    "\n",
    "\tdef __len__(self):\n",
    "\t\treturn len(self.data)\n",
    "\n",
    "\tdef __getitem__(self, index):\n",
    "\t\tutterance = self.data[index]\n",
    "\t\tfeat_path = utterance[\"feature_path\"]\n",
    "\t\tmel = torch.load(os.path.join(self.data_dir, feat_path))\n",
    "\n",
    "\t\treturn feat_path, mel\n",
    "\n",
    "\n",
    "def inference_collate_batch(batch):\n",
    "\t\"\"\"Collate a batch of data.\"\"\"\n",
    "\tfeat_paths, mels = zip(*batch)\n",
    "\n",
    "\treturn feat_paths, torch.stack(mels)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4bd25b42",
   "metadata": {
    "id": "tl0WnYwxNK_S",
    "papermill": {
     "duration": 29.432408,
     "end_time": "2022-03-25T05:20:41.567974",
     "exception": false,
     "start_time": "2022-03-25T05:20:12.135566",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Main funcrion of Inference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d57390b5",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-03-25T05:21:40.430441Z",
     "iopub.status.busy": "2022-03-25T05:21:40.429603Z",
     "iopub.status.idle": "2022-03-25T05:22:06.800454Z",
     "shell.execute_reply": "2022-03-25T05:22:06.799974Z",
     "shell.execute_reply.started": "2022-03-25T04:38:59.415747Z"
    },
    "id": "i8SAbuXEJb2A",
    "papermill": {
     "duration": 55.912573,
     "end_time": "2022-03-25T05:22:06.800579",
     "exception": false,
     "start_time": "2022-03-25T05:21:10.888006",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Info]: Use cuda now!\n",
      "[Info]: Finish loading data!\n",
      "[Info]: Finish creating model!\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "cfa16dc5eb924b1c88e8d0e283d6acaa",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/8000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import json\n",
    "import csv\n",
    "from pathlib import Path\n",
    "from tqdm.notebook import tqdm\n",
    "\n",
    "import torch\n",
    "from torch.utils.data import DataLoader\n",
    "\n",
    "def parse_args():\n",
    "\t\"\"\"arguments\"\"\"  \n",
    "\tconfig = {\n",
    "\t\t\"data_dir\": \"../input/ml2022spring-hw4/Dataset\",\n",
    "\t\t\"model_path\": \"model.ckpt\",\n",
    "\t\t\"output_path\": \"output.csv\",\n",
    "\t}\n",
    "\n",
    "\treturn config\n",
    "\n",
    "\n",
    "def main(\n",
    "\tdata_dir,\n",
    "\tmodel_path,\n",
    "\toutput_path,\n",
    "):\n",
    "\t\"\"\"Main function.\"\"\"\n",
    "\tdevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\tprint(f\"[Info]: Use {device} now!\")\n",
    "\n",
    "\tmapping_path = Path(data_dir) / \"mapping.json\"\n",
    "\tmapping = json.load(mapping_path.open())\n",
    "\n",
    "\tdataset = InferenceDataset(data_dir)\n",
    "\tdataloader = DataLoader(\n",
    "\t\tdataset,\n",
    "\t\tbatch_size=1,\n",
    "\t\tshuffle=False,\n",
    "\t\tdrop_last=False,\n",
    "\t\tnum_workers=8,\n",
    "\t\tcollate_fn=inference_collate_batch,\n",
    "\t)\n",
    "\tprint(f\"[Info]: Finish loading data!\",flush = True)\n",
    "\n",
    "\tspeaker_num = len(mapping[\"id2speaker\"])\n",
    "\tmodel = Classifier(n_spks=speaker_num).to(device)\n",
    "\tmodel.load_state_dict(torch.load(model_path))\n",
    "\tmodel.eval()\n",
    "\tprint(f\"[Info]: Finish creating model!\",flush = True)\n",
    "\n",
    "\tresults = [[\"Id\", \"Category\"]]\n",
    "\tfor feat_paths, mels in tqdm(dataloader):\n",
    "\t\twith torch.no_grad():\n",
    "\t\t\tmels = mels.to(device)\n",
    "\t\t\touts = model(mels)\n",
    "\t\t\tpreds = outs.argmax(1).cpu().numpy()\n",
    "\t\t\tfor feat_path, pred in zip(feat_paths, preds):\n",
    "\t\t\t\tresults.append([feat_path, mapping[\"id2speaker\"][str(pred)]])\n",
    "\n",
    "\twith open(output_path, 'w', newline='') as csvfile:\n",
    "\t\twriter = csv.writer(csvfile)\n",
    "\t\twriter.writerows(results)\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "\tmain(**parse_args())"
   ]
  }
 ],
 "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.12"
  },
  "papermill": {
   "default_parameters": {},
   "duration": 2016.975461,
   "end_time": "2022-03-25T05:22:37.214954",
   "environment_variables": {},
   "exception": null,
   "input_path": "__notebook__.ipynb",
   "output_path": "__notebook__.ipynb",
   "parameters": {},
   "start_time": "2022-03-25T04:49:00.239493",
   "version": "2.3.3"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {
     "1ba4272ca8f34cf680198d183501b5ac": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "DescriptionStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "description_width": ""
      }
     },
     "2b739d7363854eb2bc4215c7a9d1fd64": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "FloatProgressModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "FloatProgressModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "ProgressView",
       "bar_style": "success",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_89d63163a3e1481f8f66f423ac9e9215",
       "max": 8000.0,
       "min": 0.0,
       "orientation": "horizontal",
       "style": "IPY_MODEL_d124bf7b7f4c4bdd97b30e4430278d72",
       "value": 8000.0
      }
     },
     "76bbb7fc8804471ebc81424c9d03bdb9": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HTMLModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HTMLModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HTMLView",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_a9a01c6aa5ab4c3a8f7f027d01732af9",
       "placeholder": "​",
       "style": "IPY_MODEL_d5e17146360048baa2cf5f073ef0001e",
       "value": "100%"
      }
     },
     "805c32e80edf4d6ea3806b72083ecfcc": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "89d63163a3e1481f8f66f423ac9e9215": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "a9a01c6aa5ab4c3a8f7f027d01732af9": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "cfa16dc5eb924b1c88e8d0e283d6acaa": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HBoxModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HBoxModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HBoxView",
       "box_style": "",
       "children": [
        "IPY_MODEL_76bbb7fc8804471ebc81424c9d03bdb9",
        "IPY_MODEL_2b739d7363854eb2bc4215c7a9d1fd64",
        "IPY_MODEL_e990e723d3254f8c8f934df1423f38a2"
       ],
       "layout": "IPY_MODEL_805c32e80edf4d6ea3806b72083ecfcc"
      }
     },
     "d124bf7b7f4c4bdd97b30e4430278d72": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ProgressStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "ProgressStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "bar_color": null,
       "description_width": ""
      }
     },
     "d5e17146360048baa2cf5f073ef0001e": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "DescriptionStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "description_width": ""
      }
     },
     "e0645cba32de4a5ba0d76f4c867bedad": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "e990e723d3254f8c8f934df1423f38a2": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HTMLModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HTMLModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HTMLView",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_e0645cba32de4a5ba0d76f4c867bedad",
       "placeholder": "​",
       "style": "IPY_MODEL_1ba4272ca8f34cf680198d183501b5ac",
       "value": " 8000/8000 [00:26&lt;00:00, 318.83it/s]"
      }
     }
    },
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}