8.0-NSYNTH-iterator.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "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/8.0-NSYNTH-iterator.ipynb)\n",
    "\n",
    "## Iterator for NSynth \n",
    "\n",
    "The NSYNTH dataset is a set of thousands of musical notes saved as waveforms. To input these into a Seq2Seq model as spectrograms, I wrote a small dataset class that converts to spectrogram in tensorflow (using the code from the spectrogramming notebook). \n",
    "\n",
    "![a dataset iterator for tensorflow 2.0](imgs/nsynth-dataset.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Install packages if in colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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",
    "\n",
    "import sys, subprocess\n",
    "\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": {},
   "source": [
    "### load packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T04:26:55.963169Z",
     "start_time": "2019-05-14T04:26:50.333533Z"
    }
   },
   "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 numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T04:26:56.068693Z",
     "start_time": "2019-05-14T04:26:55.984505Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0.0-dev20190513\n"
     ]
    }
   ],
   "source": [
    "print(tf.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T04:26:56.152232Z",
     "start_time": "2019-05-14T04:26:56.072195Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PosixPath('/mnt/cube/tsainbur/Projects/github_repos/tf2_gen_models/data')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DATA_DIR = Path(\"data\").resolve()\n",
    "DATA_DIR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T04:26:57.433005Z",
     "start_time": "2019-05-14T04:26:56.154669Z"
    }
   },
   "outputs": [],
   "source": [
    "ds_train, ds_test = tfds.load(\n",
    "    name=\"nsynth\", split=[\"train\", \"test\"], data_dir=DATA_DIR\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T04:26:57.446559Z",
     "start_time": "2019-05-14T04:26:57.436208Z"
    }
   },
   "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": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ds_train"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Prepare spectrogramming and parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T04:26:57.559856Z",
     "start_time": "2019-05-14T04:26:57.448599Z"
    },
    "code_folding": []
   },
   "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": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T04:26:57.651322Z",
     "start_time": "2019-05-14T04:26:57.561803Z"
    }
   },
   "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": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T04:26:57.742833Z",
     "start_time": "2019-05-14T04:26:57.653238Z"
    }
   },
   "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"
    }
   },
   "source": [
    "### Create the dataset class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T04:26:57.881149Z",
     "start_time": "2019-05-14T04:26:57.745008Z"
    }
   },
   "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": {},
   "source": [
    "### Produce the dataset from tfrecords"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T00:45:23.645916Z",
     "start_time": "2019-05-14T00:45:23.640539Z"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T04:26:57.995096Z",
     "start_time": "2019-05-14T04:26:57.883022Z"
    }
   },
   "outputs": [],
   "source": [
    "training_tfrecords = [str(i) for i in list((DATA_DIR / \"nsynth\").glob('**/*train.tfrecord*'))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T04:26:58.066926Z",
     "start_time": "2019-05-14T04:26:57.997209Z"
    }
   },
   "outputs": [],
   "source": [
    "hparams.batch_size = 32"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T04:26:58.822190Z",
     "start_time": "2019-05-14T04:26:58.069025Z"
    }
   },
   "outputs": [],
   "source": [
    "dset = NSynthDataset(training_tfrecords, hparams)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T04:26:58.834053Z",
     "start_time": "2019-05-14T04:26:58.828359Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.NSynthDataset at 0x7fdc2016c588>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test plot an example from the dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T04:27:02.046893Z",
     "start_time": "2019-05-14T04:26:58.837749Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(32, 128, 160, 1)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ex = next(iter(dset.dataset_test))\n",
    "np.shape(ex[\"spectrogram\"].numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T04:28:35.761169Z",
     "start_time": "2019-05-14T04:28:35.355846Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.colorbar.Colorbar at 0x7fdbe4158320>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(ncols=1, figsize=(15,4))\n",
    "cax = ax.matshow(np.squeeze(ex[\"spectrogram\"].numpy()[10]), aspect='auto', origin='lower')\n",
    "fig.colorbar(cax)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T04:28:39.985812Z",
     "start_time": "2019-05-14T04:28:39.980972Z"
    }
   },
   "source": [
    "### test how fast we can iterate over the dataset\n",
    "This value is around 15 iterations/second on my computer locally with 10 parallel threads. It might be slower on colab or other free resources. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T04:28:40.757052Z",
     "start_time": "2019-05-14T04:28:40.751528Z"
    }
   },
   "outputs": [],
   "source": [
    "from tqdm.autonotebook import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-14T04:29:59.782683Z",
     "start_time": "2019-05-14T04:28:46.857524Z"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d3ab408b35b542aa968d5f93e6be77c0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=1000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "for batch, train_x in tqdm(\n",
    "        zip(range(1000), dset.dataset_train), total=1000):\n",
    "    continue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "provenance": [],
   "toc_visible": true
  },
  "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": 2
}