9.0-seq2seq-NSYNTH.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "mbkdsxm4UjlZ"
   },
   "source": [
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/timsainb/tensorflow2-generative-models/blob/master/9.0-seq2seq-NSYNTH.ipynb)\n",
    "\n",
    "### Seq2Seq Autoencoder (without attention)  \n",
    "Seq2Seq models use recurrent neural network cells (like LSTMs) to better capture sequential organization in data. This implementation uses Convolutional Layers as input to the LSTM cells, and a single Bidirectional LSTM layer. \n",
    "\n",
    "![a seq2seq bidirectional lstm in tensorflow 2.0](https://github.com/timsainb/tensorflow2-generative-models/blob/f3360a819b5773692e943dfe181972a76b9d91bb/imgs/seq2seq.png?raw=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7ZpchPpwUjlb"
   },
   "source": [
    "### Install packages if in colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "EvXRBCw7Ujlc"
   },
   "outputs": [],
   "source": [
    "### install necessary packages if in colab\n",
    "def run_subprocess_command(cmd):\n",
    "  process = subprocess.Popen(cmd.split(), stdout=subprocess.PIPE)\n",
    "  for line in process.stdout:\n",
    "      print(line.decode().strip())\n",
    "      \n",
    "import sys, subprocess\n",
    "IN_COLAB = 'google.colab' in sys.modules\n",
    "colab_requirements = [\n",
    "    'pip install tf-nightly-gpu-2.0-preview==2.0.0.dev20190513',\n",
    "    'pip install librosa'\n",
    "]\n",
    "if IN_COLAB:\n",
    "  for i in colab_requirements:\n",
    "    run_subprocess_command(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "XCVo73YzUjlg"
   },
   "source": [
    "### load packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "1mDpGonuUjlg"
   },
   "outputs": [],
   "source": [
    ""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T05:33:25.609133Z",
     "start_time": "2019-05-14T05:33:25.605104Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "7JW9zJj6Ujlj",
    "outputId": "344667f0-a44f-421f-8557-145656ea04ff"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "env: CUDA_VISIBLE_DEVICES=2\n"
     ]
    }
   ],
   "source": [
    "# make visible the only one GPU\n",
    "#%env CUDA_VISIBLE_DEVICES=2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T05:33:31.950743Z",
     "start_time": "2019-05-14T05:33:25.610868Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "KZB9pwb-Ujlp"
   },
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import tensorflow_datasets as tfds\n",
    "from tensorflow.io import FixedLenFeature, parse_single_example\n",
    "from librosa.core.time_frequency import mel_frequencies\n",
    "from pathlib2 import Path\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from IPython import display\n",
    "from tqdm.autonotebook import tqdm\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T05:33:31.963252Z",
     "start_time": "2019-05-14T05:33:31.952815Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "ZFqhdD89Ujls",
    "outputId": "34876516-b1ee-435e-8c9a-492ac226c059"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0.0-dev20190513\n"
     ]
    }
   ],
   "source": [
    "print(tf.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "pAXySDnqUjlv"
   },
   "source": [
    "### Download or load dataset\n",
    "Tensorflow datasets will automatically download or load the dataset for you at this location"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T05:33:32.048595Z",
     "start_time": "2019-05-14T05:33:31.965075Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "IploxhlMUjlw",
    "outputId": "237c204f-de34-41e3-83c4-f087412902e2"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PosixPath('/mnt/cube/tsainbur/Projects/github_repos/tf2_gen_models/data')"
      ]
     },
     "execution_count": 4,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DATA_DIR = Path(\"data\").resolve()\n",
    "DATA_DIR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T05:33:36.728321Z",
     "start_time": "2019-05-14T05:33:32.050453Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "1d0S_llSUjl0"
   },
   "outputs": [],
   "source": [
    "ds_train, ds_test = tfds.load(\n",
    "    name=\"nsynth\", split=[\"train\", \"test\"], data_dir=DATA_DIR\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T05:33:36.736428Z",
     "start_time": "2019-05-14T05:33:36.730184Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "k8E1fJStUjl3",
    "outputId": "99275da1-5b31-4ade-9110-441ec244049a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<_OptionsDataset shapes: {id: (), audio: (64000,), pitch: (), velocity: (), instrument: {label: (), family: (), source: ()}, qualities: {bright: (), dark: (), distortion: (), fast_decay: (), long_release: (), multiphonic: (), nonlinear_env: (), percussive: (), reverb: (), tempo-synced: ()}}, types: {id: tf.string, audio: tf.float32, pitch: tf.int64, velocity: tf.int64, instrument: {label: tf.int64, family: tf.int64, source: tf.int64}, qualities: {bright: tf.bool, dark: tf.bool, distortion: tf.bool, fast_decay: tf.bool, long_release: tf.bool, multiphonic: tf.bool, nonlinear_env: tf.bool, percussive: tf.bool, reverb: tf.bool, tempo-synced: tf.bool}}>"
      ]
     },
     "execution_count": 6,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ds_train"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "x7X5QJCbUjl6"
   },
   "source": [
    "### Prepare spectrogramming and parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T05:33:36.820836Z",
     "start_time": "2019-05-14T05:33:36.738100Z"
    },
    "code_folding": [],
    "colab": {},
    "colab_type": "code",
    "id": "G23vz1NEUjl7"
   },
   "outputs": [],
   "source": [
    "def _normalize_tensorflow(S, hparams):\n",
    "    return tf.clip_by_value((S - hparams.min_level_db) / -hparams.min_level_db, 0, 1)\n",
    "\n",
    "def _tf_log10(x):\n",
    "    numerator = tf.math.log(x)\n",
    "    denominator = tf.math.log(tf.constant(10, dtype=numerator.dtype))\n",
    "    return numerator / denominator\n",
    "\n",
    "\n",
    "def _amp_to_db_tensorflow(x):\n",
    "    return 20 * _tf_log10(tf.clip_by_value(tf.abs(x), 1e-5, 1e100))\n",
    "\n",
    "\n",
    "def _stft_tensorflow(signals, hparams):\n",
    "    return tf.signal.stft(\n",
    "        signals,\n",
    "        hparams.win_length,\n",
    "        hparams.hop_length,\n",
    "        hparams.n_fft,\n",
    "        pad_end=True,\n",
    "        window_fn=tf.signal.hann_window,\n",
    "    )\n",
    "\n",
    "\n",
    "def spectrogram_tensorflow(y, hparams):\n",
    "    D = _stft_tensorflow(y, hparams)\n",
    "    S = _amp_to_db_tensorflow(tf.abs(D)) - hparams.ref_level_db\n",
    "    return _normalize_tensorflow(S, hparams)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T05:33:36.946645Z",
     "start_time": "2019-05-14T05:33:36.822589Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "Cu0jsEdIUjl9"
   },
   "outputs": [],
   "source": [
    "class HParams(object):\n",
    "    \"\"\" Hparams was removed from tf 2.0alpha so this is a placeholder\n",
    "    \"\"\"\n",
    "    def __init__(self, **kwargs):\n",
    "        self.__dict__.update(kwargs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T05:33:37.028015Z",
     "start_time": "2019-05-14T05:33:36.948405Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "Wmnn230sUjmA"
   },
   "outputs": [],
   "source": [
    "hparams = HParams( \n",
    "    # network\n",
    "    batch_size = 32,\n",
    "    # spectrogramming\n",
    "    sample_rate = 16000,\n",
    "    create_spectrogram = True,\n",
    "    win_length = 1024,\n",
    "    n_fft = 1024,\n",
    "    hop_length= 400,\n",
    "    ref_level_db = 50,\n",
    "    min_level_db = -100,\n",
    "    # mel scaling\n",
    "    num_mel_bins = 128,\n",
    "    mel_lower_edge_hertz = 0,\n",
    "    mel_upper_edge_hertz = 8000,\n",
    "    # inversion\n",
    "    power = 1.5, # for spectral inversion\n",
    "    griffin_lim_iters = 50,\n",
    "    pad=True,\n",
    "    #\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-13T19:31:28.258830Z",
     "start_time": "2019-05-13T19:31:28.254192Z"
    },
    "colab_type": "text",
    "id": "sTSg-xkRUjmC"
   },
   "source": [
    "### Create the dataset class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T05:33:37.153107Z",
     "start_time": "2019-05-14T05:33:37.029665Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "4SbKOmDOUjmD"
   },
   "outputs": [],
   "source": [
    "class NSynthDataset(object):\n",
    "    def __init__(\n",
    "        self,\n",
    "        tf_records,\n",
    "        hparams,\n",
    "        is_training=True,\n",
    "        test_size = 1000,\n",
    "        prefetch=1000, # how many spectrograms to prefetch\n",
    "        num_parallel_calls=10, # how many parallel threads should be preparing data\n",
    "        n_samples = 305979, # how many items are in the dataset\n",
    "        shuffle_buffer = 1000,\n",
    "    ):\n",
    "        self.is_training = is_training\n",
    "        self.nsamples = n_samples\n",
    "        self.test_size = test_size\n",
    "        self.hparams = hparams\n",
    "        self.prefetch = prefetch\n",
    "        self.shuffle_buffer = shuffle_buffer\n",
    "        # prepare for mel scaling\n",
    "        if self.hparams.create_spectrogram:\n",
    "            self.mel_matrix = self._make_mel_matrix()\n",
    "        # create dataset of tfrecords\n",
    "        self.raw_dataset = tf.data.TFRecordDataset(tf_records)\n",
    "        # prepare dataset iterations\n",
    "        self.dataset = self.raw_dataset.map(\n",
    "            lambda x: self._parse_function(x), num_parallel_calls=num_parallel_calls\n",
    "        )\n",
    "        # make and split train and test datasets\n",
    "        self.prepare_datasets()\n",
    "        \n",
    "    def prepare_datasets(self):\n",
    "        # Note: there are better ways to do batching and shuffling here:\n",
    "        #    https://www.tensorflow.org/guide/performance/datasets\n",
    "        \n",
    "        self.dataset_train = self.dataset.skip(self.test_size)\n",
    "        self.dataset_train = self.dataset_train.shuffle(self.shuffle_buffer)\n",
    "        self.dataset_train = self.dataset_train.prefetch(self.prefetch)\n",
    "        self.dataset_train = self.dataset_train.batch(hparams.batch_size)\n",
    "        \n",
    "        \n",
    "        self.dataset_test = self.dataset.take(self.test_size)\n",
    "        self.dataset_test = self.dataset_test.shuffle(self.shuffle_buffer)\n",
    "        self.dataset_test = self.dataset_test.prefetch(self.prefetch)\n",
    "        self.dataset_test = self.dataset_test.batch(hparams.batch_size)\n",
    "        \n",
    "        \n",
    "        \n",
    "    def _make_mel_matrix(self):\n",
    "        # create mel matrix\n",
    "        mel_matrix = tf.signal.linear_to_mel_weight_matrix(\n",
    "            num_mel_bins=self.hparams.num_mel_bins,\n",
    "            num_spectrogram_bins=int(self.hparams.n_fft / 2) + 1,\n",
    "            sample_rate=self.hparams.sample_rate,\n",
    "            lower_edge_hertz=self.hparams.mel_lower_edge_hertz,\n",
    "            upper_edge_hertz=self.hparams.mel_upper_edge_hertz,\n",
    "            dtype=tf.dtypes.float32,\n",
    "            name=None,\n",
    "        )\n",
    "        # gets the center frequencies of mel bands\n",
    "        mel_f = mel_frequencies(\n",
    "            n_mels=hparams.num_mel_bins + 2,\n",
    "            fmin=hparams.mel_lower_edge_hertz,\n",
    "            fmax=hparams.mel_upper_edge_hertz,\n",
    "        )\n",
    "        # Slaney-style mel is scaled to be approx constant energy per channel (from librosa)\n",
    "        enorm = tf.dtypes.cast(\n",
    "            tf.expand_dims(tf.constant(2.0 / (mel_f[2 : hparams.num_mel_bins + 2] - mel_f[:hparams.num_mel_bins])), 0),\n",
    "            tf.float32,\n",
    "        )\n",
    "        # normalize matrix\n",
    "        mel_matrix = tf.multiply(mel_matrix, enorm)\n",
    "        mel_matrix = tf.divide(mel_matrix, tf.reduce_sum(mel_matrix, axis=0))\n",
    "        \n",
    "        return mel_matrix\n",
    "\n",
    "    def print_feature_list(self):\n",
    "        # get the features\n",
    "        element = list(self.raw_dataset.take(count=1))[0]\n",
    "        # parse the element in to the example message\n",
    "        example = tf.train.Example()\n",
    "        example.ParseFromString(element.numpy())\n",
    "        print(list(example.features.feature))\n",
    "\n",
    "    def _parse_function(self, example_proto):\n",
    "        \"\"\" There are a number of features here (listed above). \n",
    "        I'm only grabbing a few here\n",
    "        \"\"\"\n",
    "        features = {\n",
    "            \"id\": FixedLenFeature([], dtype=tf.string),\n",
    "            \"pitch\": FixedLenFeature([1], dtype=tf.int64),\n",
    "            \"velocity\": FixedLenFeature([1], dtype=tf.int64),\n",
    "            \"audio\": FixedLenFeature([64000], dtype=tf.float32),\n",
    "            \"instrument/source\": FixedLenFeature([1], dtype=tf.int64),\n",
    "            \"instrument/family\": FixedLenFeature([1], dtype=tf.int64),\n",
    "            \"instrument/label\": FixedLenFeature([1], dtype=tf.int64),\n",
    "        }\n",
    "        example = parse_single_example(example_proto, features)\n",
    "\n",
    "        if self.hparams.create_spectrogram:\n",
    "            # create spectrogram\n",
    "            example[\"spectrogram\"] = spectrogram_tensorflow(\n",
    "                example[\"audio\"], self.hparams\n",
    "            )\n",
    "            # create melspectrogram\n",
    "            example[\"spectrogram\"] = tf.expand_dims(\n",
    "                tf.transpose(tf.tensordot(\n",
    "                    example[\"spectrogram\"], self.mel_matrix, 1\n",
    "            )), axis=2\n",
    "            )\n",
    "            \n",
    "        return example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "gaswmAhaUjmF"
   },
   "source": [
    "### Produce the dataset from tfrecords"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T05:33:37.372727Z",
     "start_time": "2019-05-14T05:33:37.154927Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "K0HHLRyuUjmG"
   },
   "outputs": [],
   "source": [
    "training_tfrecords = [str(i) for i in list((DATA_DIR / \"nsynth\").glob('**/*train.tfrecord*'))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T05:33:38.357385Z",
     "start_time": "2019-05-14T05:33:37.375071Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "tMtMjFEfUjmI"
   },
   "outputs": [],
   "source": [
    "dset = NSynthDataset(training_tfrecords, hparams)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T05:33:40.697363Z",
     "start_time": "2019-05-14T05:33:38.359394Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "oLSS_iIqUjmN"
   },
   "outputs": [],
   "source": [
    "ex = next(iter(dset.dataset_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T05:33:41.056935Z",
     "start_time": "2019-05-14T05:33:40.702553Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "csUDjCsVUjmQ",
    "outputId": "74a2a55f-3075-479d-9abd-85f9d45fa626"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.colorbar.Colorbar at 0x7ff05c34ee80>"
      ]
     },
     "execution_count": 14,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(ncols=1, figsize=(15,4))\n",
    "cax = ax.matshow(np.squeeze(ex[\"spectrogram\"].numpy()[0]), aspect='auto', origin='lower')\n",
    "fig.colorbar(cax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T05:33:41.063844Z",
     "start_time": "2019-05-14T05:33:41.059196Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "zuwGKocLUjmW",
    "outputId": "b3d761fe-644a-4284-e83f-a7efbbe9206a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(128, 160, 1)"
      ]
     },
     "execution_count": 15,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spec_shape = np.shape(ex[\"spectrogram\"].numpy()[10])\n",
    "spec_shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "JSIPUvyhUjma"
   },
   "source": [
    "### Define the network as tf.keras.model object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T05:33:41.146482Z",
     "start_time": "2019-05-14T05:33:41.065669Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "sriWcAe4Ujmb"
   },
   "outputs": [],
   "source": [
    "class AE(tf.keras.Model):\n",
    "    \"\"\"a basic autoencoder class for tensorflow\n",
    "    Extends:\n",
    "        tf.keras.Model\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, **kwargs):\n",
    "        super(AE, self).__init__()\n",
    "        self.__dict__.update(kwargs)\n",
    "\n",
    "        self.enc = tf.keras.Sequential(self.enc)\n",
    "        self.dec = tf.keras.Sequential(self.dec)\n",
    "\n",
    "    @tf.function\n",
    "    def encode(self, x):\n",
    "        return self.enc(x)\n",
    "\n",
    "    @tf.function\n",
    "    def decode(self, z):\n",
    "        return self.dec(z)\n",
    "\n",
    "    @tf.function\n",
    "    def compute_loss(self, x):\n",
    "        z = self.encode(x)\n",
    "        _x = self.decode(z)\n",
    "        ae_loss = tf.reduce_mean(tf.square(x - _x))\n",
    "        return ae_loss\n",
    "\n",
    "    @tf.function\n",
    "    def compute_gradients(self, x):\n",
    "        with tf.GradientTape() as tape:\n",
    "            loss = self.compute_loss(x)\n",
    "        return tape.gradient(loss, self.trainable_variables)\n",
    "\n",
    "    @tf.function\n",
    "    def train(self, train_x):\n",
    "        gradients = self.compute_gradients(train_x)\n",
    "        self.optimizer.apply_gradients(zip(gradients, self.trainable_variables))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-13T20:04:30.551321Z",
     "start_time": "2019-05-13T20:04:30.464323Z"
    },
    "colab_type": "text",
    "id": "Z7oirx76Ujmh"
   },
   "source": [
    "### Define the network architecture"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T05:33:41.274897Z",
     "start_time": "2019-05-14T05:33:41.148797Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "TNTlOEDrUjmi"
   },
   "outputs": [],
   "source": [
    "from tensorflow.keras.layers import (\n",
    "    Conv2D,\n",
    "    Reshape,\n",
    "    Bidirectional,\n",
    "    Dense,\n",
    "    RepeatVector,\n",
    "    TimeDistributed,\n",
    "    LSTM,\n",
    ")\n",
    "\n",
    "# from tensorflow.keras.layers import UnifiedLSTM as LSTM\n",
    "\n",
    "N_Z = 512\n",
    "shape_final = (8, 10, 128)  # x channel will be the sequence length\n",
    "\n",
    "enc = [\n",
    "    Conv2D(\n",
    "        filters=16, kernel_size=3, strides=(2, 2), activation=\"relu\", padding=\"same\"\n",
    "    ),\n",
    "    Conv2D(\n",
    "        filters=32, kernel_size=3, strides=(2, 2), activation=\"relu\", padding=\"same\"\n",
    "    ),\n",
    "    Conv2D(\n",
    "        filters=64, kernel_size=3, strides=(2, 2), activation=\"relu\", padding=\"same\"\n",
    "    ),\n",
    "    Conv2D(\n",
    "        filters=shape_final[2],\n",
    "        kernel_size=3,\n",
    "        strides=(2, 2),\n",
    "        activation=\"relu\",\n",
    "        padding=\"same\",\n",
    "    ),\n",
    "    Reshape(target_shape=(shape_final[0], np.prod(shape_final[1:]))),\n",
    "    Bidirectional(LSTM(units=100, activation=\"relu\")),\n",
    "    Dense(units=512),\n",
    "    Dense(units=N_Z),\n",
    "]\n",
    "\n",
    "dec = [\n",
    "    Dense(units=512),\n",
    "    RepeatVector(shape_final[0]),\n",
    "    Bidirectional(LSTM(units=100, activation=\"relu\", return_sequences=True)),\n",
    "    TimeDistributed(Dense(np.prod(shape_final[1:]))),\n",
    "    Reshape(target_shape=(shape_final[0], shape_final[1], shape_final[2])),\n",
    "    tf.keras.layers.Conv2DTranspose(\n",
    "        filters=shape_final[2],\n",
    "        kernel_size=3,\n",
    "        strides=(2, 2),\n",
    "        padding=\"SAME\",\n",
    "        activation=\"relu\",\n",
    "    ),\n",
    "    tf.keras.layers.Conv2DTranspose(\n",
    "        filters=64, kernel_size=3, strides=(2, 2), padding=\"SAME\", activation=\"relu\"\n",
    "    ),\n",
    "    tf.keras.layers.Conv2DTranspose(\n",
    "        filters=32, kernel_size=3, strides=(2, 2), padding=\"SAME\", activation=\"relu\"\n",
    "    ),\n",
    "    tf.keras.layers.Conv2DTranspose(\n",
    "        filters=16, kernel_size=3, strides=(2, 2), padding=\"SAME\", activation=\"relu\"\n",
    "    ),\n",
    "    tf.keras.layers.Conv2DTranspose(\n",
    "        filters=1, kernel_size=1, strides=(1, 1), activation=\"sigmoid\"\n",
    "    ),\n",
    "    Reshape(target_shape=spec_shape),\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-10T18:40:40.306731Z",
     "start_time": "2019-05-10T18:40:40.292930Z"
    },
    "colab_type": "text",
    "id": "iv4pD_ERUjmk"
   },
   "source": [
    "### Create Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T05:33:41.348434Z",
     "start_time": "2019-05-14T05:33:41.276659Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "lIRszaLyUjmk"
   },
   "outputs": [],
   "source": [
    "# optimizers\n",
    "optimizer = tf.keras.optimizers.Adam(1e-3, beta_1=0.5)\n",
    "\n",
    "# model\n",
    "model = AE(\n",
    "    enc = enc,\n",
    "    dec = dec,\n",
    "    optimizer = optimizer,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T05:33:43.741275Z",
     "start_time": "2019-05-14T05:33:41.350078Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "IDewWhjJUjmm",
    "outputId": "a1773dbf-b94f-4507-b6d9-535b45b1338e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TensorShape([32, 128, 160, 1])"
      ]
     },
     "execution_count": 19,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# exampled data for plotting results\n",
    "example_data = next(iter(dset.dataset_test))['spectrogram']\n",
    "example_data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T05:33:45.879263Z",
     "start_time": "2019-05-14T05:33:43.743480Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "k4lzePZ7Ujmp",
    "outputId": "534e248f-1f6a-42fa-c848-fe0e1a3ea32b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(32, 512)\n"
     ]
    }
   ],
   "source": [
    "ex_z = model.encode(example_data)\n",
    "print(ex_z.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T05:33:47.873647Z",
     "start_time": "2019-05-14T05:33:45.883038Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "vApYbrYZUjmr",
    "outputId": "755f82e3-395c-4e19-9163-bd1c36091929"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(32, 128, 160, 1)\n"
     ]
    }
   ],
   "source": [
    "ex_x = model.decode(ex_z)\n",
    "print(ex_x.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "2nLurN91Ujmt"
   },
   "source": [
    "### Train model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T05:33:47.893342Z",
     "start_time": "2019-05-14T05:33:47.878152Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "28vJxJEfUjmu"
   },
   "outputs": [],
   "source": [
    "def plot_reconstruction(model, example_data, nex=5, zm=2):\n",
    "\n",
    "    example_data_reconstructed = model.decode(model.encode(example_data))\n",
    "    fig, axs = plt.subplots(ncols=nex, nrows=2, figsize=(zm * nex, zm * 2))\n",
    "    for exi in range(nex):\n",
    "        axs[0, exi].matshow(\n",
    "            example_data.numpy()[exi].squeeze(), cmap=plt.cm.viridis, vmin=0, vmax=1,\n",
    "            origin = 'lower'\n",
    "        )\n",
    "        axs[1, exi].matshow(\n",
    "            example_data_reconstructed.numpy()[exi].squeeze(),\n",
    "            cmap=plt.cm.viridis,\n",
    "            vmin=0,\n",
    "            vmax=1,\n",
    "            origin = 'lower'\n",
    "        )\n",
    "    for ax in axs.flatten():\n",
    "        ax.axis(\"off\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T05:33:48.013562Z",
     "start_time": "2019-05-14T05:33:47.896060Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "0i4wcme_Ujmw"
   },
   "outputs": [],
   "source": [
    "# a pandas dataframe to save the loss information to\n",
    "losses = pd.DataFrame(columns = ['MSE'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T05:33:48.100233Z",
     "start_time": "2019-05-14T05:33:48.017505Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "3drrskLFUjmz",
    "outputId": "3f8aa6e8-a54c-4a44-e32a-9e8bc50618a7"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(9561, 31)"
      ]
     },
     "execution_count": 24,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n_batches_train = int(dset.nsamples/hparams.batch_size)\n",
    "n_batches_test = int(dset.test_size/hparams.batch_size)\n",
    "n_batches_train, n_batches_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T05:33:48.178891Z",
     "start_time": "2019-05-14T05:33:48.104169Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "hFdQTAsZUjm1"
   },
   "outputs": [],
   "source": [
    "# lets make epochs smaller so we can visualize training faster\n",
    "n_batches_train = 200"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T05:57:51.419502Z",
     "start_time": "2019-05-14T05:33:48.182759Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "zAopv_8YUjm3",
    "outputId": "2c940a43-ec8d-4ecd-82a7-75bae18a89ff"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 49 | MSE: 0.0038840165361762047\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_epochs = 50\n",
    "for epoch in range(n_epochs):\n",
    "    # train\n",
    "    for batch, train_x in tqdm(\n",
    "        zip(range(n_batches_train), dset.dataset_train), total=n_batches_train\n",
    "    ):\n",
    "        model.train(train_x['spectrogram'])\n",
    "    # test on holdout\n",
    "    loss = []\n",
    "    for batch, test_x in tqdm(\n",
    "        zip(range(n_batches_test), dset.dataset_test), total=n_batches_test\n",
    "    ):\n",
    "        loss.append(model.compute_loss(test_x['spectrogram']))\n",
    "    losses.loc[len(losses)] = np.mean(loss, axis=0)\n",
    "    # plot results\n",
    "    display.clear_output()\n",
    "    print(\n",
    "        \"Epoch: {} | MSE: {}\".format(\n",
    "            epoch, losses.MSE.values[-1]\n",
    "        )\n",
    "    )\n",
    "    plot_reconstruction(model, example_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "oXUzLBnwUjm6"
   },
   "outputs": [],
   "source": [
    ""
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "9.0-seq2seq-NSYNTH.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": 0
}