{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "Training deep models in *nussl*\n", "==============================\n", "\n", "*nussl* has a tightly integrated deep learning pipeline for computer audition,\n", "with a focus on source separation. This pipeline includes:\n", "\n", "- Existing source separation architectures (Deep Clustering, Mask Inference, etc),\n", "- Building blocks for creating new architectures (Recurrent Stacks, Embedding spaces, Mask Layers,\n", " Mel Projection Layers, etc),\n", "- Handling data and common data sets (WSJ, MUSDB, etc),\n", "- Training architectures via an easy to use API powered by [PyTorch Ignite](\n", "https://pytorch.org/ignite/index.html),\n", "- Evaluating model performance (SDR, SI-SDR, etc),\n", "- Using the models on new audio signals for inference,\n", "- Storing and distributing trained models via the [External File Zoo](\n", "http://nussl.ci.northwestern.edu/).\n", "\n", "This tutorial will walk you through *nussl*'s model training capabilities on a simple\n", "synthetic dataset for illustration purposes. While *nussl* has support for a broad variety of\n", "models, we will focus on straight-forward mask inference networks." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "# Do our imports and setup for this tutorial.\n", "import os\n", "import json\n", "import logging\n", "import copy\n", "import tempfile\n", "import glob\n", "import time\n", "import shutil\n", "from concurrent.futures import ThreadPoolExecutor\n", "\n", "import torch\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import tqdm\n", "\n", "import nussl\n", "\n", "start_time = time.time()\n", "\n", "# seed this notebook\n", "# (this seeds python's random, np.random, and torch.random)\n", "nussl.utils.seed(0)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "SeparationModel\n", "---------------\n", "\n", "At the heart of *nussl*'s deep learning pipeline is the SeparationModel class.\n", "SeparationModel takes in a description of the model architecture and instantiates it.\n", "Model architectures are described via a dictionary. A model architecture has three\n", "parts: the building blocks, or *modules*, how the building blocks are wired together,\n", "and the outputs of the model.\n", "\n", "### Modules ##\n", "\n", "Let's take a look how a simple architecture is described. This model will be a single\n", "linear layer that estimates the spectra for 3 sources for every frame in the STFT." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "# define the building blocks\n", "num_features = 129 # number of frequency bins in STFT\n", "num_sources = 3 # how many sources to estimate\n", "mask_activation = 'sigmoid' # activation function for masks\n", "num_audio_channels = 1 # number of audio channels\n", "\n", "modules = {\n", " 'mix_magnitude': {},\n", " 'my_log_spec': {\n", " 'class': 'AmplitudeToDB'\n", " },\n", " 'my_norm': {\n", " 'class': 'BatchNorm',\n", " },\n", " 'my_mask': {\n", " 'class': 'Embedding',\n", " 'args': {\n", " 'num_features': num_features,\n", " 'hidden_size': num_features,\n", " 'embedding_size': num_sources,\n", " 'activation': mask_activation,\n", " 'num_audio_channels': num_audio_channels,\n", " 'dim_to_embed': [2, 3] # embed the frequency dimension (2) for all audio channels (3)\n", " }\n", " },\n", " 'my_estimates': {\n", " 'class': 'Mask',\n", " },\n", "}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The lines above define the building blocks, or *modules* of the SeparationModel. \n", "There are four building blocks:\n", "\n", "- `mix_magnitude`, the input to the model (this key is not user-definable),\n", "- `my_log_spec`, a \"layer\" that converts the spectrogram to dB space,\n", "- `my_norm`, a BatchNorm normalization layer, and\n", "- `my_mask`, which outputs the resultant mask. \n", "\n", "Each module in the dictionary has a key and a\n", "value. The key tells SeparationModel the user-definable name of that layer in our architecture.\n", "For example, `my_log_spec` will be the name of a building block. The value is\n", "also a dictionary with two values: `class` and `args`. `class` tells SeparationModel\n", "what the code for this module should be. `args` tells SeparationModel what the \n", "arguments to the class should be when instantiating it. Finally, if the dictionary\n", "that the key points to is empty, then it is assumed to be something that comes from\n", "the input dictionary to the model. Note that we haven't fully defined the model yet! We still\n", "need to determine how these modules are put together.\n", "\n", "So where does the code for each of these classes live? The code for these modules\n", "is in `nussl.ml.modules`. The existing modules in *nussl* are as follows:" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "lines_to_end_of_cell_marker": 2 }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "nussl.ml.modules contents:\n", "--------------------------\n", "AmplitudeToDB\n", "BatchNorm\n", "Concatenate\n", "ConvolutionalStack2D\n", "DualPath\n", "DualPathBlock\n", "Embedding\n", "Expand\n", "FilterBank\n", "GaussianMixtureTorch\n", "InstanceNorm\n", "LayerNorm\n", "LearnedFilterBank\n", "Mask\n", "MelProjection\n", "RecurrentStack\n", "STFT\n", "ShiftAndScale\n", "Split\n", "blocks\n", "filter_bank\n" ] } ], "source": [ "def print_existing_modules():\n", " excluded = ['checkpoint', 'librosa', 'nn', 'np', 'torch', 'warnings']\n", " print('nussl.ml.modules contents:')\n", " print('--------------------------')\n", " existing_modules = [x for x in dir(nussl.ml.modules) if\n", " x not in excluded and not x.startswith('__')]\n", " print('\\n'.join(existing_modules))\n", "\n", "\n", "print_existing_modules()" ] }, { "cell_type": "markdown", "metadata": { "lines_to_next_cell": 2 }, "source": [ "Descriptions of each of these modules and their arguments can be found in the API docs.\n", "In the model we have described above, we have used: \n", "\n", "1. `AmplitudeToDB` to compute log-magnitude spectrograms from the input `mix_magnitude`.\n", "2. `BatchNorm` to normalize each spectrogram input by the mean and standard\n", " deviation of all the data (one mean/std for the entire spectrogram, not per feature).\n", "3. `Embedding` to embed each 129-dimensional frame into 3*129-dimensional space with a\n", " sigmoid activation.\n", "4. `Mask` to take the output of the embedding and element-wise multiply it by the input\n", " `mix_magnitude` to generate source estimates.\n", " \n", "### Connections ###\n", "\n", "Now we have to define the next part of SeparationModel - how the modules are wired together.\n", "We do this by defining the `connections` of the model." ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "lines_to_next_cell": 2 }, "outputs": [], "source": [ "# define the topology\n", "connections = [\n", " ['my_log_spec', ['mix_magnitude', ]],\n", " ['my_norm', ['my_log_spec', ]],\n", " ['my_mask', ['my_norm', ]],\n", " ['my_estimates', ['my_mask', 'mix_magnitude']]\n", "]" ] }, { "cell_type": "markdown", "metadata": { "lines_to_next_cell": 2 }, "source": [ "`connections` is a list of lists. Each item of `connections` has two elements. The first\n", "element contains the name of our module (defined in `modules`). The second element\n", "contains the arguments that will go into the module defined in the first element.\n", "\n", "So for example, `my_log_spec`, which corresponded to the `AmplitudeToDB`\n", "class takes in `my_mix_magnitude`. In the forward pass `my_mix_magnitude` corresponds to\n", "the data in the input dictionary. The output of `my_log_spec` (a\n", "log-magnitude spectrogram) is passed to the module named `my_norm`, (a `BatchNorm`\n", "layer). This output is then passed to the `my_mask` module, which\n", "constructs the masks using an `Embedding` class. Finally, the source estimates\n", "are constructed by passing both `mix_magnitude` and `my_mask` to the `my_estimates`\n", "module, which uses a `Mask` class.\n", "\n", "Complex forward passes can be defined via these connections. Connections can be\n", "even more detailed. Modules can take in keyword arguments by making the second\n", "element a dictionary. If modules also output a dictionary, then specific outputs\n", "can be reference in the connections via `module_name:key_in_dictionary`. For\n", "example, `nussl.ml.modules.GaussianMixtureTorch` (which is a differentiable\n", "GMM unfolded on some input data) outputs a dictionary with\n", "the following keys: `resp, log_prob, means, covariance, prior`. If this module\n", "was named `gmm`, then these outputs can be used in the second element via\n", "`gmm:means`, `gmm:resp`, `gmm:covariance`, etc.\n", "\n", "### Output and forward pass ###\n", "\n", "Next, models have to actually output some data to be used later on. Let's have\n", "this model output the keys for `my_estimates` and `my_mask` (as defined in our `modules` dict, above) by doing this:" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "lines_to_next_cell": 2 }, "outputs": [], "source": [ "# define the outputs\n", "output = ['my_estimates', 'my_mask']" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You can use these outputs directly or you can use them as a part of a \n", "larger deep learning pipeline. SeparationModel can be, for example, a\n", "first step before you do something more complicated with the output\n", "that doesn't fit cleanly into how SeparationModels are built.\n", "\n", "### Putting it all together ###\n", "\n", "Finally, let's put it all together in one config dictionary. The dictionary\n", "must have the following keys to be valid: `modules`, `connections`, and \n", "`output`. If these keys don't exist, then SeparationModel will throw\n", "an error." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{\n", " \"modules\": {\n", " \"mix_magnitude\": {},\n", " \"my_log_spec\": {\n", " \"class\": \"AmplitudeToDB\"\n", " },\n", " \"my_norm\": {\n", " \"class\": \"BatchNorm\"\n", " },\n", " \"my_mask\": {\n", " \"class\": \"Embedding\",\n", " \"args\": {\n", " \"num_features\": 129,\n", " \"hidden_size\": 129,\n", " \"embedding_size\": 3,\n", " \"activation\": \"sigmoid\",\n", " \"num_audio_channels\": 1,\n", " \"dim_to_embed\": [\n", " 2,\n", " 3\n", " ]\n", " }\n", " },\n", " \"my_estimates\": {\n", " \"class\": \"Mask\"\n", " }\n", " },\n", " \"connections\": [\n", " [\n", " \"my_log_spec\",\n", " [\n", " \"mix_magnitude\"\n", " ]\n", " ],\n", " [\n", " \"my_norm\",\n", " [\n", " \"my_log_spec\"\n", " ]\n", " ],\n", " [\n", " \"my_mask\",\n", " [\n", " \"my_norm\"\n", " ]\n", " ],\n", " [\n", " \"my_estimates\",\n", " [\n", " \"my_mask\",\n", " \"mix_magnitude\"\n", " ]\n", " ]\n", " ],\n", " \"output\": [\n", " \"my_estimates\",\n", " \"my_mask\"\n", " ]\n", "}\n" ] } ], "source": [ "# put it all together\n", "config = {\n", " 'modules': modules,\n", " 'connections': connections,\n", " 'output': output\n", "}\n", "\n", "print(json.dumps(config, indent=2))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's load this config into SeparationModel and print the model\n", "architecture:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "lines_to_next_cell": 2 }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "SeparationModel(\n", " (layers): ModuleDict(\n", " (my_estimates): Mask()\n", " (my_log_spec): AmplitudeToDB()\n", " (my_mask): Embedding(\n", " (linear): Linear(in_features=129, out_features=387, bias=True)\n", " )\n", " (my_norm): BatchNorm(\n", " (batch_norm): BatchNorm1d(1, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " )\n", " )\n", ")\n", "Number of parameters: 50312\n" ] } ], "source": [ "model = nussl.ml.SeparationModel(config)\n", "print(model)" ] }, { "cell_type": "markdown", "metadata": { "lines_to_next_cell": 2 }, "source": [ "Now let's put some random data through it, with the expected size." ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "lines_to_next_cell": 2 }, "outputs": [ { "ename": "ValueError", "evalue": "Not all keys present in data! Needs mix_magnitude", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;31m# so: batch size is 1, 400 frames, 129 frequencies, and 1 audio channel\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mmix_magnitude\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrand\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m400\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m129\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmix_magnitude\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;32m~/.conda/envs/nussl-refactor/lib/python3.7/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 530\u001b[0m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_slow_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 531\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 532\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 533\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mhook\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_forward_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 534\u001b[0m \u001b[0mhook_result\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mhook\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/Dropbox/research/nussl_refactor/nussl/ml/networks/separation_model.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, data)\u001b[0m\n\u001b[1;32m 103\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mname\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 104\u001b[0m raise ValueError(\n\u001b[0;32m--> 105\u001b[0;31m f'Not all keys present in data! Needs {\", \".join(self.input)}')\n\u001b[0m\u001b[1;32m 106\u001b[0m \u001b[0moutput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 107\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mValueError\u001b[0m: Not all keys present in data! Needs mix_magnitude" ] } ], "source": [ "# The expected shape is: (batch_size, n_frames, n_frequencies, n_channels)\n", "# so: batch size is 1, 400 frames, 129 frequencies, and 1 audio channel\n", "mix_magnitude = torch.rand(1, 400, 129, 1)\n", "model(mix_magnitude)" ] }, { "cell_type": "markdown", "metadata": { "lines_to_next_cell": 2 }, "source": [ "Uh oh! Putting in the data directly resulted in an error. This is because \n", "SeparationModel expects a *dictionary*. The dictionary must contain all of the\n", "input keys that were defined. Here it was `my_mix_magnitude`. So let's try \n", "again:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "lines_to_next_cell": 2 }, "outputs": [], "source": [ "mix_magnitude = torch.rand(1, 400, 129, 1)\n", "data = {'mix_magnitude': mix_magnitude}\n", "output = model(data)" ] }, { "cell_type": "markdown", "metadata": { "lines_to_next_cell": 2 }, "source": [ "Now we have passed the data through the model. Note a few things here:\n", "\n", "1. The tensor passed through the model had the following shape:\n", " `(n_batch, sequence_length, num_frequencies, num_audio_channels)`. This is\n", " different from how STFTs for an AudioSignal are shaped. Those are shaped as:\n", " `(num_frequencies, sequence_length, num_audio_channels)`. We added a batch\n", " dimension here, and the ordering of frequency and audio channel dimensions\n", " were swapped. This is because recurrent networks are a popular way to process\n", " spectrograms, and these expect (and operate more efficiently) when sequence\n", " length is right after the batch dimension.\n", "2. The key in the dictionary had to match what we put in the configuration\n", " before.\n", "3. We embedded *both* the channel dimension (3) as well as the frequency dimension (2)\n", " when building up the configuration.\n", "\n", "Now let's take a look at what's in the output!" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "lines_to_next_cell": 2 }, "outputs": [ { "data": { "text/plain": [ "dict_keys(['my_estimates', 'my_mask'])" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "output.keys()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "There are two keys as expected: `my_estimates` and `my_mask`. They both have the\n", "same shape as `mix_magnitude` with one addition:" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(torch.Size([1, 400, 129, 1, 3]), torch.Size([1, 400, 129, 1, 3]))" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "output['my_estimates'].shape, output['my_mask'].shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The last dimension is 3! Which is the number of sources we're trying to\n", "separate. Let's look at the first source." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "i = 0\n", "plt.figure(figsize=(5, 5))\n", "plt.imshow(output['my_estimates'][0, ..., 0, i].T.cpu().data.numpy())\n", "plt.title(\"Source\")\n", "plt.show()\n", "\n", "plt.figure(figsize=(5, 5))\n", "plt.imshow(output['my_mask'][0, ..., 0, i].T.cpu().data.numpy())\n", "plt.title(\"Mask\")\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Not much to look at! " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Saving and loading a model ###\n", "\n", "Now let's save this model and load it back up." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "dict_keys(['state_dict', 'config', 'nussl_version'])\n", "SeparationModel(\n", " (layers): ModuleDict(\n", " (my_estimates): Mask()\n", " (my_log_spec): AmplitudeToDB()\n", " (my_mask): Embedding(\n", " (linear): Linear(in_features=129, out_features=387, bias=True)\n", " )\n", " (my_norm): BatchNorm(\n", " (batch_norm): BatchNorm1d(1, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " )\n", " )\n", ")\n", "Number of parameters: 50312\n" ] } ], "source": [ "with tempfile.NamedTemporaryFile(suffix='.pth', delete=True) as f:\n", " loc = model.save(f.name)\n", " reloaded_dict = torch.load(f.name)\n", "\n", " print(reloaded_dict.keys())\n", "\n", " new_model = nussl.ml.SeparationModel(reloaded_dict['config'])\n", " new_model.load_state_dict(reloaded_dict['state_dict'])\n", "\n", " print(new_model)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "When models are saved, both the config AND the weights are saved. Both of these can be easily\n", "loaded back into a new SeparationModel object." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Custom modules\n", "--------------\n", "\n", "There's also straightforward support for *custom* modules that don't \n", "exist in *nussl* but rather exist in the end-user code. These can be\n", "registered with SeparationModel easily. Let's build a custom module\n", "and register it with a copy of our existing model. Let's make this \n", "module a lambda, which takes in some arbitrary function and runs \n", "it on the input. We'll call it LambdaLayer:" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Shape is torch.Size([1, 400, 129, 1])\n" ] } ], "source": [ "class LambdaLayer(torch.nn.Module):\n", " def __init__(self, func):\n", " self.func = func\n", " super().__init__()\n", "\n", " def forward(self, data):\n", " return self.func(data)\n", "\n", "\n", "def print_shape(x):\n", " print(f'Shape is {x.shape}')\n", "\n", "\n", "lamb = LambdaLayer(print_shape)\n", "output = lamb(mix_magnitude)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now let's put it into a copy of our model and update the connections so that it\n", "prints for every layer." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "# Copy our previous modules and add our new Lambda class\n", "new_modules = copy.deepcopy(modules)\n", "new_modules['lambda'] = {\n", " 'class': 'LambdaLayer',\n", " 'args': {\n", " 'func': print_shape\n", " }\n", "}\n", "\n", "new_connections = [\n", " ['my_log_spec', ['mix_magnitude', ]],\n", " ['lambda', ['mix_magnitude', ]],\n", " ['lambda', ['my_log_spec', ]],\n", " ['my_norm', ['my_log_spec', ]],\n", " ['lambda', ['my_norm', ]],\n", " ['my_mask', ['my_norm', ]],\n", " ['lambda', ['my_mask', ]],\n", " ['my_estimates', ['my_mask', 'mix_magnitude']],\n", " ['lambda', ['my_estimates', ]]\n", "]\n", "\n", "new_config = {\n", " 'modules': new_modules,\n", " 'connections': new_connections,\n", " 'output': ['my_estimates', 'my_mask']\n", "}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "But right now, SeparationModel doesn't know about our LambdaLayer class! So,\n", "let's make it aware by registering the module with nussl:" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "nussl.ml.modules contents:\n", "--------------------------\n", "AmplitudeToDB\n", "BatchNorm\n", "Concatenate\n", "ConvolutionalStack2D\n", "DualPath\n", "DualPathBlock\n", "Embedding\n", "Expand\n", "FilterBank\n", "GaussianMixtureTorch\n", "InstanceNorm\n", "LambdaLayer\n", "LayerNorm\n", "LearnedFilterBank\n", "Mask\n", "MelProjection\n", "RecurrentStack\n", "STFT\n", "ShiftAndScale\n", "Split\n", "blocks\n", "filter_bank\n" ] } ], "source": [ "nussl.ml.register_module(LambdaLayer)\n", "print_existing_modules()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now LambdaLayer is a registered module! Let's build the SeparationModel and\n", "put some data through it:" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Shape is torch.Size([1, 400, 129, 1])\n", "Shape is torch.Size([1, 400, 129, 1])\n", "Shape is torch.Size([1, 400, 129, 1])\n", "Shape is torch.Size([1, 400, 129, 1, 3])\n", "Shape is torch.Size([1, 400, 129, 1, 3])\n" ] } ], "source": [ "verbose_model = nussl.ml.SeparationModel(new_config)\n", "output = verbose_model(data)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can see the outputs of the Lambda layer recurring after each connection.\n", "(**Note**: that because we used a non-serializable argument (the function, ``func``)\n", "to the LambdaLayer, this model won't save without special handling!)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Alright, now let's see how to use some actual audio data with our model..." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Handling data\n", "-------------\n", "\n", "As described in the datasets tutorial, the heart of *nussl* data handling\n", "is BaseDataset and its associated subclasses. We built a simple one in that\n", "tutorial that just produced random sine waves. Let's grab it again:" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "def make_sine_wave(freq, sample_rate, duration):\n", " dt = 1 / sample_rate\n", " x = np.arange(0.0, duration, dt)\n", " x = np.sin(2 * np.pi * freq * x)\n", " return x\n", "\n", "\n", "class SineWaves(nussl.datasets.BaseDataset):\n", " def __init__(self, *args, num_sources=3, num_frequencies=20, **kwargs):\n", " self.num_sources = num_sources\n", " self.frequencies = np.random.choice(\n", " np.arange(110, 4000, 100), num_frequencies,\n", " replace=False)\n", "\n", " super().__init__(*args, **kwargs)\n", "\n", " def get_items(self, folder):\n", " # ignore folder and return a list\n", " # 100 items in this dataset\n", " items = list(range(100))\n", " return items\n", "\n", " def process_item(self, item):\n", " # we're ignoring ``items`` and making\n", " # sums of random sine waves\n", " sources = {}\n", " freqs = np.random.choice(\n", " self.frequencies, self.num_sources,\n", " replace=False)\n", " for i in range(self.num_sources):\n", " freq = freqs[i]\n", " _data = make_sine_wave(freq, self.sample_rate, 2)\n", " # this is a helper function in BaseDataset for\n", " # making an audio signal from data\n", " signal = self._load_audio_from_array(_data)\n", " signal.path_to_input_file = f'{item}.wav'\n", " sources[f'sine{i}'] = signal * 1 / self.num_sources\n", "\n", " mix = sum(sources.values())\n", "\n", " metadata = {\n", " 'frequencies': freqs\n", " }\n", "\n", " output = {\n", " 'mix': mix,\n", " 'sources': sources,\n", " 'metadata': metadata\n", " }\n", " return output" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As a reminder, this dataset makes random mixtures of sine waves with fundamental frequencies\n", "between 110 Hz and 4000 Hz. Let's now set it up with appropriate STFT parameters that result\n", "in 129 frequencies in the spectrogram." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "text/html": [ "
" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "{'frequencies': array([1610, 310, 1210])}\n" ] } ], "source": [ "nussl.utils.seed(0) # make sure this does the same thing each time\n", "\n", "# We're not reading data, so we can 'ignore' the folder\n", "folder = 'ignored'\n", "\n", "stft_params = nussl.STFTParams(window_length=256, hop_length=64)\n", "\n", "sine_wave_dataset = SineWaves(\n", " folder, sample_rate=8000, stft_params=stft_params\n", ")\n", "\n", "item = sine_wave_dataset[0]\n", "\n", "\n", "def visualize_and_embed(sources, y_axis='mel'):\n", " plt.figure(figsize=(10, 4))\n", " plt.subplot(111)\n", " nussl.utils.visualize_sources_as_masks(\n", " sources, db_cutoff=-60, y_axis=y_axis)\n", " plt.tight_layout()\n", " plt.show()\n", "\n", " nussl.play_utils.multitrack(sources, ext='.wav')\n", "\n", "\n", "visualize_and_embed(item['sources'])\n", "print(item['metadata'])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's check the shape of the `mix` stft:" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(129, 251, 1)" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "item['mix'].stft().shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Great! There's 129 frequencies and 251 frames and 1 audio channel. To put it into our\n", "model though, we need the STFT in the right shape, and we also need some training data.\n", "Let's use some of *nussl*'s transforms to do this. Specifically, we'll use the\n", "`PhaseSensitiveSpectrumApproximation` and the `ToSeparationModel` transforms. We'll \n", "also use the `MagnitudeWeights` transform in case we want to use deep clustering loss\n", "functions." ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "dict_keys(['index', 'mix_magnitude', 'ideal_binary_mask', 'source_magnitudes', 'weights'])" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "folder = 'ignored'\n", "stft_params = nussl.STFTParams(window_length=256, hop_length=64)\n", "tfm = nussl.datasets.transforms.Compose([\n", " nussl.datasets.transforms.PhaseSensitiveSpectrumApproximation(),\n", " nussl.datasets.transforms.MagnitudeWeights(),\n", " nussl.datasets.transforms.ToSeparationModel()\n", "])\n", "\n", "sine_wave_dataset = SineWaves(\n", " folder, sample_rate=8000, stft_params=stft_params,\n", " transform=tfm\n", ")\n", "\n", "# Let's inspect the 0th item from the dataset\n", "item = sine_wave_dataset[0]\n", "item.keys()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now the item has all the keys that SeparationModel needs. The `ToSeparationModel` transform set everything up for us: it set up the dictionary from `SineWaves.process_item()` exactly as we needed it. It swapped the frequency and sequence length dimension appropriately, and made them all torch Tensors:" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "torch.Size([251, 129, 1])" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "item['mix_magnitude'].shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We still need to add a batch dimension and make everything have float type\n", "though. So let's do that for each key, if the key is a torch Tensor:" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "torch.Size([1, 251, 129, 1])" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "for key in item:\n", " if torch.is_tensor(item[key]):\n", " item[key] = item[key].unsqueeze(0).float()\n", "\n", "item['mix_magnitude'].shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we can pass this through our model:" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "output = model(item)\n", "\n", "i = 0\n", "plt.figure(figsize=(5, 5))\n", "plt.imshow(\n", " output['my_estimates'][0, ..., 0, i].T.cpu().data.numpy(),\n", " origin='lower')\n", "plt.title(\"Source\")\n", "plt.show()\n", "\n", "plt.figure(figsize=(5, 5))\n", "plt.imshow(\n", " output['my_mask'][0, ..., 0, i].T.cpu().data.numpy(),\n", " origin='lower')\n", "plt.title(\"Mask\")\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We've now seen how to use *nussl* transforms, datasets, and SeparationModel\n", "together to make a forward pass. But so far our model does nothing practical; let's see how to train the model so it actually does something." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Closures and loss functions\n", "---------------------------\n", "\n", "*nussl* trains models via *closures*, which define the forward and backward passes for a\n", "model on a single batch. Closures use *loss functions* within them, which compute the \n", "loss on a single batch. There are a bunch of common loss functions already in *nussl*." ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "nussl.ml.train.loss contents:\n", "-----------------------------\n", "CombinationInvariantLoss\n", "DeepClusteringLoss\n", "KLDivLoss\n", "L1Loss\n", "MSELoss\n", "PermutationInvariantLoss\n", "SISDRLoss\n", "WhitenedKMeansLoss\n" ] } ], "source": [ "def print_existing_losses():\n", " excluded = ['nn', 'torch', 'combinations', 'permutations']\n", " print('nussl.ml.train.loss contents:')\n", " print('-----------------------------')\n", " existing_losses = [x for x in dir(nussl.ml.train.loss) if\n", " x not in excluded and not x.startswith('__')]\n", " print('\\n'.join(existing_losses))\n", "\n", "\n", "print_existing_losses()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In addition to standard loss functions for spectrograms, like L1 Loss and MSE, there is also an SDR loss for time series audio, as well as permutation invariant versions of\n", "these losses for training things like speaker separation networks. See the API docs for more details on all of these loss functions. A closure uses these loss functions in a simple way. For example, here is the code for training a model with a closure:" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [], "source": [ "from nussl.ml.train.closures import Closure\n", "from nussl.ml.train import BackwardsEvents\n", "\n", "\n", "class TrainClosure(Closure):\n", " \"\"\"\n", " This closure takes an optimization step on a SeparationModel object given a\n", " loss.\n", " \n", " Args:\n", " loss_dictionary (dict): Dictionary containing loss functions and specification.\n", " optimizer (torch Optimizer): Optimizer to use to train the model.\n", " model (SeparationModel): The model to be trained.\n", " \"\"\"\n", "\n", " def __init__(self, loss_dictionary, optimizer, model):\n", " super().__init__(loss_dictionary)\n", " self.optimizer = optimizer\n", " self.model = model\n", "\n", " def __call__(self, engine, data):\n", " self.model.train()\n", " self.optimizer.zero_grad()\n", "\n", " output = self.model(data)\n", "\n", " loss_ = self.compute_loss(output, data)\n", " loss_['loss'].backward()\n", " engine.fire_event(BackwardsEvents.BACKWARDS_COMPLETED)\n", " self.optimizer.step()\n", " loss_ = {key: loss_[key].item() for key in loss_}\n", "\n", " return loss_" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "So, this closure takes some data and puts it through the model, then calls\n", "`self.compute_loss` on the result, fires an event on the ignite `engine`, and then steps the optimizer on the loss. This is a standard PyTorch training loop. The magic here is happening in `self.compute_loss`, which comes from the\n", "parent class `Closure`." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Loss dictionary ###\n", "\n", "The parent class `Closure` takes a loss dictionary which defines the losses that get \n", "computed on the output of the model. The loss dictionary has the following format:\n", "\n", " loss_dictionary = {\n", " 'LossClassName': {\n", " 'weight': [how much to weight the loss in the sum, defaults to 1],\n", " 'keys': [key mapping items in dictionary to arguments to loss],\n", " 'args': [any positional arguments to the loss class],\n", " 'kwargs': [keyword arguments to the loss class],\n", " }\n", " }\n", " \n", "For example, one possible loss could be:" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [], "source": [ "loss_dictionary = {\n", " 'DeepClusteringLoss': {\n", " 'weight': .2,\n", " },\n", " 'PermutationInvariantLoss': {\n", " 'weight': .8,\n", " 'args': ['L1Loss']\n", " }\n", "}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This will apply the deep clustering and a permutation invariant L1 loss to the output\n", "of the model. So, how does the model know what to compare? Each loss function is a \n", "class in *nussl*, and each class has an attribute called `DEFAULT_KEYS`, This attribute\n", "tells the Closure how to use the forward pass of the loss function. For example, this is\n", "the code for the L1 Loss:" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [], "source": [ "from torch import nn\n", "\n", "\n", "class L1Loss(nn.L1Loss):\n", " DEFAULT_KEYS = {'estimates': 'input', 'source_magnitudes': 'target'}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[L1Loss](https://pytorch.org/docs/stable/nn.html?highlight=l1%20loss#torch.nn.L1Loss) \n", "is defined in PyTorch and has the following example for its forward pass:\n", "\n", " >>> loss = nn.L1Loss()\n", " >>> input = torch.randn(3, 5, requires_grad=True)\n", " >>> target = torch.randn(3, 5)\n", " >>> output = loss(input, target)\n", " >>> output.backward()\n", " \n", "The arguments to the function are `input` and `target`. So the mapping from the dictionary\n", "provided by our dataset and model jointly is to use `my_estimates` (like we defined above) as the input and \n", "`source_magnitudes` (what we are trying to match) as the target. This results in \n", "the `DEFAULT_KEYS` you see above. Alternatively, you can pass the mapping between\n", "the dictionary and the arguments to the loss function directly into the loss dictionary\n", "like so:" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [], "source": [ "loss_dictionary = {\n", " 'L1Loss': {\n", " 'weight': 1.0,\n", " 'keys': {\n", " 'my_estimates': 'input',\n", " 'source_magnitudes': 'target',\n", " }\n", " }\n", "}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Great, now let's use this loss dictionary in a Closure and see what happens." ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[(L1Loss(),\n", " 1.0,\n", " {'my_estimates': 'input', 'source_magnitudes': 'target'},\n", " 'L1Loss')]" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "closure = nussl.ml.train.closures.Closure(loss_dictionary)\n", "closure.losses" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The closure was instantiated with the losses. Calling `closure.compute_loss` results\n", "in the following:" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "L1Loss tensor(0.0037, grad_fn=)\n", "loss tensor(0.0037, grad_fn=)\n" ] } ], "source": [ "output = model(item)\n", "loss_output = closure.compute_loss(output, item)\n", "for key, val in loss_output.items():\n", " print(key, val)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The output is a dictionary with the `loss` item corresponding to the total\n", "(summed) loss and the other keys corresponding to the individual losses." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Custom loss functions ###\n", "\n", "Loss functions can be registered with the Closure in the same way that\n", "modules are registered with SeparationModel:" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "nussl.ml.train.loss contents:\n", "-----------------------------\n", "CombinationInvariantLoss\n", "DeepClusteringLoss\n", "KLDivLoss\n", "L1Loss\n", "MSELoss\n", "MeanDifference\n", "PermutationInvariantLoss\n", "SISDRLoss\n", "WhitenedKMeansLoss\n" ] } ], "source": [ "class MeanDifference(torch.nn.Module):\n", " DEFAULT_KEYS = {'my_estimates': 'input', 'source_magnitudes': 'target'}\n", "\n", " def __init__(self):\n", " super().__init__()\n", "\n", " def forward(self, input, target):\n", " return torch.abs(input.mean() - target.mean())\n", "\n", "\n", "nussl.ml.register_loss(MeanDifference)\n", "print_existing_losses()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now this loss can be used in a closure:" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "MeanDifference tensor(0.0012, grad_fn=)\n", "loss tensor(0.0012, grad_fn=)\n" ] } ], "source": [ "new_loss_dictionary = {\n", " 'MeanDifference': {}\n", "}\n", "\n", "new_closure = nussl.ml.train.closures.Closure(new_loss_dictionary)\n", "new_closure.losses\n", "\n", "output = model(item)\n", "loss_output = new_closure.compute_loss(output, item)\n", "for key, val in loss_output.items():\n", " print(key, val)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Optimizing the model ###\n", "\n", "We now have a loss. We can then put it backwards through the model and\n", "take a step forward on the model with an optimizer. Let's define\n", "an optimizer (we'll use Adam), and then use it to take a step on\n", "the model:" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'L1Loss': tensor(0.0037, grad_fn=), 'loss': tensor(0.0037, grad_fn=)}\n" ] } ], "source": [ "optimizer = torch.optim.Adam(model.parameters(), lr=.001)\n", "\n", "optimizer.zero_grad()\n", "output = model(item)\n", "loss_output = closure.compute_loss(output, item)\n", "loss_output['loss'].backward()\n", "optimizer.step()\n", "print(loss_output)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Cool, we did a single step. Instead of manually defining this all above, we can \n", "instead use the TrainClosure from *nussl*." ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [], "source": [ "train_closure = nussl.ml.train.closures.TrainClosure(\n", " loss_dictionary, optimizer, model\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `__call__` function of the closure takes an `engine` as well as the batch data. \n", "Since we don't currently have an `engine` object (more on that below), let's just pass `None`.\n", "We can run this on a batch:" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'L1Loss': 0.003581754630431533, 'loss': 0.003581754630431533}" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "train_closure(None, item)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can run this a bunch of times and watch the loss go down." ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [], "source": [ "loss_history = []\n", "n_iter = 100\n", "\n", "for i in range(n_iter):\n", " loss_output = train_closure(None, item)\n", " loss_history.append(loss_output['loss'])" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.plot(loss_history)\n", "plt.title('Train loss')\n", "plt.xlabel('Iteration')\n", "plt.ylabel('Loss')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that there is also a `ValidationClosure` which does not take\n", "an optimization step but only computes the loss. \n", "\n", "Let's look at the model output now!" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "output = model(item)\n", "\n", "for i in range(output['my_estimates'].shape[-1]):\n", " plt.figure(figsize=(10, 5))\n", " plt.subplot(121)\n", " plt.imshow(\n", " output['my_estimates'][0, ..., 0, i].T.cpu().data.numpy(),\n", " origin='lower')\n", " plt.title(\"Source\")\n", "\n", " plt.subplot(122)\n", " plt.imshow(\n", " output['my_mask'][0, ..., 0, i].T.cpu().data.numpy(),\n", " origin='lower')\n", " plt.title(\"Mask\")\n", " plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Hey! That looks a lot better! We've now overfit the model to a single item in the dataset. Now, let's do it at scale by using a PyTorch Ignite engines with the functionality in `nussl.ml.train`." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ignite Engines\n", "--------------\n", "\n", "*nussl* uses PyTorch Ignite to power its training functionality. PyTorch\n", "At the heart of Ingite is the *Engine* object. An Engine contains a lot\n", "of functionality for iterating through a dataset and feeding data to a model.\n", "What makes Ignite so desireable is that we can define all of the things we\n", "need to train a model ahead of time, the the Ignite engine will run the code\n", "to train the model for us. This saves us a lot of time writing boilerplate\n", "code for training. *nussl* also provides a lot of boilerplate code for\n", "training source separation models, specifically.\n", "\n", "To use Ignite with *nussl*, the only thing we need to to define is a *closure*. \n", "A closure defines a pass through the model for a single batch. The rest of\n", "the details, such as queueing up data, are taken care of by\n", "`torch.utils.data.DataLoader` and the engine object. All of the state\n", "regarding a training run, such as the epoch number, the loss history, etc,\n", "is kept in the engine's state at `engine.state`.\n", "\n", "*nussl* provides a helper function to build a standard engine with a lot\n", "of nice functionality like keeping track of \n", "loss history, preparing the batches properly, setting up the \n", "train and validation closures. This function is `create_train_and_validation_engines()`.\n", "\n", "It's also possible to add attach handlers to an Engine for further \n", "functionality. These handlers make use of the engine's state. *nussl* \n", "comes with several of these:\n", "\n", "1. `add_validate_and_checkpoint`: Adds a pass on the validation data and \n", " checkpoints the model based on the validation loss to either `best`\n", " (if this was the lowest validation loss model) or `latest`.\n", "2. `add_stdout_handler`: Prints some handy information after each epoch.\n", "3. `add_tensorboard_handler`: Logs loss data to tensorboard.\n", "\n", "See the API documentation for further details on these handlers.\n", "\n", "### Putting it all together ###\n", "\n", "Let's put this all together. Let's build the dataset, model and\n", "optimizer, train and validation closures, and engines. Let's also\n", "use the GPU if it's available." ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [], "source": [ "# define everything as before\n", "modules = {\n", " 'mix_magnitude': {},\n", " 'log_spec': {\n", " 'class': 'AmplitudeToDB'\n", " },\n", " 'norm': {\n", " 'class': 'BatchNorm',\n", " },\n", " 'mask': {\n", " 'class': 'Embedding',\n", " 'args': {\n", " 'num_features': num_features,\n", " 'hidden_size': num_features,\n", " 'embedding_size': num_sources,\n", " 'activation': mask_activation,\n", " 'num_audio_channels': num_audio_channels,\n", " 'dim_to_embed': [2, 3] # embed the frequency dimension (2) for all audio channels (3)\n", " }\n", " },\n", " 'estimates': {\n", " 'class': 'Mask',\n", " },\n", "}\n", "\n", "connections = [\n", " ['log_spec', ['mix_magnitude', ]],\n", " ['norm', ['log_spec', ]],\n", " ['mask', ['norm', ]],\n", " ['estimates', ['mask', 'mix_magnitude']]\n", "]\n", "\n", "# define the outputs\n", "output = ['estimates', 'mask']\n", "\n", "config = {\n", " 'modules': modules,\n", " 'connections': connections,\n", " 'output': output\n", "}" ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [], "source": [ "BATCH_SIZE = 5\n", "LEARNING_RATE = 1e-3\n", "OUTPUT_FOLDER = os.path.expanduser('~/.nussl/tutorial/sinewave')\n", "RESULTS_DIR = os.path.join(OUTPUT_FOLDER, 'results')\n", "NUM_WORKERS = 2\n", "DEVICE = 'cuda' if torch.cuda.is_available() else 'cpu'\n", "\n", "shutil.rmtree(os.path.join(RESULTS_DIR), ignore_errors=True)\n", "\n", "os.makedirs(RESULTS_DIR, exist_ok=True)\n", "os.makedirs(OUTPUT_FOLDER, exist_ok=True)\n", "\n", "# adjust logging so we see output of the handlers\n", "logger = logging.getLogger()\n", "logger.setLevel(logging.INFO)\n", "\n", "# Put together data\n", "stft_params = nussl.STFTParams(window_length=256, hop_length=64)\n", "tfm = nussl.datasets.transforms.Compose([\n", " nussl.datasets.transforms.PhaseSensitiveSpectrumApproximation(),\n", " nussl.datasets.transforms.MagnitudeWeights(),\n", " nussl.datasets.transforms.ToSeparationModel()\n", "])\n", "sine_wave_dataset = SineWaves(\n", " 'ignored', sample_rate=8000, stft_params=stft_params,\n", " transform=tfm\n", ")\n", "dataloader = torch.utils.data.DataLoader(\n", " sine_wave_dataset, batch_size=BATCH_SIZE\n", ")\n", "\n", "# Build our simple model\n", "model = nussl.ml.SeparationModel(config).to(DEVICE)\n", "\n", "# Build an optimizer\n", "optimizer = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE)\n", "\n", "# Set up loss functions and closure\n", "# We'll use permutation invariant loss since we don't\n", "# care what order the sine waves get output in, just that\n", "# they are different.\n", "loss_dictionary = {\n", " 'PermutationInvariantLoss': {\n", " 'weight': 1.0,\n", " 'args': ['L1Loss']\n", " }\n", "}\n", "\n", "train_closure = nussl.ml.train.closures.TrainClosure(\n", " loss_dictionary, optimizer, model\n", ")\n", "val_closure = nussl.ml.train.closures.ValidationClosure(\n", " loss_dictionary, model\n", ")\n", "\n", "# Build the engine and add handlers\n", "train_engine, val_engine = nussl.ml.train.create_train_and_validation_engines(\n", " train_closure, val_closure, device=DEVICE\n", ")\n", "nussl.ml.train.add_validate_and_checkpoint(\n", " OUTPUT_FOLDER, model, optimizer, sine_wave_dataset, train_engine,\n", " val_data=dataloader, validator=val_engine\n", ")\n", "nussl.ml.train.add_stdout_handler(train_engine, val_engine)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Cool! We built an engine! (Note the distinction between using the original dataset\n", "object and using the dataloader object.) \n", "\n", "Now to train it, all we have to do is `run`\n", "the engine. Since our SineWaves dataset makes mixes \"on the fly\" (i.e., every time\n", "we get an `item`, the dataset will return a mix of random sine waves), it is\n", "impossible to loop through the whole dataset, and therefore there is no concept\n", "of an epoch. In this case, we will instead define an arbitrary `epoch_length`\n", "of 1000 and pass that value to `train_engine`. After one epoch, the validation\n", "will be run and everything will get printed by the `stdout` handler. \n", "\n", "Let's see it run:" ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "INFO:root:\n", "\n", "EPOCH SUMMARY \n", "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ \n", "- Epoch number: 0001 / 0001 \n", "- Training loss: 0.001197 \n", "- Validation loss: 0.000683 \n", "- Epoch took: 00:02:11 \n", "- Time since start: 00:02:11 \n", "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ \n", "Saving to /home/pseetharaman/.nussl/tutorial/sinewave/checkpoints/best.model.pth. \n", "Output @ /home/pseetharaman/.nussl/tutorial/sinewave \n", "\n", "INFO:ignite.engine.engine.Engine:Engine run complete. Time taken 00:02:11\n" ] }, { "data": { "text/plain": [ "State:\n", "\titeration: 1000\n", "\tepoch: 1\n", "\tepoch_length: 1000\n", "\tmax_epochs: 1\n", "\toutput: \n", "\tbatch: \n", "\tmetrics: \n", "\tdataloader: \n", "\tseed: 12\n", "\tepoch_history: \n", "\titer_history: \n", "\tpast_iter_history: \n", "\tsaved_model_path: /home/pseetharaman/.nussl/tutorial/sinewave/checkpoints/best.model.pth\n", "\toutput_folder: /home/pseetharaman/.nussl/tutorial/sinewave" ] }, "execution_count": 42, "metadata": {}, "output_type": "execute_result" } ], "source": [ "train_engine.run(dataloader, epoch_length=1000)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can check out the loss over each iteration in the single epoch\n", "by examining the state:" ] }, { "cell_type": "code", "execution_count": 43, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZQAAAEWCAYAAABBvWFzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8GearUAAAgAElEQVR4nO2dZ5gb1dWA36Pd9a7bGveO12BjsCE2YHoJmGaqIYEEQoAkJIQEQvhCAEPoiQmQQkIoCQRCQq8BExub3sHGBuNuvLiAe8Hd3vWudL8fmpFGoxlpJI22nvd59tmZO3fu3NFI98wp91wxxqAoiqIohRJp7A4oiqIoLQMVKIqiKEooqEBRFEVRQkEFiqIoihIKKlAURVGUUFCBoiiKooSCChRFaUBE5GURuaCx+6EoxUB0HoqiZEZEtjp22wG1QNTa/6kx5rEG6scS4MfGmNca4nqKkiuljd0BRWnqGGM62NuZBnURKTXG1Ddk3xSlKaEmL0XJExE5SkSWicjVIrIK+JeIdBaR/4nIWhHZYG33c5zzloj82Nr+gYi8JyJ/tOouFpET8+hHuYj8RURWWH9/EZFy61g3qw8bReRrEXlXRCLWsatFZLmIbBGRBSJyTEgfjdJKUYGiKIXRC+gCDAAuIv6b+pe1vyuwA7g7w/kHAQuAbsAdwIMiIjn24TfAwcAIYDhwIHCddewKYBnQHegJXAsYERkCXAocYIzpCJwALMnxuoqSggoURSmMGHCjMabWGLPDGLPeGPOcMWa7MWYLMA74ZobzlxpjHjDGRIF/A72JD/y5cC5wizFmjTFmLXAzcJ51rM5qc4Axps4Y866JO06jQDkwVETKjDFLjDFf5HhdRUlBBYqiFMZaY0yNvSMi7UTkHyKyVEQ2A+8Au4hIic/5q+wNY8x2a7ODT10/+gBLHftLrTKAPwDVwCsiskhExlrXqgYuB24C1ojIkyLSB0UpABUoilIY7jDJK4AhwEHGmErgSKs8VzNWLqwgbmKz2dUqwxizxRhzhTFmN+A04Fe2r8QY87gx5nDrXAPcXsQ+Kq0AFSiKEi4diftNNopIF+DGkNsvE5EKx18p8ARwnYh0F5FuwA3AowAicoqIDLL8MpuIm7piIjJEREZZzvsaq8+xkPuqtDJUoChKuPwFaAusAz4CJoXc/kTig7/9dxPwO2AaMBOYBXxilQEMBl4DtgIfAvcaY94k7j+5zernKqAHcE3IfVVaGTqxUVEURQkF1VAURVGUUFCBoiiKooSCChRFURQlFFSgKIqiKKHQqpNDduvWzVRVVTV2NxRFUZoV06dPX2eM6e4ub9UCpaqqimnTpjV2NxRFUZoVIrLUq1xNXoqiKEooqEBRFEVRQkEFiqIoihIKKlAURVGUUFCBoiiKooSCChRFURQlFFSgKIqiKKGgAiUP3pi/mnvfqqYuGmPFxh2N3R1FUZQmQaue2Jgv73y+juc/WcbSddt5atpXzL75BDqU60epKErrRjWUPKisKGVLbT0TZ60EYGe9LnSnKIqiAiUPKtuWYQxsqa0HIBrTRcoURVFUoORBZUVZyn59TDUURVEUFSh5UNk21V9SV68aiqIoigqUPOhQnqqh1KmGoiiKogIlH9q2Sf3Y6qOqoSiKoqhAyYO2ZS6TV1Q1FEVRFBUoedCuTUnKfr1GeSmKoqhAyYe2boGiGoqiKIoKlHxwC5Snp32lQkVRlFaPCpQ8aFvmFijLGPSbl3XGvKIorRoVKHlQVhL/2Hp3qkgpnzRnFbGYYcfOaGN0S1EUpVFRgZInM244jvu+v39KmQBXPzeTvW6YhDHqqFcUpXWhAiVPdmnXJs30VRoR/vvpcgC+WLu1MbqlKIrSaBRVoIjIaBFZICLVIjLW43i5iDxlHZ8iIlWOY9dY5QtE5ASrrEJEporIZyIyR0RudtQfaLVRbbXZppj3BlBaIin7kYjQszJuBvt6W12xL68oitKkKJpAEZES4B7gRGAocI6IDHVVuxDYYIwZBNwJ3G6dOxQ4GxgGjAbutdqrBUYZY4YDI4DRInKw1dbtwJ1WWxustotKR9caKLX1sUTmYc1ArChKa6OYGsqBQLUxZpExZifwJDDGVWcM8G9r+1ngGBERq/xJY0ytMWYxUA0caOLYtqQy689Y54yy2sBq8/Ri3ZhNZdvUnF41dVFilu8kpj4URVFaGcUUKH2Brxz7y6wyzzrGmHpgE9A107kiUiIiM4A1wKvGmCnWORutNvyuhXX+RSIyTUSmrV27toDbgwqXD2XtllpsxUQ1FEVRWhvNzilvjIkaY0YA/YADRWTvHM+/3xgz0hgzsnv37qH27Q+TFySiu6KqoSiK0soopkBZDvR37PezyjzriEgp0AlYH+RcY8xG4E3iPpb1wC5WG37XahBsU5eGDSuK0toopkD5GBhsRV+1Ie5kH++qMx64wNo+E3jDxEfi8cDZVhTYQGAwMFVEuovILgAi0hY4DphvnfOm1QZWmy8W8d4STLr8CH7/rX3o17ktnduVOUxeDXF1RVGUpkNp9ir5YYypF5FLgclACfCQMWaOiNwCTDPGjAceBB4RkWrga+JCB6ve08BcoB64xBgTFZHewL+tiK8I8LQx5n/WJa8GnhSR3wGfWm0XnT17VbJnr0pmLtvIa/PWUFMXnyWvPhRFUVobRRMoAMaYicBEV9kNju0a4Cyfc8cB41xlM4F9feovIh5Z1ihUlJVQszOKLUbmrdxMVbd27NmrsrG6pCiK0qA0O6d8UyUiwpbaerbWxgPN/vr6Qkb/5d1G7pWiKErDoQIlJJas29bYXVAURWlUVKCERK2mrlcUpZWjAiUk+uxS4Vn+9LSvPMsVRVFaGipQQuLGU4exW/f2aeUTZq5shN4oiqI0PCpQQqJ9eSnfHdk/rfztzwtL76IoitJcUIESIqUl+nEqitJ60REwRMpc66PY6CRHRVFaAypQQqQk4i1Q6qIxVm2qoWrsBD5atL6Be6UoitIwqEAJkbKI98dZHzN8+uUGAP71/uKG7JKiKEqDoQIlRNxLAtvUR2O0bRNfO2X7zmhDdklRFKXBUIESIuItT9gZjdGuTTxt2rbaeu9KiqIozRwVKA1AfTTplFcNRVGUlooKlBDxW1OrPmqoj8VTs6hAURSlpaICpQGoi8USocPbd6rJS1GUlokKlAagLhqj3hIo22pVQ1EUpWWiAiVEMpm8opYfZUedChRFUVomKlAaAKeGkolJs1exdL2uq6IoSvOkqEsAK3HqoiZQ+pWLH51OWYmwcNxJDdArRVGUcFENJUTcIuPm04YB8YmNdpRXNuqimvdLUZTmiWooIXLQwC4APP7jg+jesTyxvvw7C9exYuOOlLr/fHcRf3ltIbNvPqHB+6koilIMVKCESP8u7Vhy28mJ/VWbagD4+9tfpNX93YR5DdYvRVGUhkBNXkWkR8dy2pSmf8TGLxxMURSlGVNUgSIio0VkgYhUi8hYj+PlIvKUdXyKiFQ5jl1jlS8QkROssv4i8qaIzBWROSLyS0f9m0RkuYjMsP4a3bMdiQi9KtPXmnc66G3hokJGUZTmTtEEioiUAPcAJwJDgXNEZKir2oXABmPMIOBO4Hbr3KHA2cAwYDRwr9VePXCFMWYocDBwiavNO40xI6y/icW6t1zwEih/eW1hYtsWLs4gsHPu/6jo/VIURQmbYmooBwLVxphFxpidwJPAGFedMcC/re1ngWNERKzyJ40xtcaYxUA1cKAxZqUx5hMAY8wWYB7Qt4j3UDCd25elld39ZnVi+6WZKzDGEHNoKB/qIlyKojRDiilQ+gJfOfaXkT74J+oYY+qBTUDXIOda5rF9gSmO4ktFZKaIPCQinb06JSIXicg0EZm2du3aXO8pZ/xWcbT5v6c+4435a1IEiqIoSnOkWTrlRaQD8BxwuTFms1V8H7A7MAJYCfzJ61xjzP3GmJHGmJHdu3cvfl/JLFAAautjBJymoiiK0mQppkBZDvR37PezyjzriEgp0AlYn+lcESkjLkweM8Y8b1cwxqw2xkSNMTHgAeImt8YnuzyhfXmpaiiKojR7iilQPgYGi8hAEWlD3Mk+3lVnPHCBtX0m8IaJhzuNB862osAGAoOBqZZ/5UFgnjHmz86GRKS3Y/cMYHbod5QHEb9lHB2URUQFiqIozZ6iTWw0xtSLyKXAZKAEeMgYM0dEbgGmGWPGExcOj4hINfA1caGDVe9pYC7xyK5LjDFRETkcOA+YJSIzrEtda0V03SEiI4hnQFkC/LRY95YLARQU6mNGTV6KojR7ijpT3hroJ7rKbnBs1wBn+Zw7DhjnKnsPnzHaGHNeof0tBgEUFOpjMdVQFEVp9jRLp3xzIojJqy5qWLZhh+exSbNXsrmmLuxuKYqihI7m8ioyQUxeP31kumf519t2cvGjn3BAVWeeufjQcDumKIoSMqqhFJsgEsUH2wz28ZINIXVGURSleKhAKTLf3CP/uS7qV1EUpTmhAqXIjBnRl3//KM8pMSpPFEVpRqhAaQC6dWiT13kBVg1WFEVpMqhAaQDKSvL7mNXkpShKc0IFSgNQmiVBpBcvfLpcBYqiKM0KFSgNgFhzUdrkoKk8MfVLVJ4oitKcUIHSANRH43lVOrVLXxvFDxE1eSmK0rxQgdIA9LBWbfzFqEGBz4mIpGgoddEYVWMncI9jcS5FUZSmhAqUBqBT2zKW3HYy5x9SFfgct4ayvTYKwD/e/iLs7imKooSCCpQG5tfH70F5abCP3Rk2bAuXSB4OfkVRlIZABUoDc+mowTx50cFZ6xkDxqGhRK3toOJk4/adbNy+M58uKoqi5IUKlEYgSAbimDEpGsrY52b5nrtpRx0rN6VmKx5xy6uMuOXVwjqqKIqSA5ptuBEoCWC2+mjR1yxYvSWx/9q81UAyBNnmmWlfceWzMwFYctvJIfZSURQlN1RDaQSCaCgAlz3xqce5qfu2MFEURWlsVKA0AoXML8kkjB6bslT9JoqiNBoqUBqB+gKyPmaylv3mv7P59TOf5d22oihKIahAaQSisVjG4907lvseW7GpBoDJc1axYmP6ssHrtqqGoihK46BO+UagLppZQ+lQXsraLbW+x1dvruGnj0ynS/v0tPhG07UoitJIqIbSCOzapV1iu1uHdG2kXZuSjOe/u3AdEF9zXlEUpamgAqUR6LNLWxb8bjSLf38SPSvTBUplReYkkpn8JKqfKIrSWBRVoIjIaBFZICLVIjLW43i5iDxlHZ8iIlWOY9dY5QtE5ASrrL+IvCkic0Vkjoj80lG/i4i8KiILrf+di3lvhVJeWoKIeK6V0rEif0ukMVBTFy2ka4qiKHlRNIEiIiXAPcCJwFDgHBEZ6qp2IbDBGDMIuBO43Tp3KHA2MAwYDdxrtVcPXGGMGQocDFziaHMs8LoxZjDwurXf5PnFqMFpZR0KECizlm9iz+snFdIlRVGUvCimhnIgUG2MWWSM2Qk8CYxx1RkD/NvafhY4RuJTwccATxpjao0xi4Fq4EBjzEpjzCcAxpgtwDygr0db/wZOL9J9hcqxQ3ty9/f2TSnrWK6xEoqiND+KKVD6Al859peRHPzT6hhj6oFNQNcg51rmsX2BKVZRT2PMSmt7FdCz0BtoLNqrQFEUpRnSLJ3yItIBeA643Biz2X3cxGNnPf3TInKRiEwTkWlr164tck+D4Y70zWcNekVRlMammAJlOdDfsd/PKvOsIyKlQCdgfaZzRaSMuDB5zBjzvKPOahHpbdXpDazx6pQx5n5jzEhjzMju3bvneWvhki1MWFEUpTlQTIHyMTBYRAaKSBviTvbxrjrjgQus7TOBNyztYjxwthUFNhAYDEy1/CsPAvOMMX/O0NYFwIuh31GRGLVnD24+bVhi351ROBPZMhf/891FefdLURQlF4omUCyfyKXAZOLO86eNMXNE5BYROc2q9iDQVUSqgV9hRWYZY+YATwNzgUnAJcaYKHAYcB4wSkRmWH8nWW3dBhwnIguBY639ZoGIcMGhVY794OdGs+QF+92EeXn2SlEUJTeK6v01xkwEJrrKbnBs1wBn+Zw7DhjnKnsPn0ULjTHrgWMK7HKL5tr/zuLxKV/quimKohSFZumUb+kEXS8lVx6f8qVneSxm+Oe7i9i+sz7t2JrNNVSNncD0pRuK0idFUVoOKlCaIGGLk2wJI1+Zu5rfTZjHbS/PTzv24aL1ADz8wZKQe6UoSktDBUorIJufpbY+nqrFTjZZUxdl3IS5bK2tT4Q0aySzoijZCORDEZH2wA5jTExE9gD2BF42xtQVtXetlEjIo3d9zFCaITLZNrHZK0k+MfVLHnh3MaUlEQb36JBSR1EUxY+gGso7QIWI9AVeIR5p9XCxOqWESzRmeOmzFb7H7dBje92vmrqYtW+wlRsvcRKLGV1/RVGUBEEFihhjtgPfAu41xpxFPHGjUgTCVgbmr9rML5741Pe4rX1ELeFgrygZiUhCYLjnxmzaXsdu107kAZ3noiiKRWCBIiKHAOcCE6wynd5dJMTHLW+bn3JlS0169JaTpIZiC5R4eWlEEj6UVZtTlxtesyW+FPFTH3+FoigKBBcolwPXAP+1JifuBrxZvG61bvw0lGyz4v2IZTFLlVjfgoSGYv0viQjGSon2fvV63lzgmc1GURQFCChQjDFvG2NOM8bcLiIRYJ0x5rIi963V4ic2ykryC8qzNQ4/kk55u378hKmLv2bd1uQyw3NXJPNw2iIqlzQxbr5cv51PvtT5LYrSUgg0QonI4yJSaUV7zQbmisiVxe1a68VvjC4tyW/wdq/gGHOFEScEilVeb/3/4Iv1/GHygqz9ypcj//Am37r3g3AbVRSl0Qj6yjvUShN/OvAyMJB4pJdSBPx8KPmmtd+x0yVQXCYw25Rmz1dxCxxnv/a47mVOv+f9hG9Fg4kVRbEJKlDKrLTxpwPjrfknGi8aMj84tIrh/TqF7kPZ4dZQHE9uw7adnPvP+Bpltu+k3kegRAR21seY8dXGRJlOT1EUxSaoQPkHsARoD7wjIgOAtIWtlMK46bRhvHjp4Yn9XpUVAAzo2g7I34eyPYOGsmJTMnorGeXlo6E4hIfR9wlFUVwEdcrfZYzpa4w5ycRZChxd5L61WmxH9+i9e7HktpP5zsj4WmN5ayiupI9OgeJsM7uGkqybNHmpiqIoSpygTvlOIvJne+lcEfkTcW1FKQJ+Q3RpJBwN5X8zVzJp9krrWsmrxbL5ULwEik9nP/1yA7OWbcqrv0rL4auvt3PVs59Rly3UUGkRBB2hHgK2AN+x/jYD/ypWp1o79iBtz1K3B/h8nfLbXT6Uq56dycWPfsLO+lhK0sdsGorz6tnmtpxx7wecevd7efVXaTlc9exMnp62jKmLv27srigNQFCBsrsx5kZjzCLr72Zgt2J2rDVjD9z2kG2P72GFDduc+Nd3Uvbtl0g/H8qjU5YmtrMJFD9WbNzBDS/Opl7fWFsFsUTqnkbuiNIgBBUoO0Qk4S0WkcOAHRnqKwVgm5bsMfsHh1Zx8j69+fER+cnw2jrvwfuLtdtStJFsiR4Xrd2W2M6WEt+Pa/87i/98uJT3v1if1/lK8yIxAVZ9ba2CoALlYuAeEVkiIkuAu4GfFq1XrZwz9uvL0UO6c+moQQB0alfGPefuR5d2bfJqz17vxIt8BUO+GkqJJSx31ieF3E/+My2xvXZLLfXRGP/5cAmXeSS0XLh6i+/Kk0oTRNfTaVUEjfL6zBgzHPgG8A1jzL7AqKL2rBVTWVHGv354ID2tsGGbnVF/weCmoiz5aN3zUJxMnrMq9w6SNI/lmnqlTWm8X06B8urc1VSNncDbn6/lgHGv8bsJ87jhxTmM90i5f/Lf3uPa/87Kq89KwxPzyVattExyChsyxmy2ZswD/KoI/VEyMKBre04b3iexP2rPHr51zzt4QGL7/Wp/89Lf3qhObOcy+/3Z6fllGU4IFA/h+Pe3vgDiAsYPWxCpltI8SOZ8a9RuKA1EIUsA61ekgSkriXDXOfsm9v/8neG+dfOxSNXHYoFDfZ+etgzI/UtQbgmUaUvSk0Lab7Ne0dF10RgfOvwuxdZSPvtqI2u31Bb1Gq2BxHo6jdwPpWEoRKDoVOlGpn15+grOt4wZxpMXHZxXe1+s3capd7/HnBXBkyDMXbmZh95bHLi+raG8Pi89Fb79hfJabviOSfM554GPAl+nUMbc835aFFxLZu2W2rScb2EQRlZqpfmQUaCIyBYR2ezxtwXok+lcpfiUePxIzz+kioN361qQtF+wektO9W/539zAde30MZ4T3axOe93X3JUNl+nn0Y/i4dHO1P2NyZaauqJf44Bxr3Hm38PP/JxYQlrlSasgo0AxxnQ0xlR6/HU0xqS/HrsQkdEiskBEqkVkrMfxchF5yjo+RUSqHMeuscoXiMgJjvKHRGSNiMx2tXWTiCwXkRnW30lBPoDmTCRD6IytCTQ1ykvjC306nfI2tslr0bptacfqovmJyOlLNyRWlwzKdS/Mzl6pgfjsq43sc9MrTJy1kvMenJISERc2tmZ668R57H7txHAaVZNXq6Joo46IlAD3ACcCQ4FzRGSoq9qFwAZjzCDgTuB269yhwNnE160fDdxrtQfwsFXmxZ3GmBHWX0i/iOZJBw9zWFPAFnS1HgKlLkMIc76pO7593wec+rfmO2N/1vK4T+u96nW8u3BdxoCFsLj/nUV5h5O7UZNX66KYr7EHAtXWzPqdwJPAGFedMcC/re1ngWMk/s0bAzxpjKk1xiwGqq32MMa8A2gehyy0a1OSvVID8OdXP0+ZqV9maVV1sXQBEfUos6nPU0MBWL25+TrXkxMDmydG56G0KoopUPoCztjSZVaZZx1jTD2wCega8FwvLhWRmZZZrLNXBRG5yE5yuXbt2mB30gzxctg3Bne9vpAHHU77kpLULABOMgmNsJILXvH0Z7y3cF3g+n+YPJ+qsROyZhEoFvZ1vQIVmgOJeSjNViQqudA0De35cR+wOzACWAn8yauSMeZ+Y8xIY8zI7t27N2T/isq/fngAf//+fon99m2ahkCBVH+Jl8Pdxi8pZbZjQYnFDM99sozvPzgl8Dn3WnNj8r3+O5+vZeWm/LMUZcvq3NRp7v1XcqOYAmU50N+x388q86wjIqVAJ2B9wHNTMMasNsZEjTEx4AEsE1lr4eghPRi9d+/E/pF7dGN4/10458D+Gc5qGCbNXhXoTTuT3T4fDcWZcqYuGmNnHm3Yvc1mcntv4To2e0Rjnf/QVE65K38fjt88jlF/fIuqsROYMHNl3m03BC0xOeQXa7c2dheaLMUUKB8Dg0VkoIi0Ie5kH++qMx64wNo+E3jDxH9B44GzrSiwgcBgYGqmi4lIb8fuGUDTCdVpBDpWlPHiJYcxtE+nBrne2i21iXBbNwtWb+G96riZKdNKj/U5+FDaBFi9csh1kxLb178w2zMQwGblph2cff+HbNyeGipsyzgvn4/N+q21fP/BKVz6eGruMVsYrN+W2mZNXZRfPT2D1ZuzR58lw25TR2Q7Eu6Sxz/J2oYSHi/OWM4xf3qbN+YXPziiOVI0gWL5RC4FJgPzgKeNMXNE5BYROc2q9iDQVUSqiadyGWudOwd4GpgLTAIuMcZEAUTkCeBDYIiILBORC6227hCRWSIyk/hqkv9XrHtrTthO8HzXUgnKkXe8yXUvzGbdVm8H+Oert7LHb15mZoaZ+FEPLWDUH9/ig+p1aRrKsUP90854MWnOqoxJMu976ws+WvQ1L85Izx8GmTWUbbXxdhevS31z9Qt1njxnFc9/spzfBpi/Y7cQVtRVQ2NrKI3kggqduVZo9eerVUvxoqiGdit0d6Kr7AbHdg1wls+544BxHuXn+NQ/r6DOtlDsiYSRiCRfd4uAnYAyGjM88uGStOMfVK9jZzTG/zKYaHZ6DMCL1m3jhvFz0rqeQWHwb9/SULxkazbTTCbtyTallZVEWLOlhttens+tZ+zjKwSiOSyYZms5mYShFy99toKSiDB3xWZ+ccygxPyfhqYhBMmm7XUMv+UVbjhlKD86fGBxL5ZY/K64l2muNB3PrZIX158ylP6d2/oeL7MnODbQD6A+Zrj+xTlp5R0qsn/V/FLie6UEsetGY4a6aIyf/GcaO3ZGefZnh/q2nxQo6QO58TEt2bg1lP98uIQjB3enqlv7hPbUpiTCrRPm8cKMFRwxuBtH7eGtRdkCpSSHJZ1zDQr4hSP1f2XbUi46cvdA5x1/59s5XScbdq+LOQCvskyHT378ZdEFih2tlsl025ppSVFerZILDx/I8cN6+R63TV75rl+SK14z4AHaBYg68wvNjWs/qcfs8fVnj05nz+sn8e7CdUxbmp5wMqVvUX+BkvBV+JzrFCg1dVFueHEO373/QyAZMFBWEqHGWsysvLTENwggKVAydhdwDMQFPD6/FDLTl25g+M2vpPiNwjbl2M/08xzT+eRCQ4YmS8gaijGmIHPmph11/OmVBU1mBVQVKM2UoC6RkgaeUea33HAh8zi276xP+wHb7b2Sw8xxW9g55cmEmSut1CyZTV5Op7wtQLbW1Kfsl5VIwjRVXhrxFa5RE1xDyeVNeO6KzXz19fa08s07vHOB3fNmNZt21Hlmfg4L+7ld8cxnnlFw9dFYoOCEINfwe3ZrNtfwwqcZg0QDE/av6Y+vLGD3ayfmbNK0+f3EefztjWom5bmuUdioQGmGvHjJYbw/Ntj6ZvY69A0VtuknUIKYbPxq1NTF0trNVeMSkule7M9iW209lzz+Cec/ONWxFoz3B3XeP6cwcVbc/2NrK7awttstK4kktstLS1Kiyl6etTJhustFQ8nl5fWku97liDveTCv3Gsgh+VLi91mOuOWV4Bf3wdlyjYfp8qaX5nDQra8XlAAzk9CtXrOVA299ncufmsH2nfV5X8MmqaGEo6I88mE8MjLfTM+277KQTBJhogKlGTK8/y707uTvN3HifAuudPkxOgaYTf/t/frl1Ldnpy/zLA+ikmf6jW7b6RYo3vWe+th/4S1bY6ipi3H/O18kfoTLN+5IrsXiI3hXbKrh54/FQ3RtbaW0JHX1yTalkYTgi0iq+e9nj33C9S/GI9kTArcx9VcAACAASURBVCWAlLc/k0KGCzsKzY3tL/IzuWzcXniWY+fA63UVOzeZXx+DXSP+38uUec3zMzOeO+OrjTkN5vYLR1jxLfYzyFc+NbXgABUoLRxnJNHMm05IOWanQcnEsXvlFp77mM9KikGyBefy1ldbH+U7//gwrfzq52ZhjOE/Hy5JKReRlAH+1onz2Wa9sQq5zei278X+bBMCxeFDue6F2Wk+lC/Xx81RuTjlw3D+OjWQ9Vtr+c+HSzDGJIRntMBR6S+vfc7MZRs9jzlbLtbgF/TZuYXA2i21nH7P+/z62c8CXytsH0qivZDaaWxUoLRwMvlQAoWtZjh2yjd6ZziaSpCZ7rn8qKrXbGPqYu8coQ+8u4gbXJFmX2/byQ8f/jil7NDb3gDiwiaXrLi2tlXqMnm9Pn9NYt2WReu2pflQ7NDjICav+976gulLv85r4HILZqcG8utnPuOGF+cwZ8XmxBt9oXNc/vLaQk67+33PY05hlslMWYjgNBn8X85Luq9vm8D8hKEX9iXCivJKtNfUVI08UYHSwrEHPS/fQKn1hnxMhrXpM33PK8qCz20IFPaa02/Kv/JrHqtBZkLEGSnkjy2cbeFYmmmxMGD+qtRFweyB26kROJc1XrxuG9t31vPQe4u5fdJ8vn3fh4mBJpcBx60ZOT/7rbXxQfTrbTt5eXbckVuI/T1bvzIN6GFgjEkIs2wJNI3rMSVCgHPpVoEmqvTm7DDk/GhqYkgFSgsno4aScNj71wnrTSyIhhJGAsg2pRHKApjynDhNXjUZ0rPYwvmdz+NpZFZvruG56ct8+129Jh6CW1EW/5nZ9eyMAA+8u5hzHviI6Us3YIzh6D++xfkPTk1ZAdPu1wuOGfyvz8sc2eZOMRNz9M+e4PifD5NpcgrRUJwD67/eX8xxf37b9/gZ937Aw+8v9mwn35Bf52c/c9mmtO+Z887CEGgRDxNVLGa47oVZLMojx5d91w0V1v/SZysYct3LvsEzhaICpYVTmsFObw+QQaKNvMjlRxDkC5xpNrobv0GwbVlJIjtAUEQk8aa9rdY/EsgWzvaAX1sf44pnPvO9N3cfvTQUiPs17GPuuTRed/nUx195lCZxm9qmLd2QGGjLrYmuzo+oEB/Kwx8sSWzf/NJcFq5JHVSdGszaLbXc9JJ3upkgLy6L121LWQoB0l9UMuVrc99nPv4Q8ZgqP3/VFh796MtE0EYuhO2TycZtL8+ntj7mmyKpUFSgtHAyayiRrHUyftENfKNfsOSTHweY65DLMr8bfCKQyksjuQsUkgN3pvDV7TujHGb5XZz4CRRb4NompYRAcQmalZtqeN5nnoTX55/NzeOlDU5ZFPc3lVvaknO9nEI0w1s88pEt37gjEYDg1bQxhpc+W5HSzyBdOOvvH/Db/81N+bzr6lNPfH3e6tTIsgA+HDtdUBAt2suJ7hYK67bW8sy0zELfqw/5kKvvpdi+GhUoLZxSl/nnljHDkscsQZLJ9pzp6xczhsd/cnBB/Qub/l3a+WYi7tS2jNOG90krF0eas3ve/CJj+8s3pq9tst0n7NQeJOpd/92Dx43j53DVs97hrUFNjqP++FZi28snEonEJz5OnBX3m9TWJQfP61/wT8ydaYa73+B02G1vcOQf3ozX8ej/a/PW8IsnPuWu1xcmymIBBlSvlwh3FuhfPjmDZ6YvY/vOelZtSp0w6TeWrtpcw/UvzuEhl/bjRdKJ7l/n4kemc+WzM1nh8V3xa7FQk1euSywXa0lmFSgtHLf2cf4hVZy8T++UY5k1FP8vesw0vbXrt9XWM2GWdwLKkoikCViIpyZ56TPvLMNB2OFr8krdt016n34ZPKrIa5z18jfY6ezj56SfVFYS4Z/vLkrs+/XZzfce+Mj3mJ8gdeL19dlgpXpZ6Rjwg4yntiB23p+XVnH3G9UMvWEyB//+dT5xfNbuz8V9TT+t10lSQzG+ZWu21Pr2za89p1ysXrOF9UUySRUbFSgtHK/Jc/YPyzYNZZtgd9zQnp7lmd6qzty/H/vtukvQbobG/FX+b9QREcpySMgYlK99cmVFY27neNyR/+Gi9Z71PfH4jLO9XHqZT+qjhjpHedDJfJnMkFtqMs88H3PP+4nBNRu5+HGc9+c2eQF86ZF+BtKFc7qAMRhj+N/MFb7CIMhExISQCHBL9qN8bEoySOLYP7/DqD8FS9KpUV5Kg+KlfdiDRFsr7DcSER44fyTnHzLAs40Hzh/pWZ7py3zo7l15LkPm38agJJJuAgyDZ3yyA7jH4vpYLOcUG/kMGF6CvrY+mqKFBV29MpOGmi1dymdf5aKJBb9TW05vra33TSvjfZ4rSMJ1zZgxvDZvDZc+/il/c5jjvEjxobjCjyMJoZP9nmzh8493FqWUb9pRR01dlOo1xUmqWSxfigqUFk5iAHWMo/bbV9s2cYFSIsJxQ3tyy5i9087P9L3L9KWsj5qi2WnzpTQSadAZxWkDWMxknSuR1kZeGkp6WVooccABxauaMYaH3lvMcXe+E6iNIMRihr1vnMxjU5Zy56ufc8jvX/eva3Vq7xsnc8rfgi+v7JdgNNlufCAHuOuNajZ5mMCCRGUlQ4Gz9ylTuPQVT3/GsX9+J1AOsqbyS1OB0sLx1lBSQ0idVqD//jxVq8jkFLZ/VP081mPJtGRurjz8wwNCaScSadjcR27TU33M5Py55NNfL5NXbX2Mdm2SE1GDOMEh/iZ++j3vc+9b1YmyZRt2eEZ35cqz05exerPtbzBsra3n+hdm89fXF6b4V9zkG+ZcH4vxrXvfTyzf62UCc2aPeGZ6eqSWcz2UlZt2cOC41xLzT+zmkgLfu5+bttcFmp3/9udrAW+zXqGoU17JC695KO6Z3s635n137ZxS1/7tXvzN3Xn8xwelHLPfFO/87oi0awzLYS37IT07Mry/v7+lU9uywG1lIkgyxjBxz6vZuL2ON3KcxZ9PNKmnQKmLppQHHZSNMcz4aiN3TFqQKKteE/7yt/Z3Kcj9ZpvY6ceWmno++XIjv3xiRso1bSbOWhlf2TQDia+QiU8SXLOllkc+WuqqkzmB5PcfnJKY3Z/pK2nPJ3K+hExb8jVPTHXkywsYzHDfW18ksiRA8UxeTStERwmdkkTqlST2Urt2WaZ5G/b3buyJe/oec5txjt2rJyMyCAg3Pzysir16VzLmHu98UG1Kw3nviUSkQddm95pkN27ivJza+Pvb6WHM2WaVe2lBtfWxVIESUFHy+rji68eEi1/I7sxlGxnauzLx8gPxBKDfPWDXnK/hFiDu78LqzbUpGornHCD7GMnPJpER2pWx2m/MnrV8U7w/MZPxSdp+LluwzFu5mTP/Hk+Ies6BqfefSTBNmr2K2yfNTwljLpamrhpKC8crAWSda12QIEkivbA1B7dZLVeNIiKSMXS5V2VF7p3zYNHa9ISNxcQ51yNM3GHRr7kWGavzuMfa+ljKBMbgJq/0emGktXfjNbFzwaotnHb3+/zhlQVpx4LMGXGTLWwYUr/LXvfuXA/F/pzd9SIJDSW1/O3P1/KoQ5upi8VSTE9+z8S2KNiCCHKbCGn7YLbtrE/0tFipXlSgtHC8nMD2F9Q+UppJQ8nQ9mkj+ljXSC13XvKOb38jeyfF/w3r18fvQdcO5WnmtnypbcClUhvqWj/+z7SU/bM95o6416MJmubGa+Da6LMCZNis3xb3r8z4cmOagzwfH07iI0iE9abfm5eGEovF86y9OGN5QjtctmEHf3r185R6SR9KMovzJ19uYNQf32LKovVc8NBUrnthduL34p6AGjXGU6jUubJbA4y4+RXrmtkFg5clQTUUJS/sRInfOyipIrvXVs+kofjZWt++8iiOGNw9pR0b596Re3TP2kfBf3KlvRb9oYO6ZW0nCA2roRQnAV82vB6Ze15F0Ddc5zyUqrETWL+1NmUN+mLiTK8fdCJmJrKZvCDVP2Qf3RmNsXjdNq58dmbixcfO1OysZ2/Y3+RozPDhF+tZtG5bwsEOye96PBIytT9bPHLJ7bSc8s4XP3e9TGZQr8XjVENR8qK0JML8347m+pOHJsqSJi9LoGSYm+H3tevVKWmGymSuCmJNExFfh3kYfvSzD+if2PYSKEGEXj40pPDKhrsvueRNc/L+F+t5YmpuearyxRYodTFT8CJgkD6IesnU3788P63MFjy+L14uDcWOg3FqHM6XLvuzn7NiU4rmddfrCxl+c/qyy/bLQFmepmn7PmvqYonouWK5EosqUERktIgsEJFqERnrcbxcRJ6yjk8RkSrHsWus8gUicoKj/CERWSMis11tdRGRV0VkofU/NVypFVNRVpISvXLPuftx0j696NaxDZDFh+LzxXMKALdAcQqBIOGJkqFeGHFZPR0+GK9BPs/faVaCTh5sCO56ozplP5fMzk7+88GSwjsTcDCzvxL10Vhgn08mbMGQzMcVrE3bNFUi4vk9dZudbG0hGjOJgdvrO/a9f05J0TT+65Mg1BYoXi9uQW7BFqTjHRNbm93ERhEpAe4BTgSGAueIyFBXtQuBDcaYQcCdwO3WuUOBs4FhwGjgXqs9gIetMjdjgdeNMYOB1619xYN9d+3Mvefun/gyZvKh+OF848o0WS+T9pI4P+JfL4x4eafAHDMiPTlkIQtMZaIuGkvM9Wlq5HvPYWgKV2dZ593GmaU5DBONO6tyNhllX9KOmotEvA1LflFeKf0O8D32u0X7xSRTNKaz+Uc/WkrV2AmJrMxewqM5aigHAtXGmEXGmJ3Ak8AYV50xwL+t7WeBYyQ+gowBnjTG1BpjFgPVVnsYY94BvNZ+dbb1b+D0MG+mJeLl7HPTr0v6pEVI/QKnaSg4hU3mPgzq0YGjh/TwNXk5z89XtrR1TOj77gH96dq+Tcrx96rX5ddwFlZvrg0t5Dls8k1ZH4amEFQ22N/PumgslMXXog4h+tXX23k/y3O3NY9MGkK8nguH7ydhBgvw3fUTmrZWndE07Tj1z1awgJ1rzavVsBbOc1PMb3tfwGlsXWaVedYxxtQDm4CuAc9109MYY8dTrgI8MxqKyEUiMk1Epq1du9arSqvBfgP0e/OZcNnhHLq7tzPcqTm4hUFQk1dJRHjtV99kl3Zt/IVFQE0oE+cfUpXSH2efvjuyv8cZ4dF0NZT8TF5e6fuLhT2Q1scMxwRMlpgJp1A68a/v8tds+bqs6vbvJCLiPTjbyzRb+4korphxaC3Zv7t+MtPuZyaT19ufJyfM2p9bzBhq6qKegjPERBYpNM1ve4GY+FP0fDzGmPuNMSONMSO7dy+OM7a5YP/A/N68vGa7/9+xe6SVZUrgm8nk5eeHGXdGMqeY82y7yp/OGp4o85pw6WTMiD5pWoLTBPCr49Pvx4+Dd+sSuK6N39osjU2+b/zrfDIrFwPb1OM1ryYfLn50OhB/qdiaYWVON05N3st8ZJcsXb+d216en1ieIOYweS1d750B2YnfKoqJ5Q4yPLKnpy3juhdmAfFEoBAXLFc/N5PJc9IzC8xavrEok3yL+W1fDjhf//pZZZ51RKQU6ASsD3ium9Ui0ttqqzeQW46LVkh9wjYb/M3/l8cOZsltJ6eUZXLKZ1L1nYLI2ca5Bw3wbMvWLPrskjTD5RNJ5TQt5KL0PHD+SF771Tc9c5f5UV5W4lne2OvIZFoqt6lgP9ti9DWXybzOFy/vZJnJbWdmgx8+/HFiyeLnPvHOSJ2JnpXlAOzapR2QrsHMWbGJZRuTgurRj76kpi6aiCLbGY3xkc9SCVc/N4tX567yPFYIxRQoHwODRWSgiLQh7mQf76ozHrjA2j4TeMPSLsYDZ1tRYAOBwcDULNdztnUB8GII99CiOcVavXBkVeqbd2lEclrLJFOOrIwOe8cxv2pe/hinAMw2LHgNAM4fZhBTxG9P35s7vzucjhVlDOrRgfeuHpX1HBs/DaVYkWUtCVtDWb8tXK1o0466QBrawtVbqBo7gfcWxk1GJRHx9HNkipiqKSBbgm2KHtanMn4dl4py8l3vMXv55pQyp+a1sz7Ghm3+k1APqMpd485G0QSK5RO5FJgMzAOeNsbMEZFbROQ0q9qDQFcRqQZ+hRWZZYyZAzwNzAUmAZcYY6IAIvIE8CEwRESWiciFVlu3AceJyELgWGtfycA39+jOkttOZvfuHVLKq289ied/fljgdtL9JMn9TJEpzlDmIE55u45Tm7nwiIGctE+vwH0FePwnyVn3QQTKsD6VnLFvv5yuYWOv4e7GnYTwsmMGs1u39nldo6XityxyQ/HCjHiY7b1vxbWOkoiPD6VI11+2Ie6venn2KrbW1geKzNrqWPSsLhrLGLretUN5wX10U1S92xgzEZjoKrvBsV0DnOVz7jhgnEf5OT711wPHFNJfJT8yvW2XRIRuHco97cNOYeMfNuy8jqSd165NKdedPDSxVvqFhw9MmBkg+WO/5Ojd6dUpbqpy+oaCaAr5BgOAv4bizod12vA+LF63LWUpX6Vp4AwH9tZQit+HvW+czBXHZff3Oeey2BmNG5Km6TFUmhVuDaVPp9Rkjn5KSluHf8Hdxln7p2sEdhW38LH3e3Qs5/pT3FOd4lx5wp6cd/CAtPKgEy/zxRmynIn+XdrmnaRTKS72fA5fH0oDLcRr5w7LRLbItWKjAkUpGHsY7NS2jLu/ty8/O2r3lOPuN/wrTxgCpA62biHhTrTn3HYPvHZobn/LeZnSTpbXx2JrKAMDmLHalpVQXloSaBKo0vBss5ZtjohPlFfDyJNmgQoUpWCcKb1P+UaftJn37gH5MCvRo3MFQbcPxdZenPM47PHW3f4u7drwj/P254HzR+bcdz9hsVv3pCAoZLL+Pn2zLzSW0LwaYcnkob0rG/yazZUgUV6tHRUoSsF0rCijX+e23PqtfTyPu9+8d1hvfBUpJq/Uc64aPYTLjx3MKd9Ipkqx2ymNCB//5lg+GJuMtjphWC+6uGbAQ3aHqd8Y/uiF4aTL/6Yj8eSZHmY8JyU5hG+HxYTLDk+YF/v7ZEVQ4pRGxNMxnm9etJaIChSlYEoiwntXj0oZ/J24LTm2zdmZtNEtdDpWlHH5sXuklIsjyqt7x/KU+ShetCmJcOHhAzPWiYh4CpWgucoyMahHByocWti39/MWKHbrjeFDERF6WPMdztq/PzNvOr7B+9BciETE019SSGhwS0MFilJ03CGyh+zWlWtO3JPfnZ6cER/E3GM3E3SA/3zciey3a+ak0yLe7QXNIbZnr45pEz2dVFaUJSK92pRmToCZiw/l2L08MwvlxeGD4lrU3n0rqazIbbVNJ907hh+G2pQoEW8NpaaR1r1piqhAUYrO8H6pkyRFhJ9+c/eUpYKDyAh7kmOYiwNFRDwd8xJQQ7GPzbzpeKZfd2xqG9b/964+mnFn7E3fXVKDBvbo2SGlXm4+lPA+g0N278on1x/HqD0LE1LH7tWTV//vyJB6lZ1irWPjx+wVm5i/cnNauQqUJCpQlKLz+2/tw/M/P5SXLj2cP5zpvSRwkPDdU4f3BqBDRXjTp/yERVAN5Q7rfiorytilXboPB6BHZQXnHjQgpc1Ft57EkxcdklIvFx+KMw/T6R4p+XO10nn5n3KlNCIM7tmR74zMbRLoZaMG5XW90cNym9BaKDV1MV6ZuzrtBURNXklUoChFp6KshP127cw+/TpxVgHZfceeuBefXn9cQWYZN/HJal7lwdK77N03+CRJp+kvEnGsUmlHr+Vg8nIuZ1LikZ3TqyU7hUexsE12Rw3pkdN5bpNoJm48NTnPqLHm7bhffuzZ6PkkD21pqEBRmgzfO2hXHvqBf+hvSUToHMKbtBPxmVuQIlACvu5nq+fWhmwHb8LklSltswvnuiSZknueOjypvfw3h3Q6ufCP8/anU9uyRERbrkEMuZj6DhzYhW4d4t+Bxpq345Wlt2NFKeccuGsj9KZp0bgpTxXFwa1neIcdFxsvDUVCeNVyj5PugTO5mJ/3hE0/3ClAMr3h3/md4bxkLf0adLGv3p0qEmuPB+GEYb04wWF+ytXclouGYl0ByLzgVENTXhrRiamohqIonhQyO94Pt5Cy5+HYvoAgA9IfzvwGU649NuUt2esN/69n78uQnh3zGuS+k4NZ8u7v7ZtWlutnl0t1Y3KP9msI2pRENHUOqqEoShoXHj7Q5Q8JJ6IqLRtAmxKm/uYYOrcLbsIZ0LU93TuWp2gofT3WZzl1eJ8Uc5cXu3f3TguTy93u7bEIW67DqlMw7NO3E7OWb8pY367elAbw8rKSnEyWLRX9BJRWz4EDU52p158yNGUdlnyjlMU1tHq9UffoWJHInhxkgLT9PU4Npbw0wj3f2y+nvu3WrT2vX3GU30UCtdGrsoJerkSgkHkFTy+cd71Lu3jAxRiPyLVE+9bnmLuprHiohhJHBYrS6nnoBwcw+fLU+RPFyCCbbaD101CuPGEIB1TFJ2javXL6fYTcF+x67Vff9D3mbPvHGTINfHTtMSnpc5L9yX9gPWpIDyrKIvz48N145MIDGditPYN6JNfriZu8LIESKNS8D//64QF59ycoFWUN50PZu2/Tzb+mAkVp9XQoL2VIr44pZc41V3IRLZccvbvvOvfZBsBMa8LY59rKg9spH/Rt/W/n7Mu4M/bOWN9eehZgZFVnvptjqLffbfqZ4Jz1u3csZ/5vT2Sffp04YnB33vz1UezpeDYGgyva2hM78ejfztmXo4f08F2XJiwq25Z5CtdMZMqw4KZHM8lCoAJFaZV8a9++GY+XlUSo6pqeDj8bV56wZ0pCSCfZwmP9BIoxUNU17u/oaE3qdJq8RCQRSpuNU4f34dyD0teFceI+nnPUls8Jd509IreGEtdPNT/au5k0vgmXHcEd305Oos0UWh0GndqW0bldePOj3JyxX+bva1NBBYrS4rj06EFZM/v+6TvDWXTrSRnruNPk54p7XLX3/WZ4+9ngYzHDTacN44HzRyYmUjoFSkRg/wFdeOgHI7nzu8O5/NjBBfU7EhGOH5pMwxKWQAk6nyftPMd2704VifYzmdYGdmvPdw5IalZujWzGDccltp//+aGe2QZyobJtWV5zpC7+5u7ZKwGXHJ3MJuC+73evOjqtvt9y0mHmgPNCo7yUFsevrQW8MiE+WYZT6lj/c3XK+9UXEab+5hh2aes98JSXeptM6mOGtm1KOM4xyDtNXvYAU2guLm+EM/fvzxNTv+IHh1bx8AdLsp9RgDLgNcnUbm/cGXvTo9IhUHK4jlv7c87J2W/XzlRWlCXWkM+HTm3L2KVt7hrK2BP35O9vf5G1XiaHv1fW7Y4VpQzo2o6l67enlF970p68Nm91zv0MimooimLx3M8O4cELkjP1izHNoUfHCt8JhhVl3uVbaurTyq49aa/EdrF9wfsP6MyS207mptOGBaqf6+eWTWDbzXUoL01pPxeNxz0gu7WoQh3qbctKKC2JcMhuXQtqx4/MCUrTy2LG+57y1RKDohqKoljsP8A7F1NDrRnu59TdsH1nWtlRQ3pw+og+vDBjRVEm+BVyx16mqDC6mMgsYO17DaTTrjuWrR4COJsAKTTk127viYsOZt7KzZz413cLas+vffAypab3PWaMp8+u2C8fqqEoig/2G3GuS/PaczNOz+L4d9PWJVCutEx3XgLFSROaMA54D1qFCD17wLQFeyYfSrcO5VR5+A/cAsP9TN0C5pmLUzNBZ8PZ/l5FWFY51+9gzHh/5sXOLqAaiqL4cO+5+/P8p8tS5kEEoUv7Nsz/7WjKA+bOsnFrKGft348/TF7AaT7htrYW0ZRSkID3hMNC3ozdvqzkPJT8++TedwucAV2CRfjZfqViz0Hx+kyvGj3ENxzaGON5TtH7WdTWFaUZ06tTBT8/apCnSaG3xwxxJxVlJTnbq93rvPSorGDJbSfzLZ+lg22KKU/yaTvbgmW5dyL+L5lMM1nunMtxwjD/oIRsQtc9+LYrD/aubQcRNKRQt6+0T99O/PiI3TzrGANesqZZCxQRGS0iC0SkWkTGehwvF5GnrONTRKTKcewaq3yBiJyQrU0ReVhEFovIDOsvv6B3RQnAO1cdzee/OzHUNnfr1p4bThmavaKFPYh5ZUtuTAb37JhWlqvJxonbtCUJDSW1/B/n+S99kM1H4j4e1KcSS2hNqeXfPzi/VPb3nbufZ8JNJ2dbafL38Pick/1K+lD+/v39E+XNVqCISAlwD3AiMBQ4R0Tcv5YLgQ3GmEHAncDt1rlDgbOBYcBo4F4RKQnQ5pXGmBHW34xi3ZuilJVEAqeDD4qI8KMMqU7c2Ca1nfXhrxhYyCrLlRVlabPACzJ52RqKq61cmvQy/+zevX3iM3QPtEHlX2JNG9cJA7vlZia1OXGf3hw+qFvGOmNG9GHJbSfTs9JfS446TF7OWytEsAehmD6UA4FqY8wiABF5EhgDzHXUGQPcZG0/C9wt8SczBnjSGFMLLBaRaqs9ArSpKM2eIDPfbZ9LbX3mNc3/86MDMx73okv7+JwKd6BAvgQ1CXkJMvtMe+5NcqZ8fKNPpwpWZFm/xUvjmHT5kWl+meQ1cxt43bfX3yMDdPC2ko3tP6Az05duSDke5LM0Jik8nMKy2Ak1i2ny6gt85dhfZpV51jHG1AObgK4Zzs3W5jgRmSkid4qIZ/IbEblIRKaJyLS1a9fmfleKUmSm/uYY3vz1UVnr2W/X2dY0P3KP7hzpkw7GjxtOHcbNpw3jiMGZ35aDUsiL8UgrMebu3eNv/ckorzhvXnkU8387OmMbXoOwU8t0ayhBx113KLPN8cN6JSLFnGl+LnXMePfva3L70QsP4oOxo1KOB/ksTYqGkjyh2Zq8GoFrgD2BA4AuwNVelYwx9xtjRhpjRnbvntuPTFEagh4dK+hYkX3WdXlADSUfOpSXcsGhVaFNhMv0Zpwtiu47I/vz7lVHs/+AuGCx+2T/Ly8tyZqY37eXhQAAC3JJREFUMdvqjhVlJdx3bnIJgMAalb3hUf+Aqi58duPx3HGmM6dY9iHXee22bUrSZsIH6VvMoaE4qxfb5FVMgbIccKYp7WeVedYRkVKgE7A+w7m+bRpjVpo4tcC/SJrIFKVFYmsotUXwoYTBMxcfkngj9xrIelk+gGP26pnIKOw1iVRE6O8I483nJTvIIHziPr0TmZVF4iHBPzki1afVq7KCy0Zl1zJsOrUtS8kJ943+6QuS5drXILcfMyaRPLMhNZRi+lA+BgaLyEDig/7ZwPdcdcYDFwAfAmcCbxhjjIiMBx4XkT8DfYDBwFTin6VnmyLS2xiz0vLBnA7MLuK9KUqjkxAoWUxexWDCZYdnrXNAVRcGdG3H3W9We2o6b/76KOpi8b4P6dWR+au2BLp2cl5K8MiBoAEUt35rH244dSgikkg188C7ixPHX/rF4XTvWM7+VV0wxjB5zuqUPmXj6CE9stbJJvsyCZw7vv0NrnpuZsq6Mc68b81WoBhj6kXkUmAyUAI8ZIyZIyK3ANOMMeOBB4FHLKf718QFBFa9p4k72+uBS4wxUQCvNq1LPiYi3Yk/2xnAxcW6N0VpCthmnp3R8E1e2RjmsfSvF5a8SNMq7v7evrRtU0Jbcnf65xMuXRnAhAjxAbe9zxyUIwZ3SwRL2EsUTJ6zCgh3LpCfwKisKGVzTX3Gax1m+byMMQnhkbJ2TpGnyxR1prwxZiIw0VV2g2O7BjjL59xxwLggbVrlo9xlitKSOXP/fsxctpH/O3aPxu6KL1FrMHO/GZ/yjdTZ/zmFAHu8eWejUx6ZgN08cuFBeZ9706lDPVPCAAztXcnclZsT+36D/ouXHs4HX6zL6NfqXVnBd0b24/xDqrjz1c8BiDoU2GInh2xJTnlFaVVUlJVwx5nD6dqh4Vbz++k3vWdm+xGL5TaTPIiMSMxLyUFDCUOgeJGM8sp8fz84bCBH+Zi7Jv7yiJR9v89qYLf2WRdHi0SEO84czt59OyUCIaINOPNVc3kpihKYa07ci2tO3Ct7RYvuHcvpWF6akm6/UJICJfhAeeQe3Xjo/cXZK+ZIWjqYANx46lC6u5b0fe1XR7JmS23ObWWiJA9NrlBUoCiKUjQqykqYdXMicxJTf3MM9dHCBrh8fChHDenBp9cfx76/fTXn67UpjfD9LJpBLvzwsPRsCIN6dGRQj3ikW1hmqRLVUBRFacn06OidLiSXQTQfHwqQ1xK9QMacbYnUK3m1nJmDd/Nenyco9keqGoqiKIoP7txejUk+Jq8gvH3lUWlmsVwpbQQNRZ3yiqI0GYI55RveN5CNXHN/ZWNA1/a0a1PY+76dWWBAV+/osmKgGoqiKI1ObmHD1kYe8uQXowaxrTa8eTtNR6Sl8/2DB3DYoG7sZuVAs7MRFBMVKIqiNBmCDNClVk6RfDSUK44fkvM5mbjw8IG8Nm81R+3Z9PICikhCmMy86Xjf1R3DRAWKoijNilvP2JvenSpyzqBcDPbqXcmMG45v7G5kJWimgEJRgaIoSrOiR2UFvz1978buRpPi5H16B1pDp9ioQFEUpfFpuCXZWyT3OFLvNyYa5aUoSqPzkyN2o1uHNhw1pPHNWEr+qIaiKEqjs1fvSqZdd1xjd6NV8NezR9CtSPnfVKAoiqK0IsaMcK/EHh5q8lIURVFCQQWKoiiKEgoqUBRFUZRQUIGiKIqihIIKFEVRFCUUVKAoiqIooaACRVEURQkFFSiKoihKKIhpQovUNDQishZYmufp3YB1IXanOaD33DrQe24dFHLPA4wxaXlyWrVAKQQRmWaMGdnY/WhI9J5bB3rPrYNi3LOavBRFUZRQUIGiKIqihIIKlPy5v7E70AjoPbcO9J5bB6Hfs/pQFEVRlFBQDUVRFEUJBRUoiqIoSiioQMkDERktIgtEpFpExjZ2f8JARPqLyJsiMldE5ojIL63yLiLyqogstP53tspFRO6yPoOZItI0FrXOAxEpEZFPReR/1v5AEZli3dtTItLGKi+39qut41WN2e98EZFdRORZEZkvIvNE5JCW/pxF5P+s7/VsEXlCRCpa2nMWkYdEZI2IzHaU5fxcReQCq/5CEbkglz6oQMkRESkB7gFOBIYC54jI0MbtVSjUA1cYY4YCBwOXWPc1FnjdGDMYeN3ah/j9D7b+LgLua/guh8YvgXmO/duBO40xg4ANwIVW+YXABqv8Tqtec+SvwCRjzJ7AcOL33mKfs4j0BS4DRhpj9gZKgLNpec/5YWC0qyyn5yoiXYAbgYOAA4EbbSEUCGOM/uXwBxwCTHbsXwNc09j9KsJ9vggcBywAeltlvYEF1vY/gHMc9RP1mtMf0M/6oY0C/gcI8dnDpe7nDUwGDrG2S6160tj3kOP9dgIWu/vdkp8z0Bf4CuhiPbf/ASe0xOcMVAGz832uwDnAPxzlKfWy/amGkjv2l9NmmVXWYrBU/H2BKUBPY8xK69AqoKe13VI+h78AVwExa78rsNEYU2/tO+8rcc/W8U1W/ebEQGAt8C/LzPdPEWlPC37OxpjlwB+BL4GVxJ/bdFr2c7bJ9bkW9LxVoCgpiEgH4DngcmPMZucxE39laTFx5iJyCrDGGDO9sfvSgJQC+wH3GWP2BbaRNIMALfI5dwbGEBemfYD2pJuGWjwN8VxVoOTOcqC/Y7+fVdbsEZEy4sLkMWPM81bxahHpbR3vDayxylvC53AYcJqILAGeJG72+iuwi4iUWnWc95W4Z+t4J2B9Q3Y4BJYBy4wxU6z9Z4kLmJb8nI8FFhtj1hpj6oDniT/7lvycbXJ9rgU9bxUoufMxMNiKEGlD3Lk3vpH7VDAiIsCDwDxjzJ8dh8YDdqTHBcR9K3b5+Va0yMHAJodq3SwwxlxjjOlnjKki/hzfMMacC7wJnGlVc9+z/VmcadVvVm/yxphVwFciMsQqOgaYSwt+zsRNXQeLSDvre27fc4t9zg5yfa6TgeNFpLOl2R1vlQWjsZ1IzfEPOAn4HPgC+E1j9yekezqcuDo8E5hh/Z1E3Hb8OrAQeA3oYtUX4tFuXwCziEfQNPp9FHD/RwH/s7Z3A6YC1cAzQLlVXmHtV1vHd2vsfud5ryOAadazfgHo3NKfM3AzMB+YDTwClLe05ww8QdxHVEdcE70wn+cK/Mi692rgh7n0QVOvKIqiKKGgJi9FURQlFFSgKIqiKKGgAkVRFEUJBRUoiqIoSiioQFEURVFCQQWKooSAiGy1/leJyPdCbvta1/4HYbavKGGhAkVRwqUKyEmgOGZr+5EiUIwxh+bYJ0VpEFSgKEq43AYcISIzrDU4SkTkDyLysbXuxE8BROQoEXlXRMYTn7WNiLwgItOtdTsusspuA9pa7T1mldnakFhtzxaRWSLyXUfbb0lyzZPHrBniilJUsr0ZKYqSG2OBXxtjTgGwBMMmY8wBIlIOvC8ir1h19wP2NsYstvZ/ZIz5WkTaAh+LyHPGmLEicqkxZoTHtb5FfNb7cKCbdc471rF9gWHACuB94rmr3gv/dhUliWooilJcjieeM2kG8eUAuhJf1AhgqkOYAFwmIp8BHxFP0DeYzBwOPGGMiRpjVgNvAwc42l5mjIkRT6NTFcrdKEoGVENRlOIiwC+MMSkJ9kTkKOKp4537xxJf2Gm7iLxFPKdUvtQ6tqPob11pAFRDUZRw2QJ0dOxPBn5mLQ2AiOxhLWjlphPxZWe3i8iexJdhtqmzz3fxLvBdy0/THTiSeDJDRWkU9K1FUcJlJhC1TFcPE19fpQr4xHKMrwVO9zhvEnCxiMwjvhzrR45j9wMzReQTE0+vb/Nf4kvXfkY8U/RVxphVlkBSlAZHsw0riqIooaAmL0VRFCUUVKAoiqIooaACRVEURQkFFSiKoihKKKhAURRFUUJBBYqiKIoSCipQFEVRlFD4f3B8fJm7g35nAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.plot(train_engine.state.iter_history['loss'])\n", "plt.xlabel('Iteration')\n", "plt.ylabel('Loss')\n", "plt.title('Train Loss')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's also see what got saved in the output folder:" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\u001b[01;34m/home/pseetharaman/.nussl/tutorial/sinewave\u001b[00m\r\n", "├── \u001b[01;34mcheckpoints\u001b[00m\r\n", "│   ├── best.model.pth\r\n", "│   ├── best.optimizer.pth\r\n", "│   ├── latest.model.pth\r\n", "│   └── latest.optimizer.pth\r\n", "└── \u001b[01;34mresults\u001b[00m\r\n", "\r\n", "2 directories, 4 files\r\n" ] } ], "source": [ "!tree {OUTPUT_FOLDER}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "So the models and optimizers got saved! Let's load back one of these\n", "models and see what's in it." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "What's in a model?\n", "------------------\n", "\n", "After we're finished training the model, it will be saved by our \n", "`add_validate_and_checkpoint` handler. What gets saved in our model? Let's see:" ] }, { "cell_type": "code", "execution_count": 45, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "dict_keys(['state_dict', 'config', 'metadata', 'nussl_version'])\n" ] } ], "source": [ "saved_model = torch.load(train_engine.state.saved_model_path)\n", "print(saved_model.keys())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As expected, there's the `state_dict` containing the weights of\n", "the trained model, the `config` containing the configuration of the model.\n", "There also a `metadata` key in the saved model. Let's check out the metadata..." ] }, { "cell_type": "code", "execution_count": 46, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "dict_keys(['stft_params', 'sample_rate', 'num_channels', 'folder', 'transforms', 'trainer.state_dict', 'trainer.state.epoch_history'])\n" ] } ], "source": [ "print(saved_model['metadata'].keys())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "There's a whole bunch of stuff related to training, like the folder \n", "it was trained on, the state dictionary of the engine used to train the \n", "model, the loss history for each epoch (not each iteration - that's too big).\n", "\n", "There are also keys that are related to the parameters of the AudioSignal. \n", "Namely, `stft_params`, `sample_rate`, and `num_channels`. These \n", "are used by *nussl* to prepare an AudioSignal object to be put into a\n", "deep learning based separation algorithm. There's also a `transforms`\n", "key - this is used by *nussl* to construct the input dictionary at\n", "inference time on an AudioSignal so that the data going into the model\n", "matches how it was given during training time. Let's look at each of these:" ] }, { "cell_type": "code", "execution_count": 47, "metadata": { "lines_to_next_cell": 2 }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "stft_params: STFTParams(window_length=256, hop_length=64, window_type=None)\n", "sample_rate: 8000\n", "num_channels: 1\n", "folder: ignored\n", "transforms: Compose(\n", " PhaseSensitiveSpectrumApproximation(mix_key = mix, source_key = sources)\n", " \n", " ToSeparationModel()\n", ")\n", "trainer.state_dict: {'epoch': 1, 'epoch_length': 1000, 'max_epochs': 1, 'output': {'PermutationInvariantLoss': 0.000967394735198468, 'loss': 0.000967394735198468}, 'metrics': {}, 'seed': 12}\n", "trainer.state.epoch_history: {'validation/PermutationInvariantLoss': [0.000682936332304962], 'validation/loss': [0.000682936332304962], 'train/PermutationInvariantLoss': [0.0011968749410734745], 'train/loss': [0.0011968749410734745]}\n" ] } ], "source": [ "for key in saved_model['metadata']:\n", " print(f\"{key}: {saved_model['metadata'][key]}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "**Importantly**, everything saved with the model makes training it *entirely reproduceable*. We have everything we need to recreate another model exactly like this if we need to.\n", "\n", "Now that we've trained our toy model, let's move on to actually using and evaluating it." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Using and evaluating a trained model\n", "------------------------------------\n", "\n", "In this tutorial, we built very simple a deep mask estimation network. There is a \n", "corresponding separation algorithm in *nussl* for using \n", "deep mask estimation networks. Let's build our dataset\n", "again, this time *without* transforms, so we have access to\n", "the actual AudioSignal objects. Then let's instantiate the\n", "separation algorithm and use it to separate an item from the \n", "dataset." ] }, { "cell_type": "code", "execution_count": 48, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "text/html": [ "
" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "tt_dataset = SineWaves(\n", " 'ignored', sample_rate=8000\n", ")\n", "tt_dataset.frequencies = sine_wave_dataset.frequencies\n", "\n", "item = tt_dataset[0] # <-- This is an AugioSignal obj\n", "\n", "MODEL_PATH = os.path.join(OUTPUT_FOLDER, 'checkpoints/best.model.pth')\n", "\n", "separator = nussl.separation.deep.DeepMaskEstimation(\n", " item['mix'], model_path=MODEL_PATH\n", ")\n", "estimates = separator()\n", "\n", "visualize_and_embed(estimates)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Evaluation in parallel ###\n", "\n", "We'll usually want to run many mixtures through the model, separate,\n", "and get evaluation metrics like SDR, SIR, and SAR. We can do that with\n", "the following bit of code:" ] }, { "cell_type": "code", "execution_count": 49, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/pseetharaman/Dropbox/research/nussl_refactor/nussl/separation/base/separation_base.py:71: UserWarning: input_audio_signal has no data!\n", " warnings.warn('input_audio_signal has no data!')\n", "/home/pseetharaman/Dropbox/research/nussl_refactor/nussl/core/audio_signal.py:445: UserWarning: Initializing STFT with data that is non-complex. This might lead to weird results!\n", " warnings.warn('Initializing STFT with data that is non-complex. '\n", " 96%|█████████▌| 96/100 [00:04<00:00, 17.45it/s]/home/pseetharaman/Dropbox/research/nussl_refactor/nussl/evaluation/bss_eval.py:33: RuntimeWarning: divide by zero encountered in log10\n", " srr = -10 * np.log10((1 - (1/alpha)) ** 2)\n", "100%|██████████| 100/100 [00:05<00:00, 19.65it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " \n", " MEAN +/- STD OF METRICS \n", " \n", "┌─────────┬──────────────────┬──────────────────┬──────────────────┬──────────────────┐\n", "│ METRIC │ OVERALL │ SINE1 │ SINE2 │ SINE3 │\n", "╞═════════╪══════════════════╪══════════════════╪══════════════════╪══════════════════╡\n", "│ # │ 300 │ 100 │ 100 │ 100 │\n", "├─────────┼──────────────────┼──────────────────┼──────────────────┼──────────────────┤\n", "│ SI-SDR │ 14.83 +/- 15.89 │ 15.44 +/- 14.83 │ 14.20 +/- 17.41 │ 14.85 +/- 15.44 │\n", "├─────────┼──────────────────┼──────────────────┼──────────────────┼──────────────────┤\n", "│ SI-SIR │ 25.39 +/- 19.97 │ 25.79 +/- 18.48 │ 24.89 +/- 21.90 │ 25.50 +/- 19.57 │\n", "├─────────┼──────────────────┼──────────────────┼──────────────────┼──────────────────┤\n", "│ SI-SAR │ 19.46 +/- 14.75 │ 19.27 +/- 14.17 │ 19.26 +/- 15.35 │ 19.84 +/- 14.86 │\n", "├─────────┼──────────────────┼──────────────────┼──────────────────┼──────────────────┤\n", "│ SD-SDR │ 8.68 +/- 21.89 │ 8.65 +/- 21.83 │ 8.38 +/- 22.88 │ 9.02 +/- 21.15 │\n", "├─────────┼──────────────────┼──────────────────┼──────────────────┼──────────────────┤\n", "│ SNR │ 15.13 +/- 10.91 │ 15.23 +/- 10.46 │ 15.23 +/- 11.41 │ 14.92 +/- 10.96 │\n", "├─────────┼──────────────────┼──────────────────┼──────────────────┼──────────────────┤\n", "│ SRR │ 20.46 +/- 29.52 │ 20.31 +/- 29.74 │ 20.62 +/- 30.97 │ 20.45 +/- 28.06 │\n", "├─────────┼──────────────────┼──────────────────┼──────────────────┼──────────────────┤\n", "│ SI-SDRi │ 17.84 +/- 15.89 │ 18.45 +/- 14.83 │ 17.21 +/- 17.41 │ 17.86 +/- 15.44 │\n", "├─────────┼──────────────────┼──────────────────┼──────────────────┼──────────────────┤\n", "│ SD-SDRi │ 11.69 +/- 21.89 │ 11.66 +/- 21.83 │ 11.39 +/- 22.88 │ 12.03 +/- 21.15 │\n", "├─────────┼──────────────────┼──────────────────┼──────────────────┼──────────────────┤\n", "│ SNRi │ 18.14 +/- 10.91 │ 18.24 +/- 10.46 │ 18.24 +/- 11.41 │ 17.93 +/- 10.96 │\n", "└─────────┴──────────────────┴──────────────────┴──────────────────┴──────────────────┘\n", " \n", " MEDIAN OF METRICS \n", " \n", "┌─────────┬──────────────────┬──────────────────┬──────────────────┬──────────────────┐\n", "│ METRIC │ OVERALL │ SINE1 │ SINE2 │ SINE3 │\n", "╞═════════╪══════════════════╪══════════════════╪══════════════════╪══════════════════╡\n", "│ # │ 300 │ 100 │ 100 │ 100 │\n", "├─────────┼──────────────────┼──────────────────┼──────────────────┼──────────────────┤\n", "│ SI-SDR │ 19.40 │ 19.73 │ 19.16 │ 19.16 │\n", "├─────────┼──────────────────┼──────────────────┼──────────────────┼──────────────────┤\n", "│ SI-SIR │ 28.23 │ 28.29 │ 28.53 │ 27.48 │\n", "├─────────┼──────────────────┼──────────────────┼──────────────────┼──────────────────┤\n", "│ SI-SAR │ 22.07 │ 21.56 │ 22.41 │ 22.11 │\n", "├─────────┼──────────────────┼──────────────────┼──────────────────┼──────────────────┤\n", "│ SD-SDR │ 16.27 │ 17.13 │ 16.12 │ 15.66 │\n", "├─────────┼──────────────────┼──────────────────┼──────────────────┼──────────────────┤\n", "│ SNR │ 16.87 │ 17.68 │ 16.57 │ 16.05 │\n", "├─────────┼──────────────────┼──────────────────┼──────────────────┼──────────────────┤\n", "│ SRR │ 26.03 │ 26.08 │ 26.32 │ 24.06 │\n", "├─────────┼──────────────────┼──────────────────┼──────────────────┼──────────────────┤\n", "│ SI-SDRi │ 22.42 │ 22.74 │ 22.17 │ 22.17 │\n", "├─────────┼──────────────────┼──────────────────┼──────────────────┼──────────────────┤\n", "│ SD-SDRi │ 19.28 │ 20.14 │ 19.13 │ 18.67 │\n", "├─────────┼──────────────────┼──────────────────┼──────────────────┼──────────────────┤\n", "│ SNRi │ 19.88 │ 20.70 │ 19.59 │ 19.06 │\n", "└─────────┴──────────────────┴──────────────────┴──────────────────┴──────────────────┘\n", " \n", " NOTES \n", " \n", "Testing on sine waves\n" ] } ], "source": [ "# make a separator with an empty audio signal initially\n", "# this one will live on gpu (if one exists) and be used in a \n", "# threadpool for speed\n", "dme = nussl.separation.deep.DeepMaskEstimation(\n", " nussl.AudioSignal(), model_path=MODEL_PATH, device='cuda'\n", ")\n", "\n", "\n", "def forward_on_gpu(audio_signal):\n", " # set the audio signal of the object to this item's mix\n", " dme.audio_signal = audio_signal\n", " masks = dme.forward()\n", " return masks\n", "\n", "\n", "def separate_and_evaluate(item, masks):\n", " separator = nussl.separation.deep.DeepMaskEstimation(item['mix'])\n", " estimates = separator(masks)\n", "\n", " evaluator = nussl.evaluation.BSSEvalScale(\n", " list(item['sources'].values()), estimates, \n", " compute_permutation=True,\n", " source_labels=['sine1', 'sine2', 'sine3']\n", " )\n", " scores = evaluator.evaluate()\n", " output_path = os.path.join(\n", " RESULTS_DIR, f\"{item['mix'].file_name}.json\"\n", " )\n", " with open(output_path, 'w') as f:\n", " json.dump(scores, f)\n", " \n", "pool = ThreadPoolExecutor(max_workers=NUM_WORKERS)\n", "for i, item in enumerate(tqdm.tqdm(tt_dataset)):\n", " masks = forward_on_gpu(item['mix'])\n", " if i == 0:\n", " separate_and_evaluate(item, masks)\n", " else:\n", " pool.submit(separate_and_evaluate, item, masks)\n", "pool.shutdown(wait=True)\n", "\n", "json_files = glob.glob(f\"{RESULTS_DIR}/*.json\")\n", "df = nussl.evaluation.aggregate_score_files(json_files)\n", "report_card = nussl.evaluation.report_card(\n", " df, notes=\"Testing on sine waves\", report_each_source=True)\n", "print(report_card)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We parallelized the evaluation across 2 workers, kept two copies of\n", "the separator, one of which lives on the GPU, and the other which\n", "lives on the CPU. The GPU one does a forward pass in its own thread\n", "and then hands it to the other separator which actually computes the\n", "estimates and evaluates the metrics in parallel. After we're done, \n", "we aggregate all the results (each of which was saved to a JSON file)\n", "using `nussl.evaluation.aggregate_score_files` and then use the\n", "nussl report card at `nussl.evaluation.report_card` to view the results.\n", "We also now have the results as a pandas DataFrame:" ] }, { "cell_type": "code", "execution_count": 50, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
sourcefileSI-SDRSI-SIRSI-SARSD-SDRSNRSRRSI-SDRiSD-SDRiSNRi
0sine346.wav.json-20.328155-8.004939-20.066033-40.2751100.039984-40.230923-17.317855-37.2648103.050284
1sine395.wav.json28.66778047.82314228.72085625.99148826.28212229.36364131.67808029.00178829.292422
2sine310.wav.json33.81245851.03662433.89554133.17282033.24307841.80721636.82275836.18312036.253378
3sine383.wav.json9.7672979.88216725.6003889.7461699.94098932.88604012.77759712.75646912.951289
4sine322.wav.json6.32336323.4204626.408937-19.1792300.894722-19.1669809.333663-16.1689303.905022
....................................
295sine10.wav.json20.90110336.09248821.03454720.88309420.93342144.71519023.91140323.89339423.943721
296sine163.wav.json18.45784934.46241318.56821517.42933617.94966924.18919221.46814920.43963620.959969
297sine192.wav.json2.0703332.34129314.253886-7.6465932.669284-7.1563965.080632-4.6362935.679584
298sine137.wav.json-16.62066512.170543-16.614925-49.3679830.027190-49.365675-13.610365-46.3576833.037490
299sine143.wav.json19.68763220.53788127.18820719.68072119.71657947.66660322.69793222.69102122.726879
\n", "

300 rows × 11 columns

\n", "
" ], "text/plain": [ " source file SI-SDR SI-SIR SI-SAR SD-SDR \\\n", "0 sine3 46.wav.json -20.328155 -8.004939 -20.066033 -40.275110 \n", "1 sine3 95.wav.json 28.667780 47.823142 28.720856 25.991488 \n", "2 sine3 10.wav.json 33.812458 51.036624 33.895541 33.172820 \n", "3 sine3 83.wav.json 9.767297 9.882167 25.600388 9.746169 \n", "4 sine3 22.wav.json 6.323363 23.420462 6.408937 -19.179230 \n", ".. ... ... ... ... ... ... \n", "295 sine1 0.wav.json 20.901103 36.092488 21.034547 20.883094 \n", "296 sine1 63.wav.json 18.457849 34.462413 18.568215 17.429336 \n", "297 sine1 92.wav.json 2.070333 2.341293 14.253886 -7.646593 \n", "298 sine1 37.wav.json -16.620665 12.170543 -16.614925 -49.367983 \n", "299 sine1 43.wav.json 19.687632 20.537881 27.188207 19.680721 \n", "\n", " SNR SRR SI-SDRi SD-SDRi SNRi \n", "0 0.039984 -40.230923 -17.317855 -37.264810 3.050284 \n", "1 26.282122 29.363641 31.678080 29.001788 29.292422 \n", "2 33.243078 41.807216 36.822758 36.183120 36.253378 \n", "3 9.940989 32.886040 12.777597 12.756469 12.951289 \n", "4 0.894722 -19.166980 9.333663 -16.168930 3.905022 \n", ".. ... ... ... ... ... \n", "295 20.933421 44.715190 23.911403 23.893394 23.943721 \n", "296 17.949669 24.189192 21.468149 20.439636 20.959969 \n", "297 2.669284 -7.156396 5.080632 -4.636293 5.679584 \n", "298 0.027190 -49.365675 -13.610365 -46.357683 3.037490 \n", "299 19.716579 47.666603 22.697932 22.691021 22.726879 \n", "\n", "[300 rows x 11 columns]" ] }, "execution_count": 50, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Finally, we can look at the structure of the output folder again,\n", "seeing there are now 100 entries under results corresponding to each\n", "item in `sine_wave_dataset`:" ] }, { "cell_type": "code", "execution_count": 51, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\u001b[01;34m/home/pseetharaman/.nussl/tutorial/sinewave\u001b[00m\r\n", "├── \u001b[01;34mcheckpoints\u001b[00m\r\n", "│   ├── best.model.pth\r\n", "│   ├── best.optimizer.pth\r\n", "│   ├── latest.model.pth\r\n", "│   └── latest.optimizer.pth\r\n", "└── \u001b[01;34mresults\u001b[00m [100 entries exceeds filelimit, not opening dir]\r\n", "\r\n", "2 directories, 4 files\r\n" ] } ], "source": [ "!tree --filelimit 20 {OUTPUT_FOLDER}" ] }, { "cell_type": "code", "execution_count": 52, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Time taken: 169.6379 seconds\n" ] } ], "source": [ "end_time = time.time()\n", "time_taken = end_time - start_time\n", "print(f'Time taken: {time_taken:.4f} seconds')" ] } ], "metadata": { "jupytext": { "formats": "ipynb,py" }, "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.6" } }, "nbformat": 4, "nbformat_minor": 4 }