notebook.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 397
    },
    "colab_type": "code",
    "id": "HEP6rjTRGuWC",
    "outputId": "53c53f88-264e-4135-93f1-28d51a923335"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: pescador in /usr/local/lib/python3.6/dist-packages (2.0.2)\n",
      "Requirement already satisfied: joblib>=0.9 in /usr/local/lib/python3.6/dist-packages (from pescador) (0.13.2)\n",
      "Requirement already satisfied: numpy>=1.9 in /usr/local/lib/python3.6/dist-packages (from pescador) (1.16.4)\n",
      "Requirement already satisfied: pyzmq>=15.0 in /usr/local/lib/python3.6/dist-packages (from pescador) (17.0.0)\n",
      "Requirement already satisfied: decorator>=4.0 in /usr/local/lib/python3.6/dist-packages (from pescador) (4.4.0)\n",
      "Requirement already satisfied: six>=1.8 in /usr/local/lib/python3.6/dist-packages (from pescador) (1.12.0)\n",
      "Requirement already satisfied: museval in /usr/local/lib/python3.6/dist-packages (0.2.1)\n",
      "Requirement already satisfied: scipy in /usr/local/lib/python3.6/dist-packages (from museval) (1.3.0)\n",
      "Requirement already satisfied: soundfile in /usr/local/lib/python3.6/dist-packages (from museval) (0.10.2)\n",
      "Requirement already satisfied: simplejson in /usr/local/lib/python3.6/dist-packages (from museval) (3.16.0)\n",
      "Requirement already satisfied: numpy in /usr/local/lib/python3.6/dist-packages (from museval) (1.16.4)\n",
      "Requirement already satisfied: musdb==0.2.3 in /usr/local/lib/python3.6/dist-packages (from museval) (0.2.3)\n",
      "Requirement already satisfied: jsonschema in /usr/local/lib/python3.6/dist-packages (from museval) (2.6.0)\n",
      "Requirement already satisfied: six in /usr/local/lib/python3.6/dist-packages (from museval) (1.12.0)\n",
      "Requirement already satisfied: cffi>=1.0 in /usr/local/lib/python3.6/dist-packages (from soundfile->museval) (1.12.3)\n",
      "Requirement already satisfied: pyaml in /usr/local/lib/python3.6/dist-packages (from musdb==0.2.3->museval) (19.4.1)\n",
      "Requirement already satisfied: tqdm in /usr/local/lib/python3.6/dist-packages (from musdb==0.2.3->museval) (4.28.1)\n",
      "Requirement already satisfied: stempeg>=0.1.1 in /usr/local/lib/python3.6/dist-packages (from musdb==0.2.3->museval) (0.1.8)\n",
      "Requirement already satisfied: pycparser in /usr/local/lib/python3.6/dist-packages (from cffi>=1.0->soundfile->museval) (2.19)\n",
      "Requirement already satisfied: PyYAML in /usr/local/lib/python3.6/dist-packages (from pyaml->musdb==0.2.3->museval) (3.13)\n"
     ]
    }
   ],
   "source": [
    "!pip install pescador\n",
    "!pip install museval"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "h40ZAyQD9sXb",
    "outputId": "7bc558ec-e9a6-44bd-c7c4-08554c5fc4bd"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: lmdb in /usr/local/lib/python3.6/dist-packages (0.96)\n"
     ]
    }
   ],
   "source": [
    "!pip install lmdb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "slOot9JrG1FK"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import time\n",
    "import math \n",
    "import random\n",
    "import librosa\n",
    "import librosa.display\n",
    "import lmdb\n",
    "\n",
    "import numpy as np\n",
    "from torch.utils import data\n",
    "\n",
    "import glob\n",
    "from scipy.io.wavfile import read as wavread #TODO needs to check how to make the reader faster\n",
    "import pescador\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F  \n",
    "import torch.optim as optim\n",
    "from torch.autograd import grad, Variable\n",
    "from torchsummary import summary  \n",
    "import logging \n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.animation as animation\n",
    "import matplotlib\n",
    "import copy\n",
    "from IPython.display import HTML\n",
    "\n",
    "from tqdm import tqdm_notebook as tqdm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "DyA4N5jdIhh-"
   },
   "source": [
    "## Config"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "yrCdycz2HFBK"
   },
   "outputs": [],
   "source": [
    "#############################\n",
    "# Model Params\n",
    "#############################\n",
    "model_prefix = 'exp_musdb_1_wide_unpaired_ralsgan_4'#'exp_large_1' # name of the model to be saved\n",
    "n_iterations = 100000\n",
    "# for the cyclic gan use these param with ncritic 1\n",
    "# but for training wavegan model it is better to use ttur lr_g = 1e-4 lr_d=3e-4 and n_critic=1\n",
    "lr_g = 2e-4\n",
    "lr_d = 2e-4\n",
    "beta1 = 0.5\n",
    "beta2 = 0.9\n",
    "decay_lr = False\n",
    "generator_batch_size_factor = 1 # in some cases we might try to update the generator with double batch size used in the discriminator\n",
    "n_critic = 5 # update generator every n_critic steps \n",
    "# gradient penalty regularization factor.\n",
    "p_coeff = 10\n",
    "batch_size = 10\n",
    "noise_latent_dim = 100 \n",
    "model_capacity_size = 64 # reduce the capacity to 32 for faster training also in case of generating larger window size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "FEeBC1QvQh0h"
   },
   "outputs": [],
   "source": [
    "# rate of storing validation and costs params\n",
    "store_cost_every = 300\n",
    "progress_bar_step_iter_size = 400"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "iZF94hUxIqjO"
   },
   "outputs": [],
   "source": [
    "# backup params\n",
    "take_backup = True\n",
    "backup_every_n_iters = 1000\n",
    "save_samples_every = 1000 \n",
    "# folder including data under each folder train, valid and test subfolders\n",
    "# code can be updated to use mancini dataset piano and noise\n",
    "target_signals_dir = 'mancini_piano/piano'\n",
    "other_signals_dir  = 'mancini_piano/noise'\n",
    "\n",
    "output_dir = 'output'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "qO0VUGnJI_mC"
   },
   "outputs": [],
   "source": [
    "#############################\n",
    "# Audio Reading Params\n",
    "#############################\n",
    "window_length = 16384 #[16384, 32768, 65536] change model_capacity size to 32 in case of slice>16384\n",
    "sampling_rate = 16000\n",
    "normalize_audio = True "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "tI5ZYc_1JCxH",
    "outputId": "579bf630-0c5b-4d78-c8a4-cc25c0cfc5f0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Random Seed:  2014\n"
     ]
    }
   ],
   "source": [
    "#############################\n",
    "# Torch Init and seed setting\n",
    "#############################\n",
    "cuda = torch.cuda.is_available()\n",
    "device = torch.device(\"cuda:0\" if (torch.cuda.is_available()) else \"cpu\")\n",
    "# update the seed\n",
    "manual_seed = 2014 #@param {type: \"integer\"}\n",
    "#manualSeed = random.randint(1, 10000) # use if you want new results\n",
    "print(\"Random Seed: \", manual_seed)\n",
    "random.seed(manual_seed)\n",
    "torch.manual_seed(manual_seed)\n",
    "np.random.seed(manual_seed)\n",
    "if cuda:\n",
    "    torch.cuda.manual_seed(manual_seed)\n",
    "    torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "QPKhpO3rJCOr"
   },
   "outputs": [],
   "source": [
    "#############################\n",
    "# Logger init\n",
    "#############################\n",
    "LOGGER = logging.getLogger('wavegan')\n",
    "LOGGER.setLevel(logging.DEBUG)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "BLMhCmpbHeJm"
   },
   "source": [
    "## Utils"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "s9HuhlS9ozMA"
   },
   "source": [
    "### File Utils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "vm2BniJ6HQsS"
   },
   "outputs": [],
   "source": [
    "def get_recursive_files(folderPath,ext):\n",
    "\t\tresults  = os.listdir(folderPath)\n",
    "\t\toutFiles = [] \n",
    "\t\tfor file in results:\n",
    "\t\t\tif os.path.isdir(os.path.join(folderPath,file)):\n",
    "\t\t\t\toutFiles+=get_recursive_files(os.path.join(folderPath,file),ext)\n",
    "\t\t\telif file.endswith(ext) :\n",
    "\t\t\t\toutFiles.append(os.path.join(folderPath,file))\n",
    "\t\t\t\n",
    "\t\treturn outFiles\n",
    "\n",
    "def make_path(output_path):\n",
    "    if not os.path.isdir(output_path):\n",
    "        os.makedirs(output_path)\n",
    "    return output_path"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "K1tRItDco3bK"
   },
   "source": [
    "###  Wav files utils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "RJG0ti9RG1sp"
   },
   "outputs": [],
   "source": [
    "#Fast loading used with wav files only of 8 bits\n",
    "def load_wav(wav_file_path, fast_loading=False ):\n",
    "    try:\n",
    "        if fast_loading:\n",
    "            file_sampling_rate, audio_data = wavread(wav_file_path)\n",
    "            if file_sampling_rate is not None and sampling_rate != file_sampling_rate:\n",
    "                raise NotImplementedError('Scipy cannot resample audio.')\n",
    "            if audio_data.dtype == np.int16:\n",
    "                audio_data = audio_data.astype(np.float32)\n",
    "                audio_data /= 32768.\n",
    "            elif audio_data.dtype == np.float32:\n",
    "                audio_data = np.copy(audio_data)\n",
    "            else:\n",
    "                raise NotImplementedError('Scipy cannot process atypical WAV files.')\n",
    "            \n",
    "        else:\n",
    "            audio_data, _ = librosa.load(wav_file_path, sr=sampling_rate)\n",
    "\n",
    "        if normalize_audio:\n",
    "            # Clip magnitude\n",
    "            max_mag = np.max(np.abs(audio_data))\n",
    "            if max_mag > 1:\n",
    "                audio_data /= max_mag\n",
    "    except Exception as e:\n",
    "        print(wav_file_path)\n",
    "        print(str(e))\n",
    "        LOGGER.error(\"Could not load {}: {}\".format(wav_file_path, str(e)))\n",
    "        raise e\n",
    "    audio_len = len(audio_data)\n",
    "    if audio_len < window_length:\n",
    "        pad_length = window_length - audio_len\n",
    "        left_pad = pad_length // 2\n",
    "        right_pad = pad_length - left_pad \n",
    "        audio_data = np.pad(audio_data, (left_pad, right_pad), mode='constant')\n",
    "        \n",
    "    \n",
    "    return audio_data.astype('float32')\n",
    "\n",
    "\n",
    "def save_samples(epoch_samples, epoch ,prefix=''):\n",
    "    \"\"\"\n",
    "    Save output samples.\n",
    "    \"\"\"\n",
    "    sample_dir = make_path(os.path.join(output_dir, str(epoch)))\n",
    "\n",
    "    for idx, sample in enumerate(epoch_samples):\n",
    "        output_path = os.path.join(sample_dir, \"{}_{}.wav\".format(prefix,idx+1))\n",
    "        sample = sample[0]\n",
    "        librosa.output.write_wav(output_path, sample, sampling_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "offZXw-rHWzw"
   },
   "outputs": [],
   "source": [
    "def sample_audio(audio_data, start_idx=None, end_idx=None):\n",
    "    audio_len = len(audio_data)\n",
    "    if audio_len == window_length:\n",
    "        # If we only have a single 1*window_length audio, just yield.\n",
    "        sample = audio_data\n",
    "    else:\n",
    "        # Sample a random window from the audio\n",
    "        if start_idx is None or end_idx is None:\n",
    "            start_idx = np.random.randint(0, (audio_len - window_length) // 2)\n",
    "            end_idx = start_idx + window_length\n",
    "        sample = audio_data[start_idx:end_idx]\n",
    "    sample =  sample.astype('float32')\n",
    "    assert not np.any(np.isnan(sample))\n",
    "    return sample, start_idx, end_idx\n",
    "\n",
    "def audio_generator(audio_data):\n",
    "    audio_len = len(audio_data)\n",
    "    n_iters = audio_len // window_length\n",
    "    for i in range(n_iters+1):\n",
    "        start_idx = i * window_length\n",
    "        end_idx = start_idx  + window_length\n",
    "        result = np.zeros(window_length)\n",
    "        audio_size = audio_data[start_idx:end_idx].shape[0]\n",
    "        result[:audio_size] = audio_data[start_idx:end_idx]\n",
    "        yield result\n",
    "    \n",
    "    \n",
    "def sample_buffer(buffer_data, start_idx=None, end_idx=None):\n",
    "    audio_len = len(buffer_data) // 4\n",
    "    if audio_len == window_length:\n",
    "        # If we only have a single 1*window_length audio, just yield.\n",
    "        sample = buffer_data\n",
    "    else:\n",
    "        # Sample a random window from the audio\n",
    "        if start_idx is None or end_idx is None:\n",
    "            start_idx = np.random.randint(0, (audio_len - window_length) // 2)\n",
    "            end_idx = start_idx + window_length\n",
    "        sample = buffer_data[start_idx * 4:end_idx*4]\n",
    "    return sample, start_idx, end_idx\n",
    "\n",
    "\n",
    "def wav_generator(file_path, mixing_signal_path):\n",
    "    audio_data = load_wav(file_path)\n",
    "    mixing_data = load_wav(mixing_signal_path)\n",
    "    while True:\n",
    "        sample, start_idx, end_idx = sample_audio(audio_data)\n",
    "        mixing_sample, _, _ = sample_audio(mixing_data,start_idx, end_idx)\n",
    "\n",
    "        mixing_ratio = np.random.uniform(0, 1)\n",
    "        mixed_signal = mixing_ratio * mixing_sample + (1-mixing_ratio) * sample\n",
    "\n",
    "        yield {'single':sample, 'mixed':mixed_signal}\n",
    "\n",
    "def create_stream_reader(single_signal_file_list, other_signal_file_list):\n",
    "    data_streams = []\n",
    "    other_signal_len  = len(other_signal_file_list)\n",
    "    for audio_path in single_signal_file_list:\n",
    "        other_signal_indx = np.random.randint(0,other_signal_len)\n",
    "        stream = pescador.Streamer(wav_generator, audio_path, other_signal_file_list[other_signal_indx])\n",
    "        data_streams.append(stream)\n",
    "    mux = pescador.ShuffledMux(data_streams)\n",
    "    batch_gen = pescador.buffer_stream(mux, batch_size)\n",
    "    return batch_gen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "NKeUFiF0o-Jh"
   },
   "source": [
    "### Model Utils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "5-YmpyOZHNk8"
   },
   "outputs": [],
   "source": [
    "\n",
    "def sample_noise(size):\n",
    "    z = torch.FloatTensor(size,noise_latent_dim).to(device)\n",
    "    z.data.normal_() # generating latent space based on normal distribution\n",
    "    return z\n",
    "\n",
    "def weights_init(m): \n",
    "    if isinstance(m, nn.Conv1d):\n",
    "        m.weight.data.normal_(0.0, 0.02)\n",
    "        if m.bias is not None:\n",
    "            m.bias.data.fill_(0)\n",
    "        m.bias.data.fill_(0)\n",
    "    elif isinstance(m, nn.Linear):\n",
    "        m.bias.data.fill_(0)\n",
    "\n",
    "def update_optimizer_lr(optimizer,lr,decay):\n",
    "  for param_group in optimizer.param_groups:\n",
    "      param_group['lr'] = lr* decay   \n",
    "\n",
    "\n",
    "def gradients_status(model,flag):\n",
    "    for p in model.parameters():\n",
    "        p.requires_grad = flag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "1Qcmv23crtN_"
   },
   "outputs": [],
   "source": [
    "\n",
    "# used to replay some history generate to the discriminator to avoid greedy disc.\n",
    "class ReplayBuffer():\n",
    "    def __init__(self, max_size=50):\n",
    "        assert (max_size > 0), 'Empty buffer or trying to create a black hole. Be careful.'\n",
    "        self.max_size = max_size\n",
    "        self.data = []\n",
    "\n",
    "    def push_and_pop(self, data):\n",
    "        to_return = []\n",
    "        for element in data.data:\n",
    "            element = torch.unsqueeze(element, 0)\n",
    "            if len(self.data) < self.max_size:\n",
    "                self.data.append(element)\n",
    "                to_return.append(element)\n",
    "            else:\n",
    "                if random.uniform(0,1) > 0.5:\n",
    "                    i = random.randint(0, self.max_size-1)\n",
    "                    to_return.append(self.data[i].clone())\n",
    "                    self.data[i] = element\n",
    "                else:\n",
    "                    to_return.append(element)\n",
    "        return Variable(torch.cat(to_return))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "lgCxXMPApNo-"
   },
   "source": [
    "### Data Loader and Sampler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "QKOlZPMOHK6N"
   },
   "outputs": [],
   "source": [
    "def numpy_to_tensor(numpy_array):\n",
    "    numpy_array = numpy_array[:, np.newaxis, :]\n",
    "    return torch.Tensor(numpy_array).to(device)\n",
    "\n",
    "#############################\n",
    "# Creating Data Loader and Sampler\n",
    "#############################\n",
    "class WavDataLoader():\n",
    "    def __init__(self, folder_path, other_signals_folder, audio_extension='wav'):\n",
    "        self.signal_paths = get_recursive_files(folder_path, audio_extension)\n",
    "        self.mixed_wav_files = get_recursive_files(other_signals_folder, audio_extension)\n",
    "        self.data_iter = None\n",
    "        self.initialize_iterator()\n",
    "\n",
    "    def initialize_iterator(self):\n",
    "        data_iter = create_stream_reader(self.signal_paths, self.mixed_wav_files)\n",
    "        self.data_iter = iter(data_iter)\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.signal_paths)\n",
    "        \n",
    "\n",
    "\n",
    "    def __iter__(self):\n",
    "        return self\n",
    "\n",
    "    def __next__(self):\n",
    "        x =  next(self.data_iter)\n",
    "        return (numpy_to_tensor(x['single']), numpy_to_tensor(x['mixed']), numpy_to_tensor(x['foreground']))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "uN8qDopu9sYm"
   },
   "outputs": [],
   "source": [
    "class LMDBWavLoader(data.Dataset):\n",
    "    def __init__(self, lmdb_file_path, is_test=False):\n",
    "        self.env = lmdb.open(lmdb_file_path, max_readers=1, readonly=True, lock=False,\n",
    "                             readahead=False, meminit=False)\n",
    "        self.datum = datanum_pb2.DataNum()\n",
    "        self.is_test = is_test\n",
    "        \n",
    "\n",
    "    def __len__(self):\n",
    "        n_entries =  int(self.env.stat()['entries'])\n",
    "        return n_entries\n",
    "\n",
    "\n",
    "    def __getitem__(self, data_indx):\n",
    "        index = None\n",
    "        audio_indx = None\n",
    "        index = data_indx\n",
    "        with self.env.begin(write=False) as cursor:\n",
    "            raw_datum = cursor.get('{:08}'.format(index).encode('ascii'))\n",
    "        self.datum.ParseFromString(raw_datum)\n",
    "        # float is represented by 4 bytes\n",
    "        start_idx = None\n",
    "        end_idx = None\n",
    "        if self.is_test:\n",
    "            return np.array(np.frombuffer(self.datum.vocals, dtype=np.float32)).reshape(-1),np.array(np.frombuffer(self.datum.mixture, dtype=np.float32)).reshape(-1)\n",
    "                \n",
    "        mixture, start_idx, end_idx = sample_buffer(self.datum.mixture, start_idx, end_idx)\n",
    "        mixture = np.array(np.frombuffer(mixture, dtype=np.float32)).reshape(1,-1)\n",
    "        vocals, _, _ = sample_buffer(self.datum.vocals, start_idx, end_idx)\n",
    "        vocals = np.frombuffer(vocals, dtype=np.float32).reshape(1,-1)\n",
    "        return vocals, mixture"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "vtrJ-eP0pQjS"
   },
   "source": [
    "### Visualize utils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ukzdK3k6MTnP"
   },
   "outputs": [],
   "source": [
    "def visualize_audio(audio_tensor, is_monphonic=False):\n",
    "    # takes a batch ,n channels , window length and plots the spectogram\n",
    "    input_audios = audio_tensor.detach().cpu().numpy()\n",
    "    plt.figure(figsize=(18, 50))\n",
    "    for i , audio in enumerate(input_audios):\n",
    "        plt.subplot(10, 2, i+1)\n",
    "        if is_monphonic:\n",
    "            plt.title('Monophonic %i' % (i+1))\n",
    "            librosa.display.waveplot(audio[0], sr=sampling_rate)\n",
    "        else:\n",
    "            D = librosa.amplitude_to_db(np.abs(librosa.stft(audio[0])), ref=np.max)\n",
    "            librosa.display.specshow(D, y_axis='linear')\n",
    "            plt.colorbar(format='%+2.0f dB')\n",
    "            plt.title('Linear-frequency power spectrogram %i' % (i+1))\n",
    "    plt.show()\n",
    "\n",
    "def visualize_loss(loss_1, loss_2, first_legend, second_legend, y_label):\n",
    "    plt.figure(figsize=(10,5))\n",
    "    plt.title(\"{} and {} Loss During Training\".format(first_legend, second_legend))\n",
    "    plt.plot(loss_1,label=first_legend)\n",
    "    plt.plot(loss_2,label=second_legend)\n",
    "    plt.xlabel(\"iterations\")\n",
    "    plt.ylabel(y_label)\n",
    "    plt.grid(True)\n",
    "    plt.tight_layout()\n",
    "    plt.legend()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "PxHweiv2pW-5"
   },
   "outputs": [],
   "source": [
    "def latent_space_interpolation(model, n_samples=10 ):\n",
    "    z_test = sample_noise(2)\n",
    "    with torch.no_grad():  \n",
    "        interpolates = []\n",
    "        for alpha in np.linspace(0, 1, n_samples):\n",
    "            interpolate_vec = alpha * z_test[0] + ((1 - alpha) * z_test[1])\n",
    "            interpolates.append(interpolate_vec)     \n",
    "            \n",
    "        interpolates = torch.stack(interpolates)\n",
    "        generated_audio = model(interpolates)\n",
    "    visualize_audio(generated_audio, True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "7GGWmjTDIyIv",
    "outputId": "3e23f00e-b246-4f35-d9f9-46a27158950f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'output'"
      ]
     },
     "execution_count": 123,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "if os.path.isdir(output_dir):\n",
    "  os.system('rm -r {}'.format(output_dir))\n",
    "make_path(output_dir)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3PgUiN6uJYtz"
   },
   "source": [
    "## Data Download and Loading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 161
    },
    "colab_type": "code",
    "id": "vuTx8G429sY6",
    "outputId": "c8333871-0e99-4e83-ee10-94021d9d60e8"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading package lists... Done\n",
      "Building dependency tree       \n",
      "Reading state information... Done\n",
      "p7zip-full is already the newest version (16.02+dfsg-6).\n",
      "The following package was automatically installed and is no longer required:\n",
      "  libnvidia-common-410\n",
      "Use 'apt autoremove' to remove it.\n",
      "0 upgraded, 0 newly installed, 0 to remove and 4 not upgraded.\n"
     ]
    }
   ],
   "source": [
    "!apt-get install p7zip-full"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "MUSDB download from MUSDB18 corpus for music separation https://zenodo.org/record/1117372\n",
    "\n",
    "```\n",
    "@misc{MUSDB18,\n",
    "  author       = {Rafii, Zafar and\n",
    "                  Liutkus, Antoine and\n",
    "                  Fabian-Robert St{\\\"o}ter and\n",
    "                  Mimilakis, Stylianos Ioannis and\n",
    "                  Bittner, Rachel},\n",
    "  title        = {The {MUSDB18} corpus for music separation},\n",
    "  month        = dec,\n",
    "  year         = 2017,\n",
    "  doi          = {10.5281/zenodo.1117372},\n",
    "  url          = {https://doi.org/10.5281/zenodo.1117372}\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "RCG_OJ0wJxr2"
   },
   "outputs": [],
   "source": [
    "\n",
    "if not(os.path.isfile('musdb_.7z')):\n",
    "  os.system('7z x  musdb_.7z')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Q3E6Oa0o9sZD"
   },
   "outputs": [],
   "source": [
    "from protocol_buffer import  datanum_pb2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "oEO_FDuOKfId"
   },
   "outputs": [],
   "source": [
    "# loading data using data loader\n",
    "train_dataset = LMDBWavLoader('musdb_train')\n",
    "train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size,\n",
    "                                        shuffle=True, num_workers=2,drop_last=True,pin_memory=True)\n",
    "val_dataset = LMDBWavLoader('musdb_valid')\n",
    "val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=batch_size,\n",
    "                                        shuffle=True, num_workers=2,drop_last=True,pin_memory=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "mvsDhwKeHf4r"
   },
   "source": [
    "## Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "uu2hKN9kHgsl"
   },
   "outputs": [],
   "source": [
    "class Transpose1dLayer(nn.Module):\n",
    "    def __init__(self, in_channels, out_channels, kernel_size, stride, padding=11, upsample=None, output_padding=1, use_batch_norm = False):\n",
    "        super(Transpose1dLayer, self).__init__()\n",
    "        self.upsample = upsample\n",
    "        reflection_pad = nn.ConstantPad1d(kernel_size // 2, value=0)\n",
    "        conv1d = nn.Conv1d(in_channels, out_channels, kernel_size, stride)\n",
    "        conv1d.weight.data.normal_(0.0, 0.02)\n",
    "        Conv1dTrans = nn.ConvTranspose1d(in_channels, out_channels, kernel_size, stride, padding, output_padding)\n",
    "        batch_norm = nn.BatchNorm1d(out_channels)\n",
    "        if self.upsample:\n",
    "            operation_list = [\n",
    "                reflection_pad,\n",
    "                conv1d  \n",
    "            ]\n",
    "        else:\n",
    "            operation_list = [\n",
    "                Conv1dTrans\n",
    "            ]\n",
    "\n",
    "        if use_batch_norm:\n",
    "            operation_list.append(batch_norm)\n",
    "        self.transpose_ops = nn.Sequential(*operation_list )\n",
    "\n",
    "    def forward(self, x):\n",
    "        if self.upsample:\n",
    "            # recommended by wavgan paper to use nearest upsampling\n",
    "            x = nn.functional.interpolate(x,scale_factor=self.upsample, mode='nearest')\n",
    "        return self.transpose_ops(x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "o5U4rCRHHiJp"
   },
   "outputs": [],
   "source": [
    "class Conv1D(nn.Module):\n",
    "    def __init__(self,input_channels, output_channels, kernel_size,alpha = 0.2,shift_factor=2, stride=4, padding=11, use_batch_norm=False, drop_prob = 0):\n",
    "        super(Conv1D, self).__init__()\n",
    "        self.conv1d = nn.Conv1d(input_channels, output_channels, kernel_size, stride=stride, padding=padding)\n",
    "        self.batch_norm = nn.BatchNorm1d(output_channels)\n",
    "        self.phase_shuffle =  PhaseShuffle(shift_factor)\n",
    "        self.alpha = alpha\n",
    "        self.use_batch_norm = use_batch_norm\n",
    "        self.use_phase_shuffle = shift_factor==0\n",
    "        self.use_drop = drop_prob>0\n",
    "        self.dropout = nn.Dropout2d(drop_prob)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = self.conv1d(x)\n",
    "        if self.use_batch_norm:\n",
    "            x = self.batch_norm(x)\n",
    "        x = F.leaky_relu(x, negative_slope=self.alpha)\n",
    "        if self.use_phase_shuffle: \n",
    "            x = self.phase_shuffle(x)\n",
    "        if self.use_drop:\n",
    "            x = self.dropout(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "tCZoaeDOHjaP"
   },
   "outputs": [],
   "source": [
    "class PhaseShuffle(nn.Module):\n",
    "    \"\"\"\n",
    "    Performs phase shuffling, i.e. shifting feature axis of a 3D tensor\n",
    "    by a random integer in {-n, n} and performing reflection padding where\n",
    "    necessary.\n",
    "    \"\"\"\n",
    "    # Copied from https://github.com/jtcramer/wavegan/blob/master/wavegan.py#L8\n",
    "    def __init__(self, shift_factor):\n",
    "        super(PhaseShuffle, self).__init__()\n",
    "        self.shift_factor = shift_factor\n",
    "\n",
    "    def forward(self, x):\n",
    "        if self.shift_factor == 0:\n",
    "            return x\n",
    "        # uniform in (L, R)\n",
    "        k_list = torch.Tensor(x.shape[0]).random_(0, 2 * self.shift_factor + 1) - self.shift_factor\n",
    "        k_list = k_list.numpy().astype(int)\n",
    "\n",
    "        # Combine sample indices into lists so that less shuffle operations\n",
    "        # need to be performed\n",
    "        k_map = {}\n",
    "        for idx, k in enumerate(k_list):\n",
    "            k = int(k)\n",
    "            if k not in k_map:\n",
    "                k_map[k] = []\n",
    "            k_map[k].append(idx)\n",
    "\n",
    "        # Make a copy of x for our output\n",
    "        x_shuffle = x.clone()\n",
    "\n",
    "        # Apply shuffle to each sample\n",
    "        for k, idxs in k_map.items():\n",
    "            if k > 0:\n",
    "                x_shuffle[idxs] = F.pad(x[idxs][..., :-k], (k, 0), mode='reflect')\n",
    "            else:\n",
    "                x_shuffle[idxs] = F.pad(x[idxs][..., -k:], (0, -k), mode='reflect')\n",
    "\n",
    "        assert x_shuffle.shape == x.shape, \"{}, {}\".format(x_shuffle.shape,\n",
    "                                                       x.shape)\n",
    "        return x_shuffle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UI5KHANTHnq7"
   },
   "source": [
    "### Generator Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "b_pE1roiHlMJ"
   },
   "outputs": [],
   "source": [
    "class WaveGANGenerator(nn.Module):\n",
    "    def __init__(self, model_size=64, num_channels=1,\n",
    "                  verbose=False,\n",
    "                  upsample=True, slice_len=16384, use_batch_norm = False):\n",
    "        super(WaveGANGenerator, self).__init__()\n",
    "        assert slice_len in [16384, 32768, 65536] # used to predict longer utterances\n",
    "\n",
    "        self.model_size = model_size  # d \n",
    "        self.verbose = verbose\n",
    "        self.use_batch_norm = use_batch_norm\n",
    "\n",
    "        self.dim_mul = 16 if slice_len == 16384 else 32\n",
    "\n",
    "        self.fc1 = nn.Linear(noise_latent_dim, 4*4* model_size * self.dim_mul)\n",
    "        self.bn1 = nn.BatchNorm1d(num_features= model_size * self.dim_mul)\n",
    "\n",
    "        stride = 4\n",
    "        if upsample:\n",
    "            stride = 1\n",
    "            upsample = 4\n",
    "        \n",
    "        deconv_layers = [\n",
    "            Transpose1dLayer( self.dim_mul* model_size, (self.dim_mul* model_size) //2, 25, stride, upsample=upsample,use_batch_norm=use_batch_norm),\n",
    "            Transpose1dLayer((self.dim_mul* model_size) //2, (self.dim_mul* model_size) //4, 25, stride, upsample=upsample,use_batch_norm=use_batch_norm),\n",
    "            Transpose1dLayer( (self.dim_mul* model_size) //4,  (self.dim_mul* model_size) //8, 25, stride, upsample=upsample,use_batch_norm=use_batch_norm),\n",
    "            Transpose1dLayer( (self.dim_mul* model_size) //8,  (self.dim_mul* model_size) //16, 25, stride, upsample=upsample,use_batch_norm=use_batch_norm),\n",
    "        ]\n",
    "        \n",
    "\n",
    "        if slice_len== 16384:\n",
    "            deconv_layers.append( Transpose1dLayer((self.dim_mul* model_size) //16, num_channels, 25, stride, upsample=upsample))\n",
    "        elif slice_len == 32768 :\n",
    "            deconv_layers +=[ \n",
    "                Transpose1dLayer((self.dim_mul* model_size) //16, model_size, 25, stride, upsample=upsample,use_batch_norm=use_batch_norm)\n",
    "                ,Transpose1dLayer(model_size, num_channels, 25, 2, upsample=upsample)\n",
    "            ]\n",
    "        elif slice_len == 65536:\n",
    "            deconv_layers +=[\n",
    "                Transpose1dLayer((self.dim_mul* model_size) //16, model_size, 25, stride, upsample=upsample,use_batch_norm=use_batch_norm)\n",
    "                ,Transpose1dLayer(model_size, num_channels, 25, stride, upsample=upsample)\n",
    "            ]\n",
    "        else:\n",
    "            raise ValueError('slice_len {} value is not supported'.format(slice_len))\n",
    "        \n",
    "\n",
    "        self.deconv_list = nn.ModuleList(deconv_layers)\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.ConvTranspose1d) or isinstance(m, nn.Linear):\n",
    "                nn.init.kaiming_normal_(m.weight.data)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.fc1(x).view(-1, self.dim_mul* self.model_size, 16)\n",
    "        if self.use_batch_norm:\n",
    "            x = self.bn1(x)\n",
    "        x = F.relu(x)\n",
    "        if self.verbose:\n",
    "            print(x.shape)\n",
    "\n",
    "        for deconv in self.deconv_list[:-1]:\n",
    "            x = F.relu(deconv(x))\n",
    "            if self.verbose:\n",
    "                print(x.shape)\n",
    "        output = torch.tanh(self.deconv_list[-1](x))\n",
    "        return output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "VeGi98DxHqH1"
   },
   "source": [
    "### Discriminator Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "WL4yeoYXHsNS"
   },
   "outputs": [],
   "source": [
    "class WaveGANDiscriminator(nn.Module):\n",
    "    def __init__(self, model_size=64, ngpus=1, num_channels=1, shift_factor=2,\n",
    "                 alpha=0.2, verbose=False, slice_len=16384, use_batch_norm = False):\n",
    "        super(WaveGANDiscriminator, self).__init__()\n",
    "        assert slice_len in [16384, 32768, 65536] # used to predict longer utterances\n",
    "        \n",
    "        self.model_size = model_size  # d\n",
    "        self.ngpus = ngpus\n",
    "        self.use_batch_norm = use_batch_norm\n",
    "        self.num_channels = num_channels  # c\n",
    "        self.shift_factor = shift_factor  # n\n",
    "        self.alpha = alpha\n",
    "        self.verbose = verbose\n",
    "\n",
    "\n",
    "        conv_layers = [\n",
    "            Conv1D(num_channels, model_size, 25, stride=4, padding=11, use_batch_norm=use_batch_norm, alpha=alpha,shift_factor=shift_factor),\n",
    "            Conv1D(model_size, 2 * model_size, 25, stride=4, padding=11, use_batch_norm=use_batch_norm, alpha=alpha,shift_factor=shift_factor),\n",
    "            Conv1D(2 * model_size, 4 * model_size, 25, stride=4, padding=11, use_batch_norm=use_batch_norm, alpha=alpha,shift_factor=shift_factor),\n",
    "            Conv1D(4 * model_size, 8 * model_size, 25, stride=4, padding=11, use_batch_norm=use_batch_norm, alpha=alpha,shift_factor=shift_factor),\n",
    "            Conv1D(8 * model_size, 16 * model_size, 25, stride=4, padding=11, use_batch_norm=use_batch_norm, alpha=alpha,shift_factor=0 if slice_len==16384 else shift_factor)\n",
    "        ]\n",
    "        self.fc_input_size = 256 * model_size\n",
    "        if slice_len == 32768 :\n",
    "            conv_layers.append(\n",
    "                 Conv1D(16 * model_size, 32 * model_size, 25, stride=2, padding=11,use_batch_norm=use_batch_norm, alpha=alpha,shift_factor=0)\n",
    "            ) \n",
    "            self.fc_input_size = 480 * model_size\n",
    "        elif slice_len == 65536:\n",
    "            conv_layers.append(\n",
    "                 Conv1D(16 * model_size, 32 * model_size, 25, stride=4, padding=11,use_batch_norm=use_batch_norm, alpha=alpha,shift_factor=0)\n",
    "            )\n",
    "            self.fc_input_size = 512 * model_size\n",
    "        \n",
    "        self.conv_layers = nn.ModuleList(conv_layers)\n",
    "        \n",
    "        self.fc1 = nn.Linear(self.fc_input_size, 1)\n",
    "\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Conv1d) or isinstance(m, nn.Linear):\n",
    "                nn.init.kaiming_normal_(m.weight.data)\n",
    "\n",
    "    def forward(self, x):\n",
    "        for conv in self.conv_layers:\n",
    "            x= conv(x)\n",
    "            if self.verbose:\n",
    "                print(x.shape)\n",
    "        x = x.view(-1, self.fc_input_size)\n",
    "        if self.verbose:\n",
    "            print(x.shape)\n",
    "\n",
    "        return self.fc1(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "naAboFqLq9-m"
   },
   "source": [
    "### Cyclic Generator with resblocks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "cBkTYn7ErBHB"
   },
   "outputs": [],
   "source": [
    "class ResidualBlock(nn.Module):\n",
    "    def __init__(self, in_features, use_batch_norm=True, alpha=0.2, shift_factor=2):\n",
    "        super(ResidualBlock, self).__init__()\n",
    "        conv_blocks = [\n",
    "            Conv1D(in_features, in_features, 21, stride=1, padding=10, use_batch_norm=use_batch_norm, alpha=alpha,shift_factor=shift_factor),\n",
    "            Conv1D(in_features, in_features, 21, stride=1, padding=10, use_batch_norm=use_batch_norm, alpha=alpha,shift_factor=shift_factor)\n",
    "        ]\n",
    "        self.conv_blocks = nn.ModuleList(conv_blocks)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        #down_sampled_x = nn.functional.interpolate(x,scale_factor=0.25, mode='nearest')\n",
    "        output = x\n",
    "        for conv in self.conv_blocks:\n",
    "            output = conv(output)\n",
    "        return x + output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "f4TD3PoHrDtn"
   },
   "outputs": [],
   "source": [
    "class CyclicWaveGanGenerator(nn.Module):\n",
    "    def __init__(self,model_size=64,  num_channels=1, shift_factor=2,\n",
    "                 alpha=0.2, verbose=False, slice_len=16384, use_batch_norm = False, upsample=True):\n",
    "        super(CyclicWaveGanGenerator, self).__init__()\n",
    "        assert slice_len in [16384, 32768, 65536] # used to predict longer utterances\n",
    "        self.dim_mul = 16 if slice_len == 16384 else 32\n",
    "        self.verbose = verbose\n",
    "        encoder_conv = [ \n",
    "            Conv1D(num_channels, model_size, 25, stride=4, padding=11, use_batch_norm=use_batch_norm, alpha=alpha,shift_factor=shift_factor),\n",
    "            Conv1D(model_size, 2 * model_size, 25, stride=4, padding=13 if slice_len==32768 else 11, use_batch_norm=use_batch_norm, alpha=alpha,shift_factor=shift_factor),\n",
    "            #Conv1D(2 * model_size, 4*model_size , 25, stride=4, padding=13 if slice_len==32768 else 11, use_batch_norm=use_batch_norm, alpha=alpha,shift_factor=shift_factor)\n",
    "        ]\n",
    "        n_resblocks = 8\n",
    "        if slice_len == 32768:\n",
    "            encoder_conv.append(\n",
    "                Conv1D(2*model_size , (self.dim_mul* model_size) //8, 25, stride=2, padding=11, use_batch_norm=use_batch_norm, alpha=alpha,shift_factor=shift_factor)\n",
    "            )\n",
    "            n_resblocks = 9\n",
    "        elif slice_len == 65536:\n",
    "            encoder_conv.append(\n",
    "                Conv1D(2*model_size , (self.dim_mul* model_size) //8, 25, stride=4, padding=11, use_batch_norm=use_batch_norm, alpha=alpha,shift_factor=shift_factor)\n",
    "            )\n",
    "            n_resblocks = 9\n",
    "        \n",
    "        self.encoder = nn.Sequential(*encoder_conv)\n",
    "        # encoder output 1 256 256\n",
    "        \n",
    "        transformation = []\n",
    "        for _ in range(n_resblocks):\n",
    "            transformation.append(ResidualBlock((self.dim_mul* model_size) //8))\n",
    "        self.transformation = nn.Sequential(*transformation)\n",
    "\n",
    "        # Upsampling\n",
    "        stride = 4\n",
    "        if upsample:\n",
    "            stride = 1\n",
    "            upsample = 4\n",
    "        \n",
    "        deconv_layers = [\n",
    "            Transpose1dLayer( (self.dim_mul* model_size) //8,  (self.dim_mul* model_size) //16, 25, stride, upsample=upsample,use_batch_norm=use_batch_norm),\n",
    "            #Transpose1dLayer( (self.dim_mul* model_size) //8,  (self.dim_mul* model_size) //16, 25, stride, upsample=upsample,use_batch_norm=use_batch_norm),\n",
    "        ]\n",
    "        \n",
    "\n",
    "        if slice_len== 16384:\n",
    "            deconv_layers.append( Transpose1dLayer((self.dim_mul* model_size) //16, num_channels, 25, stride, upsample=upsample))\n",
    "        elif slice_len == 32768 :\n",
    "            deconv_layers +=[ \n",
    "                Transpose1dLayer((self.dim_mul* model_size) //16, model_size, 25, stride, upsample=upsample,use_batch_norm=use_batch_norm)\n",
    "                ,Transpose1dLayer(model_size, num_channels, 25, 2, upsample=upsample)\n",
    "            ]\n",
    "        elif slice_len == 65536:\n",
    "            deconv_layers +=[\n",
    "                Transpose1dLayer((self.dim_mul* model_size) //16, model_size, 25, stride, upsample=upsample,use_batch_norm=use_batch_norm)\n",
    "                ,Transpose1dLayer(model_size, num_channels, 25, stride, upsample=upsample)\n",
    "            ]\n",
    "        else:\n",
    "            raise ValueError('slice_len {} value is not supported'.format(slice_len))\n",
    "        self.upsampling = nn.Sequential( *deconv_layers)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.encoder(x)\n",
    "        if self.verbose:\n",
    "            print(x.shape)\n",
    "        x = self.transformation(x)\n",
    "        if self.verbose:\n",
    "            print(x.shape)\n",
    "        x = self.upsampling(x)\n",
    "        if self.verbose:\n",
    "            print(x.shape)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "G0BEGQGtQwCC"
   },
   "source": [
    "### Discriminator Model With Latent Code Eval"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "6ip7uE5jQ0Af"
   },
   "outputs": [],
   "source": [
    "class WaveGANDiscriminatorSep(nn.Module):\n",
    "    def __init__(self, model_size=64,  num_channels=1, shift_factor=2,\n",
    "                 alpha=0.2, verbose=False, slice_len=16384, use_batch_norm = False, drop_prob=0.2):\n",
    "        super(WaveGANDiscriminatorSep, self).__init__()\n",
    "        assert slice_len in [16384, 32768, 65536] # used to predict longer utterances\n",
    "        \n",
    "        self.verbose = verbose\n",
    "        self.model_size = model_size\n",
    " \n",
    "        conv_layers = [\n",
    "            Conv1D(num_channels, model_size, 25, stride=4, padding=11, use_batch_norm=use_batch_norm, alpha=alpha,shift_factor=shift_factor, drop_prob = drop_prob),\n",
    "            Conv1D(model_size, 2 * model_size, 25, stride=4, padding=11, use_batch_norm=use_batch_norm, alpha=alpha,shift_factor=shift_factor, drop_prob = drop_prob),\n",
    "            Conv1D(2 * model_size, 4 * model_size, 25, stride=4, padding=11, use_batch_norm=use_batch_norm, alpha=alpha,shift_factor=shift_factor, drop_prob = drop_prob),\n",
    "        ]\n",
    "\n",
    "        if slice_len == 32768 :\n",
    "            conv_layers.append(\n",
    "                 Conv1D(4 * model_size, 4 * model_size, 25, stride=2, padding=12,use_batch_norm=use_batch_norm, alpha=alpha,shift_factor=shift_factor)\n",
    "            ) \n",
    "        elif slice_len == 65536:\n",
    "            conv_layers.append(\n",
    "                 Conv1D(4 * model_size, 4 * model_size, 25, stride=4, padding=12,use_batch_norm=use_batch_norm, alpha=alpha,shift_factor=shift_factor)\n",
    "            )\n",
    "        self.infer_input_audio = nn.ModuleList(conv_layers)\n",
    "\n",
    "        self.move_z_space = nn.Linear(noise_latent_dim, 64 * model_size)\n",
    "        self.infer_z = nn.ModuleList([\n",
    "            Conv1D( 1, model_size//8, 25, stride=4, padding=11, use_batch_norm=use_batch_norm, drop_prob = drop_prob),\n",
    "            Conv1D(model_size//8, model_size//4, 25, stride=4, padding=11,use_batch_norm=use_batch_norm, drop_prob = drop_prob),\n",
    "        ])\n",
    "        \n",
    "        conv_joint_layers = [\n",
    "            Conv1D((4 * model_size)+(model_size//4), 8 * model_size, 25, stride=4, padding=11, use_batch_norm=use_batch_norm, alpha=alpha,shift_factor=shift_factor, drop_prob = drop_prob),\n",
    "            Conv1D(8 * model_size, 16 * model_size, 25, stride=4, padding=11, use_batch_norm=use_batch_norm, alpha=alpha,shift_factor=0, drop_prob = 0 if slice_len==16384 else drop_prob)\n",
    "        ]\n",
    "        \n",
    "        self.fc_input_size = 8 * 32 * model_size\n",
    "        if slice_len == 32768 :\n",
    "            conv_joint_layers.append(\n",
    "                 Conv1D(16 * model_size, 32 * model_size, 25, stride=2, padding=11,use_batch_norm=use_batch_norm, alpha=alpha,shift_factor=shift_factor)\n",
    "            ) \n",
    "            self.fc_input_size = 7 * 32 * model_size\n",
    "        elif slice_len == 65536:\n",
    "            conv_joint_layers.append(\n",
    "                 Conv1D(16 * model_size, 32 * model_size, 25, stride=4, padding=11,use_batch_norm=use_batch_norm, alpha=alpha,shift_factor=shift_factor)\n",
    "            )\n",
    "            self.fc_input_size = 4 * 32 * model_size\n",
    "        self.infer_join = nn.ModuleList(conv_joint_layers)\n",
    "        self.fc1 = nn.Linear(self.fc_input_size, 1)\n",
    "        \n",
    "\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Conv1d) or isinstance(m, nn.Linear):\n",
    "                nn.init.kaiming_normal_(m.weight.data)\n",
    "\n",
    "    def forward(self, x, z):\n",
    "        for conv in self.infer_input_audio:\n",
    "            x = conv(x)\n",
    "            if self.verbose:\n",
    "                print(x.shape)\n",
    "        if self.verbose:\n",
    "            print(x.shape)\n",
    "        z = self.move_z_space(z).view(-1, 1, self.model_size * 64)\n",
    "        if self.verbose:\n",
    "            print(z.shape)\n",
    "        for conv in self.infer_z:\n",
    "            z = conv(z)\n",
    "            if self.verbose:\n",
    "                print(z.shape)\n",
    "        \n",
    "        # join z and x\n",
    "        output = torch.cat([x, z], dim=1)\n",
    "        if self.verbose:\n",
    "            print(output.shape)\n",
    "        for conv in self.infer_join:\n",
    "            output = conv(output)\n",
    "            if self.verbose:\n",
    "                print(output.shape)\n",
    "        output = output.view(-1, self.fc_input_size)\n",
    "        if self.verbose:\n",
    "            print(output.shape)\n",
    "        return self.fc1(output)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "anx6LvECQ41-"
   },
   "source": [
    "### Latent Space Encoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ehfs42VsQ7l8"
   },
   "outputs": [],
   "source": [
    "class WaveGanEncoder(nn.Module):\n",
    "    def __init__(self,model_size=64,  num_channels=1, shift_factor=2,\n",
    "                 alpha=0.2, verbose=False, slice_len=16384, use_batch_norm = False):\n",
    "        super(WaveGanEncoder, self).__init__()\n",
    "        self.verbose = verbose\n",
    "        conv_layers = [\n",
    "            Conv1D(num_channels, model_size, 25, stride=4, padding=11, use_batch_norm=use_batch_norm, alpha=alpha,shift_factor=shift_factor),\n",
    "            Conv1D(model_size, 2 * model_size, 25, stride=4, padding=11, use_batch_norm=use_batch_norm, alpha=alpha,shift_factor=shift_factor),\n",
    "            Conv1D(2 * model_size, 4 * model_size, 25, stride=4, padding=11, use_batch_norm=use_batch_norm, alpha=alpha,shift_factor=shift_factor),\n",
    "            Conv1D(4 * model_size, 8 * model_size, 25, stride=4, padding=11, use_batch_norm=use_batch_norm, alpha=alpha,shift_factor=shift_factor),\n",
    "        ]\n",
    "        self.fc_input_size = 8 * model_size * 16\n",
    "        if slice_len == 32768 :\n",
    "            conv_layers.append(\n",
    "                 Conv1D(8 * model_size, 16 * model_size, 25, stride=2, padding=11,use_batch_norm=use_batch_norm, alpha=alpha,shift_factor=shift_factor)\n",
    "            ) \n",
    "            self.fc_input_size = 16 * model_size * 16\n",
    "        elif slice_len == 65536:\n",
    "            conv_layers.append(\n",
    "                 Conv1D(8 * model_size, 16 * model_size, 25, stride=4, padding=11,use_batch_norm=use_batch_norm, alpha=alpha,shift_factor=shift_factor)\n",
    "            )\n",
    "            self.fc_input_size = 16 * model_size * 16\n",
    "        self.conv_layers = nn.ModuleList(conv_layers)\n",
    "\n",
    "        self.adaptive_pooling = nn.AdaptiveAvgPool1d(16) # needs to be checked later\n",
    "\n",
    "        self.mu_linear = nn.Linear(self.fc_input_size, noise_latent_dim)\n",
    "        self.logvar_linear = nn.Linear(self.fc_input_size, noise_latent_dim)\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Conv1d) or isinstance(m, nn.Linear):\n",
    "                nn.init.kaiming_normal_(m.weight.data)\n",
    "    \n",
    "    def reparametrize(self, mu, logvar):\n",
    "        std = logvar.mul(0.5).exp_()\n",
    "        z = mu + std * sample_noise(std.size(0))\n",
    "        return z\n",
    "\n",
    "    def bottleneck(self, h):\n",
    "        mu, logvar = self.mu_linear(h), self.logvar_linear(h)\n",
    "        z = self.reparametrize(mu, logvar)\n",
    "        return z, mu, logvar\n",
    "\n",
    "    def forward(self, x, inference=True):\n",
    "        for conv in self.conv_layers:\n",
    "            x= conv(x)\n",
    "            if self.verbose:\n",
    "                print(x.shape)\n",
    "        x = self.adaptive_pooling(x)\n",
    "        if self.verbose:\n",
    "            print(x.shape)\n",
    "        x = x.view(-1, self.fc_input_size)\n",
    "        if self.verbose:\n",
    "            print(x.shape)\n",
    "        z, _, _ = self.bottleneck(x)\n",
    "        return z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "JXDsLG4xHuIi"
   },
   "source": [
    "### Model Init and Testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 125
    },
    "colab_type": "code",
    "id": "6IkIOCh_Hv09",
    "outputId": "d6cce5a4-cfae-4cdf-9aee-1916fd8b065c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([10, 1024, 16])\n",
      "torch.Size([10, 512, 64])\n",
      "torch.Size([10, 256, 256])\n",
      "torch.Size([10, 128, 1024])\n",
      "torch.Size([10, 64, 4096])\n",
      "torch.Size([10, 1, 16384])\n"
     ]
    }
   ],
   "source": [
    "z = sample_noise(10)\n",
    "generator_model = WaveGANGenerator(verbose=True, upsample=True,  use_batch_norm=False ,slice_len = window_length).to(device)\n",
    "generated_audio_test = generator_model(z)\n",
    "print(generated_audio_test.shape)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 539
    },
    "colab_type": "code",
    "id": "M_KXlWMWIEDQ",
    "outputId": "88745063-6360-424b-b378-e6b4bec41c17"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------------------------------------------------------------\n",
      "        Layer (type)               Output Shape         Param #\n",
      "================================================================\n",
      "            Linear-1             [-1, 1, 16384]       1,654,784\n",
      "     ConstantPad1d-2             [-1, 1024, 88]               0\n",
      "            Conv1d-3              [-1, 512, 64]      13,107,712\n",
      "  Transpose1dLayer-4              [-1, 512, 64]               0\n",
      "     ConstantPad1d-5             [-1, 512, 280]               0\n",
      "            Conv1d-6             [-1, 256, 256]       3,277,056\n",
      "  Transpose1dLayer-7             [-1, 256, 256]               0\n",
      "     ConstantPad1d-8            [-1, 256, 1048]               0\n",
      "            Conv1d-9            [-1, 128, 1024]         819,328\n",
      " Transpose1dLayer-10            [-1, 128, 1024]               0\n",
      "    ConstantPad1d-11            [-1, 128, 4120]               0\n",
      "           Conv1d-12             [-1, 64, 4096]         204,864\n",
      " Transpose1dLayer-13             [-1, 64, 4096]               0\n",
      "    ConstantPad1d-14            [-1, 64, 16408]               0\n",
      "           Conv1d-15             [-1, 1, 16384]           1,601\n",
      " Transpose1dLayer-16             [-1, 1, 16384]               0\n",
      "================================================================\n",
      "Total params: 19,065,345\n",
      "Trainable params: 19,065,345\n",
      "Non-trainable params: 0\n",
      "----------------------------------------------------------------\n",
      "Input size (MB): 0.00\n",
      "Forward/backward pass size (MB): 23.74\n",
      "Params size (MB): 72.73\n",
      "Estimated Total Size (MB): 96.47\n",
      "----------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "generator_model.verbose=False\n",
    "summary(generator_model, input_size=(1,noise_latent_dim))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 143
    },
    "colab_type": "code",
    "id": "3uWoLAztIIR5",
    "outputId": "51d033a0-f6d3-40cc-a51a-6d9f8a3dea64"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([10, 64, 4096])\n",
      "torch.Size([10, 128, 1024])\n",
      "torch.Size([10, 256, 256])\n",
      "torch.Size([10, 512, 64])\n",
      "torch.Size([10, 1024, 16])\n",
      "torch.Size([10, 16384])\n",
      "torch.Size([10, 1])\n"
     ]
    }
   ],
   "source": [
    "discriminator_model = WaveGANDiscriminator(verbose=True, use_batch_norm=True  ,slice_len = window_length).to(device)\n",
    "discriminating_output = discriminator_model(generated_audio_test)\n",
    "print(discriminating_output.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 557
    },
    "colab_type": "code",
    "id": "NQ67upDZIZqq",
    "outputId": "8e0a2296-0568-4c06-8423-77e7ecc7030b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------------------------------------------------------------\n",
      "        Layer (type)               Output Shape         Param #\n",
      "================================================================\n",
      "            Conv1d-1             [-1, 64, 4096]           1,664\n",
      "       BatchNorm1d-2             [-1, 64, 4096]             128\n",
      "            Conv1D-3             [-1, 64, 4096]               0\n",
      "            Conv1d-4            [-1, 128, 1024]         204,928\n",
      "       BatchNorm1d-5            [-1, 128, 1024]             256\n",
      "            Conv1D-6            [-1, 128, 1024]               0\n",
      "            Conv1d-7             [-1, 256, 256]         819,456\n",
      "       BatchNorm1d-8             [-1, 256, 256]             512\n",
      "            Conv1D-9             [-1, 256, 256]               0\n",
      "           Conv1d-10              [-1, 512, 64]       3,277,312\n",
      "      BatchNorm1d-11              [-1, 512, 64]           1,024\n",
      "           Conv1D-12              [-1, 512, 64]               0\n",
      "           Conv1d-13             [-1, 1024, 16]      13,108,224\n",
      "      BatchNorm1d-14             [-1, 1024, 16]           2,048\n",
      "     PhaseShuffle-15             [-1, 1024, 16]               0\n",
      "           Conv1D-16             [-1, 1024, 16]               0\n",
      "           Linear-17                    [-1, 1]          16,385\n",
      "================================================================\n",
      "Total params: 17,431,937\n",
      "Trainable params: 17,431,937\n",
      "Non-trainable params: 0\n",
      "----------------------------------------------------------------\n",
      "Input size (MB): 0.06\n",
      "Forward/backward pass size (MB): 11.75\n",
      "Params size (MB): 66.50\n",
      "Estimated Total Size (MB): 78.31\n",
      "----------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "discriminator_model.verbose=False\n",
    "summary(discriminator_model, input_size=(1,window_length))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 233
    },
    "colab_type": "code",
    "id": "1qq1MUFeRKI-",
    "outputId": "91960b91-873f-4197-9523-3c909d1ad39c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([10, 64, 4096])\n",
      "torch.Size([10, 128, 1024])\n",
      "torch.Size([10, 256, 256])\n",
      "torch.Size([10, 256, 256])\n",
      "torch.Size([10, 1, 4096])\n",
      "torch.Size([10, 8, 1024])\n",
      "torch.Size([10, 16, 256])\n",
      "torch.Size([10, 272, 256])\n",
      "torch.Size([10, 512, 64])\n",
      "torch.Size([10, 1024, 16])\n",
      "torch.Size([10, 16384])\n",
      "torch.Size([10, 1])\n"
     ]
    }
   ],
   "source": [
    "discriminator_model = WaveGANDiscriminatorSep(verbose=True  ,slice_len = window_length).to(device)\n",
    "discriminating_output = discriminator_model(generated_audio_test, sample_noise(10))\n",
    "print(discriminating_output.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 665
    },
    "colab_type": "code",
    "id": "FnL_bKItRjUr",
    "outputId": "dfc0bc0e-6800-4c34-cd87-b07dc6787f72"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------------------------------------------------------------\n",
      "        Layer (type)               Output Shape         Param #\n",
      "================================================================\n",
      "            Conv1d-1             [-1, 64, 4096]           1,664\n",
      "         Dropout2d-2             [-1, 64, 4096]               0\n",
      "            Conv1D-3             [-1, 64, 4096]               0\n",
      "            Conv1d-4            [-1, 128, 1024]         204,928\n",
      "         Dropout2d-5            [-1, 128, 1024]               0\n",
      "            Conv1D-6            [-1, 128, 1024]               0\n",
      "            Conv1d-7             [-1, 256, 256]         819,456\n",
      "         Dropout2d-8             [-1, 256, 256]               0\n",
      "            Conv1D-9             [-1, 256, 256]               0\n",
      "           Linear-10              [-1, 1, 4096]         413,696\n",
      "           Conv1d-11              [-1, 8, 1024]             208\n",
      "        Dropout2d-12              [-1, 8, 1024]               0\n",
      "           Conv1D-13              [-1, 8, 1024]               0\n",
      "           Conv1d-14              [-1, 16, 256]           3,216\n",
      "        Dropout2d-15              [-1, 16, 256]               0\n",
      "           Conv1D-16              [-1, 16, 256]               0\n",
      "           Conv1d-17              [-1, 512, 64]       3,482,112\n",
      "        Dropout2d-18              [-1, 512, 64]               0\n",
      "           Conv1D-19              [-1, 512, 64]               0\n",
      "           Conv1d-20             [-1, 1024, 16]      13,108,224\n",
      "     PhaseShuffle-21             [-1, 1024, 16]               0\n",
      "           Conv1D-22             [-1, 1024, 16]               0\n",
      "           Linear-23                    [-1, 1]          16,385\n",
      "================================================================\n",
      "Total params: 18,049,889\n",
      "Trainable params: 18,049,889\n",
      "Non-trainable params: 0\n",
      "----------------------------------------------------------------\n",
      "Input size (MB): 6.25\n",
      "Forward/backward pass size (MB): 11.94\n",
      "Params size (MB): 68.85\n",
      "Estimated Total Size (MB): 87.04\n",
      "----------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "discriminator_model.verbose=False\n",
    "summary(discriminator_model, input_size=[(1,window_length),(1,noise_latent_dim)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 143
    },
    "colab_type": "code",
    "id": "jkSypp8RRKUZ",
    "outputId": "c7a6b99d-f493-45cc-9429-111cfa14d29f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([10, 64, 4096])\n",
      "torch.Size([10, 128, 1024])\n",
      "torch.Size([10, 256, 256])\n",
      "torch.Size([10, 512, 64])\n",
      "torch.Size([10, 512, 16])\n",
      "torch.Size([10, 8192])\n",
      "torch.Size([10, 100])\n"
     ]
    }
   ],
   "source": [
    "encoder_model = WaveGanEncoder(verbose=True  ,slice_len = window_length).to(device)\n",
    "latent_encoded = encoder_model(generated_audio_test)\n",
    "print(latent_encoded.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 449
    },
    "colab_type": "code",
    "id": "c9DIl5VxRqgk",
    "outputId": "72ca9a6e-5627-44e8-8302-97a611cbbaac"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------------------------------------------------------------\n",
      "        Layer (type)               Output Shape         Param #\n",
      "================================================================\n",
      "            Conv1d-1             [-1, 64, 4096]           1,664\n",
      "            Conv1D-2             [-1, 64, 4096]               0\n",
      "            Conv1d-3            [-1, 128, 1024]         204,928\n",
      "            Conv1D-4            [-1, 128, 1024]               0\n",
      "            Conv1d-5             [-1, 256, 256]         819,456\n",
      "            Conv1D-6             [-1, 256, 256]               0\n",
      "            Conv1d-7              [-1, 512, 64]       3,277,312\n",
      "            Conv1D-8              [-1, 512, 64]               0\n",
      " AdaptiveAvgPool1d-9              [-1, 512, 16]               0\n",
      "           Linear-10                  [-1, 100]         819,300\n",
      "           Linear-11                  [-1, 100]         819,300\n",
      "================================================================\n",
      "Total params: 5,941,960\n",
      "Trainable params: 5,941,960\n",
      "Non-trainable params: 0\n",
      "----------------------------------------------------------------\n",
      "Input size (MB): 0.06\n",
      "Forward/backward pass size (MB): 7.56\n",
      "Params size (MB): 22.67\n",
      "Estimated Total Size (MB): 30.29\n",
      "----------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "encoder_model.verbose=False\n",
    "summary(encoder_model, input_size=(1,window_length))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 89
    },
    "colab_type": "code",
    "id": "XUPONVxSrOF1",
    "outputId": "8dd20e3c-393e-44d4-aef4-c0e7848f79b0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([10, 128, 1024])\n",
      "torch.Size([10, 128, 1024])\n",
      "torch.Size([10, 1, 16384])\n",
      "torch.Size([10, 1, 16384])\n"
     ]
    }
   ],
   "source": [
    "cyclic_generator = CyclicWaveGanGenerator(slice_len=window_length, verbose = True).to(device)\n",
    "generated = cyclic_generator(Variable(torch.rand(10,1,window_length)).to(device))\n",
    "print(generated.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "colab_type": "code",
    "id": "VL0-X0FAraW7",
    "outputId": "84f5a380-0cb9-4c8c-c27e-527bb3abab63"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------------------------------------------------------------\n",
      "        Layer (type)               Output Shape         Param #\n",
      "================================================================\n",
      "            Conv1d-1             [-1, 64, 4096]           1,664\n",
      "            Conv1D-2             [-1, 64, 4096]               0\n",
      "            Conv1d-3            [-1, 128, 1024]         204,928\n",
      "            Conv1D-4            [-1, 128, 1024]               0\n",
      "            Conv1d-5            [-1, 128, 1024]         344,192\n",
      "       BatchNorm1d-6            [-1, 128, 1024]             256\n",
      "            Conv1D-7            [-1, 128, 1024]               0\n",
      "            Conv1d-8            [-1, 128, 1024]         344,192\n",
      "       BatchNorm1d-9            [-1, 128, 1024]             256\n",
      "           Conv1D-10            [-1, 128, 1024]               0\n",
      "    ResidualBlock-11            [-1, 128, 1024]               0\n",
      "           Conv1d-12            [-1, 128, 1024]         344,192\n",
      "      BatchNorm1d-13            [-1, 128, 1024]             256\n",
      "           Conv1D-14            [-1, 128, 1024]               0\n",
      "           Conv1d-15            [-1, 128, 1024]         344,192\n",
      "      BatchNorm1d-16            [-1, 128, 1024]             256\n",
      "           Conv1D-17            [-1, 128, 1024]               0\n",
      "    ResidualBlock-18            [-1, 128, 1024]               0\n",
      "           Conv1d-19            [-1, 128, 1024]         344,192\n",
      "      BatchNorm1d-20            [-1, 128, 1024]             256\n",
      "           Conv1D-21            [-1, 128, 1024]               0\n",
      "           Conv1d-22            [-1, 128, 1024]         344,192\n",
      "      BatchNorm1d-23            [-1, 128, 1024]             256\n",
      "           Conv1D-24            [-1, 128, 1024]               0\n",
      "    ResidualBlock-25            [-1, 128, 1024]               0\n",
      "           Conv1d-26            [-1, 128, 1024]         344,192\n",
      "      BatchNorm1d-27            [-1, 128, 1024]             256\n",
      "           Conv1D-28            [-1, 128, 1024]               0\n",
      "           Conv1d-29            [-1, 128, 1024]         344,192\n",
      "      BatchNorm1d-30            [-1, 128, 1024]             256\n",
      "           Conv1D-31            [-1, 128, 1024]               0\n",
      "    ResidualBlock-32            [-1, 128, 1024]               0\n",
      "           Conv1d-33            [-1, 128, 1024]         344,192\n",
      "      BatchNorm1d-34            [-1, 128, 1024]             256\n",
      "           Conv1D-35            [-1, 128, 1024]               0\n",
      "           Conv1d-36            [-1, 128, 1024]         344,192\n",
      "      BatchNorm1d-37            [-1, 128, 1024]             256\n",
      "           Conv1D-38            [-1, 128, 1024]               0\n",
      "    ResidualBlock-39            [-1, 128, 1024]               0\n",
      "           Conv1d-40            [-1, 128, 1024]         344,192\n",
      "      BatchNorm1d-41            [-1, 128, 1024]             256\n",
      "           Conv1D-42            [-1, 128, 1024]               0\n",
      "           Conv1d-43            [-1, 128, 1024]         344,192\n",
      "      BatchNorm1d-44            [-1, 128, 1024]             256\n",
      "           Conv1D-45            [-1, 128, 1024]               0\n",
      "    ResidualBlock-46            [-1, 128, 1024]               0\n",
      "           Conv1d-47            [-1, 128, 1024]         344,192\n",
      "      BatchNorm1d-48            [-1, 128, 1024]             256\n",
      "           Conv1D-49            [-1, 128, 1024]               0\n",
      "           Conv1d-50            [-1, 128, 1024]         344,192\n",
      "      BatchNorm1d-51            [-1, 128, 1024]             256\n",
      "           Conv1D-52            [-1, 128, 1024]               0\n",
      "    ResidualBlock-53            [-1, 128, 1024]               0\n",
      "           Conv1d-54            [-1, 128, 1024]         344,192\n",
      "      BatchNorm1d-55            [-1, 128, 1024]             256\n",
      "           Conv1D-56            [-1, 128, 1024]               0\n",
      "           Conv1d-57            [-1, 128, 1024]         344,192\n",
      "      BatchNorm1d-58            [-1, 128, 1024]             256\n",
      "           Conv1D-59            [-1, 128, 1024]               0\n",
      "    ResidualBlock-60            [-1, 128, 1024]               0\n",
      "    ConstantPad1d-61            [-1, 128, 4120]               0\n",
      "           Conv1d-62             [-1, 64, 4096]         204,864\n",
      " Transpose1dLayer-63             [-1, 64, 4096]               0\n",
      "    ConstantPad1d-64            [-1, 64, 16408]               0\n",
      "           Conv1d-65             [-1, 1, 16384]           1,601\n",
      " Transpose1dLayer-66             [-1, 1, 16384]               0\n",
      "================================================================\n",
      "Total params: 5,924,225\n",
      "Trainable params: 5,924,225\n",
      "Non-trainable params: 0\n",
      "----------------------------------------------------------------\n",
      "Input size (MB): 0.06\n",
      "Forward/backward pass size (MB): 78.29\n",
      "Params size (MB): 22.60\n",
      "Estimated Total Size (MB): 100.95\n",
      "----------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "cyclic_generator.verbose=False\n",
    "summary(cyclic_generator, input_size=(1,window_length))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "NqLXp66Qq2mI"
   },
   "source": [
    "### Cyclic Gan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "qvy6nHfUq4KA"
   },
   "outputs": [],
   "source": [
    "class CycleGan(object):\n",
    "    def __init__(self, train_loader, val_loader, validate=True):\n",
    "        # train cyclic to just disable the model from single source to mixed as an experiment\n",
    "\n",
    "        self.validate = validate\n",
    "\n",
    "        self.val_g_cost = []\n",
    "        self.train_g_cost = []\n",
    "        self.cyclic_loss = []\n",
    "        self.valid_reconstruction = []\n",
    "\n",
    "        self.discriminator_loss = []\n",
    "\n",
    "        self.generator = CyclicWaveGanGenerator(slice_len = window_length, model_size = model_capacity_size).to(device)\n",
    "        self.generator.apply(weights_init)\n",
    "        \n",
    "        self.discriminator_1 = WaveGANDiscriminator(slice_len = window_length, model_size = model_capacity_size).to(device)\n",
    "        self.discriminator_1.apply(weights_init)\n",
    "    \n",
    "        self.discriminator_2 = WaveGANDiscriminator(slice_len = window_length, model_size = model_capacity_size).to(device)\n",
    "        self.discriminator_2.apply(weights_init)\n",
    "\n",
    "\n",
    "        self.optimizer_d_1 = optim.Adam(self.discriminator_1.parameters(), lr=lr_d, betas=(beta1,  beta2))\n",
    "        self.optimizer_d_2 = optim.Adam(self.discriminator_2.parameters(), lr=lr_d, betas=(beta1,  beta2))\n",
    "        \n",
    "\n",
    "        \n",
    "\n",
    "        self.optimizer_g = optim.Adam(self.generator.parameters(), lr=lr_g, betas=(beta1,  beta2))\n",
    "\n",
    "        self.train_loader = train_loader\n",
    "        self.val_loader = val_loader          \n",
    "    \n",
    "    def apply_zero_grad(self):\n",
    "        self.discriminator_1.zero_grad()\n",
    "        self.discriminator_2.zero_grad()\n",
    "        self.generator.zero_grad()\n",
    "\n",
    "    def enable_gen_disable_disc(self):\n",
    "        gradients_status(self.generator, True)\n",
    "        gradients_status(self.discriminator_1, False)\n",
    "        gradients_status(self.discriminator_2, False)\n",
    "    \n",
    "    def disable_all(self):\n",
    "        gradients_status(self.generator, False)\n",
    "        gradients_status(self.discriminator_1, False)\n",
    "        gradients_status(self.discriminator_2, False)\n",
    "    \n",
    "  \n",
    "    def train(self):\n",
    "        real_label = 0.9\n",
    "        progress_bar =  tqdm(total=n_iterations//progress_bar_step_iter_size)\n",
    "        val_set = iter(self.val_loader)\n",
    "        val_data = next(val_set)\n",
    "        fixed_mixed_signal = val_data[1].to(device)\n",
    "        fixed_single_signal = val_data[0].to(device)\n",
    "        save_samples(fixed_mixed_signal.detach().cpu().numpy(), 'fixed_mixed' ) \n",
    "        save_samples(fixed_single_signal.detach().cpu().numpy(), 'fixed_single' ) \n",
    "        \n",
    "        gan_model_name = 'gan_cyclic_single_2disc_{}.tar'.format(model_prefix)\n",
    "        \n",
    "        first_iter = 0\n",
    "        if take_backup and os.path.isfile(gan_model_name):\n",
    "            if cuda:\n",
    "                checkpoint = torch.load(gan_model_name)\n",
    "            else:\n",
    "                checkpoint = torch.load(gan_model_name, map_location='cpu')\n",
    "            self.generator.load_state_dict(checkpoint['generator'])\n",
    "            self.discriminator_1.load_state_dict(checkpoint['discriminator_1'])\n",
    "            self.discriminator_2.load_state_dict(checkpoint['discriminator_2'])\n",
    "            self.optimizer_d_1.load_state_dict(checkpoint['optimizer_d_1'])\n",
    "            self.optimizer_d_2.load_state_dict(checkpoint['optimizer_d_2'])\n",
    "            self.optimizer_g.load_state_dict(checkpoint['optimizer_g'])\n",
    "            self.val_g_cost = checkpoint['val_g_cost']\n",
    "            self.train_g_cost = checkpoint['train_g_cost']\n",
    "            self.cyclic_loss = checkpoint['cyclic_loss']\n",
    "            self.discriminator_loss = checkpoint['discriminator_loss']\n",
    "            first_iter = checkpoint['n_iterations'] + 1\n",
    "            for _ in range(0, first_iter, progress_bar_step_iter_size):\n",
    "                progress_bar.update()\n",
    "            \n",
    "            \n",
    "            self.generator.eval()\n",
    "        criterion_GAN = nn.MSELoss()\n",
    "        criterion_cycle = nn.L1Loss()\n",
    "        criterion_identity = nn.L1Loss()\n",
    "\n",
    "        target_real = Variable(torch.Tensor(batch_size,1).fill_(1.0), requires_grad=False).to(device)\n",
    "        target_fake = Variable(torch.Tensor(batch_size,1).fill_(0.0), requires_grad=False).to(device)\n",
    "        \n",
    "        generated_single_buffer = ReplayBuffer()\n",
    "        train_set = iter(self.train_loader)\n",
    "        for iter_indx in range(first_iter, n_iterations): \n",
    "            self.generator.train()\n",
    "            self.discriminator_1.train()\n",
    "            self.discriminator_2.train()\n",
    "            try:\n",
    "                data = next(train_set)\n",
    "            except StopIteration:\n",
    "                train_set = iter(self.train_loader)\n",
    "                data = next(train_set)\n",
    "            \n",
    "            # in case of unpaired data\n",
    "            single_signal = data[0].to(device)\n",
    "            mixed_signal = data[1].to(device)\n",
    "\n",
    "\n",
    "            #############################\n",
    "            # Training First Discriminator\n",
    "            #############################\n",
    "            self.apply_zero_grad()\n",
    "            self.disable_all()\n",
    "            gradients_status(self.discriminator_1, True)\n",
    "            generated_single_signal = self.generator(single_signal)\n",
    "            rest_of_signal = mixed_signal - generated_single_signal\n",
    "            new_mixed_signal = rest_of_signal + single_signal\n",
    "\n",
    "            # Real loss\n",
    "            is_single_signal_r = self.discriminator_1(single_signal)\n",
    "            #d_loss_real_1 = criterion_GAN(is_single_signal_r,target_real)\n",
    "\n",
    "            # generated loss\n",
    "            #generated_single_signal = generated_single_buffer.push_and_pop(generated_single_signal)\n",
    "            is_single_signal_f = self.discriminator_1(generated_single_signal.detach())\n",
    "            #d_loss_generated_1 = criterion_GAN(is_single_signal_f, target_fake)\n",
    "\n",
    "            d_loss_1 = (torch.mean((is_single_signal_r - torch.mean(is_single_signal_f) - target_real) ** 2) +\n",
    "                torch.mean((is_single_signal_f - torch.mean(is_single_signal_r) + target_real) ** 2))/2#(d_loss_real_1 + d_loss_generated_1)/2\n",
    "            d_loss_1.backward()\n",
    "            self.optimizer_d_1.step()\n",
    "            #############################\n",
    "            # Training Second Discriminator\n",
    "            #############################\n",
    "            self.apply_zero_grad()\n",
    "            self.disable_all()\n",
    "            gradients_status(self.discriminator_2, True)\n",
    "            # Real loss\n",
    "            is_mixed_signal_r = self.discriminator_2(mixed_signal)\n",
    "            #d_loss_real_1 = criterion_GAN(is_mixed_signal_r,target_real)\n",
    "\n",
    "            # generated loss\n",
    "            #generated_single_signal = generated_single_buffer.push_and_pop(generated_single_signal)\n",
    "            is_mixed_signal_f = self.discriminator_2(new_mixed_signal.detach())\n",
    "            #d_loss_generated_1 = criterion_GAN(is_mixed_signal_f, target_fake)\n",
    "\n",
    "            d_loss_2 = (torch.mean((is_mixed_signal_r - torch.mean(is_mixed_signal_f) - target_real) ** 2) +\n",
    "                torch.mean((is_mixed_signal_f - torch.mean(is_mixed_signal_r) + target_real) ** 2))/2#(d_loss_real_1 + d_loss_generated_1)/2\n",
    "            d_loss_2.backward()\n",
    "            self.optimizer_d_2.step()\n",
    "\n",
    "            #############################\n",
    "            # Training  generator\n",
    "            #############################\n",
    "            self.apply_zero_grad()\n",
    "            self.enable_gen_disable_disc()\n",
    "            \n",
    "\n",
    "            # Identity loss without it the model would make changes to input even without any need\n",
    "\n",
    "            \n",
    "            identity_loss_1 = criterion_identity(generated_single_signal, single_signal)\n",
    "        \n",
    "            # Gan Loss\n",
    "            #generated_single_signal = self.generator(mixed_signal)\n",
    "            is_single_signal_r = self.discriminator_1(single_signal)\n",
    "            is_single_signal_f = self.discriminator_1(generated_single_signal)\n",
    "            gan_loss_1 = (torch.mean((is_single_signal_r - torch.mean(is_single_signal_f) + target_real) ** 2) +\n",
    "                torch.mean((is_single_signal_f - torch.mean(is_single_signal_r) - target_real) ** 2))/2\n",
    "\n",
    "            #gan_loss_1 =criterion_GAN(is_single_signal, target_real )\n",
    "\n",
    "\n",
    "            is_mixed_signal_r = self.discriminator_2(mixed_signal)\n",
    "            is_mixed_signal_f = self.discriminator_2(new_mixed_signal)\n",
    "            gan_loss_2 = (torch.mean((is_mixed_signal_r - torch.mean(is_mixed_signal_f) + target_real) ** 2) +\n",
    "                torch.mean((is_mixed_signal_f - torch.mean(is_mixed_signal_r) - target_real) ** 2))/2\n",
    "\n",
    "            #gan_loss_2 = criterion_GAN(is_mixed_signal, target_real )\n",
    "\n",
    "            reconstructed_single_sinal = self.generator(new_mixed_signal)\n",
    "\n",
    "            cycle_loss_1 = criterion_cycle(reconstructed_single_sinal, single_signal)\n",
    "            # Total Loss\n",
    "            g_cost  =  identity_loss_1*0.5 + (gan_loss_1 + gan_loss_2)  + 10*cycle_loss_1 \n",
    "            g_cost.backward()\n",
    "            self.optimizer_g.step()\n",
    "\n",
    "\n",
    "            if self.validate and iter_indx%store_cost_every==0:\n",
    "                self.discriminator_loss.append(d_loss_1.item())\n",
    "                self.train_g_cost.append(g_cost.item())\n",
    "                # validating\n",
    "                self.disable_all()\n",
    "                with torch.no_grad():\n",
    "                    try:\n",
    "                        val_data = next(val_set)\n",
    "                    except StopIteration:\n",
    "                        val_set = iter(self.val_loader)\n",
    "                        val_data = next(val_set)\n",
    "                    val_single = val_data[0].to(device)\n",
    "                    val_mixed = val_data[1].to(device)\n",
    "                    val_cost= criterion_GAN(self.discriminator_1(val_single), target_real) + criterion_GAN(self.discriminator_2(val_single), target_real)\n",
    "                    self.val_g_cost.append(val_cost.item())\n",
    "                    reconstructed_music = self.generator(val_mixed)\n",
    "                    self.valid_reconstruction.append(F.mse_loss(reconstructed_music, val_single, reduction='sum').item())\n",
    "                    \n",
    "\n",
    "            if iter_indx%store_cost_every==0 :\n",
    "                progress_updates = {'Reconstruction': str(self.valid_reconstruction[-1]),'Loss_D1': str(d_loss_1.item()), 'Loss_g':str(g_cost.item())}\n",
    "                progress_bar.set_postfix(progress_updates)\n",
    "\n",
    "\n",
    "            if iter_indx%progress_bar_step_iter_size==0:\n",
    "                progress_bar.update()\n",
    "            # lr decay \n",
    "            if decay_lr:\n",
    "                decay = max(0.0,1.0-(iter_indx*1.0/n_iterations))\n",
    "                # update the learning rate\n",
    "                update_optimizer_lr(self.optimizer_d, lr_d, decay)\n",
    "                update_optimizer_lr(self.optimizer_g, lr_g, decay)\n",
    "\n",
    "            if (iter_indx%save_samples_every==0):\n",
    "                with torch.no_grad():\n",
    "                    fake = self.generator(fixed_mixed_signal).detach().cpu().numpy()\n",
    "                save_samples(fake, iter_indx , prefix='predictions')\n",
    "            \n",
    "            if take_backup and iter_indx%backup_every_n_iters==0:\n",
    "                saving_dict = {\n",
    "                    'generator': self.generator.state_dict(),\n",
    "                    'discriminator_1': self.discriminator_1.state_dict(),\n",
    "                    'optimizer_d_1': self.optimizer_d_1.state_dict(), \n",
    "                    'discriminator_2': self.discriminator_2.state_dict(),\n",
    "                    'optimizer_d_2': self.optimizer_d_2.state_dict(), \n",
    "                    'optimizer_g': self.optimizer_g.state_dict(),\n",
    "                    'val_g_cost': self.val_g_cost,\n",
    "                    'train_g_cost': self.train_g_cost,\n",
    "                    'cyclic_loss': self.cyclic_loss,\n",
    "                    'discriminator_loss': self.discriminator_loss,\n",
    "                    'n_iterations': iter_indx\n",
    "                }\n",
    "                torch.save(saving_dict,gan_model_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Cz3XfTqIJRBx"
   },
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 77,
     "resources": {
      "http://localhost:8080/nbextensions/google.colab/colabwidgets/controls.css": {
       "data": "/* Copyright (c) Jupyter Development Team.
 * Distributed under the terms of the Modified BSD License.
 */

 /* We import all of these together in a single css file because the Webpack
loader sees only one file at a time. This allows postcss to see the variable
definitions when they are used. */

 /*-----------------------------------------------------------------------------
| Copyright (c) Jupyter Development Team.
| Distributed under the terms of the Modified BSD License.
|----------------------------------------------------------------------------*/

 /*
This file is copied from the JupyterLab project to define default styling for
when the widget styling is compiled down to eliminate CSS variables. We make one
change - we comment out the font import below.
*/

 /**
 * The material design colors are adapted from google-material-color v1.2.6
 * https://github.com/danlevan/google-material-color
 * https://github.com/danlevan/google-material-color/blob/f67ca5f4028b2f1b34862f64b0ca67323f91b088/dist/palette.var.css
 *
 * The license for the material design color CSS variables is as follows (see
 * https://github.com/danlevan/google-material-color/blob/f67ca5f4028b2f1b34862f64b0ca67323f91b088/LICENSE)
 *
 * The MIT License (MIT)
 *
 * Copyright (c) 2014 Dan Le Van
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

 /*
The following CSS variables define the main, public API for styling JupyterLab.
These variables should be used by all plugins wherever possible. In other
words, plugins should not define custom colors, sizes, etc unless absolutely
necessary. This enables users to change the visual theme of JupyterLab
by changing these variables.

Many variables appear in an ordered sequence (0,1,2,3). These sequences
are designed to work well together, so for example, `--jp-border-color1` should
be used with `--jp-layout-color1`. The numbers have the following meanings:

* 0: super-primary, reserved for special emphasis
* 1: primary, most important under normal situations
* 2: secondary, next most important under normal situations
* 3: tertiary, next most important under normal situations

Throughout JupyterLab, we are mostly following principles from Google's
Material Design when selecting colors. We are not, however, following
all of MD as it is not optimized for dense, information rich UIs.
*/

 /*
 * Optional monospace font for input/output prompt.
 */

 /* Commented out in ipywidgets since we don't need it. */

 /* @import url('https://fonts.googleapis.com/css?family=Roboto+Mono'); */

 /*
 * Added for compabitility with output area
 */

 :root {

  /* Borders

  The following variables, specify the visual styling of borders in JupyterLab.
   */

  /* UI Fonts

  The UI font CSS variables are used for the typography all of the JupyterLab
  user interface elements that are not directly user generated content.
  */ /* Base font size */ /* Ensures px perfect FontAwesome icons */

  /* Use these font colors against the corresponding main layout colors.
     In a light theme, these go from dark to light.
  */

  /* Use these against the brand/accent/warn/error colors.
     These will typically go from light to darker, in both a dark and light theme
   */

  /* Content Fonts

  Content font variables are used for typography of user generated content.
  */ /* Base font size */


  /* Layout

  The following are the main layout colors use in JupyterLab. In a light
  theme these would go from light to dark.
  */

  /* Brand/accent */

  /* State colors (warn, error, success, info) */

  /* Cell specific styles */
  /* A custom blend of MD grey and blue 600
   * See https://meyerweb.com/eric/tools/color-blend/#546E7A:1E88E5:5:hex */
  /* A custom blend of MD grey and orange 600
   * https://meyerweb.com/eric/tools/color-blend/#546E7A:F4511E:5:hex */

  /* Notebook specific styles */

  /* Console specific styles */

  /* Toolbar specific styles */
}

 /* Copyright (c) Jupyter Development Team.
 * Distributed under the terms of the Modified BSD License.
 */

 /*
 * We assume that the CSS variables in
 * https://github.com/jupyterlab/jupyterlab/blob/master/src/default-theme/variables.css
 * have been defined.
 */

 /* This file has code derived from PhosphorJS CSS files, as noted below. The license for this PhosphorJS code is:

Copyright (c) 2014-2017, PhosphorJS Contributors
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice, this
  list of conditions and the following disclaimer.

* Redistributions in binary form must reproduce the above copyright notice,
  this list of conditions and the following disclaimer in the documentation
  and/or other materials provided with the distribution.

* Neither the name of the copyright holder nor the names of its
  contributors may be used to endorse or promote products derived from
  this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

 /*
 * The following section is derived from https://github.com/phosphorjs/phosphor/blob/23b9d075ebc5b73ab148b6ebfc20af97f85714c4/packages/widgets/style/tabbar.css 
 * We've scoped the rules so that they are consistent with exactly our code.
 */

 .jupyter-widgets.widget-tab > .p-TabBar {
  display: -webkit-box;
  display: -ms-flexbox;
  display: flex;
  -webkit-user-select: none;
  -moz-user-select: none;
  -ms-user-select: none;
  user-select: none;
}

 .jupyter-widgets.widget-tab > .p-TabBar[data-orientation='horizontal'] {
  -webkit-box-orient: horizontal;
  -webkit-box-direction: normal;
      -ms-flex-direction: row;
          flex-direction: row;
}

 .jupyter-widgets.widget-tab > .p-TabBar[data-orientation='vertical'] {
  -webkit-box-orient: vertical;
  -webkit-box-direction: normal;
      -ms-flex-direction: column;
          flex-direction: column;
}

 .jupyter-widgets.widget-tab > .p-TabBar > .p-TabBar-content {
  margin: 0;
  padding: 0;
  display: -webkit-box;
  display: -ms-flexbox;
  display: flex;
  -webkit-box-flex: 1;
      -ms-flex: 1 1 auto;
          flex: 1 1 auto;
  list-style-type: none;
}

 .jupyter-widgets.widget-tab > .p-TabBar[data-orientation='horizontal'] > .p-TabBar-content {
  -webkit-box-orient: horizontal;
  -webkit-box-direction: normal;
      -ms-flex-direction: row;
          flex-direction: row;
}

 .jupyter-widgets.widget-tab > .p-TabBar[data-orientation='vertical'] > .p-TabBar-content {
  -webkit-box-orient: vertical;
  -webkit-box-direction: normal;
      -ms-flex-direction: column;
          flex-direction: column;
}

 .jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tab {
  display: -webkit-box;
  display: -ms-flexbox;
  display: flex;
  -webkit-box-orient: horizontal;
  -webkit-box-direction: normal;
      -ms-flex-direction: row;
          flex-direction: row;
  -webkit-box-sizing: border-box;
          box-sizing: border-box;
  overflow: hidden;
}

 .jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tabIcon,
.jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tabCloseIcon {
  -webkit-box-flex: 0;
      -ms-flex: 0 0 auto;
          flex: 0 0 auto;
}

 .jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tabLabel {
  -webkit-box-flex: 1;
      -ms-flex: 1 1 auto;
          flex: 1 1 auto;
  overflow: hidden;
  white-space: nowrap;
}

 .jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tab.p-mod-hidden {
  display: none !important;
}

 .jupyter-widgets.widget-tab > .p-TabBar.p-mod-dragging .p-TabBar-tab {
  position: relative;
}

 .jupyter-widgets.widget-tab > .p-TabBar.p-mod-dragging[data-orientation='horizontal'] .p-TabBar-tab {
  left: 0;
  -webkit-transition: left 150ms ease;
  transition: left 150ms ease;
}

 .jupyter-widgets.widget-tab > .p-TabBar.p-mod-dragging[data-orientation='vertical'] .p-TabBar-tab {
  top: 0;
  -webkit-transition: top 150ms ease;
  transition: top 150ms ease;
}

 .jupyter-widgets.widget-tab > .p-TabBar.p-mod-dragging .p-TabBar-tab.p-mod-dragging {
  -webkit-transition: none;
  transition: none;
}

 /* End tabbar.css */

 :root { /* margin between inline elements */

    /* From Material Design Lite */
}

 .jupyter-widgets {
    margin: 2px;
    -webkit-box-sizing: border-box;
            box-sizing: border-box;
    color: black;
    overflow: visible;
}

 .jupyter-widgets.jupyter-widgets-disconnected::before {
    line-height: 28px;
    height: 28px;
}

 .jp-Output-result > .jupyter-widgets {
    margin-left: 0;
    margin-right: 0;
}

 /* vbox and hbox */

 .widget-inline-hbox {
    /* Horizontal widgets */
    -webkit-box-sizing: border-box;
            box-sizing: border-box;
    display: -webkit-box;
    display: -ms-flexbox;
    display: flex;
    -webkit-box-orient: horizontal;
    -webkit-box-direction: normal;
        -ms-flex-direction: row;
            flex-direction: row;
    -webkit-box-align: baseline;
        -ms-flex-align: baseline;
            align-items: baseline;
}

 .widget-inline-vbox {
    /* Vertical Widgets */
    -webkit-box-sizing: border-box;
            box-sizing: border-box;
    display: -webkit-box;
    display: -ms-flexbox;
    display: flex;
    -webkit-box-orient: vertical;
    -webkit-box-direction: normal;
        -ms-flex-direction: column;
            flex-direction: column;
    -webkit-box-align: center;
        -ms-flex-align: center;
            align-items: center;
}

 .widget-box {
    -webkit-box-sizing: border-box;
            box-sizing: border-box;
    display: -webkit-box;
    display: -ms-flexbox;
    display: flex;
    margin: 0;
    overflow: auto;
}

 .widget-gridbox {
    -webkit-box-sizing: border-box;
            box-sizing: border-box;
    display: grid;
    margin: 0;
    overflow: auto;
}

 .widget-hbox {
    -webkit-box-orient: horizontal;
    -webkit-box-direction: normal;
        -ms-flex-direction: row;
            flex-direction: row;
}

 .widget-vbox {
    -webkit-box-orient: vertical;
    -webkit-box-direction: normal;
        -ms-flex-direction: column;
            flex-direction: column;
}

 /* General Button Styling */

 .jupyter-button {
    padding-left: 10px;
    padding-right: 10px;
    padding-top: 0px;
    padding-bottom: 0px;
    display: inline-block;
    white-space: nowrap;
    overflow: hidden;
    text-overflow: ellipsis;
    text-align: center;
    font-size: 13px;
    cursor: pointer;

    height: 28px;
    border: 0px solid;
    line-height: 28px;
    -webkit-box-shadow: none;
            box-shadow: none;

    color: rgba(0, 0, 0, .8);
    background-color: #EEEEEE;
    border-color: #E0E0E0;
    border: none;
}

 .jupyter-button i.fa {
    margin-right: 4px;
    pointer-events: none;
}

 .jupyter-button:empty:before {
    content: "\200b"; /* zero-width space */
}

 .jupyter-widgets.jupyter-button:disabled {
    opacity: 0.6;
}

 .jupyter-button i.fa.center {
    margin-right: 0;
}

 .jupyter-button:hover:enabled, .jupyter-button:focus:enabled {
    /* MD Lite 2dp shadow */
    -webkit-box-shadow: 0 2px 2px 0 rgba(0, 0, 0, .14),
                0 3px 1px -2px rgba(0, 0, 0, .2),
                0 1px 5px 0 rgba(0, 0, 0, .12);
            box-shadow: 0 2px 2px 0 rgba(0, 0, 0, .14),
                0 3px 1px -2px rgba(0, 0, 0, .2),
                0 1px 5px 0 rgba(0, 0, 0, .12);
}

 .jupyter-button:active, .jupyter-button.mod-active {
    /* MD Lite 4dp shadow */
    -webkit-box-shadow: 0 4px 5px 0 rgba(0, 0, 0, .14),
                0 1px 10px 0 rgba(0, 0, 0, .12),
                0 2px 4px -1px rgba(0, 0, 0, .2);
            box-shadow: 0 4px 5px 0 rgba(0, 0, 0, .14),
                0 1px 10px 0 rgba(0, 0, 0, .12),
                0 2px 4px -1px rgba(0, 0, 0, .2);
    color: rgba(0, 0, 0, .8);
    background-color: #BDBDBD;
}

 .jupyter-button:focus:enabled {
    outline: 1px solid #64B5F6;
}

 /* Button "Primary" Styling */

 .jupyter-button.mod-primary {
    color: rgba(255, 255, 255, 1.0);
    background-color: #2196F3;
}

 .jupyter-button.mod-primary.mod-active {
    color: rgba(255, 255, 255, 1);
    background-color: #1976D2;
}

 .jupyter-button.mod-primary:active {
    color: rgba(255, 255, 255, 1);
    background-color: #1976D2;
}

 /* Button "Success" Styling */

 .jupyter-button.mod-success {
    color: rgba(255, 255, 255, 1.0);
    background-color: #4CAF50;
}

 .jupyter-button.mod-success.mod-active {
    color: rgba(255, 255, 255, 1);
    background-color: #388E3C;
 }

 .jupyter-button.mod-success:active {
    color: rgba(255, 255, 255, 1);
    background-color: #388E3C;
 }

 /* Button "Info" Styling */

 .jupyter-button.mod-info {
    color: rgba(255, 255, 255, 1.0);
    background-color: #00BCD4;
}

 .jupyter-button.mod-info.mod-active {
    color: rgba(255, 255, 255, 1);
    background-color: #0097A7;
}

 .jupyter-button.mod-info:active {
    color: rgba(255, 255, 255, 1);
    background-color: #0097A7;
}

 /* Button "Warning" Styling */

 .jupyter-button.mod-warning {
    color: rgba(255, 255, 255, 1.0);
    background-color: #FF9800;
}

 .jupyter-button.mod-warning.mod-active {
    color: rgba(255, 255, 255, 1);
    background-color: #F57C00;
}

 .jupyter-button.mod-warning:active {
    color: rgba(255, 255, 255, 1);
    background-color: #F57C00;
}

 /* Button "Danger" Styling */

 .jupyter-button.mod-danger {
    color: rgba(255, 255, 255, 1.0);
    background-color: #F44336;
}

 .jupyter-button.mod-danger.mod-active {
    color: rgba(255, 255, 255, 1);
    background-color: #D32F2F;
}

 .jupyter-button.mod-danger:active {
    color: rgba(255, 255, 255, 1);
    background-color: #D32F2F;
}

 /* Widget Button*/

 .widget-button, .widget-toggle-button {
    width: 148px;
}

 /* Widget Label Styling */

 /* Override Bootstrap label css */

 .jupyter-widgets label {
    margin-bottom: 0;
    margin-bottom: initial;
}

 .widget-label-basic {
    /* Basic Label */
    color: black;
    font-size: 13px;
    overflow: hidden;
    text-overflow: ellipsis;
    white-space: nowrap;
    line-height: 28px;
}

 .widget-label {
    /* Label */
    color: black;
    font-size: 13px;
    overflow: hidden;
    text-overflow: ellipsis;
    white-space: nowrap;
    line-height: 28px;
}

 .widget-inline-hbox .widget-label {
    /* Horizontal Widget Label */
    color: black;
    text-align: right;
    margin-right: 8px;
    width: 80px;
    -ms-flex-negative: 0;
        flex-shrink: 0;
}

 .widget-inline-vbox .widget-label {
    /* Vertical Widget Label */
    color: black;
    text-align: center;
    line-height: 28px;
}

 /* Widget Readout Styling */

 .widget-readout {
    color: black;
    font-size: 13px;
    height: 28px;
    line-height: 28px;
    overflow: hidden;
    white-space: nowrap;
    text-align: center;
}

 .widget-readout.overflow {
    /* Overflowing Readout */

    /* From Material Design Lite
        shadow-key-umbra-opacity: 0.2;
        shadow-key-penumbra-opacity: 0.14;
        shadow-ambient-shadow-opacity: 0.12;
     */
    -webkit-box-shadow: 0 2px 2px 0 rgba(0, 0, 0, .2),
                        0 3px 1px -2px rgba(0, 0, 0, .14),
                        0 1px 5px 0 rgba(0, 0, 0, .12);

    box-shadow: 0 2px 2px 0 rgba(0, 0, 0, .2),
                0 3px 1px -2px rgba(0, 0, 0, .14),
                0 1px 5px 0 rgba(0, 0, 0, .12);
}

 .widget-inline-hbox .widget-readout {
    /* Horizontal Readout */
    text-align: center;
    max-width: 148px;
    min-width: 72px;
    margin-left: 4px;
}

 .widget-inline-vbox .widget-readout {
    /* Vertical Readout */
    margin-top: 4px;
    /* as wide as the widget */
    width: inherit;
}

 /* Widget Checkbox Styling */

 .widget-checkbox {
    width: 300px;
    height: 28px;
    line-height: 28px;
}

 .widget-checkbox input[type="checkbox"] {
    margin: 0px 8px 0px 0px;
    line-height: 28px;
    font-size: large;
    -webkit-box-flex: 1;
        -ms-flex-positive: 1;
            flex-grow: 1;
    -ms-flex-negative: 0;
        flex-shrink: 0;
    -ms-flex-item-align: center;
        align-self: center;
}

 /* Widget Valid Styling */

 .widget-valid {
    height: 28px;
    line-height: 28px;
    width: 148px;
    font-size: 13px;
}

 .widget-valid i:before {
    line-height: 28px;
    margin-right: 4px;
    margin-left: 4px;

    /* from the fa class in FontAwesome: https://github.com/FortAwesome/Font-Awesome/blob/49100c7c3a7b58d50baa71efef11af41a66b03d3/css/font-awesome.css#L14 */
    display: inline-block;
    font: normal normal normal 14px/1 FontAwesome;
    font-size: inherit;
    text-rendering: auto;
    -webkit-font-smoothing: antialiased;
    -moz-osx-font-smoothing: grayscale;
}

 .widget-valid.mod-valid i:before {
    content: "\f00c";
    color: green;
}

 .widget-valid.mod-invalid i:before {
    content: "\f00d";
    color: red;
}

 .widget-valid.mod-valid .widget-valid-readout {
    display: none;
}

 /* Widget Text and TextArea Stying */

 .widget-textarea, .widget-text {
    width: 300px;
}

 .widget-text input[type="text"], .widget-text input[type="number"]{
    height: 28px;
    line-height: 28px;
}

 .widget-text input[type="text"]:disabled, .widget-text input[type="number"]:disabled, .widget-textarea textarea:disabled {
    opacity: 0.6;
}

 .widget-text input[type="text"], .widget-text input[type="number"], .widget-textarea textarea {
    -webkit-box-sizing: border-box;
            box-sizing: border-box;
    border: 1px solid #9E9E9E;
    background-color: white;
    color: rgba(0, 0, 0, .8);
    font-size: 13px;
    padding: 4px 8px;
    -webkit-box-flex: 1;
        -ms-flex-positive: 1;
            flex-grow: 1;
    min-width: 0; /* This makes it possible for the flexbox to shrink this input */
    -ms-flex-negative: 1;
        flex-shrink: 1;
    outline: none !important;
}

 .widget-textarea textarea {
    height: inherit;
    width: inherit;
}

 .widget-text input:focus, .widget-textarea textarea:focus {
    border-color: #64B5F6;
}

 /* Widget Slider */

 .widget-slider .ui-slider {
    /* Slider Track */
    border: 1px solid #BDBDBD;
    background: #BDBDBD;
    -webkit-box-sizing: border-box;
            box-sizing: border-box;
    position: relative;
    border-radius: 0px;
}

 .widget-slider .ui-slider .ui-slider-handle {
    /* Slider Handle */
    outline: none !important; /* focused slider handles are colored - see below */
    position: absolute;
    background-color: white;
    border: 1px solid #9E9E9E;
    -webkit-box-sizing: border-box;
            box-sizing: border-box;
    z-index: 1;
    background-image: none; /* Override jquery-ui */
}

 /* Override jquery-ui */

 .widget-slider .ui-slider .ui-slider-handle:hover, .widget-slider .ui-slider .ui-slider-handle:focus {
    background-color: #2196F3;
    border: 1px solid #2196F3;
}

 .widget-slider .ui-slider .ui-slider-handle:active {
    background-color: #2196F3;
    border-color: #2196F3;
    z-index: 2;
    -webkit-transform: scale(1.2);
            transform: scale(1.2);
}

 .widget-slider  .ui-slider .ui-slider-range {
    /* Interval between the two specified value of a double slider */
    position: absolute;
    background: #2196F3;
    z-index: 0;
}

 /* Shapes of Slider Handles */

 .widget-hslider .ui-slider .ui-slider-handle {
    width: 16px;
    height: 16px;
    margin-top: -7px;
    margin-left: -7px;
    border-radius: 50%;
    top: 0;
}

 .widget-vslider .ui-slider .ui-slider-handle {
    width: 16px;
    height: 16px;
    margin-bottom: -7px;
    margin-left: -7px;
    border-radius: 50%;
    left: 0;
}

 .widget-hslider .ui-slider .ui-slider-range {
    height: 8px;
    margin-top: -3px;
}

 .widget-vslider .ui-slider .ui-slider-range {
    width: 8px;
    margin-left: -3px;
}

 /* Horizontal Slider */

 .widget-hslider {
    width: 300px;
    height: 28px;
    line-height: 28px;

    /* Override the align-items baseline. This way, the description and readout
    still seem to align their baseline properly, and we don't have to have
    align-self: stretch in the .slider-container. */
    -webkit-box-align: center;
        -ms-flex-align: center;
            align-items: center;
}

 .widgets-slider .slider-container {
    overflow: visible;
}

 .widget-hslider .slider-container {
    height: 28px;
    margin-left: 6px;
    margin-right: 6px;
    -webkit-box-flex: 1;
        -ms-flex: 1 1 148px;
            flex: 1 1 148px;
}

 .widget-hslider .ui-slider {
    /* Inner, invisible slide div */
    height: 4px;
    margin-top: 12px;
    width: 100%;
}

 /* Vertical Slider */

 .widget-vbox .widget-label {
    height: 28px;
    line-height: 28px;
}

 .widget-vslider {
    /* Vertical Slider */
    height: 200px;
    width: 72px;
}

 .widget-vslider .slider-container {
    -webkit-box-flex: 1;
        -ms-flex: 1 1 148px;
            flex: 1 1 148px;
    margin-left: auto;
    margin-right: auto;
    margin-bottom: 6px;
    margin-top: 6px;
    display: -webkit-box;
    display: -ms-flexbox;
    display: flex;
    -webkit-box-orient: vertical;
    -webkit-box-direction: normal;
        -ms-flex-direction: column;
            flex-direction: column;
}

 .widget-vslider .ui-slider-vertical {
    /* Inner, invisible slide div */
    width: 4px;
    -webkit-box-flex: 1;
        -ms-flex-positive: 1;
            flex-grow: 1;
    margin-left: auto;
    margin-right: auto;
}

 /* Widget Progress Styling */

 .progress-bar {
    -webkit-transition: none;
    transition: none;
}

 .progress-bar {
    height: 28px;
}

 .progress-bar {
    background-color: #2196F3;
}

 .progress-bar-success {
    background-color: #4CAF50;
}

 .progress-bar-info {
    background-color: #00BCD4;
}

 .progress-bar-warning {
    background-color: #FF9800;
}

 .progress-bar-danger {
    background-color: #F44336;
}

 .progress {
    background-color: #EEEEEE;
    border: none;
    -webkit-box-shadow: none;
            box-shadow: none;
}

 /* Horisontal Progress */

 .widget-hprogress {
    /* Progress Bar */
    height: 28px;
    line-height: 28px;
    width: 300px;
    -webkit-box-align: center;
        -ms-flex-align: center;
            align-items: center;

}

 .widget-hprogress .progress {
    -webkit-box-flex: 1;
        -ms-flex-positive: 1;
            flex-grow: 1;
    margin-top: 4px;
    margin-bottom: 4px;
    -ms-flex-item-align: stretch;
        align-self: stretch;
    /* Override bootstrap style */
    height: auto;
    height: initial;
}

 /* Vertical Progress */

 .widget-vprogress {
    height: 200px;
    width: 72px;
}

 .widget-vprogress .progress {
    -webkit-box-flex: 1;
        -ms-flex-positive: 1;
            flex-grow: 1;
    width: 20px;
    margin-left: auto;
    margin-right: auto;
    margin-bottom: 0;
}

 /* Select Widget Styling */

 .widget-dropdown {
    height: 28px;
    width: 300px;
    line-height: 28px;
}

 .widget-dropdown > select {
    padding-right: 20px;
    border: 1px solid #9E9E9E;
    border-radius: 0;
    height: inherit;
    -webkit-box-flex: 1;
        -ms-flex: 1 1 148px;
            flex: 1 1 148px;
    min-width: 0; /* This makes it possible for the flexbox to shrink this input */
    -webkit-box-sizing: border-box;
            box-sizing: border-box;
    outline: none !important;
    -webkit-box-shadow: none;
            box-shadow: none;
    background-color: white;
    color: rgba(0, 0, 0, .8);
    font-size: 13px;
    vertical-align: top;
    padding-left: 8px;
	appearance: none;
	-webkit-appearance: none;
	-moz-appearance: none;
    background-repeat: no-repeat;
	background-size: 20px;
	background-position: right center;
    background-image: url("data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0idXRmLTgiPz4KPCEtLSBHZW5lcmF0b3I6IEFkb2JlIElsbHVzdHJhdG9yIDE5LjIuMSwgU1ZHIEV4cG9ydCBQbHVnLUluIC4gU1ZHIFZlcnNpb246IDYuMDAgQnVpbGQgMCkgIC0tPgo8c3ZnIHZlcnNpb249IjEuMSIgaWQ9IkxheWVyXzEiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgeG1sbnM6eGxpbms9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGxpbmsiIHg9IjBweCIgeT0iMHB4IgoJIHZpZXdCb3g9IjAgMCAxOCAxOCIgc3R5bGU9ImVuYWJsZS1iYWNrZ3JvdW5kOm5ldyAwIDAgMTggMTg7IiB4bWw6c3BhY2U9InByZXNlcnZlIj4KPHN0eWxlIHR5cGU9InRleHQvY3NzIj4KCS5zdDB7ZmlsbDpub25lO30KPC9zdHlsZT4KPHBhdGggZD0iTTUuMiw1LjlMOSw5LjdsMy44LTMuOGwxLjIsMS4ybC00LjksNWwtNC45LTVMNS4yLDUuOXoiLz4KPHBhdGggY2xhc3M9InN0MCIgZD0iTTAtMC42aDE4djE4SDBWLTAuNnoiLz4KPC9zdmc+Cg");
}

 .widget-dropdown > select:focus {
    border-color: #64B5F6;
}

 .widget-dropdown > select:disabled {
    opacity: 0.6;
}

 /* To disable the dotted border in Firefox around select controls.
   See http://stackoverflow.com/a/18853002 */

 .widget-dropdown > select:-moz-focusring {
    color: transparent;
    text-shadow: 0 0 0 #000;
}

 /* Select and SelectMultiple */

 .widget-select {
    width: 300px;
    line-height: 28px;

    /* Because Firefox defines the baseline of a select as the bottom of the
    control, we align the entire control to the top and add padding to the
    select to get an approximate first line baseline alignment. */
    -webkit-box-align: start;
        -ms-flex-align: start;
            align-items: flex-start;
}

 .widget-select > select {
    border: 1px solid #9E9E9E;
    background-color: white;
    color: rgba(0, 0, 0, .8);
    font-size: 13px;
    -webkit-box-flex: 1;
        -ms-flex: 1 1 148px;
            flex: 1 1 148px;
    outline: none !important;
    overflow: auto;
    height: inherit;

    /* Because Firefox defines the baseline of a select as the bottom of the
    control, we align the entire control to the top and add padding to the
    select to get an approximate first line baseline alignment. */
    padding-top: 5px;
}

 .widget-select > select:focus {
    border-color: #64B5F6;
}

 .wiget-select > select > option {
    padding-left: 4px;
    line-height: 28px;
    /* line-height doesn't work on some browsers for select options */
    padding-top: calc(28px - var(--jp-widgets-font-size) / 2);
    padding-bottom: calc(28px - var(--jp-widgets-font-size) / 2);
}

 /* Toggle Buttons Styling */

 .widget-toggle-buttons {
    line-height: 28px;
}

 .widget-toggle-buttons .widget-toggle-button {
    margin-left: 2px;
    margin-right: 2px;
}

 .widget-toggle-buttons .jupyter-button:disabled {
    opacity: 0.6;
}

 /* Radio Buttons Styling */

 .widget-radio {
    width: 300px;
    line-height: 28px;
}

 .widget-radio-box {
    display: -webkit-box;
    display: -ms-flexbox;
    display: flex;
    -webkit-box-orient: vertical;
    -webkit-box-direction: normal;
        -ms-flex-direction: column;
            flex-direction: column;
    -webkit-box-align: stretch;
        -ms-flex-align: stretch;
            align-items: stretch;
    -webkit-box-sizing: border-box;
            box-sizing: border-box;
    -webkit-box-flex: 1;
        -ms-flex-positive: 1;
            flex-grow: 1;
    margin-bottom: 8px;
}

 .widget-radio-box label {
    height: 20px;
    line-height: 20px;
    font-size: 13px;
}

 .widget-radio-box input {
    height: 20px;
    line-height: 20px;
    margin: 0 8px 0 1px;
    float: left;
}

 /* Color Picker Styling */

 .widget-colorpicker {
    width: 300px;
    height: 28px;
    line-height: 28px;
}

 .widget-colorpicker > .widget-colorpicker-input {
    -webkit-box-flex: 1;
        -ms-flex-positive: 1;
            flex-grow: 1;
    -ms-flex-negative: 1;
        flex-shrink: 1;
    min-width: 72px;
}

 .widget-colorpicker input[type="color"] {
    width: 28px;
    height: 28px;
    padding: 0 2px; /* make the color square actually square on Chrome on OS X */
    background: white;
    color: rgba(0, 0, 0, .8);
    border: 1px solid #9E9E9E;
    border-left: none;
    -webkit-box-flex: 0;
        -ms-flex-positive: 0;
            flex-grow: 0;
    -ms-flex-negative: 0;
        flex-shrink: 0;
    -webkit-box-sizing: border-box;
            box-sizing: border-box;
    -ms-flex-item-align: stretch;
        align-self: stretch;
    outline: none !important;
}

 .widget-colorpicker.concise input[type="color"] {
    border-left: 1px solid #9E9E9E;
}

 .widget-colorpicker input[type="color"]:focus, .widget-colorpicker input[type="text"]:focus {
    border-color: #64B5F6;
}

 .widget-colorpicker input[type="text"] {
    -webkit-box-flex: 1;
        -ms-flex-positive: 1;
            flex-grow: 1;
    outline: none !important;
    height: 28px;
    line-height: 28px;
    background: white;
    color: rgba(0, 0, 0, .8);
    border: 1px solid #9E9E9E;
    font-size: 13px;
    padding: 4px 8px;
    min-width: 0; /* This makes it possible for the flexbox to shrink this input */
    -ms-flex-negative: 1;
        flex-shrink: 1;
    -webkit-box-sizing: border-box;
            box-sizing: border-box;
}

 .widget-colorpicker input[type="text"]:disabled {
    opacity: 0.6;
}

 /* Date Picker Styling */

 .widget-datepicker {
    width: 300px;
    height: 28px;
    line-height: 28px;
}

 .widget-datepicker input[type="date"] {
    -webkit-box-flex: 1;
        -ms-flex-positive: 1;
            flex-grow: 1;
    -ms-flex-negative: 1;
        flex-shrink: 1;
    min-width: 0; /* This makes it possible for the flexbox to shrink this input */
    outline: none !important;
    height: 28px;
    border: 1px solid #9E9E9E;
    background-color: white;
    color: rgba(0, 0, 0, .8);
    font-size: 13px;
    padding: 4px 8px;
    -webkit-box-sizing: border-box;
            box-sizing: border-box;
}

 .widget-datepicker input[type="date"]:focus {
    border-color: #64B5F6;
}

 .widget-datepicker input[type="date"]:invalid {
    border-color: #FF9800;
}

 .widget-datepicker input[type="date"]:disabled {
    opacity: 0.6;
}

 /* Play Widget */

 .widget-play {
    width: 148px;
    display: -webkit-box;
    display: -ms-flexbox;
    display: flex;
    -webkit-box-align: stretch;
        -ms-flex-align: stretch;
            align-items: stretch;
}

 .widget-play .jupyter-button {
    -webkit-box-flex: 1;
        -ms-flex-positive: 1;
            flex-grow: 1;
    height: auto;
}

 .widget-play .jupyter-button:disabled {
    opacity: 0.6;
}

 /* Tab Widget */

 .jupyter-widgets.widget-tab {
    display: -webkit-box;
    display: -ms-flexbox;
    display: flex;
    -webkit-box-orient: vertical;
    -webkit-box-direction: normal;
        -ms-flex-direction: column;
            flex-direction: column;
}

 .jupyter-widgets.widget-tab > .p-TabBar {
    /* Necessary so that a tab can be shifted down to overlay the border of the box below. */
    overflow-x: visible;
    overflow-y: visible;
}

 .jupyter-widgets.widget-tab > .p-TabBar > .p-TabBar-content {
    /* Make sure that the tab grows from bottom up */
    -webkit-box-align: end;
        -ms-flex-align: end;
            align-items: flex-end;
    min-width: 0;
    min-height: 0;
}

 .jupyter-widgets.widget-tab > .widget-tab-contents {
    width: 100%;
    -webkit-box-sizing: border-box;
            box-sizing: border-box;
    margin: 0;
    background: white;
    color: rgba(0, 0, 0, .8);
    border: 1px solid #9E9E9E;
    padding: 15px;
    -webkit-box-flex: 1;
        -ms-flex-positive: 1;
            flex-grow: 1;
    overflow: auto;
}

 .jupyter-widgets.widget-tab > .p-TabBar {
    font: 13px Helvetica, Arial, sans-serif;
    min-height: 25px;
}

 .jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tab {
    -webkit-box-flex: 0;
        -ms-flex: 0 1 144px;
            flex: 0 1 144px;
    min-width: 35px;
    min-height: 25px;
    line-height: 24px;
    margin-left: -1px;
    padding: 0px 10px;
    background: #EEEEEE;
    color: rgba(0, 0, 0, .5);
    border: 1px solid #9E9E9E;
    border-bottom: none;
    position: relative;
}

 .jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tab.p-mod-current {
    color: rgba(0, 0, 0, 1.0);
    /* We want the background to match the tab content background */
    background: white;
    min-height: 26px;
    -webkit-transform: translateY(1px);
            transform: translateY(1px);
    overflow: visible;
}

 .jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tab.p-mod-current:before {
    position: absolute;
    top: -1px;
    left: -1px;
    content: '';
    height: 2px;
    width: calc(100% + 2px);
    background: #2196F3;
}

 .jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tab:first-child {
    margin-left: 0;
}

 .jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tab:hover:not(.p-mod-current) {
    background: white;
    color: rgba(0, 0, 0, .8);
}

 .jupyter-widgets.widget-tab > .p-TabBar .p-mod-closable > .p-TabBar-tabCloseIcon {
    margin-left: 4px;
}

 .jupyter-widgets.widget-tab > .p-TabBar .p-mod-closable > .p-TabBar-tabCloseIcon:before {
    font-family: FontAwesome;
    content: '\f00d'; /* close */
}

 .jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tabIcon,
.jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tabLabel,
.jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tabCloseIcon {
    line-height: 24px;
}

 /* Accordion Widget */

 .p-Collapse {
    display: -webkit-box;
    display: -ms-flexbox;
    display: flex;
    -webkit-box-orient: vertical;
    -webkit-box-direction: normal;
        -ms-flex-direction: column;
            flex-direction: column;
    -webkit-box-align: stretch;
        -ms-flex-align: stretch;
            align-items: stretch;
}

 .p-Collapse-header {
    padding: 4px;
    cursor: pointer;
    color: rgba(0, 0, 0, .5);
    background-color: #EEEEEE;
    border: 1px solid #9E9E9E;
    padding: 10px 15px;
    font-weight: bold;
}

 .p-Collapse-header:hover {
    background-color: white;
    color: rgba(0, 0, 0, .8);
}

 .p-Collapse-open > .p-Collapse-header {
    background-color: white;
    color: rgba(0, 0, 0, 1.0);
    cursor: default;
    border-bottom: none;
}

 .p-Collapse .p-Collapse-header::before {
    content: '\f0da\00A0';  /* caret-right, non-breaking space */
    display: inline-block;
    font: normal normal normal 14px/1 FontAwesome;
    font-size: inherit;
    text-rendering: auto;
    -webkit-font-smoothing: antialiased;
    -moz-osx-font-smoothing: grayscale;
}

 .p-Collapse-open > .p-Collapse-header::before {
    content: '\f0d7\00A0'; /* caret-down, non-breaking space */
}

 .p-Collapse-contents {
    padding: 15px;
    background-color: white;
    color: rgba(0, 0, 0, .8);
    border-left: 1px solid #9E9E9E;
    border-right: 1px solid #9E9E9E;
    border-bottom: 1px solid #9E9E9E;
    overflow: auto;
}

 .p-Accordion {
    display: -webkit-box;
    display: -ms-flexbox;
    display: flex;
    -webkit-box-orient: vertical;
    -webkit-box-direction: normal;
        -ms-flex-direction: column;
            flex-direction: column;
    -webkit-box-align: stretch;
        -ms-flex-align: stretch;
            align-items: stretch;
}

 .p-Accordion .p-Collapse {
    margin-bottom: 0;
}

 .p-Accordion .p-Collapse + .p-Collapse {
    margin-top: 4px;
}

 /* HTML widget */

 .widget-html, .widget-htmlmath {
    font-size: 13px;
}

 .widget-html > .widget-html-content, .widget-htmlmath > .widget-html-content {
    /* Fill out the area in the HTML widget */
    -ms-flex-item-align: stretch;
        align-self: stretch;
    -webkit-box-flex: 1;
        -ms-flex-positive: 1;
            flex-grow: 1;
    -ms-flex-negative: 1;
        flex-shrink: 1;
    /* Makes sure the baseline is still aligned with other elements */
    line-height: 28px;
    /* Make it possible to have absolutely-positioned elements in the html */
    position: relative;
}

/*# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../node_modules/@jupyter-widgets/controls/css/widgets.css","../node_modules/@jupyter-widgets/controls/css/labvariables.css","../node_modules/@jupyter-widgets/controls/css/materialcolors.css","../node_modules/@jupyter-widgets/controls/css/widgets-base.css","../node_modules/@jupyter-widgets/controls/css/phosphor.css"],"names":[],"mappings":"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","file":"controls.css","sourcesContent":["/* Copyright (c) Jupyter Development Team.\n * Distributed under the terms of the Modified BSD License.\n */\n\n /* We import all of these together in a single css file because the Webpack\nloader sees only one file at a time. This allows postcss to see the variable\ndefinitions when they are used. */\n\n@import \"./labvariables.css\";\n@import \"./widgets-base.css\";\n","/*-----------------------------------------------------------------------------\n| Copyright (c) Jupyter Development Team.\n| Distributed under the terms of the Modified BSD License.\n|----------------------------------------------------------------------------*/\n\n/*\nThis file is copied from the JupyterLab project to define default styling for\nwhen the widget styling is compiled down to eliminate CSS variables. We make one\nchange - we comment out the font import below.\n*/\n\n@import \"./materialcolors.css\";\n\n/*\nThe following CSS variables define the main, public API for styling JupyterLab.\nThese variables should be used by all plugins wherever possible. In other\nwords, plugins should not define custom colors, sizes, etc unless absolutely\nnecessary. This enables users to change the visual theme of JupyterLab\nby changing these variables.\n\nMany variables appear in an ordered sequence (0,1,2,3). These sequences\nare designed to work well together, so for example, `--jp-border-color1` should\nbe used with `--jp-layout-color1`. The numbers have the following meanings:\n\n* 0: super-primary, reserved for special emphasis\n* 1: primary, most important under normal situations\n* 2: secondary, next most important under normal situations\n* 3: tertiary, next most important under normal situations\n\nThroughout JupyterLab, we are mostly following principles from Google's\nMaterial Design when selecting colors. We are not, however, following\nall of MD as it is not optimized for dense, information rich UIs.\n*/\n\n\n/*\n * Optional monospace font for input/output prompt.\n */\n /* Commented out in ipywidgets since we don't need it. */\n/* @import url('https://fonts.googleapis.com/css?family=Roboto+Mono'); */\n\n/*\n * Added for compabitility with output area\n */\n:root {\n  --jp-icon-search: none;\n  --jp-ui-select-caret: none;\n}\n\n\n:root {\n\n  /* Borders\n\n  The following variables, specify the visual styling of borders in JupyterLab.\n   */\n\n  --jp-border-width: 1px;\n  --jp-border-color0: var(--md-grey-700);\n  --jp-border-color1: var(--md-grey-500);\n  --jp-border-color2: var(--md-grey-300);\n  --jp-border-color3: var(--md-grey-100);\n\n  /* UI Fonts\n\n  The UI font CSS variables are used for the typography all of the JupyterLab\n  user interface elements that are not directly user generated content.\n  */\n\n  --jp-ui-font-scale-factor: 1.2;\n  --jp-ui-font-size0: calc(var(--jp-ui-font-size1)/var(--jp-ui-font-scale-factor));\n  --jp-ui-font-size1: 13px; /* Base font size */\n  --jp-ui-font-size2: calc(var(--jp-ui-font-size1)*var(--jp-ui-font-scale-factor));\n  --jp-ui-font-size3: calc(var(--jp-ui-font-size2)*var(--jp-ui-font-scale-factor));\n  --jp-ui-icon-font-size: 14px; /* Ensures px perfect FontAwesome icons */\n  --jp-ui-font-family: \"Helvetica Neue\", Helvetica, Arial, sans-serif;\n\n  /* Use these font colors against the corresponding main layout colors.\n     In a light theme, these go from dark to light.\n  */\n\n  --jp-ui-font-color0: rgba(0,0,0,1.0);\n  --jp-ui-font-color1: rgba(0,0,0,0.8);\n  --jp-ui-font-color2: rgba(0,0,0,0.5);\n  --jp-ui-font-color3: rgba(0,0,0,0.3);\n\n  /* Use these against the brand/accent/warn/error colors.\n     These will typically go from light to darker, in both a dark and light theme\n   */\n\n  --jp-inverse-ui-font-color0: rgba(255,255,255,1);\n  --jp-inverse-ui-font-color1: rgba(255,255,255,1.0);\n  --jp-inverse-ui-font-color2: rgba(255,255,255,0.7);\n  --jp-inverse-ui-font-color3: rgba(255,255,255,0.5);\n\n  /* Content Fonts\n\n  Content font variables are used for typography of user generated content.\n  */\n\n  --jp-content-font-size: 13px;\n  --jp-content-line-height: 1.5;\n  --jp-content-font-color0: black;\n  --jp-content-font-color1: black;\n  --jp-content-font-color2: var(--md-grey-700);\n  --jp-content-font-color3: var(--md-grey-500);\n\n  --jp-ui-font-scale-factor: 1.2;\n  --jp-ui-font-size0: calc(var(--jp-ui-font-size1)/var(--jp-ui-font-scale-factor));\n  --jp-ui-font-size1: 13px; /* Base font size */\n  --jp-ui-font-size2: calc(var(--jp-ui-font-size1)*var(--jp-ui-font-scale-factor));\n  --jp-ui-font-size3: calc(var(--jp-ui-font-size2)*var(--jp-ui-font-scale-factor));\n\n  --jp-code-font-size: 13px;\n  --jp-code-line-height: 1.307;\n  --jp-code-padding: 5px;\n  --jp-code-font-family: monospace;\n\n\n  /* Layout\n\n  The following are the main layout colors use in JupyterLab. In a light\n  theme these would go from light to dark.\n  */\n\n  --jp-layout-color0: white;\n  --jp-layout-color1: white;\n  --jp-layout-color2: var(--md-grey-200);\n  --jp-layout-color3: var(--md-grey-400);\n\n  /* Brand/accent */\n\n  --jp-brand-color0: var(--md-blue-700);\n  --jp-brand-color1: var(--md-blue-500);\n  --jp-brand-color2: var(--md-blue-300);\n  --jp-brand-color3: var(--md-blue-100);\n\n  --jp-accent-color0: var(--md-green-700);\n  --jp-accent-color1: var(--md-green-500);\n  --jp-accent-color2: var(--md-green-300);\n  --jp-accent-color3: var(--md-green-100);\n\n  /* State colors (warn, error, success, info) */\n\n  --jp-warn-color0: var(--md-orange-700);\n  --jp-warn-color1: var(--md-orange-500);\n  --jp-warn-color2: var(--md-orange-300);\n  --jp-warn-color3: var(--md-orange-100);\n\n  --jp-error-color0: var(--md-red-700);\n  --jp-error-color1: var(--md-red-500);\n  --jp-error-color2: var(--md-red-300);\n  --jp-error-color3: var(--md-red-100);\n\n  --jp-success-color0: var(--md-green-700);\n  --jp-success-color1: var(--md-green-500);\n  --jp-success-color2: var(--md-green-300);\n  --jp-success-color3: var(--md-green-100);\n\n  --jp-info-color0: var(--md-cyan-700);\n  --jp-info-color1: var(--md-cyan-500);\n  --jp-info-color2: var(--md-cyan-300);\n  --jp-info-color3: var(--md-cyan-100);\n\n  /* Cell specific styles */\n\n  --jp-cell-padding: 5px;\n  --jp-cell-editor-background: #f7f7f7;\n  --jp-cell-editor-border-color: #cfcfcf;\n  --jp-cell-editor-background-edit: var(--jp-ui-layout-color1);\n  --jp-cell-editor-border-color-edit: var(--jp-brand-color1);\n  --jp-cell-prompt-width: 100px;\n  --jp-cell-prompt-font-family: 'Roboto Mono', monospace;\n  --jp-cell-prompt-letter-spacing: 0px;\n  --jp-cell-prompt-opacity: 1.0;\n  --jp-cell-prompt-opacity-not-active: 0.4;\n  --jp-cell-prompt-font-color-not-active: var(--md-grey-700);\n  /* A custom blend of MD grey and blue 600\n   * See https://meyerweb.com/eric/tools/color-blend/#546E7A:1E88E5:5:hex */\n  --jp-cell-inprompt-font-color: #307FC1;\n  /* A custom blend of MD grey and orange 600\n   * https://meyerweb.com/eric/tools/color-blend/#546E7A:F4511E:5:hex */\n  --jp-cell-outprompt-font-color: #BF5B3D;\n\n  /* Notebook specific styles */\n\n  --jp-notebook-padding: 10px;\n  --jp-notebook-scroll-padding: 100px;\n\n  /* Console specific styles */\n\n  --jp-console-background: var(--md-grey-100);\n\n  /* Toolbar specific styles */\n\n  --jp-toolbar-border-color: var(--md-grey-400);\n  --jp-toolbar-micro-height: 8px;\n  --jp-toolbar-background: var(--jp-layout-color0);\n  --jp-toolbar-box-shadow: 0px 0px 2px 0px rgba(0,0,0,0.24);\n  --jp-toolbar-header-margin: 4px 4px 0px 4px;\n  --jp-toolbar-active-background: var(--md-grey-300);\n}\n","/**\n * The material design colors are adapted from google-material-color v1.2.6\n * https://github.com/danlevan/google-material-color\n * https://github.com/danlevan/google-material-color/blob/f67ca5f4028b2f1b34862f64b0ca67323f91b088/dist/palette.var.css\n *\n * The license for the material design color CSS variables is as follows (see\n * https://github.com/danlevan/google-material-color/blob/f67ca5f4028b2f1b34862f64b0ca67323f91b088/LICENSE)\n *\n * The MIT License (MIT)\n *\n * Copyright (c) 2014 Dan Le Van\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n:root {\n  --md-red-50: #FFEBEE;\n  --md-red-100: #FFCDD2;\n  --md-red-200: #EF9A9A;\n  --md-red-300: #E57373;\n  --md-red-400: #EF5350;\n  --md-red-500: #F44336;\n  --md-red-600: #E53935;\n  --md-red-700: #D32F2F;\n  --md-red-800: #C62828;\n  --md-red-900: #B71C1C;\n  --md-red-A100: #FF8A80;\n  --md-red-A200: #FF5252;\n  --md-red-A400: #FF1744;\n  --md-red-A700: #D50000;\n\n  --md-pink-50: #FCE4EC;\n  --md-pink-100: #F8BBD0;\n  --md-pink-200: #F48FB1;\n  --md-pink-300: #F06292;\n  --md-pink-400: #EC407A;\n  --md-pink-500: #E91E63;\n  --md-pink-600: #D81B60;\n  --md-pink-700: #C2185B;\n  --md-pink-800: #AD1457;\n  --md-pink-900: #880E4F;\n  --md-pink-A100: #FF80AB;\n  --md-pink-A200: #FF4081;\n  --md-pink-A400: #F50057;\n  --md-pink-A700: #C51162;\n\n  --md-purple-50: #F3E5F5;\n  --md-purple-100: #E1BEE7;\n  --md-purple-200: #CE93D8;\n  --md-purple-300: #BA68C8;\n  --md-purple-400: #AB47BC;\n  --md-purple-500: #9C27B0;\n  --md-purple-600: #8E24AA;\n  --md-purple-700: #7B1FA2;\n  --md-purple-800: #6A1B9A;\n  --md-purple-900: #4A148C;\n  --md-purple-A100: #EA80FC;\n  --md-purple-A200: #E040FB;\n  --md-purple-A400: #D500F9;\n  --md-purple-A700: #AA00FF;\n\n  --md-deep-purple-50: #EDE7F6;\n  --md-deep-purple-100: #D1C4E9;\n  --md-deep-purple-200: #B39DDB;\n  --md-deep-purple-300: #9575CD;\n  --md-deep-purple-400: #7E57C2;\n  --md-deep-purple-500: #673AB7;\n  --md-deep-purple-600: #5E35B1;\n  --md-deep-purple-700: #512DA8;\n  --md-deep-purple-800: #4527A0;\n  --md-deep-purple-900: #311B92;\n  --md-deep-purple-A100: #B388FF;\n  --md-deep-purple-A200: #7C4DFF;\n  --md-deep-purple-A400: #651FFF;\n  --md-deep-purple-A700: #6200EA;\n\n  --md-indigo-50: #E8EAF6;\n  --md-indigo-100: #C5CAE9;\n  --md-indigo-200: #9FA8DA;\n  --md-indigo-300: #7986CB;\n  --md-indigo-400: #5C6BC0;\n  --md-indigo-500: #3F51B5;\n  --md-indigo-600: #3949AB;\n  --md-indigo-700: #303F9F;\n  --md-indigo-800: #283593;\n  --md-indigo-900: #1A237E;\n  --md-indigo-A100: #8C9EFF;\n  --md-indigo-A200: #536DFE;\n  --md-indigo-A400: #3D5AFE;\n  --md-indigo-A700: #304FFE;\n\n  --md-blue-50: #E3F2FD;\n  --md-blue-100: #BBDEFB;\n  --md-blue-200: #90CAF9;\n  --md-blue-300: #64B5F6;\n  --md-blue-400: #42A5F5;\n  --md-blue-500: #2196F3;\n  --md-blue-600: #1E88E5;\n  --md-blue-700: #1976D2;\n  --md-blue-800: #1565C0;\n  --md-blue-900: #0D47A1;\n  --md-blue-A100: #82B1FF;\n  --md-blue-A200: #448AFF;\n  --md-blue-A400: #2979FF;\n  --md-blue-A700: #2962FF;\n\n  --md-light-blue-50: #E1F5FE;\n  --md-light-blue-100: #B3E5FC;\n  --md-light-blue-200: #81D4FA;\n  --md-light-blue-300: #4FC3F7;\n  --md-light-blue-400: #29B6F6;\n  --md-light-blue-500: #03A9F4;\n  --md-light-blue-600: #039BE5;\n  --md-light-blue-700: #0288D1;\n  --md-light-blue-800: #0277BD;\n  --md-light-blue-900: #01579B;\n  --md-light-blue-A100: #80D8FF;\n  --md-light-blue-A200: #40C4FF;\n  --md-light-blue-A400: #00B0FF;\n  --md-light-blue-A700: #0091EA;\n\n  --md-cyan-50: #E0F7FA;\n  --md-cyan-100: #B2EBF2;\n  --md-cyan-200: #80DEEA;\n  --md-cyan-300: #4DD0E1;\n  --md-cyan-400: #26C6DA;\n  --md-cyan-500: #00BCD4;\n  --md-cyan-600: #00ACC1;\n  --md-cyan-700: #0097A7;\n  --md-cyan-800: #00838F;\n  --md-cyan-900: #006064;\n  --md-cyan-A100: #84FFFF;\n  --md-cyan-A200: #18FFFF;\n  --md-cyan-A400: #00E5FF;\n  --md-cyan-A700: #00B8D4;\n\n  --md-teal-50: #E0F2F1;\n  --md-teal-100: #B2DFDB;\n  --md-teal-200: #80CBC4;\n  --md-teal-300: #4DB6AC;\n  --md-teal-400: #26A69A;\n  --md-teal-500: #009688;\n  --md-teal-600: #00897B;\n  --md-teal-700: #00796B;\n  --md-teal-800: #00695C;\n  --md-teal-900: #004D40;\n  --md-teal-A100: #A7FFEB;\n  --md-teal-A200: #64FFDA;\n  --md-teal-A400: #1DE9B6;\n  --md-teal-A700: #00BFA5;\n\n  --md-green-50: #E8F5E9;\n  --md-green-100: #C8E6C9;\n  --md-green-200: #A5D6A7;\n  --md-green-300: #81C784;\n  --md-green-400: #66BB6A;\n  --md-green-500: #4CAF50;\n  --md-green-600: #43A047;\n  --md-green-700: #388E3C;\n  --md-green-800: #2E7D32;\n  --md-green-900: #1B5E20;\n  --md-green-A100: #B9F6CA;\n  --md-green-A200: #69F0AE;\n  --md-green-A400: #00E676;\n  --md-green-A700: #00C853;\n\n  --md-light-green-50: #F1F8E9;\n  --md-light-green-100: #DCEDC8;\n  --md-light-green-200: #C5E1A5;\n  --md-light-green-300: #AED581;\n  --md-light-green-400: #9CCC65;\n  --md-light-green-500: #8BC34A;\n  --md-light-green-600: #7CB342;\n  --md-light-green-700: #689F38;\n  --md-light-green-800: #558B2F;\n  --md-light-green-900: #33691E;\n  --md-light-green-A100: #CCFF90;\n  --md-light-green-A200: #B2FF59;\n  --md-light-green-A400: #76FF03;\n  --md-light-green-A700: #64DD17;\n\n  --md-lime-50: #F9FBE7;\n  --md-lime-100: #F0F4C3;\n  --md-lime-200: #E6EE9C;\n  --md-lime-300: #DCE775;\n  --md-lime-400: #D4E157;\n  --md-lime-500: #CDDC39;\n  --md-lime-600: #C0CA33;\n  --md-lime-700: #AFB42B;\n  --md-lime-800: #9E9D24;\n  --md-lime-900: #827717;\n  --md-lime-A100: #F4FF81;\n  --md-lime-A200: #EEFF41;\n  --md-lime-A400: #C6FF00;\n  --md-lime-A700: #AEEA00;\n\n  --md-yellow-50: #FFFDE7;\n  --md-yellow-100: #FFF9C4;\n  --md-yellow-200: #FFF59D;\n  --md-yellow-300: #FFF176;\n  --md-yellow-400: #FFEE58;\n  --md-yellow-500: #FFEB3B;\n  --md-yellow-600: #FDD835;\n  --md-yellow-700: #FBC02D;\n  --md-yellow-800: #F9A825;\n  --md-yellow-900: #F57F17;\n  --md-yellow-A100: #FFFF8D;\n  --md-yellow-A200: #FFFF00;\n  --md-yellow-A400: #FFEA00;\n  --md-yellow-A700: #FFD600;\n\n  --md-amber-50: #FFF8E1;\n  --md-amber-100: #FFECB3;\n  --md-amber-200: #FFE082;\n  --md-amber-300: #FFD54F;\n  --md-amber-400: #FFCA28;\n  --md-amber-500: #FFC107;\n  --md-amber-600: #FFB300;\n  --md-amber-700: #FFA000;\n  --md-amber-800: #FF8F00;\n  --md-amber-900: #FF6F00;\n  --md-amber-A100: #FFE57F;\n  --md-amber-A200: #FFD740;\n  --md-amber-A400: #FFC400;\n  --md-amber-A700: #FFAB00;\n\n  --md-orange-50: #FFF3E0;\n  --md-orange-100: #FFE0B2;\n  --md-orange-200: #FFCC80;\n  --md-orange-300: #FFB74D;\n  --md-orange-400: #FFA726;\n  --md-orange-500: #FF9800;\n  --md-orange-600: #FB8C00;\n  --md-orange-700: #F57C00;\n  --md-orange-800: #EF6C00;\n  --md-orange-900: #E65100;\n  --md-orange-A100: #FFD180;\n  --md-orange-A200: #FFAB40;\n  --md-orange-A400: #FF9100;\n  --md-orange-A700: #FF6D00;\n\n  --md-deep-orange-50: #FBE9E7;\n  --md-deep-orange-100: #FFCCBC;\n  --md-deep-orange-200: #FFAB91;\n  --md-deep-orange-300: #FF8A65;\n  --md-deep-orange-400: #FF7043;\n  --md-deep-orange-500: #FF5722;\n  --md-deep-orange-600: #F4511E;\n  --md-deep-orange-700: #E64A19;\n  --md-deep-orange-800: #D84315;\n  --md-deep-orange-900: #BF360C;\n  --md-deep-orange-A100: #FF9E80;\n  --md-deep-orange-A200: #FF6E40;\n  --md-deep-orange-A400: #FF3D00;\n  --md-deep-orange-A700: #DD2C00;\n\n  --md-brown-50: #EFEBE9;\n  --md-brown-100: #D7CCC8;\n  --md-brown-200: #BCAAA4;\n  --md-brown-300: #A1887F;\n  --md-brown-400: #8D6E63;\n  --md-brown-500: #795548;\n  --md-brown-600: #6D4C41;\n  --md-brown-700: #5D4037;\n  --md-brown-800: #4E342E;\n  --md-brown-900: #3E2723;\n\n  --md-grey-50: #FAFAFA;\n  --md-grey-100: #F5F5F5;\n  --md-grey-200: #EEEEEE;\n  --md-grey-300: #E0E0E0;\n  --md-grey-400: #BDBDBD;\n  --md-grey-500: #9E9E9E;\n  --md-grey-600: #757575;\n  --md-grey-700: #616161;\n  --md-grey-800: #424242;\n  --md-grey-900: #212121;\n\n  --md-blue-grey-50: #ECEFF1;\n  --md-blue-grey-100: #CFD8DC;\n  --md-blue-grey-200: #B0BEC5;\n  --md-blue-grey-300: #90A4AE;\n  --md-blue-grey-400: #78909C;\n  --md-blue-grey-500: #607D8B;\n  --md-blue-grey-600: #546E7A;\n  --md-blue-grey-700: #455A64;\n  --md-blue-grey-800: #37474F;\n  --md-blue-grey-900: #263238;\n}","/* Copyright (c) Jupyter Development Team.\n * Distributed under the terms of the Modified BSD License.\n */\n\n/*\n * We assume that the CSS variables in\n * https://github.com/jupyterlab/jupyterlab/blob/master/src/default-theme/variables.css\n * have been defined.\n */\n\n@import \"./phosphor.css\";\n\n:root {\n    --jp-widgets-color: var(--jp-content-font-color1);\n    --jp-widgets-label-color: var(--jp-widgets-color);\n    --jp-widgets-readout-color: var(--jp-widgets-color);\n    --jp-widgets-font-size: var(--jp-ui-font-size1);\n    --jp-widgets-margin: 2px;\n    --jp-widgets-inline-height: 28px;\n    --jp-widgets-inline-width: 300px;\n    --jp-widgets-inline-width-short: calc(var(--jp-widgets-inline-width) / 2 - var(--jp-widgets-margin));\n    --jp-widgets-inline-width-tiny: calc(var(--jp-widgets-inline-width-short) / 2 - var(--jp-widgets-margin));\n    --jp-widgets-inline-margin: 4px; /* margin between inline elements */\n    --jp-widgets-inline-label-width: 80px;\n    --jp-widgets-border-width: var(--jp-border-width);\n    --jp-widgets-vertical-height: 200px;\n    --jp-widgets-horizontal-tab-height: 24px;\n    --jp-widgets-horizontal-tab-width: 144px;\n    --jp-widgets-horizontal-tab-top-border: 2px;\n    --jp-widgets-progress-thickness: 20px;\n    --jp-widgets-container-padding: 15px;\n    --jp-widgets-input-padding: 4px;\n    --jp-widgets-radio-item-height-adjustment: 8px;\n    --jp-widgets-radio-item-height: calc(var(--jp-widgets-inline-height) - var(--jp-widgets-radio-item-height-adjustment));\n    --jp-widgets-slider-track-thickness: 4px;\n    --jp-widgets-slider-border-width: var(--jp-widgets-border-width);\n    --jp-widgets-slider-handle-size: 16px;\n    --jp-widgets-slider-handle-border-color: var(--jp-border-color1);\n    --jp-widgets-slider-handle-background-color: var(--jp-layout-color1);\n    --jp-widgets-slider-active-handle-color: var(--jp-brand-color1);\n    --jp-widgets-menu-item-height: 24px;\n    --jp-widgets-dropdown-arrow: url(\"data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0idXRmLTgiPz4KPCEtLSBHZW5lcmF0b3I6IEFkb2JlIElsbHVzdHJhdG9yIDE5LjIuMSwgU1ZHIEV4cG9ydCBQbHVnLUluIC4gU1ZHIFZlcnNpb246IDYuMDAgQnVpbGQgMCkgIC0tPgo8c3ZnIHZlcnNpb249IjEuMSIgaWQ9IkxheWVyXzEiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgeG1sbnM6eGxpbms9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGxpbmsiIHg9IjBweCIgeT0iMHB4IgoJIHZpZXdCb3g9IjAgMCAxOCAxOCIgc3R5bGU9ImVuYWJsZS1iYWNrZ3JvdW5kOm5ldyAwIDAgMTggMTg7IiB4bWw6c3BhY2U9InByZXNlcnZlIj4KPHN0eWxlIHR5cGU9InRleHQvY3NzIj4KCS5zdDB7ZmlsbDpub25lO30KPC9zdHlsZT4KPHBhdGggZD0iTTUuMiw1LjlMOSw5LjdsMy44LTMuOGwxLjIsMS4ybC00LjksNWwtNC45LTVMNS4yLDUuOXoiLz4KPHBhdGggY2xhc3M9InN0MCIgZD0iTTAtMC42aDE4djE4SDBWLTAuNnoiLz4KPC9zdmc+Cg\");\n    --jp-widgets-input-color: var(--jp-ui-font-color1);\n    --jp-widgets-input-background-color: var(--jp-layout-color1);\n    --jp-widgets-input-border-color: var(--jp-border-color1);\n    --jp-widgets-input-focus-border-color: var(--jp-brand-color2);\n    --jp-widgets-input-border-width: var(--jp-widgets-border-width);\n    --jp-widgets-disabled-opacity: 0.6;\n\n    /* From Material Design Lite */\n    --md-shadow-key-umbra-opacity: 0.2;\n    --md-shadow-key-penumbra-opacity: 0.14;\n    --md-shadow-ambient-shadow-opacity: 0.12;\n}\n\n.jupyter-widgets {\n    margin: var(--jp-widgets-margin);\n    box-sizing: border-box;\n    color: var(--jp-widgets-color);\n    overflow: visible;\n}\n\n.jupyter-widgets.jupyter-widgets-disconnected::before {\n    line-height: var(--jp-widgets-inline-height);\n    height: var(--jp-widgets-inline-height);\n}\n\n.jp-Output-result > .jupyter-widgets {\n    margin-left: 0;\n    margin-right: 0;\n}\n\n/* vbox and hbox */\n\n.widget-inline-hbox {\n    /* Horizontal widgets */\n    box-sizing: border-box;\n    display: flex;\n    flex-direction: row;\n    align-items: baseline;\n}\n\n.widget-inline-vbox {\n    /* Vertical Widgets */\n    box-sizing: border-box;\n    display: flex;\n    flex-direction: column;\n    align-items: center;\n}\n\n.widget-box {\n    box-sizing: border-box;\n    display: flex;\n    margin: 0;\n    overflow: auto;\n}\n\n.widget-gridbox {\n    box-sizing: border-box;\n    display: grid;\n    margin: 0;\n    overflow: auto;\n}\n\n.widget-hbox {\n    flex-direction: row;\n}\n\n.widget-vbox {\n    flex-direction: column;\n}\n\n/* General Button Styling */\n\n.jupyter-button {\n    padding-left: 10px;\n    padding-right: 10px;\n    padding-top: 0px;\n    padding-bottom: 0px;\n    display: inline-block;\n    white-space: nowrap;\n    overflow: hidden;\n    text-overflow: ellipsis;\n    text-align: center;\n    font-size: var(--jp-widgets-font-size);\n    cursor: pointer;\n\n    height: var(--jp-widgets-inline-height);\n    border: 0px solid;\n    line-height: var(--jp-widgets-inline-height);\n    box-shadow: none;\n\n    color: var(--jp-ui-font-color1);\n    background-color: var(--jp-layout-color2);\n    border-color: var(--jp-border-color2);\n    border: none;\n}\n\n.jupyter-button i.fa {\n    margin-right: var(--jp-widgets-inline-margin);\n    pointer-events: none;\n}\n\n.jupyter-button:empty:before {\n    content: \"\\200b\"; /* zero-width space */\n}\n\n.jupyter-widgets.jupyter-button:disabled {\n    opacity: var(--jp-widgets-disabled-opacity);\n}\n\n.jupyter-button i.fa.center {\n    margin-right: 0;\n}\n\n.jupyter-button:hover:enabled, .jupyter-button:focus:enabled {\n    /* MD Lite 2dp shadow */\n    box-shadow: 0 2px 2px 0 rgba(0, 0, 0, var(--md-shadow-key-penumbra-opacity)),\n                0 3px 1px -2px rgba(0, 0, 0, var(--md-shadow-key-umbra-opacity)),\n                0 1px 5px 0 rgba(0, 0, 0, var(--md-shadow-ambient-shadow-opacity));\n}\n\n.jupyter-button:active, .jupyter-button.mod-active {\n    /* MD Lite 4dp shadow */\n    box-shadow: 0 4px 5px 0 rgba(0, 0, 0, var(--md-shadow-key-penumbra-opacity)),\n                0 1px 10px 0 rgba(0, 0, 0, var(--md-shadow-ambient-shadow-opacity)),\n                0 2px 4px -1px rgba(0, 0, 0, var(--md-shadow-key-umbra-opacity));\n    color: var(--jp-ui-font-color1);\n    background-color: var(--jp-layout-color3);\n}\n\n.jupyter-button:focus:enabled {\n    outline: 1px solid var(--jp-widgets-input-focus-border-color);\n}\n\n/* Button \"Primary\" Styling */\n\n.jupyter-button.mod-primary {\n    color: var(--jp-inverse-ui-font-color1);\n    background-color: var(--jp-brand-color1);\n}\n\n.jupyter-button.mod-primary.mod-active {\n    color: var(--jp-inverse-ui-font-color0);\n    background-color: var(--jp-brand-color0);\n}\n\n.jupyter-button.mod-primary:active {\n    color: var(--jp-inverse-ui-font-color0);\n    background-color: var(--jp-brand-color0);\n}\n\n/* Button \"Success\" Styling */\n\n.jupyter-button.mod-success {\n    color: var(--jp-inverse-ui-font-color1);\n    background-color: var(--jp-success-color1);\n}\n\n.jupyter-button.mod-success.mod-active {\n    color: var(--jp-inverse-ui-font-color0);\n    background-color: var(--jp-success-color0);\n }\n\n.jupyter-button.mod-success:active {\n    color: var(--jp-inverse-ui-font-color0);\n    background-color: var(--jp-success-color0);\n }\n\n /* Button \"Info\" Styling */\n\n.jupyter-button.mod-info {\n    color: var(--jp-inverse-ui-font-color1);\n    background-color: var(--jp-info-color1);\n}\n\n.jupyter-button.mod-info.mod-active {\n    color: var(--jp-inverse-ui-font-color0);\n    background-color: var(--jp-info-color0);\n}\n\n.jupyter-button.mod-info:active {\n    color: var(--jp-inverse-ui-font-color0);\n    background-color: var(--jp-info-color0);\n}\n\n/* Button \"Warning\" Styling */\n\n.jupyter-button.mod-warning {\n    color: var(--jp-inverse-ui-font-color1);\n    background-color: var(--jp-warn-color1);\n}\n\n.jupyter-button.mod-warning.mod-active {\n    color: var(--jp-inverse-ui-font-color0);\n    background-color: var(--jp-warn-color0);\n}\n\n.jupyter-button.mod-warning:active {\n    color: var(--jp-inverse-ui-font-color0);\n    background-color: var(--jp-warn-color0);\n}\n\n/* Button \"Danger\" Styling */\n\n.jupyter-button.mod-danger {\n    color: var(--jp-inverse-ui-font-color1);\n    background-color: var(--jp-error-color1);\n}\n\n.jupyter-button.mod-danger.mod-active {\n    color: var(--jp-inverse-ui-font-color0);\n    background-color: var(--jp-error-color0);\n}\n\n.jupyter-button.mod-danger:active {\n    color: var(--jp-inverse-ui-font-color0);\n    background-color: var(--jp-error-color0);\n}\n\n/* Widget Button*/\n\n.widget-button, .widget-toggle-button {\n    width: var(--jp-widgets-inline-width-short);\n}\n\n/* Widget Label Styling */\n\n/* Override Bootstrap label css */\n.jupyter-widgets label {\n    margin-bottom: initial;\n}\n\n.widget-label-basic {\n    /* Basic Label */\n    color: var(--jp-widgets-label-color);\n    font-size: var(--jp-widgets-font-size);\n    overflow: hidden;\n    text-overflow: ellipsis;\n    white-space: nowrap;\n    line-height: var(--jp-widgets-inline-height);\n}\n\n.widget-label {\n    /* Label */\n    color: var(--jp-widgets-label-color);\n    font-size: var(--jp-widgets-font-size);\n    overflow: hidden;\n    text-overflow: ellipsis;\n    white-space: nowrap;\n    line-height: var(--jp-widgets-inline-height);\n}\n\n.widget-inline-hbox .widget-label {\n    /* Horizontal Widget Label */\n    color: var(--jp-widgets-label-color);\n    text-align: right;\n    margin-right: calc( var(--jp-widgets-inline-margin) * 2 );\n    width: var(--jp-widgets-inline-label-width);\n    flex-shrink: 0;\n}\n\n.widget-inline-vbox .widget-label {\n    /* Vertical Widget Label */\n    color: var(--jp-widgets-label-color);\n    text-align: center;\n    line-height: var(--jp-widgets-inline-height);\n}\n\n/* Widget Readout Styling */\n\n.widget-readout {\n    color: var(--jp-widgets-readout-color);\n    font-size: var(--jp-widgets-font-size);\n    height: var(--jp-widgets-inline-height);\n    line-height: var(--jp-widgets-inline-height);\n    overflow: hidden;\n    white-space: nowrap;\n    text-align: center;\n}\n\n.widget-readout.overflow {\n    /* Overflowing Readout */\n\n    /* From Material Design Lite\n        shadow-key-umbra-opacity: 0.2;\n        shadow-key-penumbra-opacity: 0.14;\n        shadow-ambient-shadow-opacity: 0.12;\n     */\n    -webkit-box-shadow: 0 2px 2px 0 rgba(0, 0, 0, 0.2),\n                        0 3px 1px -2px rgba(0, 0, 0, 0.14),\n                        0 1px 5px 0 rgba(0, 0, 0, 0.12);\n\n    -moz-box-shadow: 0 2px 2px 0 rgba(0, 0, 0, 0.2),\n                     0 3px 1px -2px rgba(0, 0, 0, 0.14),\n                     0 1px 5px 0 rgba(0, 0, 0, 0.12);\n\n    box-shadow: 0 2px 2px 0 rgba(0, 0, 0, 0.2),\n                0 3px 1px -2px rgba(0, 0, 0, 0.14),\n                0 1px 5px 0 rgba(0, 0, 0, 0.12);\n}\n\n.widget-inline-hbox .widget-readout {\n    /* Horizontal Readout */\n    text-align: center;\n    max-width: var(--jp-widgets-inline-width-short);\n    min-width: var(--jp-widgets-inline-width-tiny);\n    margin-left: var(--jp-widgets-inline-margin);\n}\n\n.widget-inline-vbox .widget-readout {\n    /* Vertical Readout */\n    margin-top: var(--jp-widgets-inline-margin);\n    /* as wide as the widget */\n    width: inherit;\n}\n\n/* Widget Checkbox Styling */\n\n.widget-checkbox {\n    width: var(--jp-widgets-inline-width);\n    height: var(--jp-widgets-inline-height);\n    line-height: var(--jp-widgets-inline-height);\n}\n\n.widget-checkbox input[type=\"checkbox\"] {\n    margin: 0px calc( var(--jp-widgets-inline-margin) * 2 ) 0px 0px;\n    line-height: var(--jp-widgets-inline-height);\n    font-size: large;\n    flex-grow: 1;\n    flex-shrink: 0;\n    align-self: center;\n}\n\n/* Widget Valid Styling */\n\n.widget-valid {\n    height: var(--jp-widgets-inline-height);\n    line-height: var(--jp-widgets-inline-height);\n    width: var(--jp-widgets-inline-width-short);\n    font-size: var(--jp-widgets-font-size);\n}\n\n.widget-valid i:before {\n    line-height: var(--jp-widgets-inline-height);\n    margin-right: var(--jp-widgets-inline-margin);\n    margin-left: var(--jp-widgets-inline-margin);\n\n    /* from the fa class in FontAwesome: https://github.com/FortAwesome/Font-Awesome/blob/49100c7c3a7b58d50baa71efef11af41a66b03d3/css/font-awesome.css#L14 */\n    display: inline-block;\n    font: normal normal normal 14px/1 FontAwesome;\n    font-size: inherit;\n    text-rendering: auto;\n    -webkit-font-smoothing: antialiased;\n    -moz-osx-font-smoothing: grayscale;\n}\n\n.widget-valid.mod-valid i:before {\n    content: \"\\f00c\";\n    color: green;\n}\n\n.widget-valid.mod-invalid i:before {\n    content: \"\\f00d\";\n    color: red;\n}\n\n.widget-valid.mod-valid .widget-valid-readout {\n    display: none;\n}\n\n/* Widget Text and TextArea Stying */\n\n.widget-textarea, .widget-text {\n    width: var(--jp-widgets-inline-width);\n}\n\n.widget-text input[type=\"text\"], .widget-text input[type=\"number\"]{\n    height: var(--jp-widgets-inline-height);\n    line-height: var(--jp-widgets-inline-height);\n}\n\n.widget-text input[type=\"text\"]:disabled, .widget-text input[type=\"number\"]:disabled, .widget-textarea textarea:disabled {\n    opacity: var(--jp-widgets-disabled-opacity);\n}\n\n.widget-text input[type=\"text\"], .widget-text input[type=\"number\"], .widget-textarea textarea {\n    box-sizing: border-box;\n    border: var(--jp-widgets-input-border-width) solid var(--jp-widgets-input-border-color);\n    background-color: var(--jp-widgets-input-background-color);\n    color: var(--jp-widgets-input-color);\n    font-size: var(--jp-widgets-font-size);\n    padding: var(--jp-widgets-input-padding) calc( var(--jp-widgets-input-padding) *  2 );\n    flex-grow: 1;\n    min-width: 0; /* This makes it possible for the flexbox to shrink this input */\n    flex-shrink: 1;\n    outline: none !important;\n}\n\n.widget-textarea textarea {\n    height: inherit;\n    width: inherit;\n}\n\n.widget-text input:focus, .widget-textarea textarea:focus {\n    border-color: var(--jp-widgets-input-focus-border-color);\n}\n\n/* Widget Slider */\n\n.widget-slider .ui-slider {\n    /* Slider Track */\n    border: var(--jp-widgets-slider-border-width) solid var(--jp-layout-color3);\n    background: var(--jp-layout-color3);\n    box-sizing: border-box;\n    position: relative;\n    border-radius: 0px;\n}\n\n.widget-slider .ui-slider .ui-slider-handle {\n    /* Slider Handle */\n    outline: none !important; /* focused slider handles are colored - see below */\n    position: absolute;\n    background-color: var(--jp-widgets-slider-handle-background-color);\n    border: var(--jp-widgets-slider-border-width) solid var(--jp-widgets-slider-handle-border-color);\n    box-sizing: border-box;\n    z-index: 1;\n    background-image: none; /* Override jquery-ui */\n}\n\n/* Override jquery-ui */\n.widget-slider .ui-slider .ui-slider-handle:hover, .widget-slider .ui-slider .ui-slider-handle:focus {\n    background-color: var(--jp-widgets-slider-active-handle-color);\n    border: var(--jp-widgets-slider-border-width) solid var(--jp-widgets-slider-active-handle-color);\n}\n\n.widget-slider .ui-slider .ui-slider-handle:active {\n    background-color: var(--jp-widgets-slider-active-handle-color);\n    border-color: var(--jp-widgets-slider-active-handle-color);\n    z-index: 2;\n    transform: scale(1.2);\n}\n\n.widget-slider  .ui-slider .ui-slider-range {\n    /* Interval between the two specified value of a double slider */\n    position: absolute;\n    background: var(--jp-widgets-slider-active-handle-color);\n    z-index: 0;\n}\n\n/* Shapes of Slider Handles */\n\n.widget-hslider .ui-slider .ui-slider-handle {\n    width: var(--jp-widgets-slider-handle-size);\n    height: var(--jp-widgets-slider-handle-size);\n    margin-top: calc((var(--jp-widgets-slider-track-thickness) - var(--jp-widgets-slider-handle-size)) / 2 - var(--jp-widgets-slider-border-width));\n    margin-left: calc(var(--jp-widgets-slider-handle-size) / -2 + var(--jp-widgets-slider-border-width));\n    border-radius: 50%;\n    top: 0;\n}\n\n.widget-vslider .ui-slider .ui-slider-handle {\n    width: var(--jp-widgets-slider-handle-size);\n    height: var(--jp-widgets-slider-handle-size);\n    margin-bottom: calc(var(--jp-widgets-slider-handle-size) / -2 + var(--jp-widgets-slider-border-width));\n    margin-left: calc((var(--jp-widgets-slider-track-thickness) - var(--jp-widgets-slider-handle-size)) / 2 - var(--jp-widgets-slider-border-width));\n    border-radius: 50%;\n    left: 0;\n}\n\n.widget-hslider .ui-slider .ui-slider-range {\n    height: calc( var(--jp-widgets-slider-track-thickness) * 2 );\n    margin-top: calc((var(--jp-widgets-slider-track-thickness) - var(--jp-widgets-slider-track-thickness) * 2 ) / 2 - var(--jp-widgets-slider-border-width));\n}\n\n.widget-vslider .ui-slider .ui-slider-range {\n    width: calc( var(--jp-widgets-slider-track-thickness) * 2 );\n    margin-left: calc((var(--jp-widgets-slider-track-thickness) - var(--jp-widgets-slider-track-thickness) * 2 ) / 2 - var(--jp-widgets-slider-border-width));\n}\n\n/* Horizontal Slider */\n\n.widget-hslider {\n    width: var(--jp-widgets-inline-width);\n    height: var(--jp-widgets-inline-height);\n    line-height: var(--jp-widgets-inline-height);\n\n    /* Override the align-items baseline. This way, the description and readout\n    still seem to align their baseline properly, and we don't have to have\n    align-self: stretch in the .slider-container. */\n    align-items: center;\n}\n\n.widgets-slider .slider-container {\n    overflow: visible;\n}\n\n.widget-hslider .slider-container {\n    height: var(--jp-widgets-inline-height);\n    margin-left: calc(var(--jp-widgets-slider-handle-size) / 2 - 2 * var(--jp-widgets-slider-border-width));\n    margin-right: calc(var(--jp-widgets-slider-handle-size) / 2 - 2 * var(--jp-widgets-slider-border-width));\n    flex: 1 1 var(--jp-widgets-inline-width-short);\n}\n\n.widget-hslider .ui-slider {\n    /* Inner, invisible slide div */\n    height: var(--jp-widgets-slider-track-thickness);\n    margin-top: calc((var(--jp-widgets-inline-height) - var(--jp-widgets-slider-track-thickness)) / 2);\n    width: 100%;\n}\n\n/* Vertical Slider */\n\n.widget-vbox .widget-label {\n    height: var(--jp-widgets-inline-height);\n    line-height: var(--jp-widgets-inline-height);\n}\n\n.widget-vslider {\n    /* Vertical Slider */\n    height: var(--jp-widgets-vertical-height);\n    width: var(--jp-widgets-inline-width-tiny);\n}\n\n.widget-vslider .slider-container {\n    flex: 1 1 var(--jp-widgets-inline-width-short);\n    margin-left: auto;\n    margin-right: auto;\n    margin-bottom: calc(var(--jp-widgets-slider-handle-size) / 2 - 2 * var(--jp-widgets-slider-border-width));\n    margin-top: calc(var(--jp-widgets-slider-handle-size) / 2 - 2 * var(--jp-widgets-slider-border-width));\n    display: flex;\n    flex-direction: column;\n}\n\n.widget-vslider .ui-slider-vertical {\n    /* Inner, invisible slide div */\n    width: var(--jp-widgets-slider-track-thickness);\n    flex-grow: 1;\n    margin-left: auto;\n    margin-right: auto;\n}\n\n/* Widget Progress Styling */\n\n.progress-bar {\n    -webkit-transition: none;\n    -moz-transition: none;\n    -ms-transition: none;\n    -o-transition: none;\n    transition: none;\n}\n\n.progress-bar {\n    height: var(--jp-widgets-inline-height);\n}\n\n.progress-bar {\n    background-color: var(--jp-brand-color1);\n}\n\n.progress-bar-success {\n    background-color: var(--jp-success-color1);\n}\n\n.progress-bar-info {\n    background-color: var(--jp-info-color1);\n}\n\n.progress-bar-warning {\n    background-color: var(--jp-warn-color1);\n}\n\n.progress-bar-danger {\n    background-color: var(--jp-error-color1);\n}\n\n.progress {\n    background-color: var(--jp-layout-color2);\n    border: none;\n    box-shadow: none;\n}\n\n/* Horisontal Progress */\n\n.widget-hprogress {\n    /* Progress Bar */\n    height: var(--jp-widgets-inline-height);\n    line-height: var(--jp-widgets-inline-height);\n    width: var(--jp-widgets-inline-width);\n    align-items: center;\n\n}\n\n.widget-hprogress .progress {\n    flex-grow: 1;\n    margin-top: var(--jp-widgets-input-padding);\n    margin-bottom: var(--jp-widgets-input-padding);\n    align-self: stretch;\n    /* Override bootstrap style */\n    height: initial;\n}\n\n/* Vertical Progress */\n\n.widget-vprogress {\n    height: var(--jp-widgets-vertical-height);\n    width: var(--jp-widgets-inline-width-tiny);\n}\n\n.widget-vprogress .progress {\n    flex-grow: 1;\n    width: var(--jp-widgets-progress-thickness);\n    margin-left: auto;\n    margin-right: auto;\n    margin-bottom: 0;\n}\n\n/* Select Widget Styling */\n\n.widget-dropdown {\n    height: var(--jp-widgets-inline-height);\n    width: var(--jp-widgets-inline-width);\n    line-height: var(--jp-widgets-inline-height);\n}\n\n.widget-dropdown > select {\n    padding-right: 20px;\n    border: var(--jp-widgets-input-border-width) solid var(--jp-widgets-input-border-color);\n    border-radius: 0;\n    height: inherit;\n    flex: 1 1 var(--jp-widgets-inline-width-short);\n    min-width: 0; /* This makes it possible for the flexbox to shrink this input */\n    box-sizing: border-box;\n    outline: none !important;\n    box-shadow: none;\n    background-color: var(--jp-widgets-input-background-color);\n    color: var(--jp-widgets-input-color);\n    font-size: var(--jp-widgets-font-size);\n    vertical-align: top;\n    padding-left: calc( var(--jp-widgets-input-padding) * 2);\n\tappearance: none;\n\t-webkit-appearance: none;\n\t-moz-appearance: none;\n    background-repeat: no-repeat;\n\tbackground-size: 20px;\n\tbackground-position: right center;\n    background-image: var(--jp-widgets-dropdown-arrow);\n}\n.widget-dropdown > select:focus {\n    border-color: var(--jp-widgets-input-focus-border-color);\n}\n\n.widget-dropdown > select:disabled {\n    opacity: var(--jp-widgets-disabled-opacity);\n}\n\n/* To disable the dotted border in Firefox around select controls.\n   See http://stackoverflow.com/a/18853002 */\n.widget-dropdown > select:-moz-focusring {\n    color: transparent;\n    text-shadow: 0 0 0 #000;\n}\n\n/* Select and SelectMultiple */\n\n.widget-select {\n    width: var(--jp-widgets-inline-width);\n    line-height: var(--jp-widgets-inline-height);\n\n    /* Because Firefox defines the baseline of a select as the bottom of the\n    control, we align the entire control to the top and add padding to the\n    select to get an approximate first line baseline alignment. */\n    align-items: flex-start;\n}\n\n.widget-select > select {\n    border: var(--jp-widgets-input-border-width) solid var(--jp-widgets-input-border-color);\n    background-color: var(--jp-widgets-input-background-color);\n    color: var(--jp-widgets-input-color);\n    font-size: var(--jp-widgets-font-size);\n    flex: 1 1 var(--jp-widgets-inline-width-short);\n    outline: none !important;\n    overflow: auto;\n    height: inherit;\n\n    /* Because Firefox defines the baseline of a select as the bottom of the\n    control, we align the entire control to the top and add padding to the\n    select to get an approximate first line baseline alignment. */\n    padding-top: 5px;\n}\n\n.widget-select > select:focus {\n    border-color: var(--jp-widgets-input-focus-border-color);\n}\n\n.wiget-select > select > option {\n    padding-left: var(--jp-widgets-input-padding);\n    line-height: var(--jp-widgets-inline-height);\n    /* line-height doesn't work on some browsers for select options */\n    padding-top: calc(var(--jp-widgets-inline-height)-var(--jp-widgets-font-size)/2);\n    padding-bottom: calc(var(--jp-widgets-inline-height)-var(--jp-widgets-font-size)/2);\n}\n\n\n\n/* Toggle Buttons Styling */\n\n.widget-toggle-buttons {\n    line-height: var(--jp-widgets-inline-height);\n}\n\n.widget-toggle-buttons .widget-toggle-button {\n    margin-left: var(--jp-widgets-margin);\n    margin-right: var(--jp-widgets-margin);\n}\n\n.widget-toggle-buttons .jupyter-button:disabled {\n    opacity: var(--jp-widgets-disabled-opacity);\n}\n\n/* Radio Buttons Styling */\n\n.widget-radio {\n    width: var(--jp-widgets-inline-width);\n    line-height: var(--jp-widgets-inline-height);\n}\n\n.widget-radio-box {\n    display: flex;\n    flex-direction: column;\n    align-items: stretch;\n    box-sizing: border-box;\n    flex-grow: 1;\n    margin-bottom: var(--jp-widgets-radio-item-height-adjustment);\n}\n\n.widget-radio-box label {\n    height: var(--jp-widgets-radio-item-height);\n    line-height: var(--jp-widgets-radio-item-height);\n    font-size: var(--jp-widgets-font-size);\n}\n\n.widget-radio-box input {\n    height: var(--jp-widgets-radio-item-height);\n    line-height: var(--jp-widgets-radio-item-height);\n    margin: 0 calc( var(--jp-widgets-input-padding) * 2 ) 0 1px;\n    float: left;\n}\n\n/* Color Picker Styling */\n\n.widget-colorpicker {\n    width: var(--jp-widgets-inline-width);\n    height: var(--jp-widgets-inline-height);\n    line-height: var(--jp-widgets-inline-height);\n}\n\n.widget-colorpicker > .widget-colorpicker-input {\n    flex-grow: 1;\n    flex-shrink: 1;\n    min-width: var(--jp-widgets-inline-width-tiny);\n}\n\n.widget-colorpicker input[type=\"color\"] {\n    width: var(--jp-widgets-inline-height);\n    height: var(--jp-widgets-inline-height);\n    padding: 0 2px; /* make the color square actually square on Chrome on OS X */\n    background: var(--jp-widgets-input-background-color);\n    color: var(--jp-widgets-input-color);\n    border: var(--jp-widgets-input-border-width) solid var(--jp-widgets-input-border-color);\n    border-left: none;\n    flex-grow: 0;\n    flex-shrink: 0;\n    box-sizing: border-box;\n    align-self: stretch;\n    outline: none !important;\n}\n\n.widget-colorpicker.concise input[type=\"color\"] {\n    border-left: var(--jp-widgets-input-border-width) solid var(--jp-widgets-input-border-color);\n}\n\n.widget-colorpicker input[type=\"color\"]:focus, .widget-colorpicker input[type=\"text\"]:focus {\n    border-color: var(--jp-widgets-input-focus-border-color);\n}\n\n.widget-colorpicker input[type=\"text\"] {\n    flex-grow: 1;\n    outline: none !important;\n    height: var(--jp-widgets-inline-height);\n    line-height: var(--jp-widgets-inline-height);\n    background: var(--jp-widgets-input-background-color);\n    color: var(--jp-widgets-input-color);\n    border: var(--jp-widgets-input-border-width) solid var(--jp-widgets-input-border-color);\n    font-size: var(--jp-widgets-font-size);\n    padding: var(--jp-widgets-input-padding) calc( var(--jp-widgets-input-padding) *  2 );\n    min-width: 0; /* This makes it possible for the flexbox to shrink this input */\n    flex-shrink: 1;\n    box-sizing: border-box;\n}\n\n.widget-colorpicker input[type=\"text\"]:disabled {\n    opacity: var(--jp-widgets-disabled-opacity);\n}\n\n/* Date Picker Styling */\n\n.widget-datepicker {\n    width: var(--jp-widgets-inline-width);\n    height: var(--jp-widgets-inline-height);\n    line-height: var(--jp-widgets-inline-height);\n}\n\n.widget-datepicker input[type=\"date\"] {\n    flex-grow: 1;\n    flex-shrink: 1;\n    min-width: 0; /* This makes it possible for the flexbox to shrink this input */\n    outline: none !important;\n    height: var(--jp-widgets-inline-height);\n    border: var(--jp-widgets-input-border-width) solid var(--jp-widgets-input-border-color);\n    background-color: var(--jp-widgets-input-background-color);\n    color: var(--jp-widgets-input-color);\n    font-size: var(--jp-widgets-font-size);\n    padding: var(--jp-widgets-input-padding) calc( var(--jp-widgets-input-padding) *  2 );\n    box-sizing: border-box;\n}\n\n.widget-datepicker input[type=\"date\"]:focus {\n    border-color: var(--jp-widgets-input-focus-border-color);\n}\n\n.widget-datepicker input[type=\"date\"]:invalid {\n    border-color: var(--jp-warn-color1);\n}\n\n.widget-datepicker input[type=\"date\"]:disabled {\n    opacity: var(--jp-widgets-disabled-opacity);\n}\n\n/* Play Widget */\n\n.widget-play {\n    width: var(--jp-widgets-inline-width-short);\n    display: flex;\n    align-items: stretch;\n}\n\n.widget-play .jupyter-button {\n    flex-grow: 1;\n    height: auto;\n}\n\n.widget-play .jupyter-button:disabled {\n    opacity: var(--jp-widgets-disabled-opacity);\n}\n\n/* Tab Widget */\n\n.jupyter-widgets.widget-tab {\n    display: flex;\n    flex-direction: column;\n}\n\n.jupyter-widgets.widget-tab > .p-TabBar {\n    /* Necessary so that a tab can be shifted down to overlay the border of the box below. */\n    overflow-x: visible;\n    overflow-y: visible;\n}\n\n.jupyter-widgets.widget-tab > .p-TabBar > .p-TabBar-content {\n    /* Make sure that the tab grows from bottom up */\n    align-items: flex-end;\n    min-width: 0;\n    min-height: 0;\n}\n\n.jupyter-widgets.widget-tab > .widget-tab-contents {\n    width: 100%;\n    box-sizing: border-box;\n    margin: 0;\n    background: var(--jp-layout-color1);\n    color: var(--jp-ui-font-color1);\n    border: var(--jp-border-width) solid var(--jp-border-color1);\n    padding: var(--jp-widgets-container-padding);\n    flex-grow: 1;\n    overflow: auto;\n}\n\n.jupyter-widgets.widget-tab > .p-TabBar {\n    font: var(--jp-widgets-font-size) Helvetica, Arial, sans-serif;\n    min-height: calc(var(--jp-widgets-horizontal-tab-height) + var(--jp-border-width));\n}\n\n.jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tab {\n    flex: 0 1 var(--jp-widgets-horizontal-tab-width);\n    min-width: 35px;\n    min-height: calc(var(--jp-widgets-horizontal-tab-height) + var(--jp-border-width));\n    line-height: var(--jp-widgets-horizontal-tab-height);\n    margin-left: calc(-1 * var(--jp-border-width));\n    padding: 0px 10px;\n    background: var(--jp-layout-color2);\n    color: var(--jp-ui-font-color2);\n    border: var(--jp-border-width) solid var(--jp-border-color1);\n    border-bottom: none;\n    position: relative;\n}\n\n.jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tab.p-mod-current {\n    color: var(--jp-ui-font-color0);\n    /* We want the background to match the tab content background */\n    background: var(--jp-layout-color1);\n    min-height: calc(var(--jp-widgets-horizontal-tab-height) + 2 * var(--jp-border-width));\n    transform: translateY(var(--jp-border-width));\n    overflow: visible;\n}\n\n.jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tab.p-mod-current:before {\n    position: absolute;\n    top: calc(-1 * var(--jp-border-width));\n    left: calc(-1 * var(--jp-border-width));\n    content: '';\n    height: var(--jp-widgets-horizontal-tab-top-border);\n    width: calc(100% + 2 * var(--jp-border-width));\n    background: var(--jp-brand-color1);\n}\n\n.jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tab:first-child {\n    margin-left: 0;\n}\n\n.jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tab:hover:not(.p-mod-current) {\n    background: var(--jp-layout-color1);\n    color: var(--jp-ui-font-color1);\n}\n\n.jupyter-widgets.widget-tab > .p-TabBar .p-mod-closable > .p-TabBar-tabCloseIcon {\n    margin-left: 4px;\n}\n\n.jupyter-widgets.widget-tab > .p-TabBar .p-mod-closable > .p-TabBar-tabCloseIcon:before {\n    font-family: FontAwesome;\n    content: '\\f00d'; /* close */\n}\n\n.jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tabIcon,\n.jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tabLabel,\n.jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tabCloseIcon {\n    line-height: var(--jp-widgets-horizontal-tab-height);\n}\n\n/* Accordion Widget */\n\n.p-Collapse {\n    display: flex;\n    flex-direction: column;\n    align-items: stretch;\n}\n\n.p-Collapse-header {\n    padding: var(--jp-widgets-input-padding);\n    cursor: pointer;\n    color: var(--jp-ui-font-color2);\n    background-color: var(--jp-layout-color2);\n    border: var(--jp-widgets-border-width) solid var(--jp-border-color1);\n    padding: calc(var(--jp-widgets-container-padding) * 2 / 3) var(--jp-widgets-container-padding);\n    font-weight: bold;\n}\n\n.p-Collapse-header:hover {\n    background-color: var(--jp-layout-color1);\n    color: var(--jp-ui-font-color1);\n}\n\n.p-Collapse-open > .p-Collapse-header {\n    background-color: var(--jp-layout-color1);\n    color: var(--jp-ui-font-color0);\n    cursor: default;\n    border-bottom: none;\n}\n\n.p-Collapse .p-Collapse-header::before {\n    content: '\\f0da\\00A0';  /* caret-right, non-breaking space */\n    display: inline-block;\n    font: normal normal normal 14px/1 FontAwesome;\n    font-size: inherit;\n    text-rendering: auto;\n    -webkit-font-smoothing: antialiased;\n    -moz-osx-font-smoothing: grayscale;\n}\n\n.p-Collapse-open > .p-Collapse-header::before {\n    content: '\\f0d7\\00A0'; /* caret-down, non-breaking space */\n}\n\n.p-Collapse-contents {\n    padding: var(--jp-widgets-container-padding);\n    background-color: var(--jp-layout-color1);\n    color: var(--jp-ui-font-color1);\n    border-left: var(--jp-widgets-border-width) solid var(--jp-border-color1);\n    border-right: var(--jp-widgets-border-width) solid var(--jp-border-color1);\n    border-bottom: var(--jp-widgets-border-width) solid var(--jp-border-color1);\n    overflow: auto;\n}\n\n.p-Accordion {\n    display: flex;\n    flex-direction: column;\n    align-items: stretch;\n}\n\n.p-Accordion .p-Collapse {\n    margin-bottom: 0;\n}\n\n.p-Accordion .p-Collapse + .p-Collapse {\n    margin-top: 4px;\n}\n\n\n\n/* HTML widget */\n\n.widget-html, .widget-htmlmath {\n    font-size: var(--jp-widgets-font-size);\n}\n\n.widget-html > .widget-html-content, .widget-htmlmath > .widget-html-content {\n    /* Fill out the area in the HTML widget */\n    align-self: stretch;\n    flex-grow: 1;\n    flex-shrink: 1;\n    /* Makes sure the baseline is still aligned with other elements */\n    line-height: var(--jp-widgets-inline-height);\n    /* Make it possible to have absolutely-positioned elements in the html */\n    position: relative;\n}\n","/* This file has code derived from PhosphorJS CSS files, as noted below. The license for this PhosphorJS code is:\n\nCopyright (c) 2014-2017, PhosphorJS Contributors\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n\n* Redistributions of source code must retain the above copyright notice, this\n  list of conditions and the following disclaimer.\n\n* Redistributions in binary form must reproduce the above copyright notice,\n  this list of conditions and the following disclaimer in the documentation\n  and/or other materials provided with the distribution.\n\n* Neither the name of the copyright holder nor the names of its\n  contributors may be used to endorse or promote products derived from\n  this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\nAND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\nIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\nFOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\nDAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\nSERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\nCAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\nOR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n*/\n\n/*\n * The following section is derived from https://github.com/phosphorjs/phosphor/blob/23b9d075ebc5b73ab148b6ebfc20af97f85714c4/packages/widgets/style/tabbar.css \n * We've scoped the rules so that they are consistent with exactly our code.\n */\n\n.jupyter-widgets.widget-tab > .p-TabBar {\n  display: flex;\n  -webkit-user-select: none;\n  -moz-user-select: none;\n  -ms-user-select: none;\n  user-select: none;\n}\n\n\n.jupyter-widgets.widget-tab > .p-TabBar[data-orientation='horizontal'] {\n  flex-direction: row;\n}\n\n\n.jupyter-widgets.widget-tab > .p-TabBar[data-orientation='vertical'] {\n  flex-direction: column;\n}\n\n\n.jupyter-widgets.widget-tab > .p-TabBar > .p-TabBar-content {\n  margin: 0;\n  padding: 0;\n  display: flex;\n  flex: 1 1 auto;\n  list-style-type: none;\n}\n\n\n.jupyter-widgets.widget-tab > .p-TabBar[data-orientation='horizontal'] > .p-TabBar-content {\n  flex-direction: row;\n}\n\n\n.jupyter-widgets.widget-tab > .p-TabBar[data-orientation='vertical'] > .p-TabBar-content {\n  flex-direction: column;\n}\n\n\n.jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tab {\n  display: flex;\n  flex-direction: row;\n  box-sizing: border-box;\n  overflow: hidden;\n}\n\n\n.jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tabIcon,\n.jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tabCloseIcon {\n  flex: 0 0 auto;\n}\n\n\n.jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tabLabel {\n  flex: 1 1 auto;\n  overflow: hidden;\n  white-space: nowrap;\n}\n\n\n.jupyter-widgets.widget-tab > .p-TabBar .p-TabBar-tab.p-mod-hidden {\n  display: none !important;\n}\n\n\n.jupyter-widgets.widget-tab > .p-TabBar.p-mod-dragging .p-TabBar-tab {\n  position: relative;\n}\n\n\n.jupyter-widgets.widget-tab > .p-TabBar.p-mod-dragging[data-orientation='horizontal'] .p-TabBar-tab {\n  left: 0;\n  transition: left 150ms ease;\n}\n\n\n.jupyter-widgets.widget-tab > .p-TabBar.p-mod-dragging[data-orientation='vertical'] .p-TabBar-tab {\n  top: 0;\n  transition: top 150ms ease;\n}\n\n\n.jupyter-widgets.widget-tab > .p-TabBar.p-mod-dragging .p-TabBar-tab.p-mod-dragging {\n  transition: none;\n}\n\n/* End tabbar.css */\n"]} */",
       "headers": [
        [
         "content-type",
         "text/css"
        ]
       ],
       "ok": true,
       "status": 200,
       "status_text": ""
      }
     }
    },
    "colab_type": "code",
    "id": "_ObmMvYCJSDV",
    "outputId": "2af85b3f-6133-485a-cb8d-f17c4aec8241"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b35a969e1bf844eb9cf45497258fbb8c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=250), HTML(value='')))"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "gan_model = CycleGan(train_loader,val_loader)\n",
    "gan_model.train()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "gyThAcWdtrIk"
   },
   "outputs": [],
   "source": [
    "## Results SIR 11.670795746936527 SAR 11.670795746936527 SDR 6.5125854585956136\n",
    "\n",
    "import mir_eval\n",
    "import museval\n",
    "import gc\n",
    "def _any_source_silent(sources):\n",
    "    \"\"\"Returns true if the parameter sources has any silent first dimensions\"\"\"\n",
    "    return np.any(np.all(np.sum(\n",
    "        sources, axis=tuple(range(2, sources.ndim))) == 0, axis=1))\n",
    "\n",
    "test_dataset = LMDBWavLoader('musdb_test',True)\n",
    "test_data_len = len(test_dataset) \n",
    "eps = 1e-15\n",
    "with torch.no_grad():\n",
    "    # to get 1 min output\n",
    "    reconstructed_signals = []\n",
    "    mixed_signals = []\n",
    "    original_signals = []\n",
    "    out_sdr = []\n",
    "    out_sir = []\n",
    "    out_sar = []\n",
    "    for i in tqdm(range(test_data_len)):\n",
    "        #sample_rate = 20480\n",
    "        val_data  = test_dataset[i] \n",
    "        mixed_signal = []\n",
    "        wav_iter = list(audio_generator(val_data[1]))\n",
    "        subsample_n_samples = len(wav_iter)\n",
    "        for j in range(subsample_n_samples):\n",
    "            mixed_signal.append(wav_iter[j])\n",
    "        mixed_signal = torch.squeeze(torch.from_numpy(np.stack(mixed_signal,axis=0)).float()).to(device)\n",
    "        mixed_signal = torch.unsqueeze(mixed_signal, dim=1)\n",
    "        reconstructed = gan_model.generator(mixed_signal) \n",
    "        single_source = val_data[0]\n",
    "        \n",
    "        n_items_per_eval = 3\n",
    "        data_len = (single_source.shape[-1]//n_items_per_eval) * n_items_per_eval\n",
    "        reconstructed = torch.squeeze(reconstructed).detach().cpu().numpy().reshape(1,-1)[:,:data_len]\n",
    "\n",
    "        reconstructed = reconstructed[:data_len].reshape( -1)\n",
    "        single_source = single_source[:data_len].reshape( -1) \n",
    "        mixed_source = val_data[1][:data_len].reshape( -1)\n",
    "        clean_inference = mixed_source - single_source\n",
    "        predicted_inference = mixed_source - reconstructed\n",
    "        #single_source = librosa.resample(single_source, sample_rate, window_length) \n",
    "        #reconstructed = librosa.resample(reconstructed, sample_rate, window_length)\n",
    "        reference_music =single_source#, mixed_signal[:data_len].reshape(n_items_per_eval, -1) - single_source[:data_len].reshape(n_items_per_eval, -1)])\n",
    "        estimates_music = reconstructed#, mixed_signal[:data_len].reshape(n_items_per_eval, -1) - reconstructed])\n",
    "        del reconstructed\n",
    "        del single_source\n",
    "        del mixed_signal\n",
    "        gc.collect()\n",
    "        sdr_b,  sir_b, sar_b, _ =mir_eval.separation.bss_eval_sources_framewise(np.array([reference_music, clean_inference]), np.array([estimates_music, predicted_inference]))\n",
    "        sdr, sir, sar = sdr_b, sir_b, sar_b\n",
    "        #sdr_inter, sir_inter, sar_inter = sdr_b[1], sir_b[1], sar_b[1]\n",
    "        out_sdr.append(np.mean(sdr[~np.isnan(sdr)]))\n",
    "        out_sir.append(np.mean(sir[~np.isnan(sir)]))\n",
    "        out_sar.append(np.mean(sir[~np.isnan(sar)]))\n",
    "    sdr  = np.median(out_sdr)\n",
    "    sir = np.median(out_sir)\n",
    "    sar = np.median(out_sar)\n",
    "    print('SIR {} SAR {} SDR {}'.format(str(sir),str(sar),str(sdr)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "PwITOkhsSPgD"
   },
   "outputs": [],
   "source": [
    "def preprocess(x):\n",
    "    output_array = np.copy(x)\n",
    "    audio_len = output_array.shape[-1]\n",
    "    for i in range(window_length, audio_len, window_length):\n",
    "        output_array[0,0,i-1] = 0\n",
    "    return output_array\n",
    "    \n",
    "def predict_long_wav(wav_file_path, out_folder_name):\n",
    "    wav_data = load_wav(wav_file_path)\n",
    "    wav_iter = list(audio_generator(wav_data))\n",
    "    wav_iter = np.stack(wav_iter)\n",
    "    wav_iter = torch.from_numpy(wav_iter).float().to(device)\n",
    "    wav_iter = torch.unsqueeze(wav_iter,dim=1)\n",
    "    reconstructed = gan_model.generator(wav_iter)\n",
    "    x = reconstructed.view(1,1,-1).detach().cpu().numpy()\n",
    "    x = preprocess(x)\n",
    "    save_samples(x,  out_folder_name )\n",
    "predict_long_wav('mixture_blue.wav', 'blue')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Mi8SaE4_9r-1"
   },
   "outputs": [],
   "source": [
    "torch.cuda.empty_cache()"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "Music_Generator_CycleGan_single_gen Muse DB.ipynb",
   "provenance": [],
   "toc_visible": true,
   "version": "0.3.2"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}