generator_transformer_cond.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x7f0d901ba590>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "from data.process_data import MidiEncoder, MIDIEncoderREMI\n",
    "import pickle as pkl\n",
    "from torch.utils.data import DataLoader\n",
    "from data.dataset import TransformerDatasetREMI\n",
    "import numpy as np\n",
    "import glob\n",
    "import torch\n",
    "torch.manual_seed(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "path_to_midi = \"data/emopia/EMOPIA_2.2/midis/\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Instantiate your MidiEncoder and MidiEncoderREMI\n",
    "midi_files_list = [os.path.join(path_to_midi, file) for file in os.listdir(path_to_midi) if file.endswith(\".mid\")]\n",
    "midi_encoder = MidiEncoder(steps_per_sec=100, num_vel_bins=32, min_pitch=21, max_pitch=108)\n",
    "midi_encoder_remi = MIDIEncoderREMI(dict_path=\"data/encoder_dict.pkl\", midi_files_list=midi_files_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# encoded_sequences_path = \"data/encoded_sequences.pkl\"\n",
    "# encoded_sequences = midi_encoder.encode_midi_list(midi_files_list, pkl_path=encoded_sequences_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now create the dataset and save it in a NumPy file\n",
    "dataset_path = \"data/datasets/\"\n",
    "# midi_encoder_remi.save_dataset(midi_files_list, dataset_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Save the dataset as a single file\n",
    "single_file_dataset_path = \"data/single_file_dataset.npz\"\n",
    "# midi_encoder_remi.save_dataset_as_single_file(glob.glob(os.path.join(dataset_path, '*.npy')), single_file_dataset_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/workspaces/ece661-final-proj2/data/dataset.py:239: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at ../torch/csrc/utils/tensor_new.cpp:261.)\n",
      "  self.sequences = torch.Tensor(self.sequences)\n"
     ]
    }
   ],
   "source": [
    "from data.dataset import ClassifierDataset\n",
    "max_seq_len = 256\n",
    "classifier_dataset = ClassifierDataset(single_file_dataset_path, seq_len=max_seq_len+1, labels_path=\"data/emopia/EMOPIA_2.2/label.csv\")\n",
    "train_size = int(0.7 * len(classifier_dataset))\n",
    "valid_size = int(0.15 * len(classifier_dataset))\n",
    "test_size = len(classifier_dataset) - train_size - valid_size\n",
    "train_dataset, valid_dataset, test_dataset = torch.utils.data.random_split(classifier_dataset, [train_size, valid_size, test_size])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=False, drop_last=True)\n",
    "valid_dataloader = DataLoader(valid_dataset, batch_size=batch_size, shuffle=False, drop_last=True)\n",
    "test_dataloader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False, drop_last=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "vocab_set = set()\n",
    "for dic in train_dataset:\n",
    "    ipt = dic['input'].numpy()\n",
    "    vocab_set = vocab_set.union(set(ipt))\n",
    "vocab_size = len(vocab_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Q1, Q2, Q3, Q4 = [], [], [], []\n",
    "# for dic in classifier_dataset:\n",
    "#     label = dic['target']\n",
    "#     if label == 0:\n",
    "#         Q1.append(dic)\n",
    "#     elif label == 1:\n",
    "#         Q2.append(dic)\n",
    "#     elif label == 2:\n",
    "#         Q3.append(dic)\n",
    "#     elif label == 3:\n",
    "#         Q4.append(dic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# classifier_valid = {'Q1': Q1, 'Q2': Q2, 'Q3': Q3, 'Q4': Q4}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "import torch\n",
    "from torch import nn, Tensor\n",
    "from torch.nn import TransformerEncoder, TransformerEncoderLayer, Embedding\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MultiHeadAttention(nn.Module):\n",
    "    def __init__(self, d_model, num_heads):\n",
    "        super(MultiHeadAttention, self).__init__()\n",
    "        assert d_model % num_heads == 0, \"d_model must be divisible by num_heads\"\n",
    "        \n",
    "        self.d_model = d_model\n",
    "        self.num_heads = num_heads\n",
    "        self.d_k = d_model // num_heads\n",
    "        \n",
    "        self.W_q = nn.Linear(d_model, d_model)\n",
    "        self.W_k = nn.Linear(d_model, d_model)\n",
    "        self.W_v = nn.Linear(d_model, d_model)\n",
    "        self.W_o = nn.Linear(d_model, d_model)\n",
    "        \n",
    "    def scaled_dot_product_attention(self, Q, K, V, mask=None):\n",
    "        attn_scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)\n",
    "        if mask is not None:\n",
    "            attn_scores = attn_scores.masked_fill(mask == 0, -1e9)\n",
    "        attn_probs = torch.softmax(attn_scores, dim=-1)\n",
    "        output = torch.matmul(attn_probs, V)\n",
    "        return output\n",
    "        \n",
    "    def split_heads(self, x):\n",
    "        batch_size, seq_length, d_model = x.size()\n",
    "        return x.view(batch_size, seq_length, self.num_heads, self.d_k).transpose(1, 2)\n",
    "        \n",
    "    def combine_heads(self, x):\n",
    "        batch_size, _, seq_length, d_k = x.size()\n",
    "        return x.transpose(1, 2).contiguous().view(batch_size, seq_length, self.d_model)\n",
    "        \n",
    "    def forward(self, Q, K, V, mask=None):\n",
    "        Q = self.split_heads(self.W_q(Q))\n",
    "        K = self.split_heads(self.W_k(K))\n",
    "        V = self.split_heads(self.W_v(V))\n",
    "        \n",
    "        attn_output = self.scaled_dot_product_attention(Q, K, V, mask)\n",
    "        output = self.W_o(self.combine_heads(attn_output))\n",
    "        return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PositionWiseFeedForward(nn.Module):\n",
    "    def __init__(self, d_model, d_ff):\n",
    "        super(PositionWiseFeedForward, self).__init__()\n",
    "        self.fc1 = nn.Linear(d_model, d_ff)\n",
    "        self.fc2 = nn.Linear(d_ff, d_model)\n",
    "        self.relu = nn.ReLU()\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.fc2(self.relu(self.fc1(x)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PositionalEncoding(nn.Module):\n",
    "    def __init__(self, d_model, max_seq_length):\n",
    "        super(PositionalEncoding, self).__init__()\n",
    "        \n",
    "        pe = torch.zeros(max_seq_length, d_model)\n",
    "        position = torch.arange(0, max_seq_length, dtype=torch.float).unsqueeze(1)\n",
    "        div_term = torch.exp(torch.arange(0, d_model, 2).float() * -(math.log(10000.0) / d_model))\n",
    "        \n",
    "        pe[:, 0::2] = torch.sin(position * div_term)\n",
    "        pe[:, 1::2] = torch.cos(position * div_term)\n",
    "        \n",
    "        self.register_buffer('pe', pe.unsqueeze(0))\n",
    "        \n",
    "    def forward(self, x):\n",
    "        return x + self.pe[:, :x.size(1)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class EncoderLayer(nn.Module):\n",
    "    def __init__(self, d_model, num_heads, d_ff, dropout):\n",
    "        super(EncoderLayer, self).__init__()\n",
    "        self.self_attn = MultiHeadAttention(d_model, num_heads)\n",
    "        self.feed_forward = PositionWiseFeedForward(d_model, d_ff)\n",
    "        self.norm1 = nn.LayerNorm(d_model)\n",
    "        self.norm2 = nn.LayerNorm(d_model)\n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "        \n",
    "    def forward(self, x, mask):\n",
    "        attn_output = self.self_attn(x, x, x, mask)\n",
    "        x = self.norm1(x + self.dropout(attn_output))\n",
    "        ff_output = self.feed_forward(x)\n",
    "        x = self.norm2(x + self.dropout(ff_output))\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DecoderLayer(nn.Module):\n",
    "    def __init__(self, d_model, num_heads, d_ff, dropout):\n",
    "        super(DecoderLayer, self).__init__()\n",
    "        self.self_attn = MultiHeadAttention(d_model, num_heads)\n",
    "        self.cross_attn = MultiHeadAttention(d_model, num_heads)\n",
    "        self.feed_forward = PositionWiseFeedForward(d_model, d_ff)\n",
    "        self.norm1 = nn.LayerNorm(d_model)\n",
    "        self.norm2 = nn.LayerNorm(d_model)\n",
    "        self.norm3 = nn.LayerNorm(d_model)\n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "        \n",
    "    def forward(self, x, enc_output, src_mask, tgt_mask):\n",
    "        attn_output = self.self_attn(x, x, x, tgt_mask)\n",
    "        x = self.norm1(x + self.dropout(attn_output))\n",
    "        attn_output = self.cross_attn(x, enc_output, enc_output, src_mask)\n",
    "        x = self.norm2(x + self.dropout(attn_output))\n",
    "        ff_output = self.feed_forward(x)\n",
    "        x = self.norm3(x + self.dropout(ff_output))\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Transformer(nn.Module):\n",
    "    def __init__(self, src_vocab_size, tgt_vocab_size, d_model, num_heads, num_layers, d_ff, max_seq_length, dropout, num_emotions):\n",
    "        super(Transformer, self).__init__()\n",
    "        self.encoder_embedding = nn.Embedding(src_vocab_size, d_model)\n",
    "        self.decoder_embedding = nn.Embedding(tgt_vocab_size, d_model)\n",
    "        self.positional_encoding = PositionalEncoding(d_model, max_seq_length)\n",
    "        self.emotion_embedding = nn.Embedding(num_emotions, d_model)\n",
    "\n",
    "        self.encoder_layers = nn.ModuleList([EncoderLayer(d_model, num_heads, d_ff, dropout) for _ in range(num_layers)])\n",
    "        self.decoder_layers = nn.ModuleList([DecoderLayer(d_model, num_heads, d_ff, dropout) for _ in range(num_layers)])\n",
    "        self.fc = nn.Linear(d_model, tgt_vocab_size)\n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "\n",
    "    def generate_mask(self, src, tgt):\n",
    "        src_mask = (src != 0).unsqueeze(1).unsqueeze(2)\n",
    "        tgt_mask = (tgt != 0).unsqueeze(1).unsqueeze(3)\n",
    "        seq_length = tgt.size(1)\n",
    "        nopeak_mask = (1 - torch.triu(torch.ones(1, seq_length, seq_length), diagonal=1)).bool().to(device)\n",
    "        tgt_mask = tgt_mask & nopeak_mask\n",
    "        return src_mask, tgt_mask\n",
    "\n",
    "    def forward(self, src, tgt, emotion):\n",
    "        src_mask, tgt_mask = self.generate_mask(src, tgt)\n",
    "        src_embedded = self.dropout(self.positional_encoding(self.encoder_embedding(src)) + self.emotion_embedding(emotion).unsqueeze(1))\n",
    "        tgt_embedded = self.dropout(self.positional_encoding(self.decoder_embedding(tgt)) + self.emotion_embedding(emotion).unsqueeze(1))\n",
    "\n",
    "        enc_output = src_embedded\n",
    "        for enc_layer in self.encoder_layers:\n",
    "            enc_output = enc_layer(enc_output, src_mask)\n",
    "\n",
    "        dec_output = tgt_embedded\n",
    "        for dec_layer in self.decoder_layers:\n",
    "            dec_output = dec_layer(dec_output, enc_output, src_mask, tgt_mask)\n",
    "\n",
    "        output = self.fc(dec_output)\n",
    "        return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "src_vocab_size = vocab_size\n",
    "tgt_vocab_size = vocab_size\n",
    "d_model = 512\n",
    "num_heads = 8\n",
    "num_layers = 6\n",
    "d_ff = 256\n",
    "max_seq_length = max_seq_len\n",
    "dropout = 0.2\n",
    "epochs = 100\n",
    "num_emotions = 4\n",
    "\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "transformer = Transformer(src_vocab_size, tgt_vocab_size, d_model, num_heads, num_layers, d_ff, max_seq_length, dropout, num_emotions).to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def early_stopping(val_loss, epoch,best_loss,epochs_no_improve, patience=10, checkpoint_dir=\"checkpoints/transformer_ende_cond.pt\"):\n",
    "    if epoch == 0:\n",
    "        torch.save(transformer.state_dict(), checkpoint_dir)\n",
    "        best_loss = val_loss\n",
    "        epochs_no_improve = 0\n",
    "        return False, best_loss, epochs_no_improve\n",
    "    else:\n",
    "        if val_loss < best_loss:\n",
    "            torch.save(transformer.state_dict(), checkpoint_dir)\n",
    "            print(f\"Saved model at epoch { epoch } with validation loss of {val_loss}\")\n",
    "            best_loss = val_loss\n",
    "            epochs_no_improve = 0\n",
    "            return False, best_loss, epochs_no_improve\n",
    "        else:\n",
    "            epochs_no_improve += 1\n",
    "            if epochs_no_improve >= patience:\n",
    "                print('Early stopping!')\n",
    "                return True, best_loss, epochs_no_improve\n",
    "            else:\n",
    "                return False, best_loss, epochs_no_improve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: [ 0 / 100 ]; TrainLoss: 4.24239; ValidLoss: 3.90111\n",
      "Epoch: [ 1 / 100 ]; TrainLoss: 3.30567; ValidLoss: 2.76626\n",
      "Saved model at epoch 1 with validation loss of 2.7662564624439585\n",
      "Epoch: [ 2 / 100 ]; TrainLoss: 2.67443; ValidLoss: 2.45917\n",
      "Saved model at epoch 2 with validation loss of 2.4591685208407315\n",
      "Epoch: [ 3 / 100 ]; TrainLoss: 2.33260; ValidLoss: 2.14814\n",
      "Saved model at epoch 3 with validation loss of 2.148142771287398\n",
      "Epoch: [ 4 / 100 ]; TrainLoss: 2.10476; ValidLoss: 1.96406\n",
      "Saved model at epoch 4 with validation loss of 1.9640643271532925\n",
      "Epoch: [ 5 / 100 ]; TrainLoss: 1.92551; ValidLoss: 1.79616\n",
      "Saved model at epoch 5 with validation loss of 1.796158324588429\n",
      "Epoch: [ 6 / 100 ]; TrainLoss: 1.78548; ValidLoss: 1.65536\n",
      "Saved model at epoch 6 with validation loss of 1.6553636139089412\n",
      "Epoch: [ 7 / 100 ]; TrainLoss: 1.66985; ValidLoss: 1.52068\n",
      "Saved model at epoch 7 with validation loss of 1.5206848057833584\n",
      "Epoch: [ 8 / 100 ]; TrainLoss: 1.55711; ValidLoss: 1.39441\n",
      "Saved model at epoch 8 with validation loss of 1.394412333315069\n",
      "Epoch: [ 9 / 100 ]; TrainLoss: 1.45729; ValidLoss: 1.27318\n",
      "Saved model at epoch 9 with validation loss of 1.2731836167248813\n",
      "Epoch: [ 10 / 100 ]; TrainLoss: 1.35422; ValidLoss: 1.15796\n",
      "Saved model at epoch 10 with validation loss of 1.157955830747431\n",
      "Epoch: [ 11 / 100 ]; TrainLoss: 1.25463; ValidLoss: 1.02562\n",
      "Saved model at epoch 11 with validation loss of 1.0256217067891902\n",
      "Epoch: [ 12 / 100 ]; TrainLoss: 1.15437; ValidLoss: 0.92657\n",
      "Saved model at epoch 12 with validation loss of 0.9265724149617282\n",
      "Epoch: [ 13 / 100 ]; TrainLoss: 1.06541; ValidLoss: 0.79353\n",
      "Saved model at epoch 13 with validation loss of 0.7935340133580294\n",
      "Epoch: [ 14 / 100 ]; TrainLoss: 0.99146; ValidLoss: 0.70912\n",
      "Saved model at epoch 14 with validation loss of 0.7091230587525801\n",
      "Epoch: [ 15 / 100 ]; TrainLoss: 0.92156; ValidLoss: 0.64200\n",
      "Saved model at epoch 15 with validation loss of 0.6419982205737721\n",
      "Epoch: [ 16 / 100 ]; TrainLoss: 0.86307; ValidLoss: 0.55787\n",
      "Saved model at epoch 16 with validation loss of 0.5578745007514954\n",
      "Epoch: [ 17 / 100 ]; TrainLoss: 0.79886; ValidLoss: 0.56194\n",
      "Epoch: [ 18 / 100 ]; TrainLoss: 0.76147; ValidLoss: 0.48462\n",
      "Saved model at epoch 18 with validation loss of 0.4846229580315677\n",
      "Epoch: [ 19 / 100 ]; TrainLoss: 0.70695; ValidLoss: 0.43917\n",
      "Saved model at epoch 19 with validation loss of 0.4391748986460946\n",
      "Epoch: [ 20 / 100 ]; TrainLoss: 0.66739; ValidLoss: 0.36537\n",
      "Saved model at epoch 20 with validation loss of 0.36537166888063605\n",
      "Epoch: [ 21 / 100 ]; TrainLoss: 0.61941; ValidLoss: 0.34686\n",
      "Saved model at epoch 21 with validation loss of 0.3468633619221774\n",
      "Epoch: [ 22 / 100 ]; TrainLoss: 0.57525; ValidLoss: 0.32918\n",
      "Saved model at epoch 22 with validation loss of 0.3291819231076674\n",
      "Epoch: [ 23 / 100 ]; TrainLoss: 0.55052; ValidLoss: 0.25525\n",
      "Saved model at epoch 23 with validation loss of 0.25525252385572955\n",
      "Epoch: [ 24 / 100 ]; TrainLoss: 0.52334; ValidLoss: 0.33700\n",
      "Epoch: [ 25 / 100 ]; TrainLoss: 0.48664; ValidLoss: 0.25220\n",
      "Saved model at epoch 25 with validation loss of 0.2522034292871302\n",
      "Epoch: [ 26 / 100 ]; TrainLoss: 0.46925; ValidLoss: 0.21365\n",
      "Saved model at epoch 26 with validation loss of 0.21365190094167535\n",
      "Epoch: [ 27 / 100 ]; TrainLoss: 0.44879; ValidLoss: 0.19291\n",
      "Saved model at epoch 27 with validation loss of 0.19290770454840225\n",
      "Epoch: [ 28 / 100 ]; TrainLoss: 0.42095; ValidLoss: 0.28333\n",
      "Epoch: [ 29 / 100 ]; TrainLoss: 0.39199; ValidLoss: 0.18755\n",
      "Saved model at epoch 29 with validation loss of 0.18754828518087213\n",
      "Epoch: [ 30 / 100 ]; TrainLoss: 0.37514; ValidLoss: 0.15133\n",
      "Saved model at epoch 30 with validation loss of 0.15133358538150787\n",
      "Epoch: [ 31 / 100 ]; TrainLoss: 0.35069; ValidLoss: 0.11003\n",
      "Saved model at epoch 31 with validation loss of 0.11003400588577444\n",
      "Epoch: [ 32 / 100 ]; TrainLoss: 0.33905; ValidLoss: 0.21110\n",
      "Epoch: [ 33 / 100 ]; TrainLoss: 0.32392; ValidLoss: 0.26180\n",
      "Epoch: [ 34 / 100 ]; TrainLoss: 0.29561; ValidLoss: 0.10834\n",
      "Saved model at epoch 34 with validation loss of 0.10834299502047626\n",
      "Epoch: [ 35 / 100 ]; TrainLoss: 0.27036; ValidLoss: 0.11256\n",
      "Epoch: [ 36 / 100 ]; TrainLoss: 0.25655; ValidLoss: 0.16012\n",
      "Epoch: [ 37 / 100 ]; TrainLoss: 0.23984; ValidLoss: 0.08210\n",
      "Saved model at epoch 37 with validation loss of 0.08209903199564327\n",
      "Epoch: [ 38 / 100 ]; TrainLoss: 0.22328; ValidLoss: 0.08866\n",
      "Epoch: [ 39 / 100 ]; TrainLoss: 0.21394; ValidLoss: 0.14894\n",
      "Epoch: [ 40 / 100 ]; TrainLoss: 0.18503; ValidLoss: 0.13780\n",
      "Epoch: [ 41 / 100 ]; TrainLoss: 0.17345; ValidLoss: 0.14370\n",
      "Epoch: [ 42 / 100 ]; TrainLoss: 0.15712; ValidLoss: 0.09483\n",
      "Epoch: [ 43 / 100 ]; TrainLoss: 0.13813; ValidLoss: 0.05995\n",
      "Saved model at epoch 43 with validation loss of 0.05995196950706569\n",
      "Epoch: [ 44 / 100 ]; TrainLoss: 0.12438; ValidLoss: 0.02193\n",
      "Saved model at epoch 44 with validation loss of 0.021932721984657375\n",
      "Epoch: [ 45 / 100 ]; TrainLoss: 0.09825; ValidLoss: 0.02136\n",
      "Saved model at epoch 45 with validation loss of 0.021360528401353142\n",
      "Epoch: [ 46 / 100 ]; TrainLoss: 0.08538; ValidLoss: 0.02235\n",
      "Epoch: [ 47 / 100 ]; TrainLoss: 0.07582; ValidLoss: 0.01426\n",
      "Saved model at epoch 47 with validation loss of 0.014256468804722483\n",
      "Epoch: [ 48 / 100 ]; TrainLoss: 0.06270; ValidLoss: 0.01342\n",
      "Saved model at epoch 48 with validation loss of 0.013423782011324709\n",
      "Epoch: [ 49 / 100 ]; TrainLoss: 0.05746; ValidLoss: 0.01138\n",
      "Saved model at epoch 49 with validation loss of 0.011383428407663649\n",
      "Epoch: [ 50 / 100 ]; TrainLoss: 0.04671; ValidLoss: 0.01272\n",
      "Epoch: [ 51 / 100 ]; TrainLoss: 0.03851; ValidLoss: 0.01065\n",
      "Saved model at epoch 51 with validation loss of 0.01064963706515052\n",
      "Epoch: [ 52 / 100 ]; TrainLoss: 0.03737; ValidLoss: 0.01267\n",
      "Epoch: [ 53 / 100 ]; TrainLoss: 0.09024; ValidLoss: 0.00998\n",
      "Saved model at epoch 53 with validation loss of 0.00997502559965307\n",
      "Epoch: [ 54 / 100 ]; TrainLoss: 0.02509; ValidLoss: 0.01001\n",
      "Epoch: [ 55 / 100 ]; TrainLoss: 0.02364; ValidLoss: 0.00992\n",
      "Saved model at epoch 55 with validation loss of 0.0099201240492138\n",
      "Epoch: [ 56 / 100 ]; TrainLoss: 0.02276; ValidLoss: 0.00984\n",
      "Saved model at epoch 56 with validation loss of 0.009839837608689611\n",
      "Epoch: [ 57 / 100 ]; TrainLoss: 0.02296; ValidLoss: 0.01444\n",
      "Epoch: [ 58 / 100 ]; TrainLoss: 0.04139; ValidLoss: 0.00971\n",
      "Saved model at epoch 58 with validation loss of 0.009709558788348328\n",
      "Epoch: [ 59 / 100 ]; TrainLoss: 0.01712; ValidLoss: 0.00962\n",
      "Saved model at epoch 59 with validation loss of 0.009620612233199856\n",
      "Epoch: [ 60 / 100 ]; TrainLoss: 0.01686; ValidLoss: 0.01000\n",
      "Epoch: [ 61 / 100 ]; TrainLoss: 0.01689; ValidLoss: 0.00972\n",
      "Epoch: [ 62 / 100 ]; TrainLoss: 0.01770; ValidLoss: 0.00941\n",
      "Saved model at epoch 62 with validation loss of 0.009409429928795858\n",
      "Epoch: [ 63 / 100 ]; TrainLoss: 0.01851; ValidLoss: 0.01475\n",
      "Epoch: [ 64 / 100 ]; TrainLoss: 0.07180; ValidLoss: 0.00934\n",
      "Saved model at epoch 64 with validation loss of 0.009340583262118425\n",
      "Epoch: [ 65 / 100 ]; TrainLoss: 0.01340; ValidLoss: 0.00969\n",
      "Epoch: [ 66 / 100 ]; TrainLoss: 0.01235; ValidLoss: 0.00959\n",
      "Epoch: [ 67 / 100 ]; TrainLoss: 0.01230; ValidLoss: 0.00965\n",
      "Epoch: [ 68 / 100 ]; TrainLoss: 0.01323; ValidLoss: 0.01000\n",
      "Epoch: [ 69 / 100 ]; TrainLoss: 0.01320; ValidLoss: 0.00962\n",
      "Epoch: [ 70 / 100 ]; TrainLoss: 0.01297; ValidLoss: 0.00964\n",
      "Epoch: [ 71 / 100 ]; TrainLoss: 0.04077; ValidLoss: 0.26405\n",
      "Epoch: [ 72 / 100 ]; TrainLoss: 0.03027; ValidLoss: 0.00951\n",
      "Epoch: [ 73 / 100 ]; TrainLoss: 0.00937; ValidLoss: 0.00934\n",
      "Saved model at epoch 73 with validation loss of 0.009335641495206139\n",
      "Epoch: [ 74 / 100 ]; TrainLoss: 0.00897; ValidLoss: 0.00949\n",
      "Epoch: [ 75 / 100 ]; TrainLoss: 0.00920; ValidLoss: 0.00965\n",
      "Epoch: [ 76 / 100 ]; TrainLoss: 0.00988; ValidLoss: 0.00991\n",
      "Epoch: [ 77 / 100 ]; TrainLoss: 0.00967; ValidLoss: 0.00990\n",
      "Epoch: [ 78 / 100 ]; TrainLoss: 0.01074; ValidLoss: 0.00990\n",
      "Epoch: [ 79 / 100 ]; TrainLoss: 0.01079; ValidLoss: 0.00977\n",
      "Epoch: [ 80 / 100 ]; TrainLoss: 0.01010; ValidLoss: 0.00976\n",
      "Epoch: [ 81 / 100 ]; TrainLoss: 0.01012; ValidLoss: 0.01001\n",
      "Epoch: [ 82 / 100 ]; TrainLoss: 0.00935; ValidLoss: 0.01003\n",
      "Epoch: [ 83 / 100 ]; TrainLoss: 0.00894; ValidLoss: 0.01000\n",
      "Early stopping!\n",
      "Training complete!\n",
      "Best loss:  0.009335641495206139\n"
     ]
    }
   ],
   "source": [
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.Adam(transformer.parameters(), lr=0.0001, betas=(0.9, 0.98), eps=1e-9)\n",
    "\n",
    "best_loss = 50\n",
    "epochs_no_improve = 0\n",
    "\n",
    "# save the train valid losses for each epoch, and print them after epoch ends\n",
    "\n",
    "train_losses = []\n",
    "valid_losses = []\n",
    "\n",
    "\n",
    "for epoch in range(epochs):\n",
    "    transformer.train()\n",
    "    train_loss = 0\n",
    "    valid_loss = 0\n",
    "    for batch in train_dataloader:\n",
    "        src_data = batch['input'].to(device)\n",
    "        # tgt_data = nn.functional.pad(src_data[:,1:], (0, 1), 'constant', 0).to(device)\n",
    "        tgt_data = src_data[:, 1:].to(device)\n",
    "        src_data = src_data[:, :-1]\n",
    "        emotion = batch['target'].to(device)\n",
    "        optimizer.zero_grad()\n",
    "        output = transformer(src_data, tgt_data[:, :-1], emotion)\n",
    "        loss = criterion(output.contiguous().view(-1, tgt_vocab_size), tgt_data[:, 1:].contiguous().view(-1))\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        train_loss+=loss.item()\n",
    "    train_losses.append(train_loss/len(train_dataloader))\n",
    "\n",
    "    # evaluate on validation set\n",
    "    transformer.eval()\n",
    "    with torch.no_grad():\n",
    "        for batch in valid_dataloader:\n",
    "            src_data = batch['input'].to(device)\n",
    "            tgt_data = src_data[:, 1:].to(device)\n",
    "            # tgt_data = nn.functional.pad(src_data[:,1:], (0, 1), 'constant', 0).to(device)\n",
    "            src_data = src_data[:, :-1]\n",
    "            emotion = batch['target'].to(device)\n",
    "            output = transformer(src_data, tgt_data[:, :-1], emotion)\n",
    "            loss = criterion(output.contiguous().view(-1, tgt_vocab_size), tgt_data[:, 1:].contiguous().view(-1))\n",
    "            valid_loss+=loss.item()\n",
    "            \n",
    "    valid_losses.append(valid_loss/len(valid_dataloader))\n",
    "\n",
    "    print(\"Epoch: [ {} / {} ]; TrainLoss: {:.5f}; ValidLoss: {:.5f}\".format(\n",
    "        epoch, epochs, train_loss/len(train_dataloader), valid_loss/len(valid_dataloader)\n",
    "    ))\n",
    "\n",
    "    cond, best_loss, epochs_no_improve = early_stopping(valid_loss/len(valid_dataloader), epoch, best_loss,epochs_no_improve, patience=10)\n",
    "    if cond:\n",
    "        break\n",
    "\n",
    "print(\"Training complete!\")\n",
    "print(\"Best loss: \", best_loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 454,
       "width": 554
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot losses\n",
    "import matplotlib.pyplot as plt\n",
    "%config InlineBackend.figure_format = 'retina' # Makes the plots clear on high-res screens\n",
    "plt.plot(train_losses, label='Training loss')\n",
    "plt.plot(valid_losses, label='Validation loss')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Loss')\n",
    "plt.title(\"Vanilla Transformer\")\n",
    "plt.legend(frameon=False)\n",
    "plt.tight_layout\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# generate a sequence from the transformer model using test dataloader from the best model\n",
    "transformer = Transformer(src_vocab_size, tgt_vocab_size, d_model, num_heads, num_layers, d_ff, max_seq_length, dropout, num_emotions)\n",
    "transformer.to(device)\n",
    "transformer.load_state_dict(torch.load(\"checkpoints/transformer_ende_cond.pt\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.nn.functional import softmax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def softmax_with_temperature(logits, temperature):\n",
    "    probs = torch.nn.functional.softmax(logits / temperature, dim=-1)\n",
    "    return probs\n",
    "end_token_id = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_sequence(model, prompt, emotion, max_length, temperature=1.0):\n",
    "    model.eval()  # Set the model to inference mode\n",
    "\n",
    "    # Tokenize the prompt\n",
    "    src = prompt.to(device)\n",
    "    tgt = src[:,0].unsqueeze(1).to(device)  \n",
    "\n",
    "    for i in range(max_length):\n",
    "        # Forward pass through the model\n",
    "        output = model(src, tgt, emotion)  # Add emotion as required\n",
    "        logits = output[:, -1, :]  # Consider only the last token's output\n",
    "\n",
    "        # Apply temperature scaling\n",
    "        probs = softmax_with_temperature(logits, temperature)\n",
    "\n",
    "        # Sample from the probability distribution\n",
    "        next_token = torch.multinomial(probs, num_samples=1)\n",
    "        \n",
    "        # Append to the sequence\n",
    "        tgt = torch.cat((tgt, next_token), dim=1)\n",
    "\n",
    "        # Check for end token\n",
    "        if next_token.item() == end_token_id:\n",
    "            break\n",
    "\n",
    "    return tgt.squeeze().tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_length = 256\n",
    "temperature = 1.0\n",
    "\n",
    "for i,batch in enumerate(test_dataset):\n",
    "    src_data = batch['input'].to(device)\n",
    "    # tgt_data = src_data[:, 1:].to(device)\n",
    "    src_data = src_data[:-1]\n",
    "    emotion = batch['target'].to(device)\n",
    "\n",
    "    generated_tokens = generate_sequence(transformer, src_data.unsqueeze(0), emotion.unsqueeze(0), max_length, temperature) \n",
    "    if emotion.item() == 0:\n",
    "        emo = 'Q1'\n",
    "    elif emotion.item() == 1:\n",
    "        emo = 'Q2'\n",
    "    elif emotion.item() == 2:\n",
    "        emo = 'Q3'\n",
    "    elif emotion.item() == 3:\n",
    "        emo = 'Q4'\n",
    "    midi_encoder_remi.words_to_midi(generated_tokens,f'generated_music_cond/transformer/{emo}/transformer{i}.mid')\n",
    "    midi_encoder_remi.words_to_midi(torch.tensor(src_data, dtype=torch.long),f'generated_music_cond/original/{emo}/original{i}.mid')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import os\n",
    "\n",
    "# for emo in ['Q1', 'Q2', 'Q3', 'Q4']:\n",
    "#     dir_name = f\"generated_music_cond/original/{emo}\"\n",
    "#     test = os.listdir(dir_name)\n",
    "\n",
    "#     for item in test:\n",
    "#         if item.endswith(\".mid\"):\n",
    "#             os.remove(os.path.join(dir_name, item))\n",
    "\n",
    "# for emo in ['Q1', 'Q2', 'Q3', 'Q4']:\n",
    "#     dir_name = f\"generated_music_cond/transformer/{emo}\"\n",
    "#     test = os.listdir(dir_name)\n",
    "\n",
    "#     for item in test:\n",
    "#         if item.endswith(\".mid\"):\n",
    "#             os.remove(os.path.join(dir_name, item))\n",
    "\n",
    "# dir_name = \"generated_musics/original\"\n",
    "# test = os.listdir(dir_name)\n",
    "\n",
    "# for item in test:\n",
    "#     if item.endswith(\".mid\"):\n",
    "#         os.remove(os.path.join(dir_name, item))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# GAN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# build a generator\n",
    "class Generator(nn.Module):\n",
    "    def __init__(self, vocab_size, max_seq_length, d_model, num_heads, num_layers, d_ff, dropout, num_emotions):\n",
    "        super(Generator, self).__init__()\n",
    "        self.transformer = Transformer(vocab_size, vocab_size, d_model, num_heads, num_layers, d_ff, max_seq_length, dropout, num_emotions)\n",
    "        # self.fc = nn.Linear(dim, vocab_size)\n",
    "        \n",
    "    def forward(self, src, tgt, emotion):\n",
    "        output = self.transformer(src, tgt, emotion)\n",
    "        return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Discriminator(nn.Module):\n",
    "    def __init__(self, vocab_size, max_seq_length, d_model, num_heads, num_layers, d_ff, dropout, num_emotions, num_classes):\n",
    "        super(Discriminator, self).__init__()\n",
    "        self.encoder_embedding = nn.Embedding(vocab_size, d_model)\n",
    "        self.positional_encoding = PositionalEncoding(d_model, max_seq_length)\n",
    "        self.emotion_embedding = nn.Embedding(num_emotions, d_model)\n",
    "        self.encoder_layers = nn.ModuleList([EncoderLayer(d_model, num_heads, d_ff, dropout) for _ in range(num_layers)])\n",
    "        self.fc = nn.Linear(d_model, num_classes)\n",
    "        self.sigmoid = nn.Sigmoid()\n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "\n",
    "    def generate_mask(self, src):\n",
    "        src_mask = (src != 0).unsqueeze(1).unsqueeze(2)\n",
    "        return src_mask\n",
    "\n",
    "    def forward(self, src, emotion):\n",
    "        src_mask = self.generate_mask(src)\n",
    "        src_embedded = self.dropout(self.positional_encoding(self.encoder_embedding(src)) + self.emotion_embedding(emotion).unsqueeze(1))\n",
    "\n",
    "        enc_output = src_embedded\n",
    "        for enc_layer in self.encoder_layers:\n",
    "            enc_output = enc_layer(enc_output, src_mask)\n",
    "\n",
    "        output,_ = torch.max(enc_output, dim=1)\n",
    "        output = self.fc(output)\n",
    "        output = self.sigmoid(output)\n",
    "        return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "src_vocab_size = vocab_size\n",
    "tgt_vocab_size = vocab_size\n",
    "d_model = 512\n",
    "num_heads = 8\n",
    "num_layers = 6\n",
    "d_ff = 256\n",
    "max_seq_length = max_seq_len\n",
    "dropout = 0.2\n",
    "epochs = 100\n",
    "num_emotions = 4\n",
    "\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the generator\n",
    "netG = Generator(vocab_size, max_seq_length, d_model, num_heads, num_layers, d_ff, dropout, num_emotions).to(device)\n",
    "# Create the Discriminator\n",
    "netD = Discriminator(vocab_size, max_seq_length, d_model, num_heads, num_layers, d_ff, dropout, num_emotions, num_classes=1).to(device)\n",
    "\n",
    "# Initialize the ``BCELoss`` function\n",
    "criterion_BCE = nn.BCELoss()\n",
    "\n",
    "criterion_ce = nn.CrossEntropyLoss()\n",
    "\n",
    "# Create batch of latent vectors that we will use to visualize\n",
    "#  the progression of the generator\n",
    "nz = 100\n",
    "fixed_noise = torch.randn(64, nz, 1, 1, device=device)\n",
    "\n",
    "# Establish convention for real and fake labels during training\n",
    "real_label = 1.\n",
    "fake_label = 0.\n",
    "\n",
    "lr = 0.0002\n",
    "beta1 = 0.5\n",
    "\n",
    "# Setup Adam optimizers for both G and D\n",
    "optimizerD = torch.optim.Adam(netD.parameters(), lr=lr, betas=(beta1, 0.999))\n",
    "optimizerG = torch.optim.Adam(netG.parameters(), lr=lr, betas=(beta1, 0.999))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_epochs = 5\n",
    "temperature = 1.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting Training Loop...\n",
      "[0/5][63/54]\tLoss_D: 2.8223\tLoss_G: 4.9369\tD(x): 0.9325\tD(G(z)): 0.9337 / 0.9337\n",
      "[0/5][63/54]\tLoss_D: 0.9311\tLoss_G: 0.2281\tD(x): 0.6678\tD(G(z)): 0.2944 / 0.2944\n",
      "[1/5][63/54]\tLoss_D: 1.1180\tLoss_G: 0.1899\tD(x): 0.5534\tD(G(z)): 0.2682 / 0.2682\n",
      "[1/5][63/54]\tLoss_D: 1.1710\tLoss_G: 0.0449\tD(x): 0.6165\tD(G(z)): 0.4097 / 0.4097\n",
      "[2/5][63/54]\tLoss_D: 1.0488\tLoss_G: 0.0424\tD(x): 0.6197\tD(G(z)): 0.3252 / 0.3252\n",
      "[2/5][63/54]\tLoss_D: 1.1939\tLoss_G: 0.0197\tD(x): 0.6377\tD(G(z)): 0.4513 / 0.4513\n",
      "[3/5][63/54]\tLoss_D: 0.9940\tLoss_G: 0.0185\tD(x): 0.6726\tD(G(z)): 0.3784 / 0.3784\n",
      "[3/5][63/54]\tLoss_D: 1.2154\tLoss_G: 0.0114\tD(x): 0.6069\tD(G(z)): 0.4458 / 0.4458\n",
      "[4/5][63/54]\tLoss_D: 0.9741\tLoss_G: 0.0108\tD(x): 0.6188\tD(G(z)): 0.3198 / 0.3198\n",
      "[4/5][63/54]\tLoss_D: 1.2271\tLoss_G: 0.0076\tD(x): 0.5986\tD(G(z)): 0.4394 / 0.4394\n"
     ]
    }
   ],
   "source": [
    "# Training Loop\n",
    "# Lists to keep track of progress\n",
    "txt_list = []\n",
    "G_losses = []\n",
    "D_losses = []\n",
    "iters = 0\n",
    "\n",
    "print(\"Starting Training Loop...\")\n",
    "# For each epoch\n",
    "for epoch in range(num_epochs):\n",
    "    # For each batch in the dataloader\n",
    "    for k, data in enumerate(train_dataloader):\n",
    "        src_data = data['input']\n",
    "        target = src_data[:, 1:].to(device)\n",
    "        input = src_data[:, :-1]\n",
    "        emotion = data['target'].to(device)\n",
    "        ############################\n",
    "        # (1) Update D network: maximize log(D(x)) + log(1 - D(G(z)))\n",
    "        ###########################\n",
    "        ## Train with all-real batch\n",
    "        netD.zero_grad()\n",
    "        # Format batch\n",
    "        real_cpu = input.to(device)\n",
    "        b_size = real_cpu.size(0)\n",
    "        label = torch.full((b_size,), real_label, dtype=torch.float, device=device)\n",
    "        # Forward pass real batch through D\n",
    "        output = netD(real_cpu, emotion).view(-1)\n",
    "        # Calculate loss on all-real batch\n",
    "        errD_real = criterion_BCE(output, label)\n",
    "\n",
    "        # Calculate gradients for D in backward pass\n",
    "        errD_real.backward()\n",
    "        D_x = output.mean().item()\n",
    "\n",
    "        ## Train with all-fake batch\n",
    "        # Generate batch of latent vectors\n",
    "        # noise = torch.randn(b_size, nz, 1, 1, device=device)\n",
    "        # Generate fake image batch with G\n",
    "        fake = netG(real_cpu, target, emotion)\n",
    "        fake_probabilities = nn.functional.softmax(fake.squeeze(), dim=-1)\n",
    "        fake_mat = torch.zeros((b_size, max_seq_length), dtype=torch.long).to(device)\n",
    "        for i in range(b_size):\n",
    "            for j in range(max_seq_length):\n",
    "                fake_mat[i][j] = torch.multinomial(fake_probabilities[i][j], 1).item()\n",
    "        \n",
    "        label.fill_(fake_label)\n",
    "        # Classify all fake batch with D\n",
    "        output = netD(fake_mat, emotion).view(-1)\n",
    "        # Calculate D's loss on the all-fake batch\n",
    "        errD_fake = criterion_BCE(output, label)\n",
    "        # Calculate the gradients for this batch, accumulated (summed) with previous gradients\n",
    "        errD_fake.backward()\n",
    "        D_G_z1 = output.mean().item()\n",
    "        # Compute error of D as sum over the fake and the real batches\n",
    "        errD = errD_real + errD_fake\n",
    "        # Update D\n",
    "        optimizerD.step()\n",
    "\n",
    "        ############################\n",
    "        # (2) Update G network: maximize log(D(G(z)))\n",
    "        ###########################\n",
    "        netG.zero_grad()\n",
    "        label.fill_(real_label)  # fake labels are real for generator cost\n",
    "        # Since we just updated D, perform another forward pass of all-fake batch through D\n",
    "        # output = netD(fake_mat).view(-1)\n",
    "        # Calculate G's loss based on this output\n",
    "        # errG = criterion(output, label)\n",
    "        errG = criterion_ce(fake.view(-1, vocab_size), target.view(-1))\n",
    "        # Calculate gradients for G\n",
    "        errG.backward()\n",
    "        D_G_z2 = output.mean().item()\n",
    "        # Update G\n",
    "        optimizerG.step()\n",
    "\n",
    "        # Output training stats\n",
    "        if k % 50 == 0:\n",
    "            print('[%d/%d][%d/%d]\\tLoss_D: %.4f\\tLoss_G: %.4f\\tD(x): %.4f\\tD(G(z)): %.4f / %.4f'\n",
    "                  % (epoch, num_epochs, i, len(train_dataloader),\n",
    "                     errD.item(), errG.item(), D_x, D_G_z1, D_G_z2))\n",
    "\n",
    "        # Save Losses for plotting later\n",
    "        G_losses.append(errG.item())\n",
    "        D_losses.append(errD.item())\n",
    "\n",
    "        # Check how the generator is doing by saving G's output on fixed_noise\n",
    "        if (iters % 500 == 0) or ((epoch == num_epochs-1) and (i == len(train_dataloader)-1)):\n",
    "            with torch.no_grad():\n",
    "                fake = netG(real_cpu, target, emotion).detach().cpu()\n",
    "            fake_probabilities = softmax(fake.squeeze() / temperature, dim=-1)\n",
    "            fake_mat = torch.zeros((b_size, max_seq_length), dtype=torch.long).to(device)\n",
    "            for i in range(b_size):\n",
    "                for j in range(max_seq_length):\n",
    "                    fake_mat[i][j] = torch.multinomial(fake_probabilities[i][j], 1).item()\n",
    "            txt_list.append(fake_mat)\n",
    "\n",
    "        iters += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 454,
       "width": 554
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot losses\n",
    "import matplotlib.pyplot as plt\n",
    "%config InlineBackend.figure_format = 'retina' # Makes the plots clear on high-res screens\n",
    "plt.plot(G_losses, label='G_losses')\n",
    "plt.plot(D_losses, label='D_losses')\n",
    "plt.xlabel('Steps')\n",
    "plt.ylabel('Loss')\n",
    "plt.title(\"Transformer Gan\")\n",
    "plt.legend(frameon=False)\n",
    "plt.tight_layout\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(netG.state_dict(), \"checkpoints/generator_cond.pt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_sequence(model, prompt, emotion, max_length, temperature=1.0):\n",
    "    model.eval()  # Set the model to inference mode\n",
    "\n",
    "    # Tokenize the prompt\n",
    "    src = prompt.to(device)\n",
    "    tgt = src[:,0].unsqueeze(1).to(device)  \n",
    "\n",
    "    for i in range(max_length):\n",
    "        # Forward pass through the model\n",
    "        output = model(src, tgt, emotion)  # Add emotion as required\n",
    "        logits = output[:, -1, :]  # Consider only the last token's output\n",
    "\n",
    "        # Apply temperature scaling\n",
    "        probs = softmax_with_temperature(logits, temperature)\n",
    "\n",
    "        # Sample from the probability distribution\n",
    "        next_token = torch.multinomial(probs, num_samples=1)\n",
    "        \n",
    "        # Append to the sequence\n",
    "        tgt = torch.cat((tgt, next_token), dim=1)\n",
    "\n",
    "        # Check for end token\n",
    "        if next_token.item() == end_token_id:\n",
    "            break\n",
    "\n",
    "    return tgt.squeeze().tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i,batch in enumerate(test_dataset):\n",
    "    src_data = batch['input'].to(device)\n",
    "    # tgt_data = src_data[:, 1:].to(device)\n",
    "    src_data = src_data[:-1]\n",
    "    emotion = batch['target'].to(device)\n",
    "\n",
    "    generated_tokens = generate_sequence(netG, src_data.unsqueeze(0), emotion.unsqueeze(0), max_length=256) \n",
    "    if emotion.item() == 0:\n",
    "        emo = 'Q1'\n",
    "    elif emotion.item() == 1:\n",
    "        emo = 'Q2'\n",
    "    elif emotion.item() == 2:\n",
    "        emo = 'Q3'\n",
    "    elif emotion.item() == 3:\n",
    "        emo = 'Q4'\n",
    "    # midi_encoder_remi.words_to_midi(generated_tokens,f'generated_music_cond/transformer_gan/{emo}/transformer_gan{i}.mid')\n",
    "    # midi_encoder_remi.words_to_midi(src_data,f'generated_music_cond/original/{emo}/original{i}.mid')\n",
    "    print(src_data)\n",
    "    print(generated_tokens)"
   ]
  },
  {
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}