4-3-MusicInpaintNet-eval.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "In this file we eval the music inpaintNet\n",
    "The eval process is loosely based on their releasing code\n",
    "'''\n",
    "import torch\n",
    "import os\n",
    "import numpy as np\n",
    "from torch import optim\n",
    "from torch.nn import functional as F\n",
    "from InpaintRNN.inpaintrnn import InpaintingNet\n",
    "from torch import optim\n",
    "from torch.utils.data import Dataset, DataLoader, TensorDataset\n",
    "from torch.distributions import Normal\n",
    "from MeasureVAE.measure_vae import MeasureVAE\n",
    "from utils.helpers import *\n",
    "import time\n",
    "\n",
    "###############################\n",
    "# initial parameters\n",
    "s_dir = \"\"\n",
    "input_dims = 256\n",
    "pf_hidden_dims = 512\n",
    "g_h_dims = 1024\n",
    "pf_num = 2\n",
    "inpaint_len = 4\n",
    "seq_len = 16\n",
    "batch_size = 1\n",
    "whole_data_path = [\n",
    "    s_dir + \"data/irish-dis-measure-vae-train-whole.npy\",\n",
    "    s_dir + \"data/irish-dis-measure-vae-validate-whole.npy\",\n",
    "    s_dir + \"data/irish-dis-measure-vae-validate-repetition.npy\",\n",
    "    s_dir + \"data/irish-dis-measure-vae-validate-non-repetition.npy\"\n",
    "]\n",
    "lr = 1e-4\n",
    "decay = 0.9999\n",
    "##############################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def processed_data_tensor(data):\n",
    "    print(\"processed data:\")\n",
    "    gd = [] \n",
    "    len_x = []\n",
    "    total = 0\n",
    "    for i, d in enumerate(data):\n",
    "        gd.append([list(dd[0]) for dd in d])\n",
    "        len_x.append([dd[3] for dd in d])\n",
    "        if len(gd[-1][-1]) != 24:\n",
    "            gd[-1][-1].extend([128] * (24 - len(gd[-1][-1])))\n",
    "    for i,d in enumerate(len_x):\n",
    "        for j,dd in enumerate(d):\n",
    "            if len_x[i][j] == 0:\n",
    "                gd[i][j][0] = 60\n",
    "                len_x[i][j] = 1\n",
    "                total += 1\n",
    "    gd = np.array(gd)\n",
    "    len_x = np.array(len_x)\n",
    "    gd = torch.from_numpy(gd).long()\n",
    "    return gd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load data\n",
    "\n",
    "# pick anyone you like :)\n",
    "validate_set = np.load(whole_data_path[3],allow_pickle = True)\n",
    "validate_gd = processed_data_tensor(validate_set)\n",
    "validate_set = TensorDataset(validate_gd,validate_gd)\n",
    "\n",
    "validate_loader = DataLoader(dataset = validate_set, batch_size = batch_size, \n",
    "                          shuffle = False, num_workers = 2, pin_memory = True, drop_last = True)\n",
    "\n",
    "validate_x = []\n",
    "validate_gd = []\n",
    "for x,y in validate_loader:\n",
    "    validate_x.append(x)\n",
    "    validate_gd.append(y)\n",
    "\n",
    "validate_loader = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load VAE model\n",
    "vae_num_notes = 130\n",
    "vae_note_embedding_dim=10\n",
    "vae_metadata_embedding_dim=2\n",
    "vae_num_encoder_layers=2\n",
    "vae_encoder_hidden_size=512\n",
    "vae_encoder_dropout_prob=0.5\n",
    "vae_has_metadata=False\n",
    "vae_latent_space_dim=256\n",
    "vae_num_decoder_layers=2\n",
    "vae_decoder_hidden_size=512\n",
    "vae_decoder_dropout_prob=0.5\n",
    "vae_batch_size=256\n",
    "vae_num_epochs=30\n",
    "vae_train=False\n",
    "vae_plot=False\n",
    "vae_log=True\n",
    "vae_lr=1e-4\n",
    "vae_seq_len = 6 * 4\n",
    "\n",
    "vae_model = MeasureVAE(\n",
    "        num_notes = vae_num_notes,\n",
    "        note_embedding_dim=vae_note_embedding_dim,\n",
    "        metadata_embedding_dim=vae_metadata_embedding_dim,\n",
    "        num_encoder_layers=vae_num_encoder_layers,\n",
    "        encoder_hidden_size=vae_encoder_hidden_size,\n",
    "        encoder_dropout_prob=vae_encoder_dropout_prob,\n",
    "        latent_space_dim=vae_latent_space_dim,\n",
    "        num_decoder_layers=vae_num_decoder_layers,\n",
    "        decoder_hidden_size=vae_decoder_hidden_size,\n",
    "        decoder_dropout_prob=vae_decoder_dropout_prob,\n",
    "        has_metadata=vae_has_metadata\n",
    ")\n",
    "dic = torch.load(s_dir + \"model_backup/measure-vae-param.pt\")\n",
    "for name in list(dic.keys()):\n",
    "    dic[name.replace('module.', '')] = dic.pop(name)\n",
    "vae_model.load_state_dict(dic)\n",
    "\n",
    "if torch.cuda.is_available():\n",
    "    print('Using: ', torch.cuda.get_device_name(torch.cuda.current_device()))\n",
    "    vae_model.cuda()\n",
    "else:\n",
    "    print('Using: CPU')\n",
    "vae_model.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import model\n",
    "\n",
    "model = InpaintingNet(input_dims, pf_hidden_dims, g_h_dims, pf_num, inpaint_len, vae_model, False, 2000, True)\n",
    "\n",
    "dic = torch.load(\"model_backup/musicinpaintnet-param.pt\")\n",
    "for name in list(dic.keys()):\n",
    "    dic[name.replace('module.', '')] = dic.pop(name)\n",
    "model.load_state_dict(dic)\n",
    "\n",
    "if torch.cuda.is_available():\n",
    "    print('Using: ', torch.cuda.get_device_name(torch.cuda.current_device()))\n",
    "    model.cuda()\n",
    "else:\n",
    "    print('Using: CPU')\n",
    "model.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_batch(index_file):\n",
    "    zs = []\n",
    "    for d in index_file:\n",
    "        idx,sta,end = d\n",
    "        zs.append([train_x[idx,0][sta:end + 1], train_x[idx,1][sta:end + 1]])\n",
    "    return np.array(zs)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.eval()\n",
    "device = torch.device(torch.cuda.current_device())\n",
    "n_past = 6\n",
    "n_future = 10\n",
    "n_inpaint = 4\n",
    "iteration = 0\n",
    "# save_period = 200\n",
    "output = []\n",
    "for i in range(len(validate_x)):\n",
    "    v_mean_loss = 0.0\n",
    "    v_acc = 0.0\n",
    "    v_raw_x = validate_x[i]\n",
    "    v_raw_gd =  validate_gd[i]\n",
    "\n",
    "    v_past_x = v_raw_x[:,:n_past,:]\n",
    "    v_inpaint_x = v_raw_x[:,n_past:n_past + n_inpaint,:]\n",
    "    v_future_x = v_raw_x[:,n_future:,:] \n",
    "    v_inpaint_gd = v_raw_gd[:,n_past:n_past + n_inpaint,:]\n",
    "    v_inpaint_gd = v_inpaint_gd.contiguous().view(-1)\n",
    "\n",
    "    v_past_x = v_past_x.to(device = device, non_blocking = True)\n",
    "    v_inpaint_x = v_inpaint_x.to(device = device, non_blocking = True)\n",
    "    v_future_x = v_future_x.to(device = device, non_blocking = True)\n",
    "    v_inpaint_gd = v_inpaint_gd.to(device = device, non_blocking = True)\n",
    "\n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        v_recon_x, _ = model(v_past_x, v_future_x, v_inpaint_x)\n",
    "        v_loss = F.cross_entropy(v_recon_x.view(-1, v_recon_x.size(-1)), v_inpaint_gd, reduction = \"mean\") \n",
    "        v_mean_loss = v_loss.item()\n",
    "        v_recon_x_note =  v_recon_x.max(-1)[-1]\n",
    "        correct = v_recon_x_note == v_inpaint_x\n",
    "        v_acc = torch.sum(correct.float()) / (v_recon_x.view(-1,v_recon_x.size(-1)).size(0)) \n",
    "        v_acc = v_acc.item()\n",
    "    output.append(\n",
    "        {\n",
    "         \"past\": v_past_x.cpu().detach().numpy(),\n",
    "         \"future\":v_future_x.cpu().detach().numpy(),\n",
    "         \"inpaint\":v_recon_x_note.cpu().detach().numpy(),\n",
    "         \"gd\":v_inpaint_x.cpu().detach().numpy(),\n",
    "         \"acc\":v_acc,\n",
    "         \"nll\":v_mean_loss\n",
    "        }\n",
    "    )\n",
    "    print(i)\n",
    "\n",
    "# np.save(\"irish-inpaint-ce-generate-train.npy\", i_out)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# store it as you like\n",
    "np.save(\"nonre-res-test-irish-musicinpaintnet.npy\", output)"
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}