diff --git a/08-Workshop/ML_for_Audio_myVersion.ipynb b/08-Workshop/ML_for_Audio_myVersion.ipynb new file mode 100644 index 0000000..33c4f02 --- /dev/null +++ b/08-Workshop/ML_for_Audio_myVersion.ipynb @@ -0,0 +1,6047 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Q82jF4Im84hk" + }, + "source": [ + "# SPIS Workshop\n", + "## Audio Processing from a Machine Learning Perspective\n", + "### **Differentiable Digital Signal Processing (DDSP)**\n", + "#### *Anders R. Bargum (PhD Student)*, Cumhur Erkut, Monday 7th of April, 2025\n", + "\n", + "Welcome to the main notebook of the workshop \"*Audio Processing from a Machine Learning Perspective*\", created for the \"*Signal Processing for Interactive Systems*\" course at Aalborg University Copenhagen. During this workshop we will cover how machine learning principles can be applied to audio, specifically for audio-effects and audio-processing. Some of you may be familiar with \"neural networks\", which are models that operate on an input using different layers of functions, additions and multiplications in order to predict a specific target. This workshop is NOT a walkthrough of neural networks. Rather, we will look at machine-learning principles from a signal-based approach, more specifically called \"*Differential Digital Signal Processing*\" (DDSP).\n", + "\n", + "
\n", + "\n", + "
\n", + "\n", + "\n", + "This notebook will cover the following:\n", + "\n", + "- **Introduction:** What is DDSP and how can we use it?\n", + "- **PyTorch and differentiability:** A quick recap\n", + "- **Toy problem:** A differentiable gain control\n", + "- **Loss functions**: L1, MSE, Spectral Loss\n", + "- **Other use-cases:** Filter design, waveshaping etc.\n", + "- **Optimizing physical models:** Applicable to SMC physical modelling class\n", + "\n", + "Much of this notebook is based on the workshop \"*Introduction to DDSP for Audio Synthesis*\" by Ben Hayes, Jordie Shier, Chin-Yun Yu, David Südholt, Rodrigo Diaz (https://intro2ddsp.github.io/intro.html#).\n", + "\n", + "I additionally refer you to the following work for more information:\n", + "\n", + "- DDSP, Differentiable Digital Signal Processing: https://magenta.tensorflow.org/ddsp (2019)\n", + "- Kuznetsov et. al: Differentiable IIR Filters for Machine Learning Applications (2020)\n", + "- Hayes et. al: A Review of Differentiable Digital Signal Processing for Music & Speech Synthesis (2023)\n", + "- Steinmetz et. al: Style Transfer of Audio Effects with Differentiable Signal Processing https://csteinmetz1.github.io/DeepAFx-ST/ (2022)\n", + "- Bargum et. al: Differentiable Allpass Filters for Phase Response Estimation and Automatic Signal Alignment (2023)\n", + "\n", + "Let's start by installing any needed packages:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "h7eX3cqLWGNn", + "outputId": "27d7c8ed-c50d-4490-a41e-96fe91e1cd1e", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "--2025-04-07 13:02:45-- https://raw.githubusercontent.com/SMC-AAU-CPH/SPIS/tree/main/08-Worskhop/utils.py\n", + "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.109.133, 185.199.110.133, ...\n", + "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected.\n", + "HTTP request sent, awaiting response... 404 Not Found\n", + "2025-04-07 13:02:45 ERROR 404: Not Found.\n", + "\n", + "--2025-04-07 13:02:45-- http://./\n", + "Resolving . (.)... failed: No address associated with hostname.\n", + "wget: unable to resolve host address ‘.’\n", + "--2025-04-07 13:02:45-- https://raw.githubusercontent.com/SMC-AAU-CPH/SPIS/tree/main/08-Worskhop/sound-files/guitar.wav\n", + "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.109.133, 185.199.110.133, ...\n", + "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected.\n", + "HTTP request sent, awaiting response... 404 Not Found\n", + "2025-04-07 13:02:45 ERROR 404: Not Found.\n", + "\n", + "--2025-04-07 13:02:45-- https://raw.githubusercontent.com/SMC-AAU-CPH/SPIS/tree/main/08-Worskhop/sound-files/guitar-nsynth.wav\n", + "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.109.133, 185.199.110.133, ...\n", + "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected.\n", + "HTTP request sent, awaiting response... 404 Not Found\n", + "2025-04-07 13:02:45 ERROR 404: Not Found.\n", + "\n" + ] + } + ], + "source": [ + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + " !wget https://raw.githubusercontent.com/SMC-AAU-CPH/SPIS/tree/main/08-Worskhop/utils.py .\n", + " !mkdir -p sound-files\n", + " !wget https://raw.githubusercontent.com/SMC-AAU-CPH/SPIS/tree/main/08-Worskhop/sound-files/guitar.wav -P sound-files\n", + " !wget https://raw.githubusercontent.com/SMC-AAU-CPH/SPIS/tree/main/08-Worskhop/sound-files/guitar-nsynth.wav -P sound-files\n", + "except:\n", + " IN_COLAB = False" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "OnWvOiTc84hm" + }, + "outputs": [], + "source": [ + "!pip install ipython\n", + "!pip install torch\n", + "!pip install numpy\n", + "!pip install matplotlib\n", + "!pip install numpy\n", + "!pip install librosa\n", + "!pip install torchaudio" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "RPDfW8ou84hn" + }, + "source": [ + "### Import packages" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "sykVnX8784hn" + }, + "outputs": [], + "source": [ + "from utils import plot_graph, get_sine, plot_tf, DIIRDataSet, DIIR_WRAPPER\n", + "import IPython.display as ipd\n", + "import torch\n", + "import numpy as np\n", + "from matplotlib.animation import FuncAnimation\n", + "from IPython.display import HTML\n", + "from matplotlib import pyplot as plt\n", + "from torch.nn import Module, Parameter\n", + "from torch import FloatTensor\n", + "from numpy.random import uniform\n", + "from torch.utils.data import DataLoader\n", + "import json\n", + "import librosa\n", + "import torchaudio" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "VinofphF84hn", + "outputId": "bd431856-c968-4925-a356-437bcbd46845" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using device: cuda\n" + ] + } + ], + "source": [ + "if torch.cuda.is_available():\n", + " device = \"cuda\"\n", + "elif torch.backends.mps.is_available():\n", + " device = \"mps\"\n", + "else:\n", + " device = \"cpu\"\n", + "\n", + "print(\"Using device:\", device)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-O5Gnczg84ho" + }, + "source": [ + "## Introduction: Differential Digital Signal Processing (DDSP)\n", + "\n", + "From a mathematical perspective a *differentiable* function is a function whose derivative exists at all points in its domain i.e. that we can take the derivate of function $f(x)$ no matter what value $x$ takes. In short, when we differentiate we find the rate of change of a function $f(x)$ with respect to its input $x$ (the rise in $y$ with respect to the rise in $x$). Basically, we are finding the slope of the tangent line at the specific point of $x$. When the slope of the tangent is 0, it indicates a critical point, which could be a minimum, maximum, or a saddle point. In many ML cases we want to find the minimum of a function.\n", + "\n", + "
\n", + "\n", + "
\n", + "\n", + "#### **In a machine learning context I like to think of differentiable as something that is \"updatable\"**.\n", + "\n", + "In a signal processing manner, this means that we can take a signal processor with different parameters (being a function), and approximate the specific parameters of a given behaviour. We do this by implementing the function and automatically updating the parameters such that we reach a specific minimum (can only be done if the signal processing function itself is differentiable). With this in mind, we can implement a signal processor, or a chain of different signal processors, and automatically update its internal parameters using an automatic differentiation framework such as TensorFlow, PyTorch, or Jax (which does all the troublesome differentiation-work for you).\n", + "\n", + "Lets look at an example:\n", + "\n", + "### A simple **Linear Gain** Effect\n", + "\n", + "A linear gain effect is a really simple and good example of how differentiable signal processing works, as it presents a differentiable system (we can take the derivative of $f(x)$) with an obvious parameter (the gain factor $g$). Normally, it would be very easy for us as developers just to change the value $g$ to find the desired gain.\n", + "\n", + "But what if the system was part of a larger sub-system? In that case it would not be as easy.\n", + "Or what if we were to create a specific frequency response using a filter with coefficients a1, a2, a3, b1, b2, b3? Then it would also be difficult to tune the coefficients by hand.\n", + "\n", + "In the case of the linear gain effect, we can finde the gain value $g$ using differentiability.\n", + "\n", + "We need:\n", + "\n", + "1. An input, could be anything from a sine wave to a complex instrument signal\n", + "2. An output, the same as the input signal but affected by the system we want to approximate (lets say at half the amplitude value of the input)\n", + "3. The system we want to approximate, implemented for differentiation (using nn.Module in PyTorch)\n", + "4. A loss function that can compare how far our target is from our prediction (this is the function we want to find the minimum of)\n", + "5. Gradients telling us how far the given parameters are from minimizing the loss function\n", + "\n", + "Following the pipeline below, we can then recursively keep updating gain parameter $g$ until the output of the gain-system matches that of the target.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "W0TzK4Tz84ho" + }, + "source": [ + "
\n", + "\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "YxWN-2mH84ho" + }, + "source": [ + "# PyTorch and Differentiability" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "m21hB0DQ84ho" + }, + "source": [ + "To implement above system we can use PyTorch. PyTorch provides many utilities around neural networks and deep learning, but at its very core it consists of two main features: GPU-accelerated linear algebra operations, and automatic differentiation.\n", + "\n", + "Let’s quickly recap the basics of PyTorch.\n", + "\n", + "## Tensors\n", + "\n", + "Tensors are the basic data structure in PyTorch. They are similar to numpy arrays, but offer support for the two main features mentioned above." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "SMrcGKhf84ho", + "outputId": "78cb2c18-0366-4dbe-8336-6b5704894197" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a = tensor(42.)\n", + "v = tensor([1., 2., 3.])\n", + "M = tensor([[1., 2., 3.],\n", + " [4., 5., 6.]])\n" + ] + } + ], + "source": [ + "# Create a scalar (0D tensor)\n", + "scalar = torch.tensor(42, dtype=torch.float32) # explicitly enforce float type\n", + "print(\"a =\", scalar)\n", + "\n", + "# Create a vector (1D tensor)\n", + "vector = torch.tensor([1., 2., 3.])\n", + "print(\"v =\", vector)\n", + "\n", + "# Create a matrix (2D tensor)\n", + "matrix = torch.tensor([[1., 2., 3.], [4., 5., 6.]])\n", + "print(\"M =\", matrix)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hVzuuUMN84hp" + }, + "source": [ + "Basic arithmetic operations are applied element-wise:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "kQS2GOW484hp", + "outputId": "1f824844-d7de-4d23-a49c-36eb1858749b" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "v + v = tensor([2., 4., 6.])\n", + "v * v = tensor([1., 4., 9.])\n", + "M * v = tensor([[ 1., 4., 9.],\n", + " [ 4., 10., 18.]])\n", + "M x v tensor([14., 32.])\n", + "M @ v = tensor([14., 32.])\n", + "v^2 = tensor([1., 4., 9.])\n", + "exp(v) = tensor([ 2.7183, 7.3891, 20.0855])\n", + "sin(v) = tensor([0.8415, 0.9093, 0.1411])\n" + ] + } + ], + "source": [ + "print(\"v + v =\", vector + vector) #addition of two vectors\n", + "print(\"v * v =\", vector * vector) #multiplication of two vectors (element-wise)\n", + "print(\"M * v =\", matrix * vector) #broadcasting (expanding dimensions automatically)\n", + "\n", + "print(\"M x v\", torch.matmul(matrix, vector)) #matrix multiplication/dot product ((2x3) * (3x1) = (2x1))\n", + "print(\"M @ v =\", matrix @ vector) #matrix multiplication/dot product ((2x3) * (3x1) = (2x1))\n", + "\n", + "print(\"v^2 =\", vector ** 2) #take the power of 2 element-wise\n", + "print(\"exp(v) =\", torch.exp(vector)) #take the exponent element-wise\n", + "print(\"sin(v) =\", torch.sin(vector)) #take the sine element-wise" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "wSuMW6dU84hp" + }, + "source": [ + "## Gradients and Auto-Differentiation\n", + "\n", + "As in the linear gain example, we are interested in a value that minimize the difference between the system-output and the target (also called the loss or the error). In essence, the loss is an objective function that we try to minimize. In order to do this we can use automatic differentiation: if we know the gradient of a function with respect to its inputs (the slope of all tangent lines), we know that adjusting the inputs in the opposite direction of the gradient will decrease the value of the function and go towards a minimum. This is called gradient descent optimization.\n", + "\n", + "To let PyTorch know that we want to compute the gradient with respect to a certain tensor, we need to set the requires_grad flag. Let’s take a look at what happens when we do this and perform operations on the tensor to calculate: y = g * x." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Y776wDTB84hp", + "outputId": "3017ecf8-80c2-4d7c-df9c-38e31d348fcf" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "g: tensor(0.8000, requires_grad=True)\n", + "x: tensor(0.1000, requires_grad=True)\n", + "y: tensor(0.0800, grad_fn=)\n", + "dy/dx evaluated at g=0.8: 0.8\n", + "\n", + "This makes sense as the derivative of our function g * x with respect to x equals to g\n" + ] + } + ], + "source": [ + "#We initalise the input at a random value\n", + "x = torch.tensor(0.1, requires_grad=True)\n", + "\n", + "#We intialise g at a random value\n", + "g = torch.tensor(0.8, requires_grad=True)\n", + "\n", + "#We define the function we want to optimise\n", + "y = g * x\n", + "\n", + "#We see that every tensor now carries an attribute grad_fn that describes how to compute the gradient of the operation that it resulted from.\n", + "print(\"g:\", g)\n", + "print(\"x:\", x)\n", + "print(\"y:\", y)\n", + "\n", + "# In the backward pass, this graph is used to compute the gradient of the final output with respect to the initial inputs.\n", + "# The backward pass can be triggered by calling the backward() method on the final output.\n", + "y.backward()\n", + "print(\"dy/dx evaluated at g=0.8:\", x.grad.numpy())\n", + "\n", + "print(\"\\nThis makes sense as the derivative of our function g * x with respect to x equals to g\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "VTEFV7la84hp" + }, + "source": [ + "Lets look at a more \"complicated\" example, with function:\n", + "\n", + "$\\begin{aligned} z = sin((w + 1)^3) \\end{aligned}$.\n", + "\n", + "We can either split the function into sub-computations - using the chain rule from calculus we can calculate the gradient of the final output with respect to the input by decomposing it into a product of gradients from the sub-computations:\n", + "\n", + "$\\dfrac{dz}{dw} = \\dfrac{dz}{dy} \\cdot \\dfrac{dy}{dx} \\cdot \\dfrac{dx}{dw}$\n", + "\n", + "Or, we can do it directly on the function." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Bfvki-hI84hp", + "outputId": "08656d23-f218-4e17-96f9-3bea1e7b0599" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dz/dw evaluated at w=1: tensor(-1.7460)\n", + "dz/dw evaluated at w=1: tensor(-1.7460)\n" + ] + } + ], + "source": [ + "#sub computations\n", + "w = torch.tensor(1., requires_grad=True)\n", + "x = w + 1\n", + "y = x ** 3\n", + "z = torch.sin(y)\n", + "z.backward()\n", + "print(\"dz/dw evaluated at w=1:\", w.grad)\n", + "\n", + "#directly\n", + "w = torch.tensor(1., requires_grad=True)\n", + "z = torch.sin(torch.pow((w+1),3))\n", + "z.backward()\n", + "print(\"dz/dw evaluated at w=1:\", w.grad)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3B3JPHv184hp" + }, + "source": [ + "This is the essence of auto-differentiation. In the forward pass, PyTorch builds a computational graph of operations that know how to compute their gradients locally (as done in the sub-computations). In the backward pass, this graph is used to compute the gradient of the final output with respect to the initial inputs" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GVARaKjP84hp" + }, + "source": [ + "# Optimizers\n", + "\n", + "Now that we know how to compute gradients, we can use them to find the parameters that minimize some objective function. In the most basic version of gradient descent, we update our estimate of parameters of a function according to the following rule:\n", + "\n", + "$x \\leftarrow x - \\lambda \\nabla_x f(x)$\n", + "\n", + "Where x is the parameter we want to update, $\\nabla_x f(x)$ is the gradient of the function $f$ with respect to x, and $\\lambda$ is a small scalar defining how much we want to update our parameter based on the gradient (often very small, as we do want to overshoot). $\\lambda$ is also called the \"learning rate\".\n", + "\n", + "The function above is called Stochastic Gradient Descent (SGD), whereas the update itself is called a \"step\". **SGD** and **step** are automatically implemented in PyTorch.\n", + "\n", + "*As seen earlier, the gradient points into the direction of steepest ascent (increase), so we need to subtract it from $x$ to move in the direction of steepest descent (decrease), i.e. towards the minimum of $f$ (remember that the minimum is where the loss is 0 i.e. where the processed input is similar to the target).*\n", + "\n", + "#### **Let's look at a simple example of finding the minimum of a function.**\n", + "We use the function $f(x) = x^2 - 4x + 2x - 1$\n", + "\n", + "Analytically we can find the minimum of $f(x)$ by taking its derivative, setting it to zero and solving for x:\n", + "- $\\frac{dy}{dx} = 2x - 4 + 2$\n", + "- $0 = 2x - 4 + 2 \\rightarrow x = 1$\n", + "\n", + "Let’s try to find the same minimum using gradient descent and automatic differentiation. More specifically we update the parameters based on the gradient of x with respect to y iteratively. As a default value we choose 500 iterations (we can also experiment with different learning rates and see how it affects the updated parameter)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "DrbEahdK84hp", + "outputId": "2576a1c8-42eb-4701-8aa1-894250a02dc6" + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAErCAYAAAAMkYNBAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAx7ElEQVR4nO3de1xUdf4/8NcMMAMoDKBcdRDMCyKKd0TLK2nqWrb7LTNX0cy+ttqG6LraVmpbYd+2Vk3T/JVaaXlJszS1FAVXMy8oKl4wCQVZBgSE4SIDzHx+f6AnR0AZneEw8no+HufRnM/nc2be89Gc1+PM55xRCCEEiIiIiGSilLsAIiIiatoYRoiIiEhWDCNEREQkK4YRIiIikhXDCBEREcmKYYSIiIhkxTBCREREsmIYISIiIlkxjBAREZGsGEaIiIhIVnYTRuLi4tC7d2+4ubnBx8cHY8aMQWpq6j2P27x5M0JCQuDs7IwuXbpg586dDVAtERER1ZfdhJHExERMnz4dv/zyC/bs2YPKykoMGzYMpaWldR7z888/Y9y4cZgyZQpOnjyJMWPGYMyYMUhJSWnAyomIiOhuFPb6Q3nXrl2Dj48PEhMTMWDAgFrHjB07FqWlpdixY4fU1rdvX3Tr1g0rV65sqFKJiIjoLhzlLuB+FRUVAQC8vLzqHHP48GHExsaatQ0fPhzbtm2r8xiDwQCDwSDtm0wmFBQUoEWLFlAoFA9WNBERURMihEBxcTECAgKgVNb9ZYxdhhGTyYSYmBj0798fYWFhdY7T6XTw9fU1a/P19YVOp6vzmLi4OCxcuNBqtRIRETV1mZmZaN26dZ39dhlGpk+fjpSUFBw8eNDqzz1v3jyzsylFRUUIDAxEZmYm3N3drf56REREDyu9Xg+tVgs3N7e7jrO7MDJjxgzs2LEDBw4cuGvKAgA/Pz/k5OSYteXk5MDPz6/OY9RqNdRqdY12d3d3hhEiIqL7cK9lDnZzNY0QAjNmzMC3336Lffv2ITg4+J7HREZGIj4+3qxtz549iIyMtFWZREREZCG7OTMyffp0fPXVV/juu+/g5uYmrfvQaDRwcXEBAEycOBGtWrVCXFwcAODVV1/FwIED8cEHH2DUqFHYsGEDjh8/jlWrVsn2PoiIiMic3ZwZWbFiBYqKijBo0CD4+/tL28aNG6UxGRkZyM7Olvb79euHr776CqtWrUJ4eDi++eYbbNu27a6LXomIiKhh2e19RhqKXq+HRqNBUVER14wQERFZoL6foXZzZoSIiIgeTgwjREREJCuGESIiIpIVwwgRERHJimGEiIiIZMUwQkRERLJiGCEiIiJZMYwQERGRrBhGiIiISFYMI0RERCQrhhEiIiKSFcMIERERyYphhIiIiGTFMEJERESyYhghIiIiWTGMEBERkawYRoiIiEhWDCNEREQkK4YRIiIikhXDCBEREcmKYYSIiIhkxTBCREREsmIYISIiIlkxjBAREZGsGEaIiIhIVgwjREREJCuGESIiIpIVwwgRERHJimGEiIiIZMUwQkRERLJiGCEiIiJZMYwQERGRrBhGiIiISFYMI0RERCQrhhEiIiKSlV2FkQMHDmD06NEICAiAQqHAtm3b7jo+ISEBCoWixqbT6RqmYCIiIronuwojpaWlCA8Px/Llyy06LjU1FdnZ2dLm4+NjowqJiIjIUo5yF2CJESNGYMSIERYf5+PjAw8PD+sXRERERA/Mrs6M3K9u3brB398fjz/+OA4dOnTXsQaDAXq93mwjIiIi23mow4i/vz9WrlyJLVu2YMuWLdBqtRg0aBBOnDhR5zFxcXHQaDTSptVqG7BiIiKipkchhBByF3E/FAoFvv32W4wZM8ai4wYOHIjAwEB8+eWXtfYbDAYYDAZpX6/XQ6vVoqioCO7u7g9SMhERUZOi1+uh0Wju+RlqV2tGrKFPnz44ePBgnf1qtRpqtboBKyIiImraHuqvaWqTnJwMf39/ucsgIiKim+zqzEhJSQkuXbok7aenpyM5ORleXl4IDAzEvHnzkJWVhS+++AIAsHjxYgQHB6Nz584oLy/Hp59+in379uGnn36S6y0QERHRHewqjBw/fhyDBw+W9mNjYwEA0dHRWLt2LbKzs5GRkSH1V1RUYNasWcjKyoKrqyu6du2KvXv3mj0HERERyctuF7A2lPouviEiIiJz9f0MbXJrRoiIiKhxYRghIiIiWTGMEBERkawYRoiIiEhWDCNEREQkK4YRIiIikhXDCBEREcmKYYSIiIhkxTBCREREsmIYISIiIlkxjBAREZGsGEaIiIhIVgwjREREJCuGESIiIpIVwwgRERHJimGEiIiIZMUwQkRERLJiGCEiIiJZWRxGysvL6+zLzs5+oGKIiIio6bE4jPTo0QPJyck12rds2YKuXbtaoyYiIiJqQiwOI4MGDULfvn3x3nvvAQBKS0sxadIkTJgwAa+99prVCyQiIqKHm6OlB3z88ccYNWoUXnzxRezYsQPZ2dlo3rw5jh49irCwMFvUSERERA8xi8MIAIwYMQJ//OMfsWLFCjg6OmL79u0MIkRERHRfLP6aJi0tDZGRkdixYwd+/PFHzJkzB08++STmzJmDyspKW9RIREREDzGLw0i3bt0QHByMU6dO4fHHH8fbb7+N/fv3Y+vWrejTp48taiQiIqKHmMVh5OOPP8aGDRvg4eEhtfXr1w8nT55Ejx49rFkbERERNQEKIYSQu4jGTK/XQ6PRoKioCO7u7nKXQ0REZDfq+xnKO7ASERGRrBhGiIiISFYMI0RERCSreoWRpUuXSr9Jk5GRAS4zISIiImupVxiJjY2FXq8HAAQHB+PatWs2LYqIiIiajnrdgTUgIABbtmzByJEjIYTA1atX6/z13sDAQKsWSERERA+3el3au2rVKrzyyiuoqqqqc4wQAgqFAkaj0aoFyo2X9hIREd2f+n6G1vs+I8XFxbhy5Qq6du2KvXv3okWLFrWOCw8Pv7+KGymGESIiovtj9fuMuLm5ISwsDGvWrEH//v0RHh5e62ZLBw4cwOjRoxEQEACFQoFt27bd85iEhAT06NEDarUa7dq1w9q1a21aIxEREVnG4kt7o6OjoVarkZSUhHXr1mHdunU4ceKELWqrobS0FOHh4Vi+fHm9xqenp2PUqFEYPHgwkpOTERMTgxdffBE//vijjSslIiKi+qrXAtbb5ebm4rnnnkNCQoL0+zSFhYUYPHgwNmzYAG9vb2vXKBkxYgRGjBhR7/ErV65EcHAwPvjgAwBAp06dcPDgQfz73//G8OHDbVUmERERWcDiMPLKK6+guLgYZ8+eRadOnQAA586dQ3R0NP7617/i66+/tnqR9+vw4cOIiooyaxs+fDhiYmLqPMZgMMBgMEj7ty5pJiLrEkLAaBKourUZTag0VrdVGk03+2q2SfsmE6qMAsbbxhhNAiZxawOMJiG9jkmgjr7b26v3aztG2r/5GkYhIKT+6mMEAAhAoLpP3P4Y1fsw2xdS+619wPw4k/h9PGo8n/nxMNu/vQbz55b+DGC+ZPDOFYR3Lii8c4lhjQWHdzn+XsfWfO171HaX1Y5Wf627vm7D3HeroW7vNaijDz54tuHXflocRnbv3o29e/dKQQQAQkNDsXz5cgwbNsyqxT0onU4HX19fszZfX1/o9XrcuHEDLi4uNY6Ji4vDwoULG6pEIlkJIWCoMuFGhRFllUbcqKjCjQoTyiqqUFZpRHmFEWU3+8orjDBUGVFRZYLBaIKh0oQKo6l6v8qEilt9VdVt5n3V/zVUGVFprA4RVSbePJGosSkur5TldS0OIyaTCU5OTjXanZycYDKZrFKUnObNm4fY2FhpX6/XQ6vVylgRUU1CCJRVGHG9rALF5VU3t0qUGKqgv/lYapP6q6Avr0RpRRVuVBirt0ojGlsmcFQq4OiggJNSCQcHBRyVyt/bHJRwUCqk/dv7HJVKKJUKKBWAg0IBhUIBByWgVChutivgoLh9H3BQVo8zP6Z6//dj7thXKqC4+TzVxwAKhQIKoPoxbu7ffAyzPsVtY24/7rYxt43DnX1mx9/x+I7jUVvfbcdLzHZuHnv7fo3+O/YV9R9/Z9+dz2bxa9Xov73v7s9doxIL5uFeY23lXu/BGpqpLY4FVmHxqw4ZMgSvvvoqvv76awQEBAAAsrKyMHPmTAwdOtTqBT4IPz8/5OTkmLXl5OTA3d291rMiAKBWq6FWqxuiPCKJ0SRQUFqB3OJyXCs24HpZBa6XVuJ6WQUKSitQWFaJgtKK6vabfRVG64Z/lYMSLioHuKoc4OLkID12dvq9zdnJASpHJVQOSqidlFA53Nx3VEJ9239vPVY5ONwc93ufk0P1Vh0gFHB0uBkolAopHBBR02JxGFm2bBmefPJJBAUFSWcMMjMzERYWhnXr1lm9wAcRGRmJnTt3mrXt2bMHkZGRMlVETZG+vBJZ128g6/oNZOvLcU1fjtxiw82tHLl6A/JLK2C8j1MUKgcl3F0c4ebsBDdnRzRXO8LN+fd9N/Vtj52d0PzmmFvhwlVVHTpcnBzg6MDfzSQieVgcRrRaLU6cOIG9e/fiwoULAKqvUrlzoagtlJSU4NKlS9J+eno6kpOT4eXlhcDAQMybNw9ZWVn44osvAADTpk3DsmXLMGfOHLzwwgvYt28fNm3ahB9++MHmtVLTUWqoQnpeKa7kl+Hq9TJkFd7Afwtv4Or1G8gqvIHi8rrvXHw7hQJo0UwNbzc1WjRTwcPVCV7NVPB0VcHT1QmeNx973dbn4uTAMwlEZPfqfQfWxiAhIQGDBw+u0R4dHY21a9di0qRJuHz5MhISEsyOmTlzJs6dO4fWrVvjjTfewKRJk+r9mrwDKwFAldGEy/mluJRbisv5pUi/Vor0/FJczitFbrHhnsd7ujqhlacL/DUu8HFTw8fNGT7uarPHLZqpeHaCiB4qVr8dfFPFMNK0CCGg05fjgq4Yqbdtl66VoKKq7jUaXs1UCGrhikAvVwR4uKCVpwtaebig9c0AIteiMCIiOdX3M5T/QlKTJYRAdlE5Tl8txKmrRTiVWYiUrCLo6/haxVXlgEe8m6OtdzMEtWiG4JbVW1DLZtC41LzCjIiI6odhhJqM8kojTmYU4tjlApzKrA4geSU1v2JxUCrQtmUzdPBzQ4ivGzr6uSHEzx2tPV2gVHJ9BhGRtTGM0ENLX16JpCvXcTS9AEfTC3D6aiEqjebfSjooFejo64ZwrQZdW3ugSysN2vs2h9rRQaaqiYianvsKI2lpaVizZg3S0tKwZMkS+Pj4YNeuXQgMDETnzp2tXSNRvRhNAqevFuLAxTwc+PUaTmZcr3FDL193NfoEt0B3rQfCtR7oHOAOZycGDyIiOVkcRhITEzFixAj0798fBw4cwDvvvAMfHx+cOnUKn332Gb755htb1ElUq+ulFdh7PgeJF6/h4KU8FJaZ38o4qIUr+gR7oXeQFyKCW0Dr5cJLYYmIGhmLw8jcuXPx9ttvIzY2Fm5ublL7kCFDsGzZMqsWR1QbXVE5fjqnw+4UHY6kF5jdLMzN2RGPtmuJAR28MaCDN1p51H6nXSIiajwsDiNnzpzBV199VaPdx8cHeXl5VimK6E66onJ8fyoLu1J0OJlRaNYX6u+OqE4+GNDBG920HrxXBxGRnbE4jHh4eCA7OxvBwcFm7SdPnkSrVq2sVhhRqaEKP57VYeuJLBxKyzP7Ce2ebTzxRGc/DO/sh8AWrvIVSURED8ziMPLcc8/h73//OzZv3gyFQgGTyYRDhw5h9uzZmDhxoi1qpCZECIETGdex/kgGdqfoUFZhlPp6B3niyfAADOvsB193ZxmrJCIia7I4jLz77ruYPn06tFotjEYjQkNDYTQa8fzzz+P111+3RY3UBJQaqrAtOQvrfsnA+Wy91B7UwhVPd2+Np7u34hkQIqKH1H3fDj4zMxNnzpxBSUkJunfvjvbt21u7tkaBt4O3rSv5pVh9MB1bTmShxFB951O1oxJPhgfguT6B6BHowatfiIjslM1uB//WW29h9uzZ0Gq10Gq1UvuNGzfw/vvv480337y/iqlJSckqworENOw6ky3dCyS4ZTOMjwjE//RsDQ9XlbwFEhFRg7H4zIiDgwOys7Ph4+Nj1p6fnw8fHx8YjcY6jrRPPDNiPUII/JyWjxUJaTh46fcrrwZ19MaUR4PR/5GWvN06EdFDxGZnRoQQtZ42P3XqFLy8vCx9OmoijvyWj3/9lIpjl68DqL4N++iu/vjfgY+gkz9DHhFRU1bvMOLp6QmFQgGFQoEOHTqYBRKj0YiSkhJMmzbNJkWS/Tp9tRDv/5iK//xafSZE5ajEuN5avPhYW2i9uCCViIgsCCOLFy+GEAIvvPACFi5cCI1GI/WpVCoEBQUhMjLSJkWS/bl6vQxxuy7gh9PZAABHpQJje2vxypD28NPwslwiIvpdvcNIdHQ0ACA4OBj9+vWDk5OTzYoi+1VWUYUVCWlYdeA3GKpMUCiAp7u3QszQDrw0l4iIamXxmpGBAwdKj8vLy1FRUWHWz0WeTZMQAt+f+i/idl6ATl8OAOjb1gtv/qEzQgP4d4KIiOpmcRgpKyvDnDlzsGnTJuTn59fof9iupqF7yywow+vbUpB48RoAQOvlgn+M7IThnf14jxAiIroni8PI3/72N+zfvx8rVqzAhAkTsHz5cmRlZeGTTz7BokWLbFEjNVJVRhPW/nwZH/x0ETcqjVA5KDFjSDu8NKAtnJ0c5C6PiIjshMVhZPv27fjiiy8waNAgTJ48GY899hjatWuHNm3aYP369Rg/frwt6qRG5lJuCWI3JeP01SIAQESwF979Yxc84t1c5sqIiMjeWBxGCgoK0LZtWwDV60MKCgoAAI8++ihefvll61ZHjY4QAut+uYJ3dp5HeaUJ7s6OeG1kJzzbS8sblhER0X2xOIy0bdsW6enpCAwMREhICDZt2oQ+ffpg+/bt8PDwsEGJ1FjkFpdjzjenkZBavTbksfYt8a9nwvkLukRE9EAsDiOTJ0/GqVOnMHDgQMydOxejR4/GsmXLUFlZiQ8//NAWNVIjcODiNcRsTEZBaQVUjkrMGxGC6Mggng0hIqIHdt+/2nvLlStXkJSUhHbt2qFr167WqqvRaOq/TWMyCSzffwkf7r0IIYAQPzcsea47Ovq5yV0aERE1cjb7bZo7tWnTBm3atHnQp6FGqOhGJWI3JiP+Qi4AYFwfLeaP7swrZYiIyKruK4wcO3YM+/fvR25uLkwmk1kfv6p5OFzQ6fG/XybhSn4ZVI5KvP1UGJ7trZW7LCIieghZHEbeffddvP766+jYsSN8fX3NbmrFG1w9HBIvXsP09SdQYqhCa08XrPxzT4S10tz7QCIiovtgcRhZsmQJVq9ejUmTJtmgHJLb+iNX8OZ3Z2E0CfRt64UV43vCs5lK7rKIiOghZnEYUSqV6N+/vy1qIRmZTALv7b6ATw78BgD4Y49WWPTHrlA5KmWujIiIHnYWf9LMnDkTy5cvt0UtJJOKKhNe2XBSCiIzozrgg2fCGUSIiKhBWHxmZPbs2Rg1ahQeeeQRhIaGwsnJyax/69atViuObO9GhREvr09CQuo1ODko8H//0xVPd28td1lERNSEWBxG/vrXv2L//v0YPHgwWrRowUWrdqy4vBJTPj+Oo+kFcHZSYtWEXhjQwVvusoiIqImxOIx8/vnn2LJlC0aNGmWLeqiBFJVVYsLqIzh9tQhuakesntwbvYO85C6LiIiaIIvDiJeXFx555BFb1EINRF/+exDxaqbCFy/04aW7REQkG4tXKC5YsADz589HWVmZLeohGysur0T06qNSEPl6al8GESIikpXFYWTp0qXYtWsXfH190aVLF/To0cNss7Xly5cjKCgIzs7OiIiIwNGjR+scu3btWigUCrPN2bnp/sJsqaEKL6w9hpMZhdC4OGHdlAj+xgwREcnO4q9pxowZY4My6mfjxo2IjY3FypUrERERgcWLF2P48OFITU2Fj49Prce4u7sjNTVV2m+qC24rqkyYti4Jxy5fh5uzI9ZNiUBoQNP74T8iImp8HvhXextSREQEevfujWXLlgEATCYTtFotXnnlFcydO7fG+LVr1yImJgaFhYX1fg2DwQCDwSDt6/V6aLVau/7VXpNJIGZjMr4/9V+4qhyw/sUIdA/0lLssIiJ6yNX3V3vt5q5WFRUVSEpKQlRUlNSmVCoRFRWFw4cP13lcSUkJ2rRpA61Wi6eeegpnz5696+vExcVBo9FIm1Zr3z8OJ4TAOzvP4/tT/4WjUoGVf+7JIEJERI1KvcKIl5cX8vLyAACenp7w8vKqc7OVvLw8GI1G+Pr6mrX7+vpCp9PVekzHjh2xevVqfPfdd1i3bh1MJhP69euHq1ev1vk68+bNQ1FRkbRlZmZa9X00tP/3n9/w2cF0AMC/ngnnfUSIiKjRqdeakX//+99wc3OTHtvLuovIyEhERkZK+/369UOnTp3wySef4J///Getx6jVaqjV6oYq0aZ2p2Tj3Z0XAAD/GNkJY7q3krkiIiKimuoVRqKjo6XHcv1ab8uWLeHg4ICcnByz9pycHPj5+dXrOZycnNC9e3dcunTJFiU2KilZRZi58RQAYFK/IEwd0FbmioiIiGpn8ZoRBwcH5Obm1mjPz8+Hg4ODVYqqjUqlQs+ePREfHy+1mUwmxMfHm539uBuj0YgzZ87A39/fVmU2CrnF5Zj6xXHcqDTisfYt8fqoTnKXREREVCeLL+2t6+Ibg8EAlUr1wAXdTWxsLKKjo9GrVy/06dMHixcvRmlpKSZPngwAmDhxIlq1aoW4uDgAwFtvvYW+ffuiXbt2KCwsxPvvv48rV67gxRdftGmdciqvNOJ/v0xCdlE52no3w7Lne8DRwW7WKRMRURNU7zCydOlSANX36fj000/RvHlzqc9oNOLAgQMICQmxfoW3GTt2LK5du4Y333wTOp0O3bp1w+7du6VFrRkZGVAqf//gvX79OqZOnQqdTgdPT0/07NkTP//8M0JDQ21ap5wWbj8r3dTss+je0Lg43fsgIiIiGdX7PiPBwcEAgCtXrqB169ZmX8moVCoEBQXhrbfeQkREhG0qlUl9r5FuDL5JuorZm09BoQA+n9yHV84QEZGs6vsZWu8zI+np1ZeHDh48GFu3boWnJ+9V0Zicz9bj9W1nAAAxQzswiBARkd2weDHB/v37zYKI0WhEcnIyrl+/btXCqP6Kyyvxl/UnUF5pwoAO3nhlSDu5SyIiIqo3i8NITEwMPvvsMwDVQWTAgAHo0aMHtFotEhISrF0f3YMQAnO3nkF6XikCNM5YPLYblEr7uA8MERERcB9hZPPmzQgPDwcAbN++HZcvX8aFCxcwc+ZM/OMf/7B6gXR33yRdxQ+ns+GoVGDZ+B7wambbK5qIiIiszeIwkp+fL91kbOfOnXjmmWfQoUMHvPDCCzhz5ozVC6S6XckvxYLvq39rZ+bjHdCDvzlDRER2yOIw4uvri3PnzsFoNGL37t14/PHHAQBlZWU2vekZmasymjBzYzJKK4zoE+SFaQMfkbskIiKi+2LxTc8mT56MZ599Fv7+/lAoFNKv6B45csTm9xmh3y3bfwknMgrh5uyID8eGw4HrRIiIyE5ZHEYWLFiAsLAwZGZm4plnnpF+VM7BwQFz5861eoFU0+mrhfhoX/Xv67w9JgytPV1lroiIiOj+1fumZ01VY7vpWUWVCU8uO4gLumL8oas/lj3fQ+6SiIiIalXfz9B6rxkZOXIkioqKpP1FixahsLBQ2s/Pz3+ob7PeWKxISMMFXTG8mqmw8MnOcpdDRET0wOodRn788UcYDAZp/91330VBQYG0X1VVhdTUVOtWR2ZSdcVYtv9XAMCCJzujRXO1zBURERE9uHqHkTu/zeG3Ow3LaBKYs+U0Ko0CUZ18Mbqrv9wlERERWQV/W95OrDmUjlOZ1VfPvPN0GBQKXj1DREQPh3qHEYVCUeMDkB+IDSNHX45/77kIAHhtZCf4ujvLXBEREZH11PvSXiEEJk2aJF3KW15ejmnTpqFZs2YAYLaehKzrnR/Oo7TCiO6BHhjbSyt3OURERFZV7zASHR1ttv/nP/+5xpiJEyc+eEVk5udLefj+1H+hVAD/fCqMP4JHREQPnXqHkTVr1tiyDqpFRZUJb9787Zk/922DsFYamSsiIiKyPi5gbcTWHErHpdwStGimwqxhHeUuh4iIyCYYRhqp3OJyLI2vvqfIvJGdoHFxkrkiIiIi22AYaaQW7/0VpRVGhGs98MfureQuh4iIyGYYRhqhiznF2HA0AwDw+qhOXLRKREQPNYaRRihu53mYBPBEZz/0DvKSuxwiIiKbYhhpZA7+mof9qdfgqFTg7yNC5C6HiIjI5hhGGhGjSeCdnecBABMi2yC4ZTOZKyIiIrI9hpFG5PtTWTifrYebsyP+OqS93OUQERE1CIaRRqLSaMLivdWX8r486BF4NlPJXBEREVHDYBhpJLaeuIor+WVo0UyF6MggucshIiJqMAwjjUBFlQlL4y8BqD4r0kxd77v0ExER2T2GkUZg4/FMZBXegI+bGn/u20bucoiIiBoUw4jMyiuNWLaveq3IjCHt4OzkIHNFREREDYthRGbrj2QgR29AgMYZY3tr5S6HiIiowTGMyMhQZcQniWkAgBlD2kPtyLMiRETU9DCMyGhLUhZyiw3w1zjjf3q2lrscIiIiWTCMyKTKaMInB6rPirz4WFuoHPlHQURETRM/AWWyK0WHK/ll8HR1wrg+XCtCRERNl92FkeXLlyMoKAjOzs6IiIjA0aNH7zp+8+bNCAkJgbOzM7p06YKdO3c2UKV1E0Lg44TqsyKT+gXDVcX7ihARUdNlV2Fk48aNiI2Nxfz583HixAmEh4dj+PDhyM3NrXX8zz//jHHjxmHKlCk4efIkxowZgzFjxiAlJaWBKzeXcPEazmfr4apyQHQ/3leEiIiaNoUQQshdRH1FRESgd+/eWLZsGQDAZDJBq9XilVdewdy5c2uMHzt2LEpLS7Fjxw6prW/fvujWrRtWrlxZr9fU6/XQaDQoKiqCu7u7Vd7HsysP4+jlArz4aDBe/0OoVZ6TiIiosanvZ6jdnBmpqKhAUlISoqKipDalUomoqCgcPny41mMOHz5sNh4Ahg8fXud4ADAYDNDr9WabNR2/XICjlwvg5KDAi4+1tepzExER2SO7CSN5eXkwGo3w9fU1a/f19YVOp6v1GJ1OZ9F4AIiLi4NGo5E2rda6i0vb+7ph9rAOmPJoW/hpnK363ERERPbIbsJIQ5k3bx6KioqkLTMz06rPr3Fxwowh7TF3RIhVn5eIiMhe2c1lHC1btoSDgwNycnLM2nNycuDn51frMX5+fhaNBwC1Wg21Wv3gBRMREVG92M2ZEZVKhZ49eyI+Pl5qM5lMiI+PR2RkZK3HREZGmo0HgD179tQ5noiIiBqe3ZwZAYDY2FhER0ejV69e6NOnDxYvXozS0lJMnjwZADBx4kS0atUKcXFxAIBXX30VAwcOxAcffIBRo0Zhw4YNOH78OFatWiXn2yAiIqLb2FUYGTt2LK5du4Y333wTOp0O3bp1w+7du6VFqhkZGVAqfz/Z069fP3z11Vd4/fXX8dprr6F9+/bYtm0bwsLC5HoLREREdAe7us+IHGxxnxEiIqKm4KG7zwgRERE9nBhGiIiISFYMI0RERCQrhhEiIiKSFcMIERERyYphhIiIiGTFMEJERESyYhghIiIiWTGMEBERkawYRoiIiEhWDCNEREQkK4YRIiIikhXDCBEREcmKYYSIiIhkxTBCREREsmIYISIiIlkxjBAREZGsGEaIiIhIVgwjREREJCuGESIiIpIVwwgRERHJimGEiIiIZMUwQkRERLJiGCEiIiJZMYwQERGRrBhGiIiISFYMI0RERCQrhhEiIiKSFcMIERERyYphhIiIiGTFMEJERESyYhghIiIiWTGMEBERkawYRoiIiEhWDCNEREQkK7sJIwUFBRg/fjzc3d3h4eGBKVOmoKSk5K7HDBo0CAqFwmybNm1aA1VMRERE9eEodwH1NX78eGRnZ2PPnj2orKzE5MmT8dJLL+Grr76663FTp07FW2+9Je27urraulQiIiKygF2EkfPnz2P37t04duwYevXqBQD46KOPMHLkSPzrX/9CQEBAnce6urrCz8+voUolIiIiC9lFGDl8+DA8PDykIAIAUVFRUCqVOHLkCJ5++uk6j12/fj3WrVsHPz8/jB49Gm+88cZdz44YDAYYDAZpv6ioCACg1+ut8E6IiIiajlufnUKIu46zizCi0+ng4+Nj1ubo6AgvLy/odLo6j3v++efRpk0bBAQE4PTp0/j73/+O1NRUbN26tc5j4uLisHDhwhrtWq32/t8AERFRE1ZcXAyNRlNnv6xhZO7cuXjvvffuOub8+fP3/fwvvfSS9LhLly7w9/fH0KFDkZaWhkceeaTWY+bNm4fY2Fhp32QyoaCgAC1atIBCobjvWm6n1+uh1WqRmZkJd3d3qzxnU8c5tS7Op/VxTq2Pc2pdtphPIQSKi4vvupwCkDmMzJo1C5MmTbrrmLZt28LPzw+5ublm7VVVVSgoKLBoPUhERAQA4NKlS3WGEbVaDbVabdbm4eFR79ewhLu7O/8HsjLOqXVxPq2Pc2p9nFPrsvZ83u2MyC2yhhFvb294e3vfc1xkZCQKCwuRlJSEnj17AgD27dsHk8kkBYz6SE5OBgD4+/vfV71ERERkfXZxn5FOnTrhiSeewNSpU3H06FEcOnQIM2bMwHPPPSed+snKykJISAiOHj0KAEhLS8M///lPJCUl4fLly/j+++8xceJEDBgwAF27dpXz7RAREdFt7CKMANVXxYSEhGDo0KEYOXIkHn30UaxatUrqr6ysRGpqKsrKygAAKpUKe/fuxbBhwxASEoJZs2bhT3/6E7Zv3y7XW5Co1WrMnz+/xtdBdP84p9bF+bQ+zqn1cU6tS875VIh7XW9DREREZEN2c2aEiIiIHk4MI0RERCQrhhEiIiKSFcMIERERyYphpIEtX74cQUFBcHZ2RkREhHQpMtV04MABjB49GgEBAVAoFNi2bZtZvxACb775Jvz9/eHi4oKoqCj8+uuvZmMKCgowfvx4uLu7w8PDA1OmTEFJSUkDvovGIy4uDr1794abmxt8fHwwZswYpKammo0pLy/H9OnT0aJFCzRv3hx/+tOfkJOTYzYmIyMDo0aNgqurK3x8fPC3v/0NVVVVDflWGo0VK1aga9eu0k2iIiMjsWvXLqmf8/lgFi1aBIVCgZiYGKmNc2qZBQsWQKFQmG0hISFSf6OZT0ENZsOGDUKlUonVq1eLs2fPiqlTpwoPDw+Rk5Mjd2mN0s6dO8U//vEPsXXrVgFAfPvtt2b9ixYtEhqNRmzbtk2cOnVKPPnkkyI4OFjcuHFDGvPEE0+I8PBw8csvv4j//Oc/ol27dmLcuHEN/E4ah+HDh4s1a9aIlJQUkZycLEaOHCkCAwNFSUmJNGbatGlCq9WK+Ph4cfz4cdG3b1/Rr18/qb+qqkqEhYWJqKgocfLkSbFz507RsmVLMW/ePDnekuy+//578cMPP4iLFy+K1NRU8dprrwknJyeRkpIihOB8PoijR4+KoKAg0bVrV/Hqq69K7ZxTy8yfP1907txZZGdnS9u1a9ek/sYynwwjDahPnz5i+vTp0r7RaBQBAQEiLi5Oxqrsw51hxGQyCT8/P/H+++9LbYWFhUKtVouvv/5aCCHEuXPnBABx7NgxacyuXbuEQqEQWVlZDVZ7Y5WbmysAiMTERCFE9fw5OTmJzZs3S2POnz8vAIjDhw8LIaoDolKpFDqdThqzYsUK4e7uLgwGQ8O+gUbK09NTfPrpp5zPB1BcXCzat28v9uzZIwYOHCiFEc6p5ebPny/Cw8Nr7WtM88mvaRpIRUUFkpKSEBUVJbUplUpERUXh8OHDMlZmn9LT06HT6czmU6PRICIiQprPw4cPw8PDA7169ZLGREVFQalU4siRIw1ec2NTVFQEAPDy8gIAJCUlobKy0mxOQ0JCEBgYaDanXbp0ga+vrzRm+PDh0Ov1OHv2bANW3/gYjUZs2LABpaWliIyM5Hw+gOnTp2PUqFFmcwfw7+j9+vXXXxEQEIC2bdti/PjxyMjIANC45lPW36ZpSvLy8mA0Gs3+QAHA19cXFy5ckKkq+6XT6QCg1vm81afT6eDj42PW7+joCC8vL2lMU2UymRATE4P+/fsjLCwMQPV8qVSqGj8Meeec1jbnt/qaojNnziAyMhLl5eVo3rw5vv32W4SGhiI5OZnzeR82bNiAEydO4NixYzX6+HfUchEREVi7di06duyI7OxsLFy4EI899hhSUlIa1XwyjBA1QdOnT0dKSgoOHjwodyl2r2PHjkhOTkZRURG++eYbREdHIzExUe6y7FJmZiZeffVV7NmzB87OznKX81AYMWKE9Lhr166IiIhAmzZtsGnTJri4uMhYmTl+TdNAWrZsCQcHhxqrlHNycuDn5ydTVfbr1pzdbT79/PyQm5tr1l9VVYWCgoImPeczZszAjh07sH//frRu3Vpq9/PzQ0VFBQoLC83G3zmntc35rb6mSKVSoV27dujZsyfi4uIQHh6OJUuWcD7vQ1JSEnJzc9GjRw84OjrC0dERiYmJWLp0KRwdHeHr68s5fUAeHh7o0KEDLl261Kj+jjKMNBCVSoWePXsiPj5eajOZTIiPj0dkZKSMldmn4OBg+Pn5mc2nXq/HkSNHpPmMjIxEYWEhkpKSpDH79u2DyWRCREREg9csNyEEZsyYgW+//Rb79u1DcHCwWX/Pnj3h5ORkNqepqanIyMgwm9MzZ86Yhbw9e/bA3d0doaGhDfNGGjmTyQSDwcD5vA9Dhw7FmTNnkJycLG29evXC+PHjpcec0wdTUlKCtLQ0+Pv7N66/o1ZbCkv3tGHDBqFWq8XatWvFuXPnxEsvvSQ8PDzMVinT74qLi8XJkyfFyZMnBQDx4YcfipMnT4orV64IIaov7fXw8BDfffedOH36tHjqqadqvbS3e/fu4siRI+LgwYOiffv2TfbS3pdfflloNBqRkJBgdplfWVmZNGbatGkiMDBQ7Nu3Txw/flxERkaKyMhIqf/WZX7Dhg0TycnJYvfu3cLb27vJXjY5d+5ckZiYKNLT08Xp06fF3LlzhUKhED/99JMQgvNpDbdfTSME59RSs2bNEgkJCSI9PV0cOnRIREVFiZYtW4rc3FwhROOZT4aRBvbRRx+JwMBAoVKpRJ8+fcQvv/wid0mN1v79+wWAGlt0dLQQovry3jfeeEP4+voKtVothg4dKlJTU82eIz8/X4wbN040b95cuLu7i8mTJ4vi4mIZ3o38aptLAGLNmjXSmBs3boi//OUvwtPTU7i6uoqnn35aZGdnmz3P5cuXxYgRI4SLi4to2bKlmDVrlqisrGzgd9M4vPDCC6JNmzZCpVIJb29vMXToUCmICMH5tIY7wwjn1DJjx44V/v7+QqVSiVatWomxY8eKS5cuSf2NZT4VQghhvfMsRERERJbhmhEiIiKSFcMIERERyYphhIiIiGTFMEJERESyYhghIiIiWTGMEBERkawYRoiIiEhWDCNEREQkK4YRInroBQUFYfHixXKXQUR1YBghIquaNGkSxowZAwAYNGgQYmJiGuy1165dCw8Pjxrtx44dw0svvdRgdRCRZRzlLoCI6F4qKiqgUqnu+3hvb28rVkNE1sYzI0RkE5MmTUJiYiKWLFkChUIBhUKBy5cvAwBSUlIwYsQING/eHL6+vpgwYQLy8vKkYwcNGoQZM2YgJiYGLVu2xPDhwwEAH374Ibp06YJmzZpBq9XiL3/5C0pKSgAACQkJmDx5MoqKiqTXW7BgAYCaX9NkZGTgqaeeQvPmzeHu7o5nn30WOTk5Uv+CBQvQrVs3fPnllwgKCoJGo8Fzzz2H4uJi204aURPFMEJENrFkyRJERkZi6tSpyM7ORnZ2NrRaLQoLCzFkyBB0794dx48fx+7du5GTk4Nnn33W7PjPP/8cKpUKhw4dwsqVKwEASqUSS5cuxdmzZ/H5559j3759mDNnDgCgX79+WLx4Mdzd3aXXmz17do26TCYTnnrqKRQUFCAxMRF79uzBb7/9hrFjx5qNS0tLw7Zt27Bjxw7s2LEDiYmJWLRokY1mi6hp49c0RGQTGo0GKpUKrq6u8PPzk9qXLVuG7t27491335XaVq9eDa1Wi4sXL6JDhw4AgPbt2+P//u//zJ7z9vUnQUFBePvttzFt2jR8/PHHUKlU0Gg0UCgUZq93p/j4eJw5cwbp6enQarUAgC+++AKdO3fGsWPH0Lt3bwDVoWXt2rVwc3MDAEyYMAHx8fF45513HmxiiKgGnhkhogZ16tQp7N+/H82bN5e2kJAQANVnI27p2bNnjWP37t2LoUOHolWrVnBzc8OECROQn5+PsrKyer/++fPnodVqpSACAKGhofDw8MD58+eltqCgICmIAIC/vz9yc3Mteq9EVD88M0JEDaqkpASjR4/Ge++9V6PP399fetysWTOzvsuXL+MPf/gDXn75Zbzzzjvw8vLCwYMHMWXKFFRUVMDV1dWqdTo5OZntKxQKmEwmq74GEVVjGCEim1GpVDAajWZtPXr0wJYtWxAUFARHx/r/E5SUlASTyYQPPvgASmX1Sd1Nmzbd8/Xu1KlTJ2RmZiIzM1M6O3Lu3DkUFhYiNDS03vUQkfXwaxoispmgoCAcOXIEly9fRl5eHkwmE6ZPn46CggKMGzcOx44dQ1paGn788UdMnjz5rkGiXbt2qKysxEcffYTffvsNX375pbSw9fbXKykpQXx8PPLy8mr9+iYqKgpdunTB+PHjceLECRw9ehQTJ07EwIED0atXL6vPARHdG8MIEdnM7Nmz4eDggNDQUHh7eyMjIwMBAQE4dOgQjEYjhg0bhi5duiAmJgYeHh7SGY/ahIeH48MPP8R7772HsLAwrF+/HnFxcWZj+vXrh2nTpmHs2LHw9vausQAWqP665bvvvoOnpycGDBiAqKgotG3bFhs3brT6+yei+lEIIYTcRRAREVHTxTMjREREJCuGESIiIpIVwwgRERHJimGEiIiIZMUwQkRERLJiGCEiIiJZMYwQERGRrBhGiIiISFYMI0RERCQrhhEiIiKSFcMIERERyer/A+1/Qsxu27LJAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Initial estimate\n", + "x = torch.tensor(0., requires_grad=True)\n", + "# Initialize optimizer with parameters to be optimized and learning rate \"lambda\"\n", + "optim = torch.optim.SGD([x], lr=0.01)\n", + "# Number of iterations\n", + "n_iter = 500\n", + "\n", + "#create list to track value of x\n", + "xs = []\n", + "#ys = []\n", + "\n", + "# Gradient descent loop\n", + "for i in range(n_iter):\n", + "\n", + " # Logging\n", + " xs.append(x.item())\n", + "\n", + " f = x**2 - 4*x + 2*x - 1 # forward pass\n", + " f.backward() # backward pass\n", + "\n", + " #ys.append(f.item())\n", + "\n", + " optim.step() # perform the gradient descent step\n", + " optim.zero_grad() # reset the gradients\n", + "\n", + "# Plot how the estimate for x converged\n", + "plot_graph('Iteration', 'Estimate of x', [-0.5, 2.0], xs)\n", + "#plot_graph('Iteration', 'Estimate of x', [-3.5, 2.0], ys)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "D7CX7Imr84hp" + }, + "source": [ + "We clearly see that through differentation and and automatic update, we approximate the value of x that gives us the minimum of our function $f(x)$.\n", + "\n", + "Now we will start to implement this in an actual-example. Please note that we now will start to compare the processed output towards a target using a specific loss function. This means that we are trying to optimize the loss function and not the DSP function. However, the DSP function still needs to be differentiable simply because this allows us to retrieve and track gradients as well as update the parameters in the backward() call. ####\n", + "\n", + "All loss-functions provided in PyTorch are differentiable too.\n", + "\n", + "Lets take the learned components and combine them to create a differentiable linear gain model that can predict the gain value for a specific input output pair." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Lotl1nX984hp" + }, + "source": [ + "### A simple *Differentiable* **Linear Gain** Effect\n", + "\n", + "We will now take a pair of dry audio and wet audio processed by a gain factor. We will use gradient descent to estimate the parameters that were applied to the dry signal to obtain the processed one. We can inherit the nn.Module and Parameter classes from PyTorch to define the behaviour and parameters of our gain control.\n", + "\n", + "We start by creating our train and target signals.\n", + "#### **The gain value we want to predict is 0.2**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "jSsH7SoL84hq", + "outputId": "05c24e6f-b289-4198-edac-61bdf97c21fc" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Create input and target\n", + "sr = 16000\n", + "freq = 200\n", + "target_gain = 0.2\n", + "\n", + "# generate half a second of sine wave at 300 Hz\n", + "input_audio = get_sine(1.0, freq, sr)\n", + "target_audio = get_sine(target_gain, freq, sr)\n", + "\n", + "plot_graph('Sample', 'Amplitude', [-1.2, 1.2], input_audio[:200], target_audio[:200], [\"Target\", \"Original\"])\n", + "\n", + "ipd.display(ipd.Audio(input_audio, rate=sr, normalize=False))\n", + "ipd.display(ipd.Audio(target_audio, rate=sr, normalize=False))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4uqP5_Rb84hq" + }, + "source": [ + "We define our model using nn.Module (see that it inherits a forward function), and train. The forward() function of nn.Module stores all values and computations making sure that we can call backward() where we calculate the gradients used for gradient descent." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "yWWGwRKQ84hq" + }, + "outputs": [], + "source": [ + "#create linear gain function\n", + "class LinearGain(torch.nn.Module):\n", + " def __init__(self, gain=1.0):\n", + " super().__init__()\n", + " self.gain = torch.nn.Parameter(torch.tensor(gain))\n", + "\n", + " def forward(self, x):\n", + " return self.gain * x" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3ZJiiiaF84hq" + }, + "source": [ + "We initialise the LinearGain class, a loss function we want to use to compare the processed input and target, as well as the SGD optimiser. We train for 300 iterations. Note that we use optim.zero_grad() for each iteration. This ensures that all gradient values are swiped for every parameter update." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "hfcmkMRc84hq", + "outputId": "1b0fe64f-6193-4a01-c2a4-092f55a4b064" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "diff_gain = LinearGain() # initialise module\n", + "l1_loss = torch.nn.L1Loss() # measures the mean absolute error (MAE) between each element in the input x and target\n", + "optim = torch.optim.SGD(diff_gain.parameters(), lr=0.01) #initialise optimizer\n", + "\n", + "n_iter = 300\n", + "\n", + "gains = []\n", + "losses = []\n", + "\n", + "for i in range(n_iter):\n", + " #logging\n", + " gains.append(diff_gain.gain.item())\n", + "\n", + " optim.zero_grad()\n", + "\n", + " estim_audio = diff_gain(input_audio) # forward pass\n", + "\n", + " loss = l1_loss(estim_audio, target_audio)\n", + " losses.append(loss.item())\n", + "\n", + " loss.backward() #calculate gradients based on loss\n", + "\n", + " optim.step() #update the parameter\n", + "\n", + "# Plot how the estimate for x converged\n", + "plot_graph('Iteration', 'Loss', [-0.2, 0.8], losses)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "sKB4p7JP84hq" + }, + "source": [ + "Lets look at the how the processed signal changes for each iteration compared to the target." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "M1jsYmXW84hq", + "outputId": "5840d4ff-a46a-4efa-8a8c-54d89caf15a7" + }, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Animate the fitting process\n", + "def get_gain_loss_animation(org, tgt, gains, losses):\n", + " fig, ax = plt.subplots(1, 2, figsize=(10, 4))\n", + "\n", + " # Plot target and estimate\n", + " ax[0].plot(tgt[:200])\n", + " line, = ax[0].plot([], [])\n", + " ax[0].set_xlabel(\"Time (samples)\")\n", + " ax[0].set_ylabel(\"Amplitude\")\n", + " ax[0].set_ylim(-1, 1)\n", + " ax[0].legend([\"Target\", \"Estimate\"], loc=1)\n", + "\n", + " # Plot losses animation\n", + " ax[1].set_xlim(0, len(losses))\n", + " ax[1].set_ylim(min(losses), max(losses))\n", + " line_loss, = ax[1].plot([], [], lw=2)\n", + " ax[1].set_xlabel(\"Iteration\")\n", + " ax[1].set_ylabel(\"Loss\")\n", + "\n", + " def init():\n", + " line.set_data([], [])\n", + " line_loss.set_data([], [])\n", + " return line, line_loss,\n", + "\n", + " def animate(i):\n", + " # Update estimate plot\n", + " line.set_data(np.arange(200), org[:200] * gains[i * 5])\n", + " ax[0].set_title(f\"Estimated signal after {i * 5} iterations\")\n", + " ax[1].set_title(f\"Loss after {i * 5} iterations\")\n", + "\n", + " # Update losses plot\n", + " line_loss.set_data(np.arange((i*5)+1), losses[:(i*5)+1])\n", + " return line, line_loss,\n", + "\n", + " # Create the animation\n", + " anim = FuncAnimation(fig, animate, init_func=init, frames=len(gains) // 5, interval=50, blit=True)\n", + " plt.close(fig)\n", + " return anim\n", + "\n", + "display(HTML(get_gain_loss_animation(input_audio, target_audio, gains, losses).to_html5_video()))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "TrbbPZ8N84hq" + }, + "source": [ + "We see that we over time learn the gain value that results in the target. We also see that the loss, being the mean squared amplitude difference between the processed input and the target, decreases and reaches 0 at the same iteration that the sines perfectly align in amplitude.\n", + "\n", + "However, the problem we are trying to solve is very easy. Simply because it is linear, contains input and target that is aligned time-wise and only includes one parameter.\n", + "\n", + "Rather, let's look at something a bit more complex." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zleo00KZ84hq" + }, + "source": [ + "### A simple *Differentiable* **Waveshaper**\n", + "\n", + "A waveshaper is used to shape a sound giving it more harmonics. This often results in a warm or harsh feeling also known from saturation or overdrive effects (espesically prominent in guitar pedals). If we want to model the characteristics of analog distortion, and especially tube distortion, we can use a modified tanh() function as this allows us to model the positive and negative slopes of the input differently. The modified tanh function is given by:\n", + "\n", + "$\\begin{aligned}tanh_{mod}(x) = \\frac{e^{x*(a+G)} - e^{x*(b+G)}}{e^{x*G} + e^{x*-G}}\\end{aligned}$\n", + "\n", + "Here the distortion amount $G$ defines the overall shape/drive, whereas $a$ and $b$ are small offsets added to the positive and negative parts of the input signal respectively.\n", + "\n", + "Lets create a training and random target signal using the modified tanh function. The target could here also be an analog tube distortion effect that you do not know the inner workings of. Using DDSP you could try to model it." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Qd9tbykH84hq", + "outputId": "cff2e327-b847-480b-ec44-70ed8d4b696f" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def mod_tanh(x, a, b, g):\n", + " numerator = np.exp(x*(a+g)) - np.exp(x*(b-g))\n", + " denominator = np.exp(x*g) + np.exp(x*(-g))\n", + " return numerator/denominator\n", + "\n", + "#Create input and target\n", + "sr = 48000\n", + "freq = 300\n", + "\n", + "target_a = 0.6\n", + "target_b = 0.4\n", + "target_g = 4.5\n", + "\n", + "# generate half a second of sine wave at 300 Hz\n", + "input_audio = get_sine(1.0, freq, sr)\n", + "target_audio = mod_tanh(input_audio, target_a, target_b, target_g)\n", + "\n", + "plot_graph('Sample', 'Amplitude', [-1.2, 3.2], input_audio[:200], target_audio[:200], [\"Target\", \"Original\"])\n", + "\n", + "ipd.display(ipd.Audio(input_audio, rate=sr, normalize=True))\n", + "ipd.display(ipd.Audio(target_audio, rate=sr, normalize=True))\n", + "\n", + "guitar, _ = librosa.load('sound-files/guitar.wav', sr=sr, mono=True)\n", + "guitar_dist = mod_tanh(guitar, target_a, target_b, target_g)\n", + "ipd.display(ipd.Audio(guitar, rate=sr, normalize=True))\n", + "ipd.display(ipd.Audio(guitar_dist, rate=sr, normalize=True))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0QoUG0SK84hq" + }, + "source": [ + "We implement it in the PyTorch framework for automatic differentiation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "JfTpJmh084hq" + }, + "outputs": [], + "source": [ + "class Modified_Tanh(torch.nn.Module):\n", + " def __init__(self, a=0.0, b=0.0, g=0.0):\n", + " super().__init__()\n", + " self.a = torch.nn.Parameter(torch.tensor(a))\n", + " self.b = torch.nn.Parameter(torch.tensor(b))\n", + " self.g = torch.nn.Parameter(torch.tensor(g))\n", + "\n", + " def forward(self, x):\n", + " numerator = torch.exp(x*(self.a+self.g)) - torch.exp(x*(self.b-self.g))\n", + " denominator = torch.exp(x*self.g) + torch.exp(x*(-self.g))\n", + " return numerator/denominator" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "T32Jk56M84hq" + }, + "source": [ + "Again, we train using the SGD optimizer to find the waveshaping values we applied to the target" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "GBnxdsk884hq", + "outputId": "8a3d79bb-e3ec-4df6-e917-b08eb4b6a5d2" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "diff_effect = Modified_Tanh() # initialise module\n", + "l1_loss = torch.nn.L1Loss() # measures the mean absolute error (MAE) between each element in the input x and target\n", + "optim = torch.optim.SGD(diff_effect.parameters(), lr=0.01) #initialise optimizer\n", + "\n", + "n_iter = 5000\n", + "\n", + "a = []\n", + "b = []\n", + "g = []\n", + "losses = []\n", + "\n", + "for i in range(n_iter):\n", + " #logging\n", + " a.append(diff_effect.a.item())\n", + " b.append(diff_effect.b.item())\n", + " g.append(diff_effect.g.item())\n", + "\n", + " optim.zero_grad()\n", + "\n", + " estim_audio = diff_effect(input_audio) # forward pass\n", + "\n", + " loss = l1_loss(estim_audio, target_audio)\n", + " losses.append(loss.item())\n", + "\n", + " loss.backward() #calculate gradients based on loss\n", + "\n", + " optim.step() #update the parameter\n", + "\n", + "# Plot how the estimate for x converged\n", + "plot_graph('Iteration', 'Loss', [-0.2, 0.8], losses)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qQ41wKGC84hr" + }, + "source": [ + "We can now track the parameters/coefficients to see how they change over time when we update them through gradient descent" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "ThwrKB-C84hr", + "outputId": "aa2d08b6-3596-46b7-fd58-8b144ed7809f" + }, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.animation import FuncAnimation\n", + "from IPython.display import HTML\n", + "\n", + "# Animate the fitting process\n", + "def get_loss_animation(losses_list):\n", + " num_iterations = len(losses_list[0])\n", + " num_plots = len(losses_list)\n", + "\n", + " fig, ax = plt.subplots(figsize=(6, 3))\n", + "\n", + " lines_loss = []\n", + " annotations = []\n", + " for i in range(num_plots):\n", + " if i == 0:\n", + " label = \"a\"\n", + " elif i == 1:\n", + " label = \"b\"\n", + " else:\n", + " label = \"g\"\n", + "\n", + " line_loss, = ax.plot([], [], lw=2, label=label)\n", + " lines_loss.append(line_loss)\n", + " annotations.append(ax.text(0.95, 0.9-i*0.1, '', transform=ax.transAxes, ha='right', va='center'))\n", + "\n", + " ax.set_xlim(0, num_iterations)\n", + " ax.set_ylim(0, max([max(losses) for losses in losses_list]))\n", + " ax.set_xlabel(\"Iteration\")\n", + " ax.set_ylabel(\"Param Val\")\n", + " ax.legend(loc='upper left')\n", + "\n", + " def init():\n", + " for line, annotation in zip(lines_loss, annotations):\n", + " line.set_data([], [])\n", + " annotation.set_text('')\n", + " return lines_loss + annotations\n", + "\n", + " def animate(iter_idx):\n", + " for i, (line_loss, annotation) in enumerate(zip(lines_loss, annotations)):\n", + " if i == 0:\n", + " label = \"a\"\n", + " target = target_a\n", + " elif i == 1:\n", + " label = \"b\"\n", + " target = target_b\n", + " else:\n", + " label = \"g\"\n", + " target = target_g\n", + "\n", + " line_loss.set_data(np.arange((iter_idx*30)+1), losses_list[i][:(iter_idx*30)+1])\n", + " annotation.set_text(f\"{label}: {losses_list[i][iter_idx*30]:.2f} - target: {target}\")\n", + " annotation.set_position((0.95, 0.9-i*0.1))\n", + " ax.set_title(f\"Parameters after {iter_idx * 30} iterations\")\n", + " return lines_loss + annotations\n", + "\n", + " # Create the animation\n", + " anim = FuncAnimation(fig, animate, init_func=init, frames=num_iterations // 30, interval=50, blit=True)\n", + " plt.close(fig)\n", + " return anim\n", + "\n", + "coeffs = [a, b, g]\n", + "\n", + "# Example usage:\n", + "display(HTML(get_loss_animation(coeffs).to_html5_video()))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kB7RlP4M84hr" + }, + "source": [ + "We are pretty close! Lets try to hear it on a guitar" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "KN_hd_VX84hr", + "outputId": "6dff1c3c-1b2f-4bcd-f36d-1070dc22bc67" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Original\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Target\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predicted\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "diff_effect.eval()\n", + "\n", + "input_to_process = torch.tensor(guitar)\n", + "\n", + "with torch.no_grad():\n", + " processed = diff_effect(input_to_process)\n", + "\n", + "processed = processed.reshape(-1).cpu().numpy()\n", + "print(\"Original\")\n", + "ipd.display(ipd.Audio(guitar, rate=sr, normalize=True))\n", + "print(\"Target\")\n", + "ipd.display(ipd.Audio(guitar_dist, rate=sr, normalize=True))\n", + "print(\"Predicted\")\n", + "ipd.display(ipd.Audio(processed, rate=sr, normalize=True))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xBI24msn84hu" + }, + "source": [ + "### The art of choosing the right Loss function\n", + "\n", + "There exists many different loss-functions, operating in different ways. Until now we have only used the L1 loss (also called MAE) that measures the average distance between the absolute values of our output and target:\n", + "\n", + "$\\begin{aligned}L1=\\sum_{i=1}^n\\left|y_{\\text {true }}-y_{\\text {predicted }}\\right|\\end{aligned}$\n", + "\n", + "Many other loss functions exist, with each their behaviour. Below we see the different loss functions in 2D. As we see the L1/MAE is not differentiable at the minima.\n", + "\n", + "
\n", + "\n", + "
\n", + "\n", + "Until now we’ve made the tasks a bit easy for ourselves. What if the signal we’re trying to match differs from the processed signal in more ways than just the shape or gain? What will happen if we phase-shift the target signal by 180 degree?\n", + "\n", + "Using the L1 loss, as done until now, will most likely have troubles. Although a phase shift changes nothing about the human perception of the sound, the loss function we use will not be sufficient in comparing the signals (simply because we are comparing the signals data-point by data-point). The loss will thus no longer deliver gradients that point us in the correct direction." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "4zJuGkus84hu", + "outputId": "b245ea06-68fa-488f-d57e-03ad2aaa3be0", + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAEmCAYAAACwD5CfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAACXIElEQVR4nO2dd5gURfrHvz15Z3MOsOySg2QQxKygYACzqPxEPHM4A+gpdyfqeR5G9PTMCc8cTlExAoIEEZAgOS0LC2zOM7s7uX9/1FTPbJzUvV0N9XmeeZ7dmZ6Z6unqt956oyCKoggOh8PhcDgcldCpPQAOh8PhcDjHN1wZ4XA4HA6HoypcGeFwOBwOh6MqXBnhcDgcDoejKlwZ4XA4HA6HoypcGeFwOBwOh6MqXBnhcDgcDoejKlwZ4XA4HA6HoyoGtQfAOj6fD6WlpUhMTIQgCGoPh8PhcDgczSCKImw2G/Ly8qDTdW7/4MpICEpLS5Gfn6/2MDgcDofD0SyHDx9Gz549O32dKyMhSExMBEB+yKSkJJVHw+FwOByOdmhsbER+fr60lnYGV0ZCQF0zSUlJXBnhcDgcDicKQoU58ABWDofD4XA4qsKVEQ6Hw+FwOKrClREOh8PhcDiqwpURDofD4XA4qsKVEQ6Hw+FwOKrClREOh8PhcDiqwpURDofD4XA4qsKVEQ6Hw+FwOKrClREOh8PhcDiqwpURDofD4XA4qsKVEQ6Hw+FwOKrClREOh8PhcDiqoillZOXKlZg6dSry8vIgCAIWLVoU8j0rVqzA6NGjYTab0a9fPyxcuFDxcXI4HA6HwwkfTSkjTU1NGDFiBF566aWwji8uLsYFF1yAs846C1u2bME999yDG2+8ET/++KPCI+VwOBwOhxMuBrUHEAnnnXcezjvvvLCPf/XVV9G7d288++yzAIDBgwdj9erVeO655zB58mSlhsnhdInXJ0Kv67qdNoejNnyecroTTVlGImXt2rWYNGlSq+cmT56MtWvXdvoep9OJxsbGVg8W8PlE/LK3Cnd/vBmv/VKk9nAU4Z01xbjjw01YvrsSPp+o9nAU4e3VxRj56E94b+1BtYeiCB6vD0t2VuCejzfjw3Ulag9HEV5Ytg93frgJv+6vhigem/P0xWX7MPLRn/DFpiNqD0URHG4vvt1ahns/2YKvthxVeziyI4oi/rl4J+78cBM2HqpTezhhoSnLSKSUl5cjOzu71XPZ2dlobGxES0sL4uLi2r1n/vz5ePTRR7triGHR0OzG1W/8hp1lRDH6akspTh+QicG5SSqPTD4OVNnx2OKd8InAt1vLMCgnER/cOB7pCWa1hyYby3dX4rFvd0IUgUe+2Yl+WYmY0Ddd7WHJRkWjA1e+thaHapoBAN9sLcNp/TOQn2ZVeWTyseVwPRYs2QsAWLy1DCcWpuKd68chwXzsiNIvNx/Bs/5zfPCLbRiQnYihPZJVHpV8HKiy48rXfkO13QkA+GF7OU7rn4m0eJPKI5OPX/ZW4c3VxQDIPJ00OBsvzxgNk4Fd+wO7I1OJuXPnoqGhQXocPnxY7SHhs42HsbOsEQlmA/pkxgMAXlq+X+VRycsrK4rgE4HeGfFItBiwu9yGjzeo/9vLxYEqO+76eDNEEchKNMPrE3Hnh5tQ1tCi9tBk4/3fDuFQTTNSrUb0SrPC6xPxxqoDag9LVl5ctg8A0DczHhajDhsO1mHR5mNnZ725pA4P/G8bADJPXR4fbvtgIxqa3SqPTD7eXlOMarsT2Ulm9EiJQ4vbi3d/Paj2sGRDFEX82z9PB2QnwKgXsHRXBZbsrFB5ZF1zTCsjOTk5qKhofQEqKiqQlJTUoVUEAMxmM5KSklo91OabrWUAgPsnD8R/rh4NAPh2WxkOVNnVHJZsHK5txpd+gb7gyhF46IIhAIBv/ihVc1iy8vSPe2BzeDC2IBVL55yBIblJqGly4ekf9qg9NFkQRRFfbSHX65FpJ+CJS4cBAD7ZcBhVNqeaQ5ON7UcbsGx3JXQC8MbMsbh30gAAwOKtx848nf/9brg8PpwzJBs/3nM6eqbG4XBtC174eZ/aQ5MFt9eHb/3y9JkrRuCv5w8GALy79iCanB41hyYbq/dXY3NJPcwGHd6/cTxuOLUPAPbn6TGtjEyYMAHLli1r9dySJUswYcIElUYUOYdqmvDH4XroBOD8YbkYkpeEiYOyIIrEmnAs8NrKInh8Ik7rn4FRvVIx+YQcGPUCdpfbsLfCpvbwYsbt9WH1vmoAwLypQ5BkMWLeVKJwrdhbdUzEx/xxpAEltc2IM+pxzpBsTOibjpH5KXB6fHh7TbHaw5OF//xMrJFTR+ShT2YCLhieCwBYV1yLikaHmkOTBZvDLcUXzLtwCFLjTfibf7FevrtSzaHJxqp9VahrdiMjwYwJfdIxZWgOCtOtqG92HxOWWFEU8e+lRHG8ZnwvZCVacKF/nv68uxJ2hhUuTSkjdrsdW7ZswZYtWwCQ1N0tW7agpIQEys2dOxczZ86Ujr/11ltx4MAB/OUvf8Hu3bvx8ssv49NPP8W9996rxvCjYrFfiz+5bwYyE0n8xB1n9wMAfLn5qObNpy0uLz79nQTJ3XEWOa9kqxFnDMgEcGxYR/44XA+b04NUqxFD84jvfXSvVFhNetQ2uaRYIC1DgwDPGZINq8kAQRCk6/n+2kNweXxqDi9mKm0O/LCjHABwp/+8eqZaMbpXCkQR+G5bmZrDk4W1RTXw+kT0zoiX4nxO7pcBnQAcqG7C0XrtuxSp9e7C4bkw6HXQ6wTcckZfACS4XOsByfsq7fj9UB1Meh1u9Z/XCXlJKEy3wunxYdkudl01mlJGfv/9d4waNQqjRo0CAMyePRujRo3CvHnzAABlZWWSYgIAvXv3xrfffoslS5ZgxIgRePbZZ/Hmm29qKq33a//NM21EnvTc6F6pKEy3wuMTsfmwNiKlO+OPI/VweXzISbJgfO806fmp/vP95o9SzQuIlX6ryCn9MqDzp0qaDDqc1IcEr67eX63a2OTA6xMlpTl4nk4clIUUqxE2pwe7NK5wbfJbDAblJKJ/dqL0/IXDA/NU66zyz9PT+mdIzyXHGTG8ZwoAYM0+bc/TZpcHP+0gi/FFIwPz9JJRPWDUCzha34IjddpWuH4/SObpmIJUZCdZAACCIEjzlN6nLKIpZeTMM8+EKIrtHrSq6sKFC7FixYp279m8eTOcTieKioowa9asbh93tOwpt2FPhQ0mvQ6Th+a0em10r1QAASGpVTaVBG4eQQjUNJg0OBsWow4Ha5qx7WiDWsOThdX7qgAAp/fPbPX8qf0y/K9rW8ivO1CDKpsTyXFGnD4gcI46nYBR+SkAAtdZq1D3xZiC1FbPXzA8F4IAbCqpx5G6ZjWGJhur/PP0tDbzlConqzSuNC/dVYkWtxe90qwY6Z+XAGAx6jHEb7E8lucpAPyypwqNDjat6ZpSRo43qHA4tX8GkuOMrV4b7Z9sm0rqu3tYskKVqVG9Ulo9H2824KyBWQCAlXuruntYstHQ4saWw/UAyHUM5vQB5P/1B2vhcHu7e2iysaaILFKTBme3Sx2UlGatz1P/+NsK+ewkC04sJBa9XzQ8T0tqmnGwphkGndAu3Zwqzb/ur9Z0fNNvB2oAAFOG5rTa+ADAaL/82az5eepXRgpbz9NBOYnokxkPl9fHrIWLKyMMs6OUmLaDtXgKFfKbS+rg1aiAEEWxUyEPBBQU+jtokbVF1fCJJBU0L6V1BlffzATkJFng8viwvrhWpRHGzvaj/nnaRqEEgpRmDVvwnB4vth0h1rmO5il9TsvzdKV/4zO6ILVdzZRR/vimmiYXdpVr9xx3+C2sw3u2r5kySlKatTtPa+xOFFc3AQBG57eep4Ig4MQCojSzOk+5MsIwO0rJzXNCXvv04oE5iYg36dHk8mo24+RgTTNqm1wwGXQ4Ia+9gKDPsXrzhMNKyQ+f2e41QRAka4mW40bo9elono7IT4FOAI7Wt6BSoxkn2482wuX1ISPBhF4dFHAb4i8+qOV5ukpyJWa0e81k0EnxXFp1Kbq9PuwqJ3JyaAeyhlpGdpY2atZKSTd2/bMSkGw1tnv9hB50nrLp9ubKCKM43F4UVREtt6Pqh3qdIO1EtarN093y8B7JHVYGpItbSW0zs37OUGzwWzxO6ddeyAMBE/g6vwlZa1Q2OlBtd0InAINz2isjCWYDBvgDPrU+T0f1Sm1n3gcC83R3WSM8Xm1mDW08VA+AZM90xKl+Zfo3jc7Toio7XB4fEsyGDhXKHilxyEo0w+MTsfUIm4t1KDqLF6HQecqq0syVEUbZXW6D1yciI8GErMSOS6JTV41Weg+0ZaN/cRrdyc2TYjWhh9+1sZPRG6grXB6fZDbtyGoABBTNvRV2Tfrjt/t3WX0zExBn0nd4jNbjm0IJ+cL0eMSb9HB6fDjgv95aosbulEqjD8pJ7PAY6trYU65NKyx1JQ7JS5Iy2oIRBCEovkmb8pQqzZ3J00E5SRAEoNLmZLIQIVdGGGW73785JC+5w90YEJh0Wg26km6eXh3fPAARHgC72nxXFFc3weMTkWg2IDfZ0uExhelWmPQ6tLi9mqzjsONo5y4aipYzv0RRlJTmzpQRnU6Q+kSxagLvir0VpJJzrzQrrKaOe+wMyCJKSmmDAzYNWinpdenIRUMZXZACgMThaQ2Xx4c/jtQD6HyexpsN6J1O2omwWNuIKyOM0pUfnkKDlIqrm1BjZ0/T7Qqbw409/lgXKgQ6YqgUN6JFIU/Or192QqcKpUGvk/oNaTH2h87TrhqpUX/81qMNmit+dqSuBVU2J4x6AcO6OEd6n2rRgrevksy7AdkJnR6TbDVKFtp9ldprQxGR0lxSr7naRrvKGuH0+JBqNaJPRnynxwU2d+zJU66MMMrOLoJXKclWIwrTif9zt8bMp3srbBBFIDfZgqzEjq0GgLaFPFUuBmZ3bPqm0CJadIeqJaibZkgX87R3RjyS44xweXzYr7GFjLol+mclwmLs2A0FaDvYmp7jgBDzlL6+T2NKs88nBiwjXSiUQ3skQ68TUGVzoqJRW5s7urE7oQtLOn0dYFOecmWEQTxen6RcdGVWBIivHoDmmuYd8Afn0vF3Bo0A31dp11yUO1VG+ocS8lnkN9CakG9odksVKzvKhqIIgoC+futPscZiKg5Uk/uKWq86I9idqLVd9T6/EhxKGenvt5xoTWk+VNuMJpcXZoNOmocdYTHqpeBWet21ApWnoeYpy5s7rowwSFFVE5xdRH4HQycfzbzRCjTQr3cXJkUAyEmyIC3eBK9P1JwbgwrtUJaRAf6gwb2V2jo/utvMT4trV5SvLb0ztK009wmhNA/IToRRL6Chxa2p2B9RFKVddbiWEa3dhzT+blBuEgz6rpc86uI4oDV56r+vunLRAAGlubimibkuxVwZYRAq5Ifkdhz5HQwVkprbcVaFt+MUBIH5lLSOcLi9OFRDrklXvnjyOjV/2zVVwE6Ka8rt2noHBK6z1rJNAha8ruepyaBDP3+Qp5bmaZXNiYYWN3RC6HuRzuN9GrOMSHFNXbgSKb21qoxUh6c0ZySYkZ1khigCuxkrYMeVEQahPtzBuV3vVIAgTV6zZsWubx4gUFRqN4MR4J1RVGWHTySNxjI7Sc2m9EqzwmzQwenx4XCtdvqb0B0yzSTpir5aVUaomyYj9DwN1BvRjuWAWkUK0+O7jIkBIClb5Y0ONLRoJ6Nmv9/i2FnacjCBzZ125KnH65M2PqEUSoDduBGujDDIwZrwXBhA4OY5UteimZgKr0/EoRqy6IYyKwKB3+GQBhfqgdmJXQaUAaSAHY2d0ZIJnF6PwoyuXYlAazeNVmIqGlrcqLa7AAC9wxDydCGgC4MW2BtmvAhAFOscfyfY/RpyKVJZUxiBrNGS0ny4rgVurwiLUYe85LiQxwfit9iSp1wZYRB68xSkh755MhJMSDQbIIqB97HOkbpmuLw+mAw6qahZV/TyZwxp5fyAgJDvH8JFQ5FM4BrKNqGLbjjztCDdCkEAbA6PtMCzDnUlZieZ2/Vr6YiCNPI7HNSSMlIeOq03GK0Fsfp8oqQ00+vTFXShPlzbrJk0dDpPe2ckhHTrA0Av//1aUsvWPOXKCGOIoogSevOkh95xCoIg7ci0YlqkLpre6fFh3Tx0sTtS16yZmAoq5AeGYRoGgtN7tbHjbHF5pfTHwjDmqcWoR89UonhqJb5JciWG4aIBAvdriYYseFLwapjzVGtBrOWNDrg8Phh0AvJSOi8hQMlMNCPepIdPZG+x7oxwM2koBWlsbu64MsIYVXYnml1e6ASgZ2poIQ8EXDVayagpCjN4lZKbZIHJoIPbK6JUI5kKNDOmf1Z4Qp5m3Gil3DZdcJMsBqRYTWG9p4/GMmrCTeulUAtetd0FO2OZCh0hiqJU9yUcNw05TltBrHTB7ZkaFzKTBqCbOzpPtSFP6TztG4YbCmitNLPUgoIrI4xR4r958lLiOmwe1xFaS0crro5Mk9fpBOT7d9WsafMd4fb6cNRffyNUFgalr7/WyMGaJk3EVFAXTTh+eIrW/PGRBFkDQJLFiLR4opiVaGCe1jQRpUkQwrPCAoEg1iKNKJSRuBIpWpunRRHO07yUOOh1ApweHyoZ6lHDlRHGCMSLhCccgMAk1EpGTaTmbyAgTA5pwHRaVu+ATwTMBl3ITBpKXooFggA43D5NxFTQeRqqDk4wUkaNRhaySM3fQOD30EIQKy1Yl51ogdnQdSYNJT+NbAqo+4N1DkYlT4/teWrU6ySXKUvzlCsjjEEnR68wgq0oVJPXjC8+QvM3EBAmWrCMHK4jY+yRGhcyk4ZiNuilTAX6fpahSmFhBDvOgNLM/jz1+kQU++/FvhEpzf55qoG4EZpGThemcMhMMMNi1EEUoQmXKY37iMYyogV52uhwSx2Xw8m+pPRiMG6EKyOMIaVLRqDJ00lY3+xGbRPbu2q70yMFPkZkGdHQjpMK+fwwY34o9Hi6Y2UZyTISxTwtqWmG28v2rrq0vgUujz/jK4LFmtXgwI6gSm9+BNYtQRCkWDYtzNOD1ZHL074aihmhY8xKNCPR0nUV5GACSjM758iVEcaIxqwYZ9JLKbKsmxaL/TdPerwJydZIbh5aw0FLQj78RQwI7FC1UPhMqt0QwY4zJ8mCOKMeHp/I/DnSmIjCdCv0YWR8UQoYTZvsiMO1RJnIj0DZAoLmKeMWvEgzEyk0DqqmyYWGZraLu4VbybotNM2ZJXnKlRHGKInCTQMECk+xNLk6okQqlBXhzRMUAc56gCfdMUZqGemZRnecbF9Dt9cn9V+JRMjrdIJ03Vmfp4fr6PlFN08PMlZQqiPoPOsZgWUECLbgsX2OwQG64WYmAkCC2YAsf6xXMeOWWCprwqmhEkwvBtPQuTLCEA0tbtT5NfFIhDwAyTLCuh/3aL0/niKMYmfB9Ey1QicAzS4vquzsRIB3hOSmiVjIk9+EdfP30boWeH2k4mNWmAG6FHrdWW8mR7OhIp2nVMiXNbQwH+AZtTsxjVrw2L6G1KWbm2QJWeq+LdT6w7w8pfM0QusWizF4XBlhCJoOmJFgRnwYFR+D6ZFCJpdWhHxehELeZNAhN1kb6b10Vx1JYCA5nlxD1l0YtMJoQVp82AG6FPqbMD9P66NTRjITzLD6i2axbDnw+kTpHCN3J/rnKcPnB0RWybotPfzneJT1jUF9dPKUBrA2tLhR38xGnCFXRhgikKEQ2U4FgFRdkH0h7wAQuSYPaMMV5XB7UeXP3Y92x3m0voXpSrPUtBtJ8CpFmqeMC3m6I450ngqCwGSmQlsqbQ64vSIMOkHK4goXrQRaRxN/R9GOPI1OabaaAq4oVuYpV0YYIpoMBUoPje04e0Z48wCBOBqWM2qogE4wG5ASQYAuQAI8DToBbq+ISptDieHJQjQZChRqwdOM+TuKeRowgbM7T6mLJTfFElZl0mCodavK5mS6OWc0Bc8oPTXgThTFgHUrUisswF4aOldGGIK6aSINRgKAnkFCnuUAz9IozYoAm37OtlDTdc8IaoxQDHodcv07Mpb98QHLSOTzVAs7TpfHhwq/MhjdPGW/y3S08SIAkGI1So0DWXZF0XOMpDAfJU8DMXjVdhdcHh8EAciO0LoFBDZ3JYwozVwZYYijUZqGASAnOVDBs4bRWiN2pwcNLSRAN5ymVW3RQlDZkSiDVyn5GogbkVwYUVxDOrcrGh3M1hqpaHRA9FfQzUgIr+9OMDQQmWVXlJR+HoUyQmqN0PReds+xtJ4qlNHPU5aVZjq27ERL2K1DgumVxpa7jSsjDFHa4LcaJEd+85gMgcwGVhdrKpyTLIaICvRQaABrWQO7LowjUQavUrTgjy/zz1N6PSIhI94Mk14HnwiUM3odjwS5aCK1bgHamKdSjZEIg1cpUuEzRpVmj9cnuTqjsW7R99Q3u9HEaNPDaDNpKNQKW8rIPOXKCCOIoogyvyafG8XNAwRuIFZ3ZIGgwOisBnSHU97oYDbAM5YdJ8B+QakWl1dKP8+LQhnRBbVyZ1ZpjsGVCBArJRBQ2lgkmuqrwVAlhlWlucLmhE8EDDoBGQmRpZ8DpOlhooW4olidp6VRBq9Scuk8ZeT8uDLCCI0tHrT4g8Fyo7CMAOzXcDgS482TlWiBXifA6xOljBXWCOw4oxXybLtp6AJrNemRFBdZ+jmFdRN4LMGrQECJqba74PSwGeB5ROpLE63SzHZ6L11gs5MsEVXQDYZ1eRqr0syaBY8rI4xAXTRp8aaIC/RQmL95JCEfnbKl1wkBVxSju84jUZaCp7C+46SCKzfZEpULAwhYVJjfcUZp/k61GmH2+/BZdEW5PD6UN5JxRT1PpdYFjF7DhujjRSisy9MjMbpp6G9jd3pgc6hf9p4rI4wQ8MPHcPMwHjgXq5AHAr8Pi0K+yemRXBjR7jipe6esoYXJAM9YsqEozFtGYjxHQRCk97Ky6wymotEBn0jizDKjcGEAQRY8xi0j0cQ1UVjPqImlTAJAao0kx5HYPRbmKVdGGIFGfsdy80gl4Rm1GgQK9ES3UAOBeBoWBQS9oRMtBin1MVIyEsww6gX4RKCSQVdUsGUkWqiQZ9X6E20hqWByGY4bkcW6FRTg2eJizxVV1hB98CrleNrcsSBPuTLCCHJYRlgPYA2Ugo/hHCUhr74m3xZqrYm0omUwOp2ArER2rT+xZNJQejKsUMZaSIqSK7mi2L2GsczTJIsBVhNxJ1OXD0sELHixy1MWr2HrMglyKM3qnyNXRhghkEkTu5umrtmNZhdb6Whub6CQVGyaPDV/s7eQUaGcE4NCGfx+FpWRWGo3UPKCfPGsFeiLtZAUhWXLSIUM81QQAmXkWZynAetP7JZmFt2JdGOXHGeM2goLBCzNLGTUcGWEEQI1RqK/eZIsRiSa2UxHK28ghaRMeh0y4qPzUwMISgtlTwCWy2DdAoKUEQZ3nHJYRqjC7XD7pBgbVoi1kBSFnmMZg/OULtSyKc2NbMkaQKYYPP9CXd7ogIex+K1ou5+3hSVLs+aUkZdeegmFhYWwWCwYP3481q9f3+mxCxcuhCAIrR4WS2w3oFLI4YsHAlYH1vzxR4JcNLooU+0Ati0jZTK4aYLfX87iOcpgGTEb9Mj0Z0Wx5lKUww8PBGUMMSDk2yKHOzH4/eUNbMU2OT1eVNtJFepYXBiZiWYY/KUEKhiL34ql4WgwLKX3akoZ+eSTTzB79mw8/PDD2LRpE0aMGIHJkyejsrKy0/ckJSWhrKxMehw6dKgbRxweoijKEnAFsGtalCMLAwjsOCttTuayTQLm71gFBN1xsiUAbQ43bP5qlLGe4/EyT1lUmqnFLdaNT3Yym0pzhV85Mht0SI2wWWUwep0QqFLK6jyN8RpKAawMXENNKSMLFizATTfdhOuvvx5DhgzBq6++CqvVirfffrvT9wiCgJycHOmRnZ3djSMOj5omefzUQMB0WsGAphtMQADGJuQz4km2ichgtknA/B29GwoIzAHWhLwc2UIUVquwymWhpPOcxWwTyTIim9LMlqyRXN5RlvMPhtWaOBVyXUMpZsShevyWZpQRl8uFjRs3YtKkSdJzOp0OkyZNwtq1azt9n91uR0FBAfLz83HRRRdhx44dXX6P0+lEY2Njq4fSUNN3RoI5Jj81EGQ6ZUxABKwGsS3UOp0QKLfNmoCg55h0jAp5aTcW2/kBAYWLNYWSXsNYNwXB2SYsWUe8PlH6zWN102QzGsAqR7wIRdrcMXYvlsskT+lv1OL2Stk5aqEZZaS6uhper7edZSM7Oxvl5eUdvmfgwIF4++238dVXX+H999+Hz+fDySefjCNHjnT6PfPnz0dycrL0yM/Pl/U8OiKWBnltoQKigjETPxVYsQp5IChtkiEhGOynjjUwULqGDU7VdyvBSFaDGOJFKIF5ys41BIKVkdiEvCAITKVNUqrtTnh9IvQ6QYrbiRZ2lWZ5rLBAsMLFljyV5mlibPeixahHWjzpTK12UoBmlJFomDBhAmbOnImRI0fijDPOwBdffIHMzEy89tprnb5n7ty5aGhokB6HDx9WfJxyVAukZDOqydMAMDmUkTwGLSOVfuXPFKOfGgj8Ri6vD7VNrpjHJhdyztMcZpUReawGAJsVPKlilJlgjrpnC4X+RlU2J1PZJmWSm0ZGpdnG5jzNlsP6I1nT1Z2nmlFGMjIyoNfrUVFR0er5iooK5OTkhPUZRqMRo0aNwv79+zs9xmw2IykpqdVDaeRKtQMCOzrmhLyclhEGS21LZtOk6KtaUkwGHTISyG6FpXOU+n3IME+z/POUpV21KIrSeOSx4LFnGSmXUdakJ5BsE58IVNnZsRyUyWoZIfO0kqF5and6YPcHksuyuWOkXIJmlBGTyYQxY8Zg2bJl0nM+nw/Lli3DhAkTwvoMr9eLbdu2ITc3V6lhRoUcTZ0oVMuta3Yz0zHU6xMlYSXHjpOlEsYUORXK4M9hSaksl9w0MsaMMORObGhxw+UhO/ysGN00AJtp6HLVwgFaN65kSeEqVcCdyJLSTGVCgjn2QHKAnXmqGWUEAGbPno033ngD7777Lnbt2oXbbrsNTU1NuP766wEAM2fOxNy5c6Xj//GPf+Cnn37CgQMHsGnTJvzf//0fDh06hBtvvFGtU+iQchkKSVGS44xSECwrgr6mifipdQKkHX8ssJQbT6mQKQuDQpU2ls5RzsBAKuSDd3lqQxcc0nU3us7ZwbCy4wyGpovLsaMG2Mzeq5ApdRkIdieyE79Fz08OhRlgp0Bf7GpVNzJ9+nRUVVVh3rx5KC8vx8iRI/HDDz9IQa0lJSXQ6QL6VV1dHW666SaUl5cjNTUVY8aMwa+//oohQ4aodQodIvmpZbh5aJnmktpmVDQ6pO6aakLz/jMSzDDoY9d/c6RMDHYEoFwFzygsWkYqZVzI6K7O7vSgotGBhMyEmD8zVipkXqhZDNKV0zICsFct2OnxSnFWsQZ3ApCCfF0eH+qb3UiNj30zFSsVjfLKGlYCkTWljADAnXfeiTvvvLPD11asWNHq/+eeew7PPfdcN4wqekRRlBbVrBij2ynZSWaU1DarPrkocqVLUqgft8oWyAxQGxr8JZubhjHLSLPLIxU8k2tHlp1khr2KKCN9WVBGZIxrAiA1PKxiKH1Zrv5JFJrGzkp6L/2tTXodUmIMJAdItkmq1Yi6ZjcqbA5GlBF5lWY6T9VOs9eUm+ZYpNHhgcPt91PLoMkDQBZj6b1yBgUCJHBOJwA+kbiAWECuEtsUWsyIlV01tYrEGfVS/6NYYc1yIFdaL4V+Di1qyALyz1O2ApHpgpqZaI45kJzCWrkEOcskkM9hI+mBKyMqU+W3iiRaDIgzxe6nBthLm6yUWcjrdQIyEmiUO1sC4li1jAQv1HIJ+RzWhLzM5u9UqwlGPfmtWMg2CW47IV+gNVvxW3LLGvJZbMXFUEu6XOeY6d8E2xweVasFc2VEZeQ2uZHPYkPTpcgt5IGAq4CFuJFWVS3lzqZhRgCS85PLegcELHismPjpvZgl0zzV6QRkJrCTGtrQ4obTb6GRLYCVsY2PdA1lnKfMyVOZrVtJFgMsRn/Sg4rylCsjKiO3aZh8FpsCQlaFK5GdXXWN3QmPP1uILj6xQpURGyPZJnJH8ANBNRwYUCgB+QMDAbZcptR6kRZvgsUorxW2rEH93iaA/FYD8llsBHhS5FaaBUFgIm6EKyMqo8SOkzUfp6RwyWQ1AAKLIgsKFxVScmULASTbhMZmsGA5qJSxgi6FNTeN3IHWQCAovYoBhUtSKGUKlAeA7ORAtklds7q9TQD5F2qALXnq8wUSHuSywgJsWH+4MqIySuw4g02nLOxWlLD+sKDJU2gEv5zXEAAyg7KG1KZSgYWMJTeNx+tDtZ2W2FbCSqn+NQzMU/kWMbNBL7U/YGGeKqJwMVRKoK7ZBbeXyHS5rLBAkDxVcZ5yZURlpNoNClhGml1eKR1TLRxur7RjktP8Hajgqb6AUMK6BQSEDQtCUAlXG93ZVdrUV5qr7S74RBIcnR5/bLqipEwTGRcxIFCLg4VzrFLQgseC0hywwppi7vAejGRp5jEjxy9SjREZd9VxJj2SLMTEr/ZiLeX9G3RIjos975+SJQlA9XdjVQoJebqDZWLHqcA8pb+X2yuq3hCwPGhHLWfdmiyGYpuUsuCxVE9FCVcbVSir7eo3BKxUIEAXCPxeVVqzjNTX1+PNN9/E3LlzUVtbCwDYtGkTjh49KuvgjgeU2HEGf57ara/lbCAXDEtBukoolEBgsWZByFcpIARNBh3S/UWk1F6sA+5See9DlmKblFKaMxnZGDg9ASusnG6adH+HY59ILGhqInfROgr9vTRlGdm6dSsGDBiAJ598Es888wzq6+sBAF988UWrvjCc0ARXX5XTTQOws1grES8CBIQ8rcKqJlVBhZbkJIuRmJHg6qtyX0fW5mnOMWw1UM4ywsY8lbv6KkUflKLNyjxV7j7UkGVk9uzZmDVrFvbt2weLJbCAnn/++Vi5cqWsgzvWaVV9VaHJpXY6mtzVAinp8SZmqrAGYkaUsYyoveOkpmGrSS9Ll9BgWIjiD/5++S2U7FRhpRufY9UyEsikka8wH+VYn6eS21tL2TQbNmzALbfc0u75Hj16oLy8XJZBHS/QC0+KzsiT90+RAudUvnmUCu406HVIZ6QK67FuGQnOUJBbyLPSaE0pd2lwFdZqlauwKpFNAwTmvdrpy0pkfFFYseApFTNC5wTZIKtThTViZcRsNqOxsbHd83v37kVmZqYsgzpeqFRIOABBplNGBKDcZsXgz1Qzip+42hTKpmEkS6FCwXmayYgbQymFUseIib/J6UGTv9S33OfIimVEiVo4lEDFZzbOUW6FK8ligNmfnaPW5i5iZWTatGn4xz/+AbebBAoJgoCSkhI88MADuOyyy2Qf4LGMUv4/ICDk1bYaSKZhJXYrDGQqNDo8kvlddsuI//zqmt2qmvgrFTINA+wtZErMUxaqsFJlSwlXGytxMUrUGKGwco5Kxf0IghCw/qi0+YlYGXn22Wdht9uRlZWFlpYWnHHGGejXrx8SExPx+OOPKzHGYxZJk5d5Rw0EmfgZsYzIbTUA2MhUCG50KLerLSXOCINOfRO/Urux4M9kRsgreo7qzVMllS36mTYVTfyAMtVXKSwozT6fKMkBRZTmRHXd3hGryMnJyViyZAlWr16NrVu3wm63Y/To0Zg0aZIS4zumoYtopgKWkeCJJYqi7L7+cFF0x8lAFVYlF2qdTkBmohllDQ5U2ZzIS4mT/TvCQVkLnvrKiMfrk4KgFbHgMWQZUWKeUhO/0+NDlc2J/DSr7N8RDoG+NAq6vVWcp3XNLnj8mYMZMgchA+rHxURtrzv11FNx6qmnyjmW4w4lqq9SqFBtcXvR5PLKbpoNB6fHi3oF8v4pWQwE6SoVa0ChyoiqCpdCwZ1AayGvltJc0+SCKAI6AbJWX6WwENukpLtUEIjSfKSuBZU2h3rKSKNyChcL8VtUBqTFm2CUqQdWMGrHxYS1Qr3wwgthf+Bdd90V9WCON5TU5K0mAxLMBtidHlQ2OpCQmSD7d4SCFggy6gVZ8/4p2QxYRpR0Q5HPVX9HVqHgQkZ3eC6vDw0tbqRYTbJ/Ryjob5uRIG/1VQoLVVi7Y54eqWthYp4qozSTz6y2u+DzidApME9CoaR1i3yuui02wlJGnnvuuVb/V1VVobm5GSkpKQBIRVar1YqsrCyujERAcF68EmQmmmF3elBlc6KPCspIcMVHJXa89HdTs2dEd1hGAHV3ZEpUX6VYjHokxxnR0OJGlc2pijKipNUAYCO2SUl3afDnqrUxUNoKm55ggiAAXp+I2maXIm6SUCh9DbNVtoyEZespLi6WHo8//jhGjhyJXbt2oba2FrW1tdi1axdGjx6Nxx57TOnxHjOIoqi4pqu2gKAatmJC3r841jS5VKvCqmTMCKB+6mtLULNFJZVmQL152l07TjWDkJVWmtXONlHaCmvU65DmV5TVOsfuuoZqKc0RO54eeughvPjiixg4cKD03MCBA/Hcc8/h73//u6yDO5ZpcnnR4lYm75+idnBglRT5rYxpOHi3UtesTs+I7rOMqCsALUYdEhWKO1LbFUVjDZS+hjVNLtUarXWbZUQlV5TSVlhA/XtRaQveoNxEPH35cDx60QmKfH4oIlZGysrK4PG0b0vv9XpRUVEhy6COB6jVIMFsgNWkrJBXzzKirABkYbciNck7RmNGquwBAai8kFdnR0aVZqWuYZq/dYEoEoVEDZS3/qhbSkDpTUHwZ6sna5SdpxkJZlwxNh8n981Q5PNDEbEyMnHiRNxyyy3YtGmT9NzGjRtx22238fTeCDgebp6AkD+Gz7Gbdpyqn5+CPnK1FS6llWa9TpBiDNQ4R6VTl4M/Vy2FUmmrQfBnq6Y0K6xQqk3Eysjbb7+NnJwcjB07FmazGWazGePGjUN2djbefPNNJcZ4TCK5MBQV8jTbRCUBobCQD/5sNYS8y+NTpGV5MG1TX7ub7lSaVXNFHeNKc63CqcuA+jEjgXmqjNUAYOkcj01lJGL/QGZmJr777jvs3bsXu3fvBgAMGjQIAwYMkH1wxzLcMiIPana2pQGJSgXNAeqnviqdEhr82Wq72o7Ve5HeG+kKpS4DgfOrtpNgcqW+pzOOC6X5GLeMRB2sMGDAAK6ARMue7yGUu2GEqOjNo4r5WxQBeyXgqEdi/R7okKmsgFCjs63PC1TtQUNlEzJRD2N8tmLxFKqlvnqcQPVeCFX7YYDu2BPyPh9gL4fYUo8kWxGAXEUVLqo0d2tMhdcDVO1C01E70tCIrIQein1V22Dybkt9dbcAVXtgqNkPPUzHnjz1eQFbGVrs9ch0HYYdOdwyQvnTn/7U5etvv/121IM5LvB5gc+uxyxPC2aY9ajePxQoegToe7bsX0UnbW2zC26vT5GqfRKuJmDLh8D614HqvQCA9wFUmZNgXT8NiJ8NpPeV/Wu7VcjXFAGrnwP2/gA0VWEwgA0W4LC3J7DhXmDE1YApXvavzUw0o6HFjUqbE/2zE2X//FbsXwb88iRwdCPg8+BeALebjajbORro/xjQa7zsX9mtQr6lHtj8Ppmn9YcgAPhWD5Tp0pD562XA6fcAyT1l/9qs7lSaK3YAa/4N7P0RcNRjPIBNFuCQvS+w5T5g6GWAQd4FjQaT1zS5UNnoVFYZEUVg97fAyqeB8q2A6MOjAB40m2DbMgEoeAzIHSH713ardaupGvj9HeD3twFbKeIALDcDh8UsJPwyHTjlbiAhU/lxdCMRr051dXWtHpWVlfj555/xxRdfoL6+XoEhHmO01AM9x8KuS4RR8CK38Q/gvUuA9y8DbPJmI6VZTdDrBBLFb1cwir90C/DyScB39xFFRNDBZ0mBXbQgU2hE/Pb3gVdOAX57hexIZSQgIBSMi/H5gLUvk3PY/B7QVAWYEuA0JsMrCsj3HgG+nUN+g9Itsn99tyzWtgrgvUuB9y8FDq8DfB7AkowmwQqz4EZOzTrg7XOBT68jc1hG6DVsaHEr22jt4BrgpXHAT38D6g8Bgh5eSyqaRTNyhVoYNr4BvDwB2PwBWfBkJOBOVHCeet3AiieB184Atn4COOoBcxIcBqLAFriLgEW3Aa+dDlTvk/3rpXtRyY1B3SHgnfOAT2YAZVsA0QfEpaEZFsQJLmSV/0LO/6s7AFezrF/dbUrz3h+BF8cAy/8J2EoBnQFucxocohH5QiWEtS8CL48Hdn6t7Di6mYiVkS+//LLVY/HixThw4ACmT5+Ok046SYkxHlvEpwOzFuPKpA9xqvPfODxwFqAzAvuXAm9NklVI6HQCMhIUTn3d8iHw1rlAfQmQnA+c9xTwYAn2X78do5yv41bh70Dv0wFPC/DDg8BnMwGPfIqR4rsVjwv49Frgx7nkHHqfAVy7CHjgIF4ZvxQjnG/gm7y7ybnXlwBvTwa2fCTrEBSP4q/eR+Ze0TIyF0+6Hbh7K/DAIZxj/C/Ocj6LmoFXA4IO2LkIeHsK0HBEtq9PjjPC5LfaKVYYbO3LwLtTAXsFkN4PmPoCMPcI1l+xEaOcr2Gu5SGgx1jA2Qh8dTvw9Z9lVZwVL17naiKK5Ip/AT43MPAC4Prvgb8U41/DfsAIx+v4pdcdQHwWULUbeP0sYl2QEcXvxdLNwJuTgJK1gCEOOO0+YPYuiPcXYbTnbUx2PoGmAZcAEIn1692pQFONbF9Pz8/u9KDZ1b68RcyIIrD8X8CHVxJFMnsocMnrwF9LseTCXzHK+RqeTv4bkHUC0FxD5NJPD8muOKuFLHZ7nU6H2bNntysbz+mcqiYXjoiZaDj9H8BtvwKpvcli9ta5QNlW2b5H0YyazR+QnZbXCQw4D7h1NTD+FsCciMpGJ9wwoChxHHDtV8AFzwJ6M7DrG+CzWbIpJIp27vU4gU9nArsXk7Ff+Bww8yug71mA3ohKmxN2WLG/9/8Bt64CBkwBPA5g0a2yKiSK7sjK/gDeOofMvbQ+wO1rgSnzgdQC+ESgqsmNYjEXrvOfA276GUjMBap2AW+eQ9xWMkAbrQEKXcdfXyTKpOgFhk8HblkJjLkOMFlRZXfCCRMOpJ4C/OlHYNIjROna/B7w9Z3ErSoDii7UThvwwRVA8UrAlAhc9hZw1QdAwcmA3oAqmxMNSMDBQTeTe7TgFMBlAz65FtjzvWzDUFRpPrgGeOcCoKmSLNJ3bgAmPgQk5aHR6YXDA+wRe0F/xVvAdYsBSwpw9HdizWssk2UICWYD4ox6AApdx2X/IC5SADjxJnK/jZgOGMyobHSgBRYcyJwI3LwcOHU2Oe7XF4Cf/n5MKCSyBREUFRV1WAyN0x6vT0RNcKZJ5gDghiVA3migpZZoxo2lsnyXYkJw93dk9wgA428DrvoQiEuRXqbFsrKSzIBOB5x4I3D1h2RR3/Mt8MWNsuw86fnZHB55Tfw+H/C/G4G93wMGC3D1R8DYPwFBgaqtIvjjUoGrPiK/BUDMxDIJesUW6oajwIfTgZY6oMcYMgcz+ksv17e44fYSIZcebwbyRvmPGUjMxx9eCTTXyjIUxebp5veJsAaAs/4OXPJaq7ieVi0L9Abg1HuBy94EBD2w5QPiepQBxc7P6wY+uho4tAYwJwHXfgkMu7zVPG1VfTUxmyjUw6cT5eyzWcChX2UZimJZUdX7gI+vAdxNQJ8zicUnJV96mX5fosUAi1EP9D4NuOEnYq2s2Q98dBWxHMWIokrzmheA1QvI3xc8C1zwTKu4nlaZiQYzMOlh4AL/8Wv/Ayx/XN7xqEDEysjs2bNbPe69915cddVVmD59OqZPn67EGI85apqc8NG8fxrolZAJzFwEZA4CbGVkkXDaY/4uRaqwlm0FPr+eCLORM8hOWtd6Kkk1RoID2fpNAq75GNCbgJ1fBW6+GEiyGGAykO+WVQiuehbY9TUZ69UfA/0mtjukXV8anQ6Y/C8SyEoFffm2mIeiiJB32oGPppO5ljmYLGLxrSsv0u9LtRql3xgp+cB13wQE/afyuN0UEfLFq4Cv/Y07T/4zcPp9rRZpoJPqq0MvIwoJBBJA+Ps7MQ+FzpEmlxdNThk3bT/9HTi4CjAlEPdh/ontDmmXEqo3Ahe9FLDkfXQVUFsc81AUuYZN1cAHlxO3Rc8Tyb1oSWp1SIdpvZkDyTy1ppPYki9vkWXzo4iVctc3wJKHyN+THiEbtzZ0WLPpxBsCCsnKp4lM1TARKyObN29u9di6lbgUnn32WTz//PNyj++YhE7ktPg2ef+WZOCaT4H4TBIl/s3dMZvfZN+RORqBz64jQqzfOcT33kFaqyQA27bz7ns20fwB4Od/AvuWxjQcQRDkz6jZ+2Ngp3HBAuKW6YDqjoSgTgdMe5EoXh4HCfh0NMY0HNmFvCiSuVW+jcy1az4hc68NndZuSMwm7zElkoWQCtIYkF3I2yuB/90QcM2c81jH87SzwnxDLyVuAAD47n7g8PqYhhNvNsBqktnEv+UjYN2r5O9LXgN6jml3iCiKHddR0RuBKxaSBd7R4HedxjYu2a8htU7WHQRSCojl0RjX7jDp/Npm8KT1JhZbvYks+KueiXlIgR48MrmiaouBRXeQv8ffRixzHdBpy4ITbwAm3En+XnQ7ULlbnnGpQMTKyPLly1s9li1bho8//hg333wzDAZleqwca3RZoCe1AJj+ATETb/+cRMXHQJacflxRBL65C6g9ACT1BC59nZi2O0AyDXeU4jd6JnF5QCTumhh9urIqXPZKsouCCIy9ARh9bYeHteq63Fbh0huBS98gv1FtUcxKpexC/o+PydwS9GSupRZ0eFhwX5p2ZJ8AXP4W+Xvdq8Den2IakqxZUT4vWcTsFcTqc+HzHSoiQIjCfKfOBgZPJQGhn82KOYtI1myT2gPAYv/CdfpfgMEXdniY3emBw00sAu0WMmMcUUji0oj14KfYlErZNz6/vQQcWE6CVa/5pNNU1k7vQwDodRK5/gCw4omYlUpZe/B4nGReORuA/PHAuZ13ve+ymvWkR4HC0wCXnVgq3S2xj00FIlZGzj777A5TeBsbG3H22fLXyjgWCVktsNd44My55O9v7yOCJ0pkFRB/fAzs+BLQGYgQs6Z1emhAQHRyjlOeBHJHkniFr/8sy2Iti+Xgu/vJmHKGAVOe6PSwhhY3XP4OrDRjqRXWNOCKd8hvteML8ttFiayprzVFgTiIs+Z2WTckZPXVAZODYmRuJ4pclMjqivrtFaD4F8AYD1z5LmCydnooFfIdzlNBAC5+hQT2Nh4Fvn8gpmFlytWfRhSJ+8nTQhYhKis6gN4TiWYD4vyWmVYk9yRWFQBY/xqwb0nUw5JVaS7dAix9lPw9ZT6QNbjTQ0O21hh5DTDsCmIl+9+NMVkqZe1OvGI+UQLj0oDL3yabmE4IdEDv4Bz1fnmckA1U7yEWZw0SsTKyYsUKuFztfcQOhwOrVq2SZVDHOmH1pTltNtDrZBL1/uVtUfs7M+XKNrFXktRcgAi/DnzTwXRqOqUYTEQI6s3A/iXAxoVRD002hWvXNyR1VdATn7qh82qn9PdMsRphNnQg5AEgf1xgofhxbtSLtWyprz4fMeW67CSjgkbkd0JYJbYnPUKyG5qqYrIAyeaKqj0QEMZT5pPYgS7oUsgDgDkRuPhVkmGz9eOY/PKyzdNN7xL3mCEOmPZCu3itYMK6hgPOJencAPDNPSQ7JwpkS331uPwxHm5g0IXAmFldHh7yHAWBuIZTepH6Mj92rryFQlKaY7WMlG4hQasAcet2UWivVcJDZ5u7+AzyOQCw9iUSL6UxwlZGtm7dKsWH7Ny5U/p/69at2Lx5M9566y306KFcueFjiS53YxSdnrhBTAnA4d+ADdE1IZSt0dp395MgspzhpPpfCEJaRgAgaxBZzADgx7+R9NIokEXIt9SRwmUAOb8QFRzD7mZ7yt3EytJSB3z/l6iGJlsU/8a3yVwyxgOXvErmWBd06WqjGC3EJaUzAnu+I1agKJBlVx1sMeh9OnEHdoHL40Ntk8v//V2Ugu81HjjlHvL34nujrl0hyzk2lgbcKWf/nVhtuqAyHGWEflZqIdB4JGCRiBDZUl9XP0dqocRnkgU2RKuFsBQuSzKp2QGBZFgVLY9qaLJYRrxukjYueoETLunUxUZplfDQVaPDAZOB0dcBEMmmQ4YEiO4kbGVk5MiRGDVqFARBwNlnn42RI0dKjzFjxuCf//wn5s2bp+RYAQAvvfQSCgsLYbFYMH78eKxf37UP8LPPPsOgQYNgsVgwbNgwfPfdd4qPMRRhd+xNyQ8s1ksfiWqxpjeP0+NDoyPK3Uori8F/ujQnAoDD7ZW+KzMhRL+P8beSXbq7CVg8O6qdtSzKyE9/9xfE6g+cEdocTy0/XSpbAPmtpv2H/HY7voy60FTM59hwFFjyCPl70sNklxiCsJuPZQ8BTr+f/P3dX6JarIPPz+eLUmkOthh0ElgdTE0TOT+DTkBKXIhGh2fOBbKGkGJTP/41quHFXIdDFMk94mwkqdgn3RbyLWFfQ1M8MPXf5O8Nb0SV7iuL0ly1JxBoOuWJLl3B0lvCbSBXMAEYdxP5+5u7olqsZYn7+fUFEjwel0qKRIaAKj5hNTqc/DiQ3AtoKCEF1DRE2MpIcXExioqKIIoi1q9fj+LiYulx9OhRNDY2huxbEyuffPIJZs+ejYcffhibNm3CiBEjMHnyZFRWdmz+/vXXX3H11VfjhhtuwObNm3HxxRfj4osvxvbt2xUdZygi6jA59gbirnE3RWUGtxj1SLQYWn1vRERoMQj+HpNBh6S4EEHNOh0RgtRds+3ziIcY8MVHKeSLfia7JQhE2TKGbpgWtmUEAPJGAqf4U0y/nRNVIGRMQl4USZyIy0aqjHaQOtgREc3TU+/1V4asBn6IPLaC9jLx+ETUt7gjfn8ri8HEh0gmRQiokM9IMEMXSsgbTH4zuEDcNfsjzwKLWaHc/j9S90bnV3BDWLaAIKU5nCaAfc4ERvkDtr/+M+CO/H6Kyfrj8xEZ53UB/c8lKdZhENE8nfhwoFpyFLEV9Pxq7E54o1Gaq/aSkv0AUbYSskK/JdzNK0Dcihf6033XvUJ6TGmEsJWRgoICFBYWwufzYezYsSgoKJAeubm50OtD3xixsmDBAtx00024/vrrMWTIELz66quwWq2dNuf797//jSlTpuD+++/H4MGD8dhjj2H06NH4z3/+o/hYu6LDlNDOoKmiBgtZNP/4KOLviymj5qeHAiW0w7AYkO8J3DxhdbPN6A+c4d9Z//BgxIW0aBR9VALQaScCEADG3Uyi78Mg4GoLs9PrGQ+Q39BWBiyJ3IIYk5Df+RVxoegMZC6FsYgBITJN2mIwARe9SGIrtn0G7PkhoiGaDDqkWol1IuJ52tZiMP7WsN4WlisxmJ5jSYVhgLhrIiykFdOuuqkm4OY7/T5ijQqDiBZqADj3n0BCDqkhszL0rr0tMaW+bnyHlHo3xpOU+jBkh9vrQ22zq9V3d4k5IWABWvcqULIuoiGmJ5ihEwCfGLCshY3PR5Q8r5Ok/g+fHtbbOk0/74z+5/gDdn3EbemNQrlXgbCUka+//hput1v6u6uHUrhcLmzcuBGTJk2SntPpdJg0aRLWrl3b4XvWrl3b6ngAmDx5cqfHA4DT6URjY2Orh9xELCAy+gUCIX+YG3FDvah3ZAdWkLLYANmJhWExCP6esIU8AJx8t98MXk3iRyIgWMhHHBfz82OBvjoTw1cSItqtACSNkgaYbXoXOPBLRMOMOvU1OFbl1HvDXsScHi/qm92tvjskPcYEah4svpfUr4iAqDNqdnwRscUACDMmpi1n/z2ws47QDE5dllEplD88QFxEWUNCBh4HE7YLgxKXEqgDtPp50i4gAqJOfW0sJa5ogNyHQRVWu6K2yQVRBPQ6AanWzgPOW9FvIinWCJHEbkRgAdLrBKTFRxk3suFNErNlSiCtJcLZqCHCTQFl8nziBqrYTtohaICwlJGLL74YdXV10t+dPS655BLFBlpdXQ2v14vs7OxWz2dnZ6O8vLzD95SXl0d0PADMnz8fycnJ0iM/P7ybIlxaXF7Y/BUYI5pcE+4kqbCO+ohLVEcl5F1NgeqVJ95I/K1hUhUqk6Yjgs3gf3xIrEBhQlNr3V4RDZGY+EvWAev8aY1T/012TWESVhByWwpODrhIvrkroq6iUS/USx4OxMKcFv68qfZ3eTbqBSSHiqcI5sy5JKjSVkq+OwKiCg5sriVxKgBw2pywlS0gSqXZnBioevnby8DRTWG/lX5Ptd0VWVzMnh+ItUnQETdiF1lebYl44wOQgMohF5MAy6/uBLzhx5pFHeD53f1+y9bYQFxHGNDzS483hY6nCObcf5KmgdV7SfXSCIhK4aovAZb5A4MnhhezRWnVsiBcEjKJQgKQ+ioy9ZFSkrCUEZ/Ph6ysLOnvzh5er4Ltv7uJuXPnoqGhQXocPnxY1s836gV8efvJeP3aMUgwR1AkTm8ggkhnIGXKI0gxjMoy8vPjJA0uqWcgiDZMohLyADGDj7uZ/P3NPWEv1maDXlowwz5Ht4PsiiCSXVIH5d67ImLLCGXiw+Q3rTsYUT+JqGJGDq4mVhiAKFthWraA1jExYbnaKCZrwAK08Z2IUgyjEvI/zCXWtMzBRBmJgJDp550x4Fxg6OXEDP5N+GbwtHgTBIGkatY1h1lC39EQKG424Q5ifYqAymjvxfOfJs3myrcCa8PfWUeV+rrza9KMUmfwpyqH7/IPO5C8LdY00v8FANY8H1FzUkmehqtwiaLfrWcH8k8KO2aLEpVlBABGXAX0OYu4hWSo5q00sjXKU5qMjAzo9XpUVLR2UVRUVCAnJ6fD9+Tk5ER0PACYzWYkJSW1esiJQa/DqF6pOPeEnMiEPEBSRGm54G/vCzu2IuKiYEd+J7s+AJj6PNkNRkDA/B3+4icx8SGyWNcfIu3QwyTixXrl02RXFJ9FdkkRQncrEQtBSxIx0QLkNz4SXoBZxDEjbkcgFmbMLKDwlIiGGdWOmlJ4qr/CLoiPPEylMjMpwl31viUkmJQGHkdgMQCCzjHcuJ9gpjxBzODl20ijsjAw6nVI87sSwp6nSx4mVqa0PsCZkWXxuL2B1OWIFa6ErEDRv+Xzger9Yb0tYstISz2xigAkfTr7hIiGGVEgeVuGXAQMngb4PGRjEqYFKGKleesnJOBZb/ZvKCNbdgPVVyOcp4JAZI0hjmSZbX4/svd3M2H9Ki+88ELYD6UwmUwYM2YMli1bJj3n8/mwbNkyTJjQsQthwoQJrY4HgCVLlnR6vCY4/X7SNbWpMtCNNAQRWUY8LmKahQgMv4oEQ0VI1JYRoHU0+NqXSHGgMIhosS7bSmoZAMQ/Hkb6YDARpS53xIBzgWFX+gPM7gyr0VzEqa8rnyZBiAk5pFx0hASUkSjODyDfmdQDqCsO2wIUUY8hp41YzwBSsKvn2IiHGFXMCCUhEzjXf14RmMEjuheLVxHrEkBSlbuoJNsRtECeIZJ4imBGXEV6SXmdRKkMo/BixEG6Sx8B7OUkuJumh0dATEozAJz/DLEAlf0RtgUooiBde1VQscgHWnXFDpeqUAXPuiKtN3CWX4n96W8Rxxt2J2H5CZ577rmwPkwQBNx1110xDagrZs+ejeuuuw5jx47FuHHj8Pzzz6OpqQnXX389AGDmzJno0aMH5s8nvrK7774bZ5xxBp599llccMEF+Pjjj/H777/j9ddfV2yMimPwa9dvnUtanA+9lERmd0GWVIU1jJtn9QKgahdgzSAVLKMgJiEPkOI9J1xKAhO//jNw0/JOe+BQwhbyXg/w1R3EHz54GjBkWsTDiyh1uTOmPAEULQMqdxLF6MyuM5Xapr6mxXexuJRuJqZngJjb41IiHl7MQp5agD68kliATri0w0ZuwdDMpLCE/LJ/kAJdKQXA2ZEFPFNiUpoBUmZ86yek9Pzie4CZX4cMSsxMNGN3uS30PHU1k7kPAGOuB3qfFvHw6HeElbrcEYJA+rq8PAEo+ZUUzQvhYmib+tplHMeBFa2VrQjciJSY52liNpFzi24jFqBBF4ZUGCKyjHz/l0B7iZMjXxtFUey4A3oknHQ76UVV9gcJhL5iYXSfozBhWUaCa4p09ThwIPoeKuEwffp0PPPMM5g3bx5GjhyJLVu24IcffpCCVEtKSlBWViYdf/LJJ+PDDz/E66+/jhEjRuDzzz/HokWLMHToUEXHqTj54wLpi2GUbw57oa7YCaz0+1HPfzpiiwElZiEPAOc9GfBZrw6tDIe9q171LPlMSwrZFUVBcLxIxK42Snx6oODRyqeByl1dHh526qu7BfjiFmJ6HnJRVMpW8HdELeQBolRGYAEK+xoeWgusf4P8Pe0FUrArQoIbHUYt5AWBuDENcUDxysDC2gVhWw6WPkysSkk9gHP+EdXwogqybktqASmSBxCXUX3XMXRhp7621JMqoQCppRShG5ESdexWMCOuBvpODNsCJLXYCOWK2v0t2VAJepLlFaJYZEc0ubxo8fejivpe1Bv8RQD9hRdjaGmgJDHFjIiiGFuJ8Si48847cejQITidTqxbtw7jx4+XXluxYgUWLlzY6vgrrrgCe/bsgdPpxPbt23H++ed363gVY+JDJCK74TDZJXYB1eTrmt1weTq50dwOYNGtpB/EwAtImeIo8PlEyTwc00KWkEUUEoA0lDq8ocvDw1K4StYBv/g/87ynyK4oCmQR8gAp6jTgPPKbf3lLyBbuYWXU/PxP0iwrPgu4IDyLZkfEvOOkTHmCWNkqdxKrWxfQ37PLwEBHI2nKB5EU6OpzZlTDamzxSI0OYzrHtD7kXgSAH/5KKoh2QVjzdO+PwHq/9XbqC8TKFAWyLNQAsYbkjycBmF/dQboid0LYqa/fP0CaD6b27rJbbSgirvfTEVSpNMaTOie/v9Xl4dI87UqhtFcGAo9P/jMpfBgFdJ7Em/SIjyThoS3BhRe/vgtoOBL9ZylEVMrIW2+9haFDh8JiscBisWDo0KF4883oeqdwosQUTwQVQARXF902U6xGGPVkB99po7Wf/k7MeHFpJI4iyh1/XbMLHn9MQ0asQnD4dH/Wghf43w1ddtsMWWrb0QB8cSP5rGFXACPCKzjUEbIJeUEg8TFxqeS3DxEDFDI4cO9PJM4GIK68+PSohybbOcanA+dTC9AzXbZwp+dnc3rQ4upgwRNFkr1Se4DU+ohlEfPPkySLARZjjAUbx99GYis8LcDnN3SpVNLfs9MAVltFwGIw/jagf9cu2K6QTWnW+Xf2RitxSa3s2qIY0o2x5SMSeCzoSLPMKCxblJCNDsMlpVcga3DJw0Dl7k4Pla5hYyd1jXz+7sD2CpLldeaDUQ8rECgfg7JFOfOvQN4oUh7ii1u6VCrVIGJlZN68ebj77rsxdepUfPbZZ/jss88wdepU3Hvvvd3Sm4YTRN+zAj7c/93QaRCdIAhdC8EdX5J+FABpzpeUG/WQ6OenxZtg1MeYrEUXa9pt88tbO72BurQa+LzkvfUl5LNoUacoqYo2k6YjkvL8DbxAlModX3Z6aJdCvqaICECIZE4MmBzTsGRxtVFOuJTUrfC5gU+uBWwd1/lJNBtgMepafX8rNrxJfh+dAbj8HaLERUng/GQQ8jod6exrzQAqtgHfdt5jqcvidR4n8NkskqqcPTTilPq2VNmjTF3uiMwBgfoqK+aTeI/ODu0q9bV0C4mvAUjAaq/x7Y+JgJhdbcGceCNpsOhuAj6+ptO2DfT8WtxeNHWkNK98hihtRitw5buk4GGUyLYpAEi22WVvEQvQodUhLerdTcSrxSuvvII33ngD8+fPx7Rp0zBt2jTMnz8fr7/+Ol5++WUlxsjpisn/AnqOIzv/T/6vU+tBp+bhknXAl7eRv0+dHVX2TDARV3wMhSUZuOxtkha359tOS6l3af5eMo+UQ9ebySJmSY5pSAEBIcNCBpDsGtoVdtHtnVoPOrWMOBqBj2cAzgZiTqfFjqJElniKYAR/6m3mIJI58enMDqteBjdaowupxN6fAlkJkx4F8k+MaUgxB1m3JTEbuPQ1stvf/H4ggLgNnSrNtONwya+AOQm4/O2oAjqDkQIf5VC4AGDk1f7eNSLw6XWdxjl1qjTbK4ky6nGQ3jNnRG8xAIAmpwfNrhjjKYLR6Yh8SM4HaouAL27qMN033mxAvIlY09oFW2/9NFCS4IIFQObAmIYUuIYyzdP0viTOCiBzdOO78nyuDESsjLjdbowd2z6NbsyYMfB4ouwKy4kegxmY/h5J4azcCbx/WYdluDM7yqip2AF8eAUxL/ebBJwVXVZCMGG3LI+E/BOBi/2K7tr/AGvbK72ZncXF/PqfQB2IS16JKgW0LbKZv4M5+yESROduBj64ggQTt6HD4EdHA/D+pSQDKiEHuPK/EdfbaIvN6YHTI0M8RTDmROCqDwFzMnB4HfDJDBJs24asjoIDS34jCozPQ1xsE+6IeTiyWn4o/SYBU/wxSUsfAf74uN0hHSrNokh2qVs/JkGGVyyMeREDZN5VU85/Guh5IjH1v3cJUHeo3SEdpr7aK4F3p5Jusml9gEvfiLjeRluorLHGGk8RTHwGMP190gts30/Alzd3qJB02A9r3xKSlQOQBIORV8c8HEWu4bDLA33Gvp0dcR8ppYh4Nlx77bV45ZVX2j3/+uuvY8aMGbIMihMhiTnAjE9JhsiR9cB7l7Zr495OCBavAt6dRhaz/PHAle+FTJ8NB9kCH9sy7PKAsvTjXOLXDYp6T4kzwuBPI6xpcpLXlswjufUAcNbfw+4CGgpFBITeQJTKnuOIoH93arvqpe1SX5uqyYJwZANxWcz4lMyFGKGKQKIc8RTBpPcFrv6QmK/3LwU+urqdJa9dRs3u74hy5mkB+p0DXPxK1PFMwShyDQFg/M2BTLcvbyH9XYJcNvS+aHR44HB7yUL39Z8Dwb3nPx1xNeDOUERpNsYB13xKeuTYyoCFF5JU8iDaWUYajpD5XLUbSMwFZnweVbp5W2S3wlLyRhLLlM5IOiX/70/tFOd2bu8/PiaWaaowx2idpChyDQHStmHYFWS8H1/DhIUkpgDWG2+8ETfeeCOGDRuGN954AzqdDrNnz5YenG4kdwRw3ddkUTr6O/DSuFYpXFJGTX098Wn+9yLim84ZDlzzScQFlTpDlpTQzjj9fqJUAMTE+NF00pIbgE4nSAGzDSXbSX2LNf7unGc/RDqdyoRiAsIUT65FzjBybf57EUlF9lcwbbVQ7/waeGk8aREel0pqXOSOkGUYigl5gFRn/b//Eb/1geXAKye36kNEf9P62hpiXfj4atKzpOBU4n+PIj2yI6KuoBsOk+cDJ/mtN0sfBj6/XrIgJFkMMBmI2K0v2kAW6c3vEffOBQuAE2+QZQiiKCqncFnTgP/7AkjrSywdb00G1r0uBe5KSnODA9j8AalTUrUbSMwDZn1LlFIZUGzjAwCDLiCbA72JyNFXT2vV4Ze6TRpqyknH6C9vIe6ngRcAF70cs9WHotg1FASi2I+4hgT1f3MXUYo7iefqDiLeCm/fvh2jR48GABQVkYDJjIwMZGRkYPv27dJxUddf4ERP7ghg1nfA538iZvtPZwIZA4ABU3BWlQ+Zhl24ZOd6YLu/Lsnwq0hhKpkUESB4IZPJTx2MIABn3E+CPr+5i5hR9y8j/ue8kbjLUIJM4y4M+OIPcoPpDKRPyshrZBtCcOqyIudoTQP+9CNJC9z6CTHfr3kBGHopBujT8aBhN85t3AR8epQcnzWEBKVF0CAuFLJlKHRGwclEcf7fDaRHz3uXEAWs/7k4v7YJQwy7ccnGdYDPvxsdfysp2S+TIgIofI46HTDlX0ByD9KBeseXpObEgCkQcoZjrnkP+gh7kP3xNgAiqVNy2ZukQZ1MNLZ4JHelIueYlAvc9DMJDN/7PfD9/cDKp4ATLsVwdwL+btiJ86s2AV9VkON7jCXnmNZbtiFUKbnxAYCB5wEzPiOZJzX7gLfPJb2B+k3C5bZqnG3ci2mr1gOi3zpyxgMkDkYmRQSQOZumLXojcX8n9yTXbtN/gW2fk6asp82JOWYpUiJWRpYvX67EODhykT0EuOUXUk/j1xdJ/5XqvRgJYKQBgA9AaiGxMoycIYvJOxhFYkbaMmoG8VsvfYQEte79Htj7Pa4BAD0AEWSHcs6jUZVf7gqauiwIQHpCbLEZnWKKJymPhacBq54hC/bvbyMdwK3+O1bUmyCc/GciAA3y/tYxl4IPh55jgdt+BZY+SjK5yrcB5dtwEoCT6DzNHETMySdcLPvXS9YtJc9xwh1AwSnAkodIUbRdXwO7vsb1AJmnACkKR2sGyQgNAJYldbkz4lJIHND614kV0lYKrH8NPQHcaAAgAqLRCuH0+0n1URncwMEoZjUIps+ZwB2/EaVyywfEEnl0I84CArImbxSx2MaQht0Z1UqfoyCQCsZ9zybz9MgGojjHkI4cLfLODg4bGMzAxHlEAOxfChxYjuomDz7faceBuOF46s/3RdQZMxKqlTTxB5M5gMQflG4mFTnLt2HjoVp8W5WJ/ieei6svjq7yaCioAEyzypC63BWCAIy+llh19i0BDq2G2NKAzzcexkrPCfjLnX9Gfl7s8SEdIWsmTVeY4kkNkjMeAPb9CBxcjaONbny9twVHU8fhn7f/WXZlmaK49YeSN5K40A6vJ4G7FTuwurgeP9bmYNyZUzH1HPkXMECmYmDhoNMBJ91K3Eu7vwWObICnpQGf/n4Uv/iG49k5s5GQGFv2WmcEGsgpfA3jUokFYeI8YO8PQMlvKKrz4PsDLtTlnY6HbrpBkXnq8fpQ4290qIg7MZiCCcANS4Bd35DzVWh96IqIlRGHw4EXX3wRy5cvR2VlJXxtSudu2rRJtsFxYiQuhQR+DrsczvoWPLH1Z5iadXhS0EEpJ1q3WEaCyRtFHgBW/LQHb/+8H9eiQLGv6zYBSNHpgYFTgIFTIAB4Yc/POFzbglluE/IV+kpF4346Ij6dKF0jr0Hd0QY8uXM1shxm/FMhRcTp8aK+2Q2gG5RmgCxUvcZLNTW+/3IbPqgqQRrktYYE0y1Wg2D0RmLBOuFiGAD8a/OPsHs8eMChR0JkTb/DpkpJd2lHJOaQDthjZuHI3io8s3c9BrkSFVOYa5pcEEV/VdtoGh1GiiBE3T5CDiJWRm644Qb89NNPuPzyyzFu3DgeG6IRMvwuBZfXh4YWN1IUmNzNLg/sTpIG1y1Cvg30O8NqCBgligbNhUFWogWHa1vCb9EeBYoGsIaA/q41Ta7QjdaipNpOdpsmvQ7JcfLFoYRLxJ1to0CxIOswyUw0w+70oMrmRJ/MBEW+Q817UQomD6f7cpTQa5iRYIqu0aHGiFgZWbx4Mb777jucckp0jY046mA26JFiNaK+2Y1Km1MRZYTemBajDgly5f1HQETt2aOk2y0/bQi7mVwMqCnk0+NNEATA6xNR2+RSZAw0KDAzMYZGhzEQsqy/DHS7ZaQNmYlmFFc3dV72XgbUnKdUyatpcsHt9SnispUq6Koka7qbiH/BHj16IDFRIbsbR1GU1uaDM2nUFPLdsVB3m2m4DVQIKrmQydLoMEoMeh3S44mirPQ8zVDRugUobRlRMHU5DJTeGHh9ohRPocY8TbOaJKtdjb3rbtTR0i1B1gwRsTLy7LPP4oEHHsChQ+0r73HYRlrIFHJjqG81CFRFVKqbdLfHU7RBaYUyOGhOtXPsqFqwjFSq6IYCAr9rtZJWAxUVSiDYZarMOdb63XiCAEl57U5IXSPyvUrN024LJGeEiG3pY8eOhcPhQJ8+fWC1WmE0tva51tbWyjY4jrx0l2VETdMwADjcPtidHiRa5I8HUDOeAlBeoez2oLkOyEw0Y1dZN8xTlZURqjQrYUVUe1ettGWEfm56vAkGJbPauiAz0YyKRqdi5ygpzSpZt7qbiJWRq6++GkePHsW//vUvZGdn8wBWDREoJ67UzaOuaTjOpEei2QCb04NKm1NRZUT1hUwhE3+wkFcraE7pXbXalpHuCCZX3zKitHWLfG6GilYDco6Nis1TtWVNdxOxMvLrr79i7dq1GDFCntLTnO5D6eBHtS0jACnTbKvyoLLRib4KRPGrbhnprOurTFT4Yw2yla5P0QXdtatWS8grHUze7anLHaD0NaQKgKrzVGlLs11dWdPdRGzfGjRoEFpaWkIfyGEOpYMfFemEGiFKpve2uLyw+VOX1baMVNuJz1xuAkJe/WuonDLit+CpGBiY3VF3YplQO3UZUP4aSgG6Ki7Uysfg8WyaLnniiScwZ84crFixAjU1NWhsbGz14LCL0iZ+tQNYgcBOSQkhTwVrnFGvSuoy0Dr1ta5Z/ij+CintlVtGlIQuZPT3lhO1U5fpdwNAbTNJfZUbJiwjCs5TURRVz9zrbiKWqFOmTAEATJzYus01DcTyer3yjIwjO5LVQAEBCKif9kq+W0Ehb1NfyNPU12q7C5WNTtl95mxYRpSLNwjuZqvqrtp/jhUKnCMLyhZNffX6RNTYXchJllcmVKicugwoG9tkc3rgcCvY6JBBZG2Ut23btpgGw1EWutttdHjgcHtlbaDlDepmy4JlpEIBAaF2vAglM9GCartLEQtXwPx9bO4465vdcHuJe0vN4MdsBV2mLFgoaeorzTaRWxmpZGDjo+Q8pZ+ZqGSjQ8aIWBk544wzWv1vs9nw0Ucf4c0338TGjRtx5513yjY4jrwkWQwwGXRweXyosjmRn2aV7bNrm1zwiVAt758SyBhSwjKivpCn37+rTJlzrGhkwTJCvrvJ5UWT04N4GV1i9BqmWo0wGdRJCQWUjW1iRWnOSrSgotHpP0d5m+WpXe4eCLbgyZ+i3e09sBgg6rtx5cqVuO6665Cbm4tnnnkGZ599Nn777Tc5x8aRGUEQAoFlMu+qqVBVM+8fUNZ0yoL5G4Bi1xAIXEc1ffHxZgOsJrIblHvXyco1lCx4x6hlJPj75b6GoigyMU/p+bk8PjQ6PLJ+NguuxO4moi1HeXk5Fi5ciLfeeguNjY248sor4XQ6sWjRIgwZMkSpMXJkJDPRjCN18jdaCwh5dYOtshW0jLCQ9goEx/7Iew29PpGhXbUZB2uaUWlzojAjXrbPrWQgkwZQNhOjkrF5KrfCVRfkalOzjIDFqEeixQCbw4Mqm0PWzKVKBgLJu5uwt7BTp07FwIEDsXXrVjz//PMoLS3Fiy++qOTYOAqgnGWEjd1YsImfdhCWi3JGhHxgVy3vQlbT5IRPBHQCkK5yCWqldtWsWEakANZG+VsX0KDYHFbmqcwKF533afEmVV1tQFDTQ7nn6XFoGQn7Sn7//fe44YYb8Oijj+KCCy6AXn98BNUca0hCXuaFjJUddbzZIKXdyr1YVzIQT0G+nwj5coXOLyPBLDUBUwulMmrUrr5KoZYRl8eHxhaZleYG9eMpAOWslKxcw+AxyK4085iRzlm9ejVsNhvGjBmD8ePH4z//+Q+qq6uVHBtHAZTqGMrKjhNQrrgbXfzV33Eqc36suKGAY98yQquwAvJaDtxeH2qa1K/BAQA5yeQ3lltpDqT1sjBPlamILJXzP06a5AERKCMnnXQS3njjDZSVleGWW27Bxx9/jLy8PPh8PixZsgQ2m03JcXJkIlOheANWLCPBY5BzV+1we9HQ4i+xrbqQD7hpfDJWYWVpx6mY+ZsRZQQIVGGV04JHmu8BRr16jQ4pwa4oOaHXMJuBa6hUwDwL2ULdTcQOt/j4ePzpT3/C6tWrsW3bNsyZMwdPPPEEsrKyMG3aNCXGyJERpbNpmBDyClRhpQtGnFGPJIs61VcpGQlmCALg8YmolbEKK1s7TmUsIyzNUyUseBVBdWLUanRIoUpztd0paxVWFgqeURSz4DFQs6m7iSn6Z+DAgXjqqadw5MgRfPTRR3KNiaMgyltG1F/IlAjwDK6/oXanaqNeJxXsKm9Q5hzVRrEdJ0PWHyWqsAZcbeqfX5rVBKNegChCKogoB4HYLfVljRJWWJfHh9oml//z1T/H7kKWUGS9Xo+LL74YX3/9tRwfx1EQegNX2Z2yNVoTRVHyC7Mh5P0phTIuZOUMWQ2AoLgRGYUgCw3kKFIAq4wKZbPLA5u/HgQLC5kSsT8VDC3UOp0gXUdZlWaG5qkSmzt6T5v0OqRa1Wl0qAbq5kVxuh2aKUF6RshzAzW2BPooyF32ORqUqMJayUjwKoWOg2ZOyAFLlhE6j2qaXHB65Ol3RRfEBLMBiRb1hbzkTpRRoWQl/ZwSaAgov2WEBTdNbrL8mW10nmYnq2+F7U64MnKcodcFqrCWybRbKWtsAUBKbLPQRyFbARO/JCAYEIBAQOGS0xXFSkEwoHW5drl2neUMuTAAZYqCsZQRBQSUZrnmaXA3WxbOkY7B5vCgSaa6RnSe5ibFyfJ5WoErI8ch9AaSSxkJLNTqCwdAGctIBUMCEJBfyAdXX2VhsRYEIWD9kekc6TzNTWZDyCuiUDJk3QLkr4lT3+yGyx8My0Laa6LFKNU1knueZjNgZe5OuDJyHJKbLK8QDAh5Nm4eJaqwsrbjzJbM3/Jcwxo7O9VXKdRVI1e8QRljSnMg7ke+Kqys1MKhyB1MTuNFWKi+SpF7nrImT7sLNq4mp1uR3TJCBSAjN48SVVgrGDvHwI5THhM/dWmxUH2VkiuzkKfXkBUhH9xojdawiRWW0rMB+ZVmKV6EgUB5SiB+Sy63N1tKc3fBlZHjEKUsIzkM+TizZBSCoigGLCMMxFMA8pfaZql2AyVHZqW5jDHzt9mgl7Il5IgbaZ0txMZ1DLgT5VGaWVO2gCDLiFz3IreMsE1tbS1mzJiBpKQkpKSk4IYbboDdbu/yPWeeeSYEQWj1uPXWW7tpxOxCb56yhhZZPi9gGWFDAALyxlQEZwuxsljT85Mr26SUQYUyR2aluYIxFwYgb0wFXfDjTXomsoWAoLgYmRXKXIauYa7M8pQ1d2J3oRllZMaMGdixYweWLFmCxYsXY+XKlbj55ptDvu+mm25CWVmZ9Hjqqae6YbRsI/duRbKMMBIYCAQWstJ6GYS830+dwki2EEDGIme2SblfkOalsCMAA5YReYU8SztOaSGrj/0cWQskBwL3oc0pT7YJnQu5DM1TSaGUIc3e5xOlrDZWXMLdhbp1rcNk165d+OGHH7BhwwaMHTsWAPDiiy/i/PPPxzPPPIO8vLxO32u1WpGTk9NdQ9UEwZYRURRjzmUvZ8wXDwB5fsVIjoVMEvKMuGgAkm2SnWTG4doWVNocyE+zxvR5ZfVsZZoA8gYGur0+qQooS4t1bgr5vUtlOEe6iLF0fglmA+JNejS5vKhodKBPZkJMn0c3F3kMzdNArZHYZU1NkwturwhBYCsupjvQhGVk7dq1SElJkRQRAJg0aRJ0Oh3WrVvX5Xs/+OADZGRkYOjQoZg7dy6am5u7PN7pdKKxsbHV41iDCiuHO/bAOYfbi/pmd6vPZQG6cyqTwzJC40UYUraAgHIkx46slEHLCFWMKm2xVwuuDGoglx6vbgO5YPJktIywVAo+mGzJ3Rb7PGXRMhJQmmM/P3oNMxLMMOo1sTzLhiYsI+Xl5cjKymr1nMFgQFpaGsrLyzt93zXXXIOCggLk5eVh69ateOCBB7Bnzx588cUXnb5n/vz5ePTRR2UbO4tYjCRwrq7ZjfJGB1Ji6O5Jd61Wk/oN5IKhOyc5dpyB4FVWhXzs51jGWA0OAMhIMEHnbwhYY3fGFLRI5ykLDeSCyZUseLFfQ7oYsrQpAIjSfKCqSZ55Klnw2DlH6k6stjvh8vhiSjlm0ZXYXaiqej344IPtAkzbPnbv3h315998882YPHkyhg0bhhkzZuC///0vvvzySxQVFXX6nrlz56KhoUF6HD58OOrvZ5kcmYRgmRT4aGGqdDHdOZXL4KahOzrWfLhytaAXRZFJIWjQ6wK9TWI8R1ZrN9B5WirHPGXQTQPIF4hsc7hh88edsKQ0p8WbYPJbMWI9R9bK+Xcnqm5l58yZg1mzZnV5TJ8+fZCTk4PKyspWz3s8HtTW1kYUDzJ+/HgAwP79+9G3b98OjzGbzTCb2doBK0FusgW7yhpjjnJnrf4GhQqrumY3WlxexJmiDzylCzVL6YRAIHsp1oW6pskFl8cHQWBPCGYnW1De6EBZgwPDe0b/OeWMutoky0i9I+b4LerqYe0a0gw0uRTKJIsB8WZ2rLCCICAn2YKS2mZUNMYWv0U3T6wpzd2Bqlc0MzMTmZmZIY+bMGEC6uvrsXHjRowZMwYA8PPPP8Pn80kKRjhs2bIFAJCbmxvVeI8l5Cp8FmwZYYkkSyBwrqyhJabAuVK/kO+Zws5uDAgsZKUxxhtQIZ+RYGamqiUlN8mCPxB7EKsk5Bmbp3TRaXF70dDijsllSoM7e6SyNU/zZJqn1OWax9h9CBD5V1LbHLM8ZdXV1h2wJXk6YfDgwZgyZQpuuukmrF+/HmvWrMGdd96Jq666SsqkOXr0KAYNGoT169cDAIqKivDYY49h48aNOHjwIL7++mvMnDkTp59+OoYPH67m6TCBXNUtWbWMCIIgZSrEKiCO1tPgTraEIB1PrOnLdJHIY+waAvIVlCpn1NVmMeqR5g+ojeU6ujw+yU3Tg7F52kOmeUotPyxaDeRyRdGMHBbPUWk0oYwAJCtm0KBBmDhxIs4//3yceuqpeP3116XX3W439uzZI2XLmEwmLF26FOeeey4GDRqEOXPm4LLLLsM333yj1ikwhVxNyMoYNivSMcWyI7M7PVLGEUuZJgDQ078DLm90wONvHhYNLAavUuRK76WWEdaUEUCeolkVjQ6IImAy6JjKFgICSvNRmSwjLNUzogSuoTyuKNYszd0BO463EKSlpeHDDz/s9PXCwsJWzaby8/Pxyy+/dMfQNIlsQr6RXbNingxBulSRSbIYmKlqSclMMMOoF+D2iqiwOaPeEZcymC5Jkau6JWsN5ILJTY7DjtLGmDK/jtSR36dHShxT2UJAwG1U2+RCs8sDqym6ZUcqzMegQhkofCaPMsJabFN3oBnLCEdeZDN/S5YRBncrKbEvZHQ31yM1tqJiSqDTCdLvfrQu+nMsY7CQFCVbhmrBoiiiooFNNw0QsLjFUmtEcrUxqFAmxxmR6A84jcVVI1nwGHNDAcGFz6I/P5vDjSYXae3AotKsNFwZOU6hQrmhxY1mV3Rlmj1eH6r83V6zGepLQwm4aaIXEEelHSebwqGHZALvuphfV5RpxIURbPmMhJomF1xen7+qJYvnGLsFT1KaGVyoAXlcNZqIbYrhGpYxmi3UXXBl5Dgl0WyQdivR7qrLGhzw+f3UGfEsKiOxl4RnXchTE7gcO04Wd9XB1YJrm1xRfQZ1YWQnWpjLFgICv3sssU2ljAZZU+g8jVbWBNfCYVFppr97LPFbR+rIhqIng1bY7oC9O5PTLQiCgJ7+fPgjUQqIw9LNw56fGgg2f8ceM8KqkKfjivYa+nyilAHAoqvNYtRL5c2jnqe1ZJ7mp7F3fsDxYRmJ1YLX2OJBs9+FweI8zfSnxXt9YtTX8XCtv4QAY6nZ3QVXRo5j8v2TnioVkXJEunnY1OSp0LI5PbA5ouvBI7lpGBUQPWM0f1fbnXB7RegYbsyV759f0c7Tw4zvOIPT7KN1RbGujMSahl7mT3lNtRpjKmCoFDqdIN2LUc9TSWlmc54qDVdGjmOocKY3QaTQmy6f0YU63myQ+uVE68vVimUkWhM/zeDITrLAwGhjLrpTpDvHSKEWFVbnaU6yBYIAuLw+1EThihJFUbr+rCrNsbppWOwq3RbJ0nyMzlOlYVP6cLoFaraOVshrQZPPi6FFu9vrk6LjWau+SgkW8tHsqlkuJEWh8yvWHWdPRuepUa9DZgKxSkXjUqxtcsHhJnEKLMZTAMFummiVZnazhShUiThyjFrwlOb4C9lVCK/XC7c7OleAWhQkG9EjUQ+HswUOR+RCsLnFgR6JehSmGKN6v9KYTCbkJluwu9wWleWgotEfoKvXISOBTRdGcDnxuma3VM0zXEoZLnhGyY/Rgkd34yz74nNT4lBpc6K0oQXDeiZH9F66wGclmmE2sOfCAALKCA3wjNQKR68hy/NUsjRHaf2RLCOMKs1Kw5WRGBFFEeXl5aivr1d7KBGTAR8eOSsLOgEoLi6O+P1XDbbAO9CMLJ0NxcVNCowwNnQ6HfpnxGH5nugWMkkAprDVdj4Yi1GPjAQzqu1OlNa3RKyMlNSQ69YrnV0B2DMtehO/zycGmb8ZPsfUOPxxuD6qecq6KxEgilIsBfoO+X+XXgwv1AFLc+TXsNHhlio9s6w0KwlXRmKEKiJZWVmwWq0xdd3sbrw+EWKlDQDQKysBel34uxWfT4TL/96+mQnMxRv4fD6UlpZibJaANwAcqolCGWE8KJDSIzUO1XYnjtS1YGiPyHbVB/2/SwHLQj41kPXl84kRKYaVNidcXh/0OoFpVxT9/aOZp0cYD7IGAgX6SmqbcbSuJeJ7qoTOU4aV5lgCrWmcSVq86bisMQJwZSQmvF6vpIikp6erPZyoMJrc8Ph80BlMsERQptnp9kIwmKATBMRb45hUwjIzM9HQdBiJJgGHaiO33GhhxwmQgmx/HI7OH19Cd5wMC/ncZAv0OgEurw+VNmdEcRHUf5+bzG6ALgAUpscDCFgAIkHq1sv4PM1LIZ1tSXpvWkTvPeS34BX4fycWoe6VikYnHG4vLMbwXWasJwN0B+zenRqAxohYrewK8lCYDESJcHkjC350+Qv7mAw6JhURgMSMGPUC4k06HKpujjjAUzOWkSgzajxen7RYsyzkDXqdZNWIdNcZEPJs36NUGaSLbiTQ2h3sz1NyjpGm99Y3u9DoIFWiWXbTpFqNiPenHUe6MZCCrBmfp0rClREZYHUxDgejf7fo8kRWNZAeb2J4tykIAgw6ATqB1Bqpa44swPioRnacUqZChDEVZQ0OuL0iTAYdchnvhRFw1USmjBzRSCEpahk5UtcCd4QVPOnizrwFT8o2iWyeUldiVqKZyRojFEEQAplfEVq46G/Sk9HCfN0BuysJp1ug5bEjFYDBlhGWEQRBSps8GOGukwZ3sr6Q9YjSV03jE/IZraAbTLRp6JJlhOEdNUAzYUgFz0gsXKIoSvOa1QqzlJ4p0aW+UmtRIcPWO0q0GTXHeyl4gCsjxz2mKCwjBw8eRF6KFbt3bJMsK6FYuHAhUlJSohlil+MQBAFbtmzp8jjavbckguBAl8cnCZQ+mQlRj7E76J1BhPTB6qaIXFEHNeCHp0Sb3htIl2R7odbpBCk482AE87SmyQWbwwNBYH+xpudXXB3ppoD9uCYKnWdHop2njG98lIQrI8cxhw8fxj133IJJYwZjQF4qCgoKcPfdd6OmpqbL9+Xn5+PXbfvQb+DgsC0j06dPx969e+UYdsRQX3UklpGS2mZ4fSKspkBvFFbplWaFXiegyeVFRaMz7PfR4FWWMxQo0RY+01IhqV5pRJkoiWCeHqgix/ZIiYsoYFINqFJ/tL4FDrc37PfRoF6WM74o0WTUiKLIY0bAlZHjlgMHDmDs2LE4ULQfT/znTXy7ehNeeeUVLFu2DBMmTEBtbW2H73O5XNDr9UhOy4LBYAg7ZiQuLg5ZWVlynkLYRGMZOVBlB0CsDqzHBJkMOmlHRccdDlKGghaEfFrk8QYer0+Kp2A9gBUACqOwjATPU9bJSDAh0WKAKEa2MTikgVo4lJ5RxMXUN7vR5G8CyLpLWEm4MiIjoiii2eVR5RFppsgdd9wBk8mEn378CWMnnILsvJ44d/IULF26FEePHsXf/vY3AEBhYSEee+wxzJw5E0lJSbj55ptRdKAYJ/RIxu4d26RsnK+//hr9+/eHxWLBWWedhXfffReCIEjF4Nq6aR555BGMHDkS7733HgoLC5GcnIyrrroKNptNOuaHH37AqaeeipSUFKSnp+PCCy9EUVFRxNeFBnhGIgAP+E3JrLtoKHScRRGYwA/VsJ9JQ6E7xrKG8Fu0lzc64PWJMOl1zDYBDKYgiowa6vLoq4F5KgiCNM6iymNznkYTwEqtKFmJZuatW0rC64zISIvbiyHzflTlu3f+YzKsYdYJqa2txY8//ojHH38c8fFWGBs9cHt9cHp8yMnJwYwZM/DJJ5/g5ZdfBgA888wzmDdvHh5++GEAgNsfX6IXAL1Oh+LiYlx++eW4++67ceONN2Lz5s247777Qo6jqKgIixYtwuLFi1FXV4crr7wSTzzxBB5//HEAQFNTE2bPno3hw4fDbrdj3rx5uOSSS7BlyxboIijQRrMMSiIQEMV+83cfDew4ATLOnxG+ZUQURU25aTITSICn0+PD0fqWsBamg9W0Jw37AbpAYLGNpPBZEZ2nmRqZp5nx2HK4Pux52uLyotJGXI+FGpinVBmpa3aj0eFGksUY8j3U1aaF+1BJuDJyHLJv3z6IoojBgwcDAMwGnV8Z8SLebMDgwYNRV1eHqqoqAMDZZ5+NOXPmSO/fuovEfpj8fTBee+01DBw4EE8//TQAYODAgdi+fbukVHSGz+fDwoULkZiYCAC49tprsWzZMul9l112Wavj3377bWRmZmLnzp0YOnRo2OdLm2tV212wOz1ICKPC4YFqIiy1I+TJjpMKtlBU2Z1odnmhE7Thp9bpBPTJTMCuskbsq7CHpYzsqSBWtv5Z7FsNgCDLSG1z2JVm6TzVgpsGCFhwDoRpwaMKc5LFgBRrZK0O1CDBbEB2khkVjU7sr7RjdK/UkO/ZS+dpdqLSw2MarozISJxRj53/mKzad0cKde1YjHrYnR6p82dbxo4d2+p/p5um9RJhuWfPHpx44omtjhk3blzI7y8sLJQUEQDIzc1FZWWl9P++ffswb948rFu3DtXV1fD5yPeWlJREpIwkmI1IizehtsmFQzVNOCEvdMn0A5JlRBsLGVWa6OIUCrr7zk2OYz49mzIgmygjeyttmDQkO+Tx+/xCfoBGhHyPlDgYdAJcHh8qbI6QTeE8Xp8UB6UZd6JfaQrXMqKljC/KgOxEVDQ6sa/CFpYysq+S/BYDNKI0KwVXRmREEISwXSVq0q9fPwiCgF27duGSSy6BxUgWIxrhvmvXLqSmpiIzMxMAEB/fWhA4acGzGDuEGo2tTZiCIEgKBwBMnToVBQUFeOONN5CXlwefz4ehQ4fC5XJF/F290qx+ZaQ5pDLS0OxGTRP5jt6asYwEimaFU4qaKiOFGexbRShUqdhbbgtxJEFrO06DXoceqXE4VNOMg9XNIZWRw3Ut8PhEWIzsF62jBFvwRFEMGRyupbReyoDsRKzaV4095eEpXFpTmpVCG1sijqykp6fjnHPOwcsvv4yWlhap7bjT40N5eTk++OADTJ8+vVNB4fQSpcWsJ68PHDgQv//+e6tjNmzYENMYa2pqsGfPHvz973/HxIkTJddRtAQyFUKbh4v81oXsJHNYLh0WyEwwI9FMMhXCiTmQMhTStKFsAUHKSEVoIS+KIvb5jxuQrZ0dJ7UAlITRS4laFwrT4zUREwMQV5Tgr4hcZQ+dhn5QQxlfFDrfqDLcFQ63V0pd1orSrBRcGTlO+c9//gOn04nJkydj/drVKC89ghVLf8Kkc85Bjx49Oo338PlEuDzEvWP0KzG33HILdu/ejQceeAB79+7Fp59+ioULFwKIvlR+amoq0tPT8frrr2P//v34+eefMXv27Kg+CwB6+90t+8NYyIo15qIByO8suWrCMIHvLqcdl7WjjAz0C+v9VXZ4fV1nj5U3OmBzeqDXCZqJpwACbox94cxTDWXSUCxGvZS+Gk58E52n/TWkUAaU5tDKyP5KO0QRSLEakZHAfkyMknBl5Dilf//++P3339GnTx9cfdVVuODU0fjHg/fgtNPPwNq1a5GW1nFXTYcnUKyIVl/t3bs3Pv/8c3zxxRcYPnw4XnnlFSk12GyOLqVSp9Ph448/xsaNGzF06FDce++9UoBsNJyQlwQA2FHaGPJYKShQQws1EGQCDyM4cKf/dwgnfoYVeqbGIc6oh8vjC5n+Sq0nhelWyfKnBQbnkoUsnHlKM2m0pGwBASU/lDLi9YnYVaa9eUotHJU2J+qbu3Yp76v0u2iyEpmvZ6Q02rBBcxShoKBAsmAUVzfB5nCjR0oc0hMCCsTBgwdbvcfp9qFHfi/sr7S12pFNmzYN06ZNk/5//PHH0bNnT1gsxJc9a9YszJo1S3r9kUcewSOPPNLqs++55x7cc8890v+TJk3Czp07Wx0TXE+lsLAw7PoqJ/Qgysj+KnvImIoDGkvrpdDxFoWwjNQ1uaSuokP8SpoW0OkE9MtKwLajDdhbYesyaFOrfni66O4obQgZU1GssYwvSp/MePyytyqkBe9QTROaXV6YDTpN3YsJZgN6pMThaH0L9lbYMa53xxs7IKA0a8nyoxTcMsIBACmI1RmiRw21jFja7DZffvllbNiwAQcOHMB7772Hp59+Gtddd50yg42CnCQL0uNN8PpEyfTbGVQZ0ZL5Gwg/vXenf7eZnxaH5LjQdRBYIty4Ea0Fr1IGZCfCqBfQ6PCErOIpKc1anachLHjUOjQoNwkGhruDd8TAHDLv9oRw1WhVaVYCbV1hjmJQU3aonhE0rZcqL5R9+/bhoosuwpAhQ/DYY49hzpw57SwfaiIIgmQF2FHa0OlxDrdXctP001iqHR3vvgpblzEV9PxPyNWO6ZtCgwNDCfm9GgxeBUhpf7owdTVPK20OVNqcEARtxf0AgfHuCbEp2CG5ErVjvaNQS0eozC+a1sstI1wZ4fgJpPeGsIz4lRVzGzfHc889h9LSUjgcDuzduxcPPfQQDAa2vIABE3jn/vjtRxvg9orISDBrrk9E38x4xJv0aHJ5uwye07KQH+Dfce7r4vxEUcR+WrtBgzvOcOKbNh2qB0BiDRLDqPLJEkN7JEMQSMO8ykZHp8dRZWxIrvbm6cAwglhbXF6pqJsW56nccGWEAyBgGfH4fJ32/vD6RLj8r1k0UigrmKH+uJEdRzvfcW48RNKHR/dK0VxAmUGvw8heKQCATSWdp0FLykgP7Ql5KrQPVDXB1YlLsbTBAbvTA4NOQKGGimVRhvYgSvP2LubpZv/1HV2Q0h1DkpUki1FarDubp6IoBgVZa3ee7q2wdRrXVlRFMmnS4k3ISGC/d5LSaG9F4SiCXidIlTg7s444/VYRg06nOR8uELCM7C63dapwbZKEfOjKiSxCKz5SpaotLS6vFDiopQwFSl6yBQlmAzw+UUptbcuecrKI9c6I10x12WDCsYxsLqkHAIwKo8Ini9D7q7N5WmlzoqbJBZ0ADMrRnjLSLysBgkB61HRWT4VmCmmlXYHSaO9O5SgGLSnf5PJ0+Dp93mrSTqpkMAVpViSYDXB6fFJaZDCiKGKTX8iHU8aZRaiQ39SJkN9d3gifSNq5a6GTbVuCY39+P1Tb4TG/HSDPj8xP6a5hycrg3CQIAlmQK23t3Rhurw9bj9YD0O48HRNCaaYumr6ZCYjToLyxGPVSADx1qbVl7YEaANpVKOWGKyMcCVpt1O7oWBmx+Z/XSlXStuh0guR/7sgEfqSuBVU2Jww6AcN7as9qAACj84lgO1jTjJoOdmR0tz0kL1lzbijKaf0yAACr9lZ3+PqqfeT5U/tndNuY5MRqMkiprB1ZR3aVNcLh9iE5zqiplNdgxviV5u1HG+H0tA+a33FUuy4ayqn+ebpyX1W710RRxJr9ZJ6eptF5KjdcGeFIJFqIktHs8rbLxvD5RDS5iNBIsGhTGQECdTW2d5CpQF00J+QlheztwirJVqOUVUOtPMFImTQaFvKnDSA9k9YUVbdzt1XZnJL5+5R+2hXyNG6ko/gmavUa1StFM2Xg21KQbkV6vAkurw/bj7ZXuOj9qaU6OG2hSsbKvVXt4kaKquyoaHTCbNBJitnxDldGOBImgx4mgw4iRDQ5W1tHmlweiKIIo14Hswb98JRR/gDPjgREQMhrWzh0ZgL3+UQs3012aVo17wPAsB7JSI4zwubwYGubxfrXIrLbHJKbpOmgwBE9UwAAK/e1t/5o3ZUIEHdbZy5Fh9uL1f7zHlvYecEw1jmpTzqMegFH6lpwsE2/KGq9G9c7TbMbH7nR7qrCUYREvwvG1kYZsTsDLhqtmvcB4OxBWTAbdCiqapKKf1EkIa/xnQrdabXNVPj9UB3KGx1ItBhw+gDtWg30OkEygbd11VAhr3XT95ShOQCADQdrUVrfuviZFGStYWUECMzTtkrz8t2VaHJ50SMlDqM0GvcDAPFmg3SOq9q4aqiLRsvWO7nhyshxhiAIXT5efGY+gPZxIzReJFFBF40gCFi0aJFinw8AiRYjzh6UBQD4+o9S6flg8/5ov/VEq9B0zz8O16PR4Zae/8Z/vpNPyNFUv5aOoMpGsJAXRVHaUWs1XoSSlxKHcYVpEEVg8dbAPC2qsuNIXQsEARiRr824JgpdqDccrIU7yN22eGsZAODC4bma3vgAwOl+l+LKIKXZ7fVJQdancmVEQjPKyOOPP46TTz4ZVqsVKSkpYb1HFEXMmzcPubm5iIuLw6RJk7Bv3z5lB8o4ZWVl0uP5559HUlJSq+fmPnA/BAhwerxw+QPL3F6fVOwsvk3wqsvVdSMoFpk6Ig8AsPiPMvj8sTFvrymGxydiRH4KeqZqp115R/TNTEC/rAQ4PT68t/YQAMDj9eG7bUTI0/PXMlTZ2BykcBVV2VHe6IDJoMOJGjbvU6aNJNcpWGl+7ZciAMDEQVmaK3bWluE9k5GRYEZNkwtfbjoKAGhyerBsdwUA4MLh2p+np/cnysjaomqpLs4fh+thd3qQFm/SZEE3pdCMMuJyuXDFFVfgtttuC/s9Tz31FF544QW8+uqrWLduHeLj4zF58mQ4HJ1X/YsJUQRcTeo8wmwYl5OTIz2Sk0lGBf2/qakJM6+9FmeN6o+TBvbEuHHjsHTpUtQ1EYUjzqhH/7598Nhjj2HmzJlISkrCzTffDAB44403kJ+fD6vViksuuQQLFixopzR+9dVXGD16NCwWC/r06YNHH30UHg+xuBQWFgIALrnkEgiCIP2vBGcPykKC2YCj9S3YfLgODS1uadG+48y+in1vdyEIAu44i5zHW6uL0ezy4LcDtahpciHVasTJfdNVHmHs9Ey1ok9mPLw+EYs2k4Xsg3UlAIBxhceGH/78Ybkw6ARsP9qI/ZV2lDW04Ev/ud52Zj+VRxc7ZoMet57RBwDwn+X74fb6sGx3JRxuHwrSrVKRQi0zJDcJ6fEmNLm8+GlnOURRxH/9smZC33TNBiArgWbSIh599FEAkLrMhkIURTz//PP4+9//josuuggA8N///hfZ2dlYtGgRrrrqKvkH6W4G/qWSNv/XUsAUW5qf3W7H+eefj7/87RHUOn345vOPMXXqVHy1Yj1yeuQjLcEEAHjmmWcwb948PPzwwwCANWvW4NZbb8WTTz6JadOmYenSpXjooYdaffaqVaswc+ZMvPDCCzjttNNQVFQkKTIPP/wwNmzYgKysLLzzzjuYMmUK9HrlFhOLUY9zh2Tji81H8dLyIhSkW2F3ejAwOxGTBmcr9r3dydTheXh+6T4cqmnG80v3SVk05w3LhVGDBes64qoT8/Gv73bjn4t3obLRiXfWHAQAXHdyoarjkou0eBNO65+B5Xuq8MKyfTAbdHB7RYzvnXbMZGBcM74XXllRhJLaZry0fD+W764EcGy4aABSTuCyMT3x+soDePB/27DtSAO+/qMUep2AP51SqPbwmOLYkEodUFxcjPLyckyaNEl6Ljk5GePHj8fatWs7fZ/T6URjY2Orx/HCiBEjcMstt+CUcaMwauhg3Hn/39CjVyGWL/keqVYT0qxEGTn77LMxZ84c9O3bF3379sWLL76I8847D/fddx8GDBiA22+/Heedd16rz3700Ufx4IMP4rrrrkOfPn1wzjnn4LHHHsNrr70GAMjMJObMlJQU5OTkSP8rxeVjewIAft5dKS1it5/V95jZqRj0Otzut/K8vvIA1uyvgU4ALh/TU+WRyceNp/bBlBNy4PL68J/l+wEAN5/eB+cMOTYUSgC4Ymw+AOKq+WzjEQDA7Wdp3ypCsZoMuOl0Yh15fuk+/HGkASaDDpeMOnbm6X3nDsT43mmwOz14beUBAMBfJg/EmALtuxLlRDOWkUgpLy8HAGRntxZM2dnZ0msdMX/+fMkKEzFGK7FQqIEx9jgHu92ORx55BN9++y3KysrgdnvgcLSguqwUPVLipJ3K2LFjW71vz549uOSSS1o9N27cOCxevFj6/48//sCaNWvw+OOPS895vV44HA40NzfDau3eOI2T+2bg7Vlj8dbqYqzZX4NBOYm4YFhut45BaS4Z1ROvrTyAA1VNOGNAJm49o6/mMzCC0ekEPHvlCBx8pQm7y204qU8a/jJ5oNrDkpXzh+Xi31eNxPu/HcKGg3UY1zsNp2s8OLct155UgHd/PYjyRgfOHZKNO8/qr7mO2V1hMujw6v+NwcUvr8GhmmacMyQbN/sVME4AVZWRBx98EE8++WSXx+zatQuDBg3qphEBc+fOxezZs6X/GxsbkZ+fH96bBSFmV4ma3HfffViyZAmeeeYZ9OvXD0azGVdcfgXiDGIri0F8fOTnaLfb8eijj+LSSy9t95rFYolp3NFy9qBsnD0oG5U2B+JNBk322+kKk0GHRXecgmanFznJ6vzGShNvNuCDG8djyc4KnD8895i7hgBw0cgeuGhkD1TbnZpPre+IeLMB3951Glwe3zE7T1PjTfj0lglYsacSU0fkHXPXUA5UVUbmzJmDWbNmdXlMnz7RaZA5OSRPv6KiArm5gR1vRUUFRo4c2en7zGYzzGbtFkuKhTVr1mDWrFmSlcNut+NwySHoQtw4AwcOxIYNG1o91/b/0aNHY8+ePejXr3MTs9FohNfbvjS00mQlHpsCECAdUpM0nnURivQEM64a10vtYSiOlou4hSIt3qT2EBQnO8mC6Sce+/M0WlRVRjIzMxWLDejduzdycnKwbNkySflobGzEunXrIsrIOZ7o378/vvjiC0ydOhWCIOChhx6Cz9dxd9tg/vznP+P000/HggULMHXqVPz888/4/vvvW2n/8+bNw4UXXohevXrh8ssvh06nwx9//IHt27fjn//8JwCSUbNs2TKccsopMJvNSE09dlwKHA6Hw+kczdg0S0pKsGXLFpSUlMDr9WLLli3YsmUL7Ha7dMygQYPw5ZdfAiDpjffccw/++c9/4uuvv8a2bdswc+ZM5OXl4eKLL1bpLNhmwYIFSE1Nxcknn4ypU6di8uTJGD16dMj3nXLKKXj11VexYMECjBgxAj/88APuvffeVu6XyZMnY/Hixfjpp59w4okn4qSTTsJzzz2HgoIC6Zhnn30WS5YsQX5+PkaNGqXIOXI4HA6HPQSxbYMORpk1axbefffdds8vX74cZ555JgCigLzzzjuS60cURTz88MN4/fXXUV9fj1NPPRUvv/wyBgwYEPb3NjY2Ijk5GQ0NDUhKap337nA4UFxcjN69e6sW98AqN910E3bv3o1Vq1apNgZ+fTgcDkddulpDg9GMMqIWXBkJj2eeeQbnnHMO4uPj8f3332POnDl4+eWXceONN6o2Jn59OBwOR13CVUaO2dReTveyfv16PPXUU7DZbOjTpw9eeOEFVRURDofD4WgHroxwZOHTTz9VewgcDofD0SiaCWDlcDgcDodzbMKVERngYTdswq8Lh8PhaAOujMSA0UiKSTU3N6s8Ek5HuFyk27CSTfc4HA6HEzs8ZiQG9Ho9UlJSUFlJOk1arVZe5pcRfD4fqqqqYLVaYTDwac7hcDgsw6V0jNCy81Qh4bCDTqdDr169uILI4XA4jMOVkRgRBAG5ubnIysqC2+1WezicIEwmE3Q67onkcDgc1uHKiEzo9Xoem8DhcDgcThTwbSOHw+FwOBxV4coIh8PhcDgcVeHKCIfD4XA4HFXhMSMhoIWzGhsbVR4Jh8PhcDjagq6doYpQcmUkBDabDQCQn5+v8kg4HA6Hw9EmNpsNycnJnb4uiLxmdpf4fD6UlpYiMTFRtnoVjY2NyM/Px+HDh7tsqawl+DlpA35O2uFYPC9+TtpAznMSRRE2mw15eXldllrglpEQ6HQ69OzZU5HPTkpKOmYmL4Wfkzbg56QdjsXz4uekDeQ6p64sIhQewMrhcDgcDkdVuDLC4XA4HA5HVbgyogJmsxkPP/wwzGaz2kORDX5O2oCfk3Y4Fs+Ln5M2UOOceAArh8PhcDgcVeGWEQ6Hw+FwOKrClREOh8PhcDiqwpURDofD4XA4qsKVEQ6Hw+FwOKrClREVeOmll1BYWAiLxYLx48dj/fr1ag8pLObPn48TTzwRiYmJyMrKwsUXX4w9e/a0OubMM8+EIAitHrfeeqtKIw6PRx55pN2YBw0aJL3ucDhwxx13ID09HQkJCbjssstQUVGh4ohDU1hY2O6cBEHAHXfcAUAb12nlypWYOnUq8vLyIAgCFi1a1Op1URQxb9485ObmIi4uDpMmTcK+fftaHVNbW4sZM2YgKSkJKSkpuOGGG2C327vxLFrT1Tm53W488MADGDZsGOLj45GXl4eZM2eitLS01Wd0dG2feOKJbj6TAKGu06xZs9qNd8qUKa2O0dJ1AtDhvSUIAp5++mnpGNauUzjyOxxZV1JSggsuuABWqxVZWVm4//774fF4Yh4fV0a6mU8++QSzZ8/Gww8/jE2bNmHEiBGYPHkyKisr1R5aSH755Rfccccd+O2337BkyRK43W6ce+65aGpqanXcTTfdhLKyMunx1FNPqTTi8DnhhBNajXn16tXSa/feey+++eYbfPbZZ/jll19QWlqKSy+9VMXRhmbDhg2tzmfJkiUAgCuuuEI6hvXr1NTUhBEjRuCll17q8PWnnnoKL7zwAl599VWsW7cO8fHxmDx5MhwOh3TMjBkzsGPHDixZsgSLFy/GypUrcfPNN3fXKbSjq3Nqbm7Gpk2b8NBDD2HTpk344osvsGfPHkybNq3dsf/4xz9aXbs///nP3TH8Dgl1nQBgypQprcb70UcftXpdS9cJQKtzKSsrw9tvvw1BEHDZZZe1Oo6l6xSO/A4l67xeLy644AK4XC78+uuvePfdd7Fw4ULMmzcv9gGKnG5l3Lhx4h133CH97/V6xby8PHH+/Pkqjio6KisrRQDiL7/8Ij13xhlniHfffbd6g4qChx9+WBwxYkSHr9XX14tGo1H87LPPpOd27dolAhDXrl3bTSOMnbvvvlvs27ev6PP5RFHU3nUCIH755ZfS/z6fT8zJyRGffvpp6bn6+nrRbDaLH330kSiKorhz504RgLhhwwbpmO+//14UBEE8evRot429M9qeU0esX79eBCAeOnRIeq6goEB87rnnlB1clHR0Ttddd5140UUXdfqeY+E6XXTRReLZZ5/d6jmWr5Motpff4ci67777TtTpdGJ5ebl0zCuvvCImJSWJTqczpvFwy0g34nK5sHHjRkyaNEl6TqfTYdKkSVi7dq2KI4uOhoYGAEBaWlqr5z/44ANkZGRg6NChmDt3Lpqbm9UYXkTs27cPeXl56NOnD2bMmIGSkhIAwMaNG+F2u1tds0GDBqFXr16auWYulwvvv/8+/vSnP7Vq9qjF60QpLi5GeXl5q+uSnJyM8ePHS9dl7dq1SElJwdixY6VjJk2aBJ1Oh3Xr1nX7mKOhoaEBgiAgJSWl1fNPPPEE0tPTMWrUKDz99NOymMmVZMWKFcjKysLAgQNx2223oaamRnpN69epoqIC3377LW644YZ2r7F8ndrK73Bk3dq1azFs2DBkZ2dLx0yePBmNjY3YsWNHTOPhjfK6kerqani93lYXEgCys7Oxe/dulUYVHT6fD/fccw9OOeUUDB06VHr+mmuuQUFBAfLy8rB161Y88MAD2LNnD7744gsVR9s148ePx8KFCzFw4ECUlZXh0UcfxWmnnYbt27ejvLwcJpOp3WKQnZ2N8vJydQYcIYsWLUJ9fT1mzZolPafF6xQM/e07upfoa+Xl5cjKymr1usFgQFpamiauncPhwAMPPICrr766VbOyu+66C6NHj0ZaWhp+/fVXzJ07F2VlZViwYIGKo+2cKVOm4NJLL0Xv3r1RVFSEv/71rzjvvPOwdu1a6PV6zV+nd999F4mJie1ctyxfp47kdziyrry8vMN7jr4WC1wZ4UTFHXfcge3bt7eKrQDQys87bNgw5ObmYuLEiSgqKkLfvn27e5hhcd5550l/Dx8+HOPHj0dBQQE+/fRTxMXFqTgyeXjrrbdw3nnnIS8vT3pOi9fpeMLtduPKK6+EKIp45ZVXWr02e/Zs6e/hw4fDZDLhlltuwfz585ksSX7VVVdJfw8bNgzDhw9H3759sWLFCkycOFHFkcnD22+/jRkzZsBisbR6nuXr1Jn8VhPupulGMjIyoNfr20UnV1RUICcnR6VRRc6dd96JxYsXY/ny5ejZs2eXx44fPx4AsH///u4YmiykpKRgwIAB2L9/P3JycuByuVBfX9/qGK1cs0OHDmHp0qW48cYbuzxOa9eJ/vZd3Us5OTntAsM9Hg9qa2uZvnZUETl06BCWLFkSsoX7+PHj4fF4cPDgwe4ZYIz06dMHGRkZ0lzT6nUCgFWrVmHPnj0h7y+AnevUmfwOR9bl5OR0eM/R12KBKyPdiMlkwpgxY7Bs2TLpOZ/Ph2XLlmHChAkqjiw8RFHEnXfeiS+//BI///wzevfuHfI9W7ZsAQDk5uYqPDr5sNvtKCoqQm5uLsaMGQOj0djqmu3ZswclJSWauGbvvPMOsrKycMEFF3R5nNauU+/evZGTk9PqujQ2NmLdunXSdZkwYQLq6+uxceNG6Ziff/4ZPp9PUr5Ygyoi+/btw9KlS5Genh7yPVu2bIFOp2vn6mCVI0eOoKamRpprWrxOlLfeegtjxozBiBEjQh6r9nUKJb/DkXUTJkzAtm3bWimPVGEeMmRIzAPkdCMff/yxaDabxYULF4o7d+4Ub775ZjElJaVVdDKr3HbbbWJycrK4YsUKsaysTHo0NzeLoiiK+/fvF//xj3+Iv//+u1hcXCx+9dVXYp8+fcTTTz9d5ZF3zZw5c8QVK1aIxcXF4po1a8RJkyaJGRkZYmVlpSiKonjrrbeKvXr1En/++Wfx999/FydMmCBOmDBB5VGHxuv1ir169RIfeOCBVs9r5TrZbDZx8+bN4ubNm0UA4oIFC8TNmzdLmSVPPPGEmJKSIn711Vfi1q1bxYsuukjs3bu32NLSIn3GlClTxFGjRonr1q0TV69eLfbv31+8+uqr1TqlLs/J5XKJ06ZNE3v27Clu2bKl1T1GMxV+/fVX8bnnnhO3bNkiFhUVie+//76YmZkpzpw5k8lzstls4n333SeuXbtWLC4uFpcuXSqOHj1a7N+/v+hwOKTP0NJ1ojQ0NIhWq1V85ZVX2r2fxesUSn6LYmhZ5/F4xKFDh4rnnnuuuGXLFvGHH34QMzMzxblz58Y8Pq6MqMCLL74o9urVSzSZTOK4cePE3377Te0hhQWADh/vvPOOKIqiWFJSIp5++uliWlqaaDabxX79+on333+/2NDQoO7AQzB9+nQxNzdXNJlMYo8ePcTp06eL+/fvl15vaWkRb7/9djE1NVW0Wq3iJZdcIpaVlak44vD48ccfRQDinj17Wj2vleu0fPnyDufbddddJ4oiSe996KGHxOzsbNFsNosTJ05sd641NTXi1VdfLSYkJIhJSUni9ddfL9psNhXOhtDVORUXF3d6jy1fvlwURVHcuHGjOH78eDE5OVm0WCzi4MGDxX/961+tFnaWzqm5uVk899xzxczMTNFoNIoFBQXiTTfd1G7zpaXrRHnttdfEuLg4sb6+vt37WbxOoeS3KIYn6w4ePCied955YlxcnJiRkSHOmTNHdLvdMY9P8A+Sw+FwOBwORxV4zAiHw+FwOBxV4coIh8PhcDgcVeHKCIfD4XA4HFXhygiHw+FwOBxV4coIh8PhcDgcVeHKCIfD4XA4HFXhygiHw+FwOBxV4coIh8M5bhEEAYsWLVJ7GBzOcQ9XRjgcjqJUVVXhtttuQ69evWA2m5GTk4PJkydjzZo1ag+Nw+EwgkHtAXA4nGObyy67DC6XC++++y769OmDiooKLFu2DDU1NWoPjcPhMAK3jHA4HMWor6/HqlWr8OSTT+Kss85CQUEBxo0bh7lz52LatGkAgAULFmDYsGGIj49Hfn4+br/9dtjtdukzFi5ciJSUFCxevBgDBw6E1WrF5ZdfjubmZrz77rsoLCxEamoq7rrrLni9Xul9hYWFeOyxx3D11VcjPj4ePXr0wEsvvdTleA8fPowrr7wSKSkpSEtLw0UXXaR6y3cO53iAKyMcDkcxEhISkJCQgEWLFsHpdHZ4jE6nwwsvvIAdO3bg3Xffxc8//4y//OUvrY5pbm7GCy+8gI8//hg//PADVqxYgUsuuQTfffcdvvvuO7z33nt47bXX8Pnnn7d639NPP40RI0Zg8+bNePDBB3H33XdjyZIlHY7D7XZj8uTJSExMxKpVq7BmzRokJCRgypQpcLlc8vwgHA6nY2JutcfhcDhd8Pnnn4upqamixWIRTz75ZHHu3LniH3/80enxn332mZieni79/84774gAWnVSvuWWW0Sr1dqqs+vkyZPFW265Rfq/oKBAnDJlSqvPnj59unjeeedJ/wMQv/zyS1EURfG9994TBw4cKPp8Pul1p9MpxsXFiT/++GPkJ87hcMKGW0Y4HI6iXHbZZSgtLcXXX3+NKVOmYMWKFRg9ejQWLlwIAFi6dCkmTpyIHj16IDExEddeey1qamrQ3NwsfYbVakXfvn2l/7Ozs1FYWIiEhIRWz1VWVrb67gkTJrT7f9euXR2O848//sD+/fuRmJgoWXTS0tLgcDhQVFQU68/A4XC6gAewcjgcxbFYLDjnnHNwzjnn4KGHHsKNN96Ihx9+GGeeeSYuvPBC3HbbbXj88ceRlpaG1atX44YbboDL5YLVagUAGI3GVp8nCEKHz/l8vqjHaLfbMWbMGHzwwQftXsvMzIz6czkcTmi4MsLhcLqdIUOGYNGiRdi4cSN8Ph+effZZ6HTEUPvpp5/K9j2//fZbu/8HDx7c4bGjR4/GJ598gqysLCQlJck2Bg6HExrupuFwOIpRU1ODs88+G++//z62bt2K4uJifPbZZ3jqqadw0UUXoV+/fnC73XjxxRdx4MABvPfee3j11Vdl+/41a9bgqaeewt69e/HSSy/hs88+w913393hsTNmzEBGRgYuuugirFq1CsXFxVixYgXuuusuHDlyRLYxcTic9nDLCIfDUYyEhASMHz8ezz33HIqKiuB2u5Gfn4+bbroJf/3rXxEXF4cFCxbgySefxNy5c3H66adj/vz5mDlzpizfP2fOHPz+++949NFHkZSUhAULFmDy5MkdHmu1WrFy5Uo88MADuPTSS2Gz2dCjRw9MnDiRW0o4HIURRFEU1R4Eh8PhyE1hYSHuuece3HPPPWoPhcPhhIC7aTgcDofD4agKV0Y4HA6Hw+GoCnfTcDgcDofDURVuGeFwOBwOh6MqXBnhcDgcDoejKlwZ4XA4HA6HoypcGeFwOBwOh6MqXBnhcDgcDoejKlwZ4XA4HA6HoypcGeFwOBwOh6MqXBnhcDgcDoejKlwZ4XA4HA6Hoyr/Dy9DSBfBs7KXAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sr = 16000\n", + "freq = 300\n", + "true_gain = 0.15\n", + "\n", + "# generate half a second of sine wave at 300 Hz\n", + "input_audio = get_sine(1.0, freq, sr)\n", + "target_sine = torch.cos(torch.linspace(0, 2 * torch.pi * freq, sr // 2))\n", + "target_audio = true_gain * target_sine\n", + "\n", + "plot_graph('Sample', 'Amplitude', [-1.2, 1.2], input_audio[:200], target_audio[:200], [\"Original\", \"Target\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bexYBT4h84hu" + }, + "source": [ + "The correct choice of the loss function can play a crucial role in optimizing parameters for audio controls. In this case, we want the loss to be invariant to phase shifts. In the case of gain, we can as an example compute the spectrogram and compare the magnitudes of the frequency bins.\n", + "\n", + "We can write a custom loss module to do just that:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "3Vx-ILgZ84hv" + }, + "outputs": [], + "source": [ + "class SpectralLoss(torch.nn.Module):\n", + " def __init__(self, power=1):\n", + " super().__init__()\n", + " self.power = power\n", + "\n", + " def forward(self, x, y):\n", + " x_mags = torch.fft.rfft(x).abs() ** self.power\n", + " y_mags = torch.fft.rfft(y).abs() ** self.power\n", + "\n", + " return torch.nn.functional.l1_loss(x_mags, y_mags)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "aTpOxfvY84hv" + }, + "outputs": [], + "source": [ + "def get_gain_animation(org, tgt, gains):\n", + " fig, ax = plt.subplots(figsize=(6, 3))\n", + " ax.plot(tgt[:200])\n", + " line, = ax.plot([], [])\n", + " ax.set_xlabel(\"Time (samples)\")\n", + " ax.set_ylabel(\"Amplitude\")\n", + " ax.set_ylim(-1, 1)\n", + " ax.legend([\"Target\", \"Estimate\"], loc=1)\n", + "\n", + " def init():\n", + " line.set_data([], [])\n", + " return line,\n", + "\n", + " def animate(i):\n", + " line.set_data(np.arange(200), org[:200] * gains[i * 5])\n", + " ax.set_title(f\"Estimated signal after {i * 5} iterations\")\n", + " return line,\n", + "\n", + " # Create the animation\n", + " anim = FuncAnimation(fig, animate, init_func=init, frames=len(gains) // 5, interval=50, blit=True)\n", + " plt.close(fig)\n", + " return anim" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "eraL99X684hv", + "outputId": "e424fb25-9819-4c7e-dbe4-7857d6401736", + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model = LinearGain()\n", + "\n", + "spectral_loss = SpectralLoss()\n", + "\n", + "optim = torch.optim.SGD(model.parameters(), lr=0.01)\n", + "\n", + "n_iter = 300\n", + "\n", + "gains = []\n", + "\n", + "for i in range(n_iter):\n", + " gains.append(model.gain.item())\n", + "\n", + " optim.zero_grad()\n", + " estim_audio = model(input_audio)\n", + " loss = spectral_loss(estim_audio, target_audio)\n", + " loss.backward()\n", + " optim.step()\n", + "\n", + "display(HTML(get_gain_animation(input_audio, target_audio, gains).to_html5_video()))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BFTV4Zz584hv" + }, + "source": [ + "More loss functions can be found in the PyTorch documentation https://pytorch.org/docs/stable/nn.html#loss-functions, while perceptual loss functions like spectral losses can be found in https://github.com/csteinmetz1/auraloss" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Zyc2FpN384hv" + }, + "source": [ + "### A simple *Differentiable* **IIR Filter** Effect" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FLFPiTeO84hv" + }, + "source": [ + "A system with infinite impulse response (IIR) is called an IIR filter. Here, each processed output sample is dependent on both former samples of the input and former samples of the output, each scaled by a coefficient. It is also called a recursive system because the output samples are recursively computed from past output samples.\n", + "\n", + "The z-domain transfer function of a general second order IIR filter having 2 poles and 2 zeros (poles and zeros are the roots of the numerator and denominator of the transfer function, respectively), is given by:\n", + "\n", + "$\\begin{aligned}H(z) = \\frac{b_0 + b_1z^{-1} + b_2z^{-2}}{1 + a_1z^{-1} + a_2z^{-2}}\\end{aligned}$\n", + "\n", + "Since this transfer function is the ratio of two quadratic functions, it is commonly referred to as a biquad filter, which is used for many musical purposes.\n", + "\n", + "As before, we can train (automatically update and predict) the coefficients of this filter function to estimate a specific frequency response. We use the *Transposed Direct Form-II (TDF-II)* to retrieve the difference equation from above transfer function.\n", + "\n", + "- $y[n] = b_0x[n] + h_1[n-1]$\n", + "- $h_1[n] = b_1x[n] - a_1y[n] + h_2[n-1]$\n", + "- $h_2[n] = b_2x[n] - a_2y[n]$\n", + "\n", + "We again implement this difference equation into PyTorch by inhereting from the nn.Module.\n", + "\n", + "Notice how we store the vectors h1 and h2 in a matrix for simplification purposes." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "9ljNWF0684hv" + }, + "outputs": [], + "source": [ + "class DTDFII(Module):\n", + " def __init__(self):\n", + " super(DTDFII, self).__init__()\n", + " self.b0 = Parameter(FloatTensor([uniform(-1, 1)]))\n", + " self.b1 = Parameter(FloatTensor([uniform(-1, 1)]))\n", + " self.b2 = Parameter(FloatTensor([uniform(-1, 1)]))\n", + " self.a1 = Parameter(FloatTensor([uniform(-0.5, 0.5)]))\n", + " self.a2 = Parameter(FloatTensor([uniform(-0.5, 0.5)]))\n", + "\n", + " def _cat(self, vectors):\n", + " return torch.cat([v_.unsqueeze(-1) for v_ in vectors], dim=-1)\n", + "\n", + " def forward(self, input, h):\n", + " output = input * self.b0 + h[:, 0]\n", + "\n", + " h1 = input * self.b1 + h[:, 1] - output * self.a1\n", + " h2 = input * self.b2 - output * self.a2\n", + "\n", + " h = self._cat([h1, h2])\n", + "\n", + " return output, h\n", + "\n", + " def init_states(self, size):\n", + " h = torch.zeros(size, 2).to(next(self.parameters()).device)\n", + " return h" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vVCyLLM784hv" + }, + "source": [ + "We define our input as a chirp (sine sweep) going from 0 to 20kHz in 10 seconds, with the target being the same sweep filtered by a DSP butterworth algorithm at 2kHz. By iteratively comparing the processed input to the actual filtered output, we try to adjust our differentiable IIR filter to match the frequency response of the original filter." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "BF94EX4e84hv", + "outputId": "8f6ffd3a-01fe-462c-98a2-c1472624c127" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The filter has the following coefficients:\n", + "Coeffs b: [ 0.41816335 -0.83632669 0.41816335] , coeffs a: [ 1. -0.46293803 0.20971536]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from scipy import signal\n", + "import numpy as np\n", + "\n", + "fs = 48000\n", + "sec = 10\n", + "T = int(fs * sec)\n", + "start_freq = 1\n", + "end_freq = 20000\n", + "t = np.linspace(0, sec, sec*fs)\n", + "\n", + "train_input = signal.chirp(t=t, f0=start_freq, t1=sec, f1=end_freq, method='logarithmic') + np.random.normal(scale=5e-2, size=len(t))\n", + "\n", + "fc = 18000 #Hz\n", + "b, a = signal.butter(N=2, Wn=fc/fs, btype='high')\n", + "print(\"The filter has the following coefficients:\")\n", + "print(\"Coeffs b:\", b, \", coeffs a:\", a)\n", + "sos = signal.tf2sos(b, a)\n", + "\n", + "train_target = signal.sosfilt(sos, train_input)\n", + "impulse = np.zeros(1000)\n", + "impulse[0] = 1.0\n", + "imp_filter = signal.sosfilt(sos, impulse)\n", + "\n", + "plot_tf(\"Filtered chirp signal\", fs, np.arange(T) / fs, [train_target], [imp_filter])\n", + "\n", + "ipd.display(ipd.Audio(train_input, rate=fs, normalize=True))\n", + "ipd.display(ipd.Audio(train_target, rate=fs, normalize=True))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jccF3yLa84hv" + }, + "source": [ + "Above training signal is 10 seconds long. At 48kHz, that is 480000 samples (that is a lot of data!). Performing our forward step on 480000 samples is computationally inefficient, meaning that we have to wait long for each gradient calculation and thus parameter update. In order to make the operations more efficient, we split our signals into batches of sequences, such that we now apply the filter operations on a matrix consisting of (batch_size, sequence_length, audio_channels).\n", + "\n", + "How this is done is not important, we use a utility function you can check out in the utils.py script." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "XAvo6NfQ84hv", + "outputId": "c549867c-c5dd-4676-ccd6-79270ffef90a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch dim: torch.Size([187, 512, 1])\n", + "Sequences available in dataset: 187\n", + "Batches available in dataset: 1\n" + ] + } + ], + "source": [ + "batch_size = 1024\n", + "sequence_length = 512\n", + "\n", + "loader = DataLoader(dataset=DIIRDataSet(train_input, train_target, sequence_length), batch_size=batch_size, shuffle=True, drop_last=False)\n", + "print(\"Batch dim:\", next(iter(loader))['input'].size())\n", + "print(\"Sequences available in dataset:\", int(len(train_input)/sequence_length))\n", + "print(\"Batches available in dataset:\", int(np.ceil(int(len(train_input)/sequence_length) / batch_size)))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "VYyHT38s84hv" + }, + "source": [ + "Above we see that from a training signal of 480000, we have 937 sequences of 512 samples. With a batch_size of 128, this means we have 8 batches: 7 consisting of 128 sequences, 1 consisting of 41 sequences." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vo3Xw-Jt84hv" + }, + "source": [ + "We define our model, loss function and optimizer (this time we use Adam rather than SGD)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "O829pupj84hv" + }, + "outputs": [], + "source": [ + "from torch.optim import Adam\n", + "\n", + "n_epochs = 5000\n", + "\n", + "filter_function = DTDFII()\n", + "model = DIIR_WRAPPER(filter_function).to(device)\n", + "optimizer = Adam(model.parameters(), lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0, amsgrad=False)\n", + "criterion = torch.nn.MSELoss()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "h_FQjjN684hv" + }, + "source": [ + "### Define training loop\n", + "\n", + "We define a training loop. Here we loop through each batch, calculate the loss and return it for visualisation purposes." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "7lZ_y0At84hw" + }, + "outputs": [], + "source": [ + "def train(criterion, model, loader, optimizer):\n", + " model.train()\n", + " device = next(model.parameters()).device\n", + " total_loss = 0\n", + " for batch in loader:\n", + " input_seq_batch = batch['input'].to(device)\n", + " target_seq_batch = batch['target'].to(device)\n", + "\n", + " optimizer.zero_grad()\n", + "\n", + " predicted_output = model(input_seq_batch)\n", + " loss = criterion(target_seq_batch, predicted_output)\n", + " loss.backward()\n", + "\n", + " optimizer.step()\n", + " total_loss += loss.item()\n", + "\n", + " total_loss /= len(loader)\n", + " return total_loss" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "da5Bo_Jv84hw" + }, + "source": [ + "### Train!\n", + "#### BE AWARE - ON A CPU, TRAINING MAY TAKE SEVERAL HOURS (TOOK 45 min ON A GPU)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "82YMqfa184hw", + "outputId": "756f6a2b-fe65-4f58-edd6-0a3d31817027" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0 -- Loss 6.261235E-01\n", + "Epoch 200 -- Loss 2.373521E-01\n", + "Epoch 400 -- Loss 1.217498E-01\n", + "Epoch 600 -- Loss 7.216813E-02\n", + "Epoch 800 -- Loss 4.615393E-02\n", + "Epoch 1000 -- Loss 3.054264E-02\n", + "Epoch 1200 -- Loss 2.047387E-02\n", + "Epoch 1400 -- Loss 1.395610E-02\n", + "Epoch 1600 -- Loss 9.939933E-03\n", + "Epoch 1800 -- Loss 7.635430E-03\n", + "Epoch 2000 -- Loss 6.385189E-03\n", + "Epoch 2200 -- Loss 5.709352E-03\n", + "Epoch 2400 -- Loss 5.320787E-03\n", + "Epoch 2600 -- Loss 5.076229E-03\n", + "Epoch 2800 -- Loss 4.911175E-03\n", + "Epoch 3000 -- Loss 4.795133E-03\n", + "Epoch 3200 -- Loss 4.710423E-03\n", + "Epoch 3400 -- Loss 4.644680E-03\n", + "Epoch 3600 -- Loss 4.588730E-03\n", + "Epoch 3800 -- Loss 4.535934E-03\n", + "Epoch 4000 -- Loss 4.481690E-03\n", + "Epoch 4200 -- Loss 4.422882E-03\n", + "Epoch 4400 -- Loss 4.357326E-03\n", + "Epoch 4600 -- Loss 4.283310E-03\n", + "Epoch 4800 -- Loss 4.199256E-03\n" + ] + } + ], + "source": [ + "losses = []\n", + "b0, b1, b2 = [], [], []\n", + "a1, a2 = [], []\n", + "\n", + "for epoch in range(n_epochs):\n", + " loss = train(criterion, model, loader, optimizer)\n", + " losses.append(loss)\n", + "\n", + " b0.append(model.cell.b0.item())\n", + " b1.append(model.cell.b1.item())\n", + " b2.append(model.cell.b2.item())\n", + " a1.append(model.cell.a1.item())\n", + " a2.append(model.cell.a2.item())\n", + "\n", + " if epoch %200 == 0:\n", + " print(\"Epoch {} -- Loss {:3E}\".format(epoch, loss))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "cuA71XRz84hw" + }, + "outputs": [], + "source": [ + "coeffs = [b0, b1, b2, a1, a2]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "-iCfdj8L84hw", + "outputId": "0c87f0c3-0f14-43b7-dd5f-146e405fcb3e" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(6, 3))\n", + "plt.plot(losses)\n", + "plt.xlabel('Iteration')\n", + "plt.ylabel('Loss')\n", + "plt.yscale('log')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gEsaZhck84hw" + }, + "source": [ + "Let's look at how each coefficient adjusts across each iteration.\n", + "\n", + "We clearly see that they are finding their way towards a configuration that gives the minimum of our objective function - this is the magic of DDSP." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "qVXXEFb584hw", + "outputId": "a543f122-1518-4234-bef7-20b93a2ade40", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 180 + } + }, + "outputs": [ + { + "output_type": "error", + "ename": "NameError", + "evalue": "name 'coeffs' is not defined", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\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 43\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 44\u001b[0m \u001b[0;31m# Example usage:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 45\u001b[0;31m \u001b[0mdisplay\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mHTML\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mget_loss_animation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcoeffs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto_html5_video\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[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mNameError\u001b[0m: name 'coeffs' is not defined" + ] + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.animation import FuncAnimation\n", + "from IPython.display import HTML\n", + "\n", + "# Animate the fitting process\n", + "def get_loss_animation(losses_list):\n", + " num_iterations = len(losses_list[0])\n", + " num_plots = len(losses_list)\n", + "\n", + " fig, ax = plt.subplots(figsize=(6, 3))\n", + "\n", + " lines_loss = []\n", + " for i in range(num_plots):\n", + " if i < 3:\n", + " label=f\"b{i+1}\"\n", + " else:\n", + " label=f\"a{i-3}\"\n", + " line_loss, = ax.plot([], [], lw=2, label=label)\n", + " lines_loss.append(line_loss)\n", + "\n", + " ax.set_xlim(0, num_iterations)\n", + " ax.set_ylim(-1, max([max(losses) for losses in losses_list]))\n", + " ax.set_xlabel(\"Iteration\")\n", + " ax.set_ylabel(\"Loss\")\n", + " ax.legend()\n", + "\n", + " def init():\n", + " for line in lines_loss:\n", + " line.set_data([], [])\n", + " return lines_loss\n", + "\n", + " def animate(iter_idx):\n", + " for i, line_loss in enumerate(lines_loss):\n", + " line_loss.set_data(np.arange((iter_idx*30)+1), losses_list[i][:(iter_idx*30)+1])\n", + " ax.set_title(f\"Params after {iter_idx*30} iterations\")\n", + " return lines_loss\n", + "\n", + " # Create the animation\n", + " anim = FuncAnimation(fig, animate, init_func=init, frames=num_iterations // 30, interval=50, blit=True)\n", + " plt.close(fig)\n", + " return anim\n", + "\n", + "# Example usage:\n", + "display(HTML(get_loss_animation(coeffs).to_html5_video()))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1DvL8LF184hw" + }, + "source": [ + "Let's also see if we have approached the target frequency response" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "0RiCe3LB84hw", + "outputId": "4f7c8ce1-26fc-4059-c6b7-7ae423cedcc3", + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model.eval()\n", + "\n", + "impulse = np.zeros(sequence_length)\n", + "impulse[0] = 1.0\n", + "impulse = torch.tensor(impulse, dtype=torch.float32).to(device)\n", + "\n", + "input_to_process = train_input\n", + "padding = int(np.ceil((len(input_to_process) / sequence_length)) * sequence_length) - len(input_to_process)\n", + "batched_input = torch.nn.functional.pad(torch.tensor(input_to_process, dtype=torch.float32), (0, padding)).reshape(-1, sequence_length, 1)\n", + "processed = torch.zeros(batched_input.shape)\n", + "\n", + "with torch.no_grad():\n", + " processed = model(batched_input.to(device))\n", + " imp_model = model(impulse.unsqueeze(0).unsqueeze(-1))\n", + "\n", + "processed = processed.reshape(-1).cpu().numpy()\n", + "imp_model = imp_model.reshape(-1).cpu().numpy()\n", + "\n", + "plot_tf(\n", + " \"Filtered Chirp signal\",\n", + " fs,\n", + " np.arange(len(train_target)) / fs,\n", + " [train_target, processed[:len(train_target)]],\n", + " [imp_filter, imp_model],\n", + " [\"scipy.signal.butter\", \"diff_iir\"]\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Muvepy5M84hw" + }, + "source": [ + "We see that we are approaching the target frequency reponse" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8MmGPxQ684hw" + }, + "source": [ + "## TASKS for Further Experimentation\n", + "Below are two tasks.\n", + "\n", + "a) First, we create another differentiable filter that more freely can predict frequency responses. You are tasked to experiment with the filter, trying to create a target signal and add the filter model to the wrapper. Lastly, you can try to train the filter (I recommend doing this in a notebook).\n", + "\n", + "b) Secondly we provide an implementation and training scheme for the wave equation in a differentiable manner. Many of you know the wave equation from other courses (i.e. the karplus-strong algorithm). You will see how we can use differentiable signal processing to approximate damping coefficients and other physical parameters to obtain a target sound.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "J4naqE3L84hw" + }, + "source": [ + "### a) State Variable Filter (SVF)\n", + "\n", + "The above filter problem was tailored to work. As seen in the implementation of the DTDFII module, we clamp the coefficients for stability reasons. This means that not all coefficient configurations are possible and thus not all 2nd order frequency responses can be obtained. A high-pass filter with a cutoff at 18kHz was thus deliberately chosen as I knew the DTDFII would be able to find the respective coefficients.\n", + "\n", + "To take account of this, and to be able to predict 2nd order filter frequency responses more freely, we can use the State-Variable Filter (SVF). The SVF can produce any second-order transfer function, whilst still having easily interpretable parameters. Its difference equation is given by:\n", + "\n", + "$\\begin{aligned} y_{\\mathrm{BP}}[n] & =\\frac{g\\left(x[n]-h_2[n-1]\\right)+h_1[n-1]}{1+g(g+2 R)} \\\\ y_{\\mathrm{LP}}[n] & =g y_{\\mathrm{BP}}[n]+h_2[n-1] \\\\ y_{\\mathrm{HP}}[n] & =x[n]-y_{\\mathrm{LP}}[n]-2 R y_{\\mathrm{BP}}[n] \\\\ h_1[n] & =2 y_{\\mathrm{BP}}-h_1[n-1] \\\\ h_2[n] & =2 y_{\\mathrm{LP}}-h_2[n-1] \\\\ y[n] & =c_{\\mathrm{HP}} y_{\\mathrm{HP}}+c_{\\mathrm{BP}} y_{\\mathrm{BP}}+c_{\\mathrm{LP}} y_{\\mathrm{LP}},\\end{aligned}$\n", + "\n", + "With the parameters being:\n", + "\n", + "- cHP = high-pass mixing coefficient\n", + "- cBP = band-pass mixing coefficient\n", + "- cLP = low-pass mixing coefficient\n", + "- R = damping/resonance\n", + "- g = frequency cutoff\n", + "\n", + "We will not go into technical details with the SVF and you do not need to understand the math behind it. However, it is good to be aware of each parameters functionality. Anyone interested in further details can read more about the SVF here: https://www.dafx14.fau.de/papers/dafx14_aaron_wishnick_time_varying_filters_for_.pdf\n", + "\n", + "In the following section, you will be tasked to implement the SVF into the differentiable framework and train it to match a specific frequency response. The SVF implementation and most of the needed code will be provided, you are asked to fill in the empty spaces." + ] + }, + { + "cell_type": "markdown", + "source": [ + "ALTERNATIVE_VERSION_EXCERSISE\n" + ], + "metadata": { + "id": "3rx5dlevaK_j" + } + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "XNYPnhrr84hw", + "outputId": "c2cb5a16-f45b-4376-dbfa-dca2c1053496", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 474 + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.11/dist-packages/torch/nn/modules/loss.py:610: UserWarning: Using a target size (torch.Size([1, 48000, 1])) that is different to the input size (torch.Size([1, 48000])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n", + " return F.mse_loss(input, target, reduction=self.reduction)\n" + ] + }, + { + "output_type": "error", + "ename": "OutOfMemoryError", + "evalue": "CUDA out of memory. Tried to allocate 8.58 GiB. GPU 0 has a total capacity of 14.74 GiB of which 5.77 GiB is free. Process 14440 has 8.97 GiB memory in use. Of the allocated memory 8.84 GiB is allocated by PyTorch, and 23.64 MiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation. See documentation for Memory Management (https://pytorch.org/docs/stable/notes/cuda.html#environment-variables)", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mOutOfMemoryError\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 98\u001b[0m \u001b[0moptimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzero_grad\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 99\u001b[0m \u001b[0moutput_batch\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput_batch\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 100\u001b[0;31m \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcriterion\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutput_batch\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget_batch\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 101\u001b[0m \u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\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 102\u001b[0m \u001b[0moptimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\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[0;32m/usr/local/lib/python3.11/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1737\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_compiled_call_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# type: ignore[misc]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1738\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-> 1739\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\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 1740\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1741\u001b[0m \u001b[0;31m# torchrec tests the code consistency with the following code\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.11/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1748\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_pre_hooks\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_hooks\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1749\u001b[0m or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[0;32m-> 1750\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\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 1751\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1752\u001b[0m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.11/dist-packages/torch/nn/modules/loss.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, input, target)\u001b[0m\n\u001b[1;32m 608\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 609\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mforward\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[0mTensor\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mTensor\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mTensor\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 610\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mF\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmse_loss\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreduction\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreduction\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 611\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 612\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.11/dist-packages/torch/nn/functional.py\u001b[0m in \u001b[0;36mmse_loss\u001b[0;34m(input, target, size_average, reduce, reduction, weight)\u001b[0m\n\u001b[1;32m 3903\u001b[0m )\n\u001b[1;32m 3904\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-> 3905\u001b[0;31m return torch._C._nn.mse_loss(\n\u001b[0m\u001b[1;32m 3906\u001b[0m \u001b[0mexpanded_input\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexpanded_target\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_Reduction\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_enum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreduction\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3907\u001b[0m )\n", + "\u001b[0;31mOutOfMemoryError\u001b[0m: CUDA out of memory. Tried to allocate 8.58 GiB. GPU 0 has a total capacity of 14.74 GiB of which 5.77 GiB is free. Process 14440 has 8.97 GiB memory in use. Of the allocated memory 8.84 GiB is allocated by PyTorch, and 23.64 MiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation. See documentation for Memory Management (https://pytorch.org/docs/stable/notes/cuda.html#environment-variables)" + ] + } + ], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "from torch.nn import Parameter, Module\n", + "from torch import FloatTensor\n", + "from torch.optim import Adam\n", + "from torch.utils.data import DataLoader, TensorDataset\n", + "import numpy as np\n", + "from scipy import signal\n", + "import matplotlib.pyplot as plt # For plotting (if needed)\n", + "import IPython.display as ipd # for audio playback\n", + "\n", + "# 1. Define the DSVF Class\n", + "class DSVF(Module):\n", + " def __init__(self, G=0.5, twoR=1, hp_gain=0.0, bp_gain=0.0, lp_gain=1.0):\n", + " args = locals()\n", + " del args['self']\n", + " del args['__class__']\n", + " super(DSVF, self).__init__()\n", + " for key in args:\n", + " setattr(self, key, Parameter(FloatTensor([args[key]])))\n", + " self.master_gain = Parameter(FloatTensor([1.0]))\n", + "\n", + " def forward(self, x, v):\n", + " coeff0, coeff1 = self.calc_coeffs()\n", + " input_minus_v1 = x - v[:, 1]\n", + " bp_out = coeff1 * input_minus_v1 + coeff0 * v[:, 0]\n", + " lp_out = self.G * bp_out + v[:, 1]\n", + " hp_out = x - lp_out - self.twoR * bp_out\n", + " v = torch.cat([(2 * bp_out).unsqueeze(-1), (2 * lp_out).unsqueeze(-1)], dim=-1) - v\n", + " y = self.master_gain * (self.hp_gain * hp_out + self.bp_gain * self.twoR * bp_out + self.lp_gain * lp_out)\n", + " return y, v\n", + "\n", + " def init_states(self, size):\n", + " v = torch.zeros(size, 2).to(next(self.parameters()).device)\n", + " return v\n", + "\n", + " def calc_coeffs(self):\n", + " self.G.data = torch.clamp(self.G, min=1e-8)\n", + " self.twoR.data = torch.clamp(self.twoR, min=0)\n", + " self.bp_gain.data = torch.clamp(self.bp_gain, min=-1)\n", + " self.hp_gain.data = torch.clamp(self.hp_gain, min=-1, max=1)\n", + " self.lp_gain.data = torch.clamp(self.lp_gain, min=-1, max=1)\n", + "\n", + " coeff0 = 1.0 / (1.0 + self.G * (self.G + self.twoR))\n", + " coeff1 = self.G * coeff0\n", + "\n", + " return coeff0, coeff1\n", + "\n", + "# 2. Define the DSVF Wrapper\n", + "class DSVF_WRAPPER(Module):\n", + " def __init__(self, cell):\n", + " super(DSVF_WRAPPER, self).__init__()\n", + " self.cell = cell\n", + "\n", + " def forward(self, input_seq_batch):\n", + " device = next(self.parameters()).device\n", + " batch_size, sequence_length, _ = input_seq_batch.size()\n", + "\n", + " # Initialize filter states\n", + " v = self.cell.init_states(batch_size).to(device)\n", + "\n", + " # Process the input sequence\n", + " output_seq = []\n", + " for i in range(sequence_length):\n", + " output, v = self.cell(input_seq_batch[:, i, 0], v) # Assuming single channel audio\n", + " output_seq.append(output.unsqueeze(1))\n", + "\n", + " return torch.cat(output_seq, dim=1)\n", + "\n", + "# 3. Create Target Signal (Example: Band-pass Filtered White Noise)\n", + "fs = 48000\n", + "duration = 1\n", + "white_noise = np.random.randn(int(fs * duration))\n", + "sos = signal.butter(4, [500, 5000], 'bandpass', fs=fs, output='sos')\n", + "target_audio = signal.sosfilt(sos, white_noise)\n", + "\n", + "# 4. Prepare Data for Training\n", + "input_tensor = torch.tensor(white_noise, dtype=torch.float32).unsqueeze(0).unsqueeze(-1) # Add batch and channel dimensions\n", + "target_tensor = torch.tensor(target_audio, dtype=torch.float32).unsqueeze(0).unsqueeze(-1)\n", + "dataset = TensorDataset(input_tensor, target_tensor)\n", + "loader = DataLoader(dataset, batch_size=1, shuffle=False) # Batch size 1 for this example\n", + "\n", + "# 5. Initialize Model, Optimizer, and Loss Function\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "model = DSVF_WRAPPER(DSVF()).to(device)\n", + "optimizer = Adam(model.parameters(), lr=0.001)\n", + "criterion = nn.MSELoss()\n", + "\n", + "# 6. Training Loop\n", + "n_epochs = 5000\n", + "\n", + "for epoch in range(n_epochs):\n", + " total_loss = 0\n", + " for batch in loader:\n", + " input_batch, target_batch = batch\n", + " input_batch, target_batch = input_batch.to(device), target_batch.to(device)\n", + "\n", + " optimizer.zero_grad()\n", + " output_batch = model(input_batch)\n", + " loss = criterion(output_batch, target_batch)\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " total_loss += loss.item()\n", + "\n", + " avg_loss = total_loss / len(loader)\n", + " print(f\"Epoch {epoch+1}/{n_epochs}, Loss: {avg_loss:.6f}\")\n", + "\n", + "# 7. Evaluation (Example: Compare Frequency Response)\n", + "# ... (Code to analyze frequency response of trained model and target) ...\n", + "\n", + "#8. Play audio\n", + "print(\"Original\")\n", + "ipd.display(ipd.Audio(white_noise, rate=fs, normalize=True))\n", + "print(\"Target\")\n", + "ipd.display(ipd.Audio(target_audio, rate=fs, normalize=True))\n", + "print(\"Predicted\")\n", + "with torch.no_grad():\n", + " predicted_audio = model(input_tensor.to(device)).cpu().numpy().squeeze()\n", + "ipd.display(ipd.Audio(predicted_audio, rate=fs, normalize=True))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vkcyEbJV84hw" + }, + "source": [ + "### Create input and target training signal" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "ASnI0cJY84hw" + }, + "outputs": [], + "source": [ + "fs = 48000\n", + "sec = 2\n", + "T = int(fs * sec)\n", + "start_freq = 1\n", + "end_freq = 20000\n", + "t = np.linspace(0, sec, sec*fs)\n", + "\n", + "train_input = signal.chirp(t=t, f0=start_freq, t1=sec, f1=end_freq, method='logarithmic') + np.random.normal(scale=5e-2, size=len(t))\n", + "\n", + "fc = #choose filter cutoff\n", + "filter_type = #choose filter type\n", + "b, a = signal.butter(N=2, Wn=fc/fs, btype=filter_type)\n", + "\n", + "print(\"The filter has the following coefficients:\")\n", + "print(\"Coeffs b:\", b, \", coeffs a:\", a)\n", + "sos = signal.tf2sos(b, a)\n", + "\n", + "train_target = signal.sosfilt(sos, train_input)\n", + "impulse = np.zeros(1000)\n", + "impulse[0] = 1.0\n", + "imp_filter = signal.sosfilt(sos, impulse)\n", + "\n", + "plot_tf(\"Filtered chirp signal\", fs, np.arange(T) / fs, [train_target], [imp_filter])\n", + "\n", + "ipd.display(ipd.Audio(train_input, rate=fs, normalize=True))\n", + "ipd.display(ipd.Audio(train_target, rate=fs, normalize=True))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "HRN3czwa84hx" + }, + "outputs": [], + "source": [ + "batch_size = #choose batch size\n", + "sequence_length = #choose sequence length\n", + "\n", + "loader = DataLoader(dataset=DIIRDataSet(train_input, train_target, sequence_length), batch_size=batch_size, shuffle=True, drop_last=False)\n", + "print(\"Batch dim:\", next(iter(loader))['input'].size())\n", + "print(\"Sequences available in dataset:\", int(len(train_input)/sequence_length))\n", + "print(\"Batches available in dataset:\", int(np.ceil(int(len(train_input)/sequence_length) / batch_size)))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "s1jTgU1Z84hx" + }, + "outputs": [], + "source": [ + "n_epochs = 1500\n", + "\n", + "filter_function = #initialise differentiable filter\n", + "model = #add to wrapper\n", + "optimizer = #initialise optimizer\n", + "criterion = #initialise loss" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "a2mUPXwK84hx", + "scrolled": true + }, + "outputs": [], + "source": [ + "#train the model\n", + "for epoch in range(n_epochs):\n", + " loss = #train\n", + " losses.append(loss)\n", + "\n", + " if epoch %200 == 0:\n", + " print(\"Epoch {} -- Loss {:3E}\".format(epoch, loss))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "J4JgiQ0B84hx", + "scrolled": true + }, + "outputs": [], + "source": [ + "model.eval()\n", + "\n", + "impulse = np.zeros(sequence_length)\n", + "impulse[0] = 1.0\n", + "impulse = torch.tensor(impulse, dtype=torch.float32).to(device)\n", + "\n", + "input_to_process = train_input\n", + "padding = int(np.ceil((len(input_to_process) / sequence_length)) * sequence_length) - len(input_to_process)\n", + "batched_input = torch.nn.functional.pad(torch.tensor(input_to_process, dtype=torch.float32), (0, padding)).reshape(-1, sequence_length, 1)\n", + "processed = torch.zeros(batched_input.shape)\n", + "\n", + "with torch.no_grad():\n", + " processed = model(batched_input.to(device))\n", + " imp_model = model(impulse.unsqueeze(0).unsqueeze(-1))\n", + "\n", + "processed = processed.reshape(-1).cpu().numpy()\n", + "imp_model = imp_model.reshape(-1).cpu().numpy()\n", + "\n", + "\n", + "plot_tf(\n", + " \"Filtered Chirp signal\",\n", + " fs,\n", + " np.arange(len(train_target)) / fs,\n", + " [train_target, processed[:len(train_target)]],\n", + " [imp_filter, imp_model],\n", + " [\"scipy.signal.butter\", \"diff_iir\"]\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "c35jdip584hx" + }, + "source": [ + "### b) The Wave Equation\n", + "\n", + "In this section, we'll look at physical sound synthesis and model a string sound from the wave equation. Thereafter we will use gradient descent to find the parameters of the model that best fit a given sound.\n", + "\n", + "In particular we will focus on digital waveguide synthesis (DWG). DWGs are based on D'Alembert's [travelling wave solution](https://en.wikipedia.org/wiki/D%27Alembert%27s_formula) to the wave equation, where the solution is given by waves travelling on opposite directions:\n", + "\n", + "$$\n", + "u(x, t) = F(x + ct) + G(x - ct)\n", + "$$\n", + "\n", + "here $F(x + ct)$ represents a wave traveling to the left and $G(x - ct)$ represents a wave traveling to the right.\n", + "\n", + "In DWGs, the propagation of the traveling waves is simulated using delay lines. At each sample step, losses occur, but if the loss is a linear operation, it can be commuted out of the individual samples and be applied cumulatively to the output of the delay line.\n", + "\n", + "The model of the loss should be frequency-dependent. With the simplest possible loss filter, we obtain a simulation diagram that looks like this:\n", + "\n", + "
\n", + "\n", + "
\n", + "\n", + "This might look familiar as the basic structure of the Karplus-Strong algorithm for plucked string synthesis. In fact, the Karplus-Strong algorithm can be seen as a simple DWG. We'll look at applying the same methods as before to find the parameters of this model that best fit a given sound using gradient descent.\n", + "\n", + "\n", + "The transfer function of the basic Karplus-Strong algorithm as shown before is\n", + "\n", + "$$H(z) = \\frac{1}{1 - g\\cdot(z^{-N} + z^{-N-1})},$$\n", + "\n", + "where $N$ is the length of the delay line corresponding to the modeled string and controls pitch, and $g$ is the feedback gain, which controls the decay time of the sound.\n", + "\n", + "We'll implement this transfer function in the frequency domain for more efficient estimation, and in the time domain for the final result.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Kuzd2OFm84hx", + "outputId": "db6e86d1-20e8-44e0-c4cf-2a93846572b9" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "class KarplusStrong(torch.nn.Module):\n", + "\n", + " def __init__(self, delay_len, n_fft=2048):\n", + " super().__init__()\n", + " self.delay_gain = torch.nn.Parameter(torch.tensor(0.0))\n", + " self.delay_len = delay_len\n", + "\n", + " # for frequency sampling\n", + " self.z = torch.exp(1j * torch.linspace(0, torch.pi, n_fft // 2 + 1))\n", + "\n", + " # random excitation\n", + " self.exc = torch.zeros(n_fft)\n", + " self.exc[:delay_len] = torch.rand(delay_len) - 0.5\n", + " self.exc_fft = torch.fft.rfft(self.exc)\n", + "\n", + " # scale delay gain to [0.9, 1.0]\n", + " def scaled_gain(self):\n", + " return torch.sigmoid(self.delay_gain) * 0.1 + 0.9\n", + "\n", + " # forward pass: synthesis in the frequency domain\n", + " def forward(self):\n", + " z = self.z\n", + "\n", + " delay_gain = self.scaled_gain()\n", + "\n", + " # sample transfer function\n", + " numer = 1.\n", + " denom = (1 - delay_gain * (0.5 * z ** (-self.delay_len) + 0.5 * z ** (-self.delay_len - 1)))\n", + "\n", + " # filter excitation in frequency domain\n", + " return self.exc_fft * numer / denom\n", + "\n", + " # also provide method for time domain synthesis\n", + " def time_domain_synth(self, n_samples):\n", + "\n", + " delay_gain = self.scaled_gain()\n", + "\n", + " # populate filter coefficients for IIR filter\n", + " a_coeffs = torch.zeros(self.delay_len + 2)\n", + " a_coeffs[0] = 1\n", + " a_coeffs[self.delay_len] = -delay_gain * 0.5\n", + " a_coeffs[self.delay_len + 1] = -delay_gain * 0.5\n", + "\n", + " b_coeffs = torch.zeros(self.delay_len + 2)\n", + " b_coeffs[0] = 1\n", + "\n", + " # pad or truncate self.exc to n_samples\n", + " if self.exc.shape[0] < n_samples:\n", + " audio = torch.cat([self.exc, torch.zeros(n_samples - self.exc.shape[0])])\n", + " else:\n", + " audio = self.exc[:n_samples]\n", + "\n", + " audio = torchaudio.functional.lfilter(audio, a_coeffs, b_coeffs, clamp=False)\n", + " return audio\n", + "\n", + "# let's have a listen\n", + "synth = KarplusStrong(80)\n", + "audio = synth.time_domain_synth(32000)\n", + "ipd.Audio(audio.detach(), rate=16000)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "W6GHHVOV84hx" + }, + "source": [ + "Let's now load an acoustic guitar sound file from the NSynth dataset. We'll try to have our Karplus-Strong model mimic this sound. Since it is a very simple model, we won't get too close of a match, but we should be able to tune the decay time.\n", + "\n", + "As mentioned before, pitch estimation with gradient descent can be tricky, so we'll infer the length of the delay line from the pitch of the recording: At MIDI note 51, it's about 155.56 Hz. With a sample rate of 16000 Hz, this corresponds to a delay of 102.8 samples. We'll round this to 103 samples. More accuracy could be achieved by using fractional delays, but we'll keep it simple here." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "aiF0UIQ284hx", + "outputId": "7ca2c847-936a-4a72-d00e-625bc40beb27" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Original:\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Synthesized:\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sr = 16000\n", + "\n", + "audio, sr = librosa.load(\"sound-files/guitar-nsynth.wav\", sr=sr, mono=True)\n", + "\n", + "# how many points used in sampling the transfer function\n", + "nfft = 4096\n", + "\n", + "# fix random excitation\n", + "torch.manual_seed(0)\n", + "\n", + "karplus_model = KarplusStrong(delay_len=103, n_fft=nfft)\n", + "\n", + "print(\"Original:\")\n", + "ipd.display(ipd.Audio(audio, rate=sr))\n", + "\n", + "print(\"Synthesized:\")\n", + "ipd.display(ipd.Audio(karplus_model.time_domain_synth(sr * 4).detach(), rate=sr))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Vjz2PIcm84hx" + }, + "source": [ + "This doesn't sound close at all. Let's see if we can once again use gradient descent to find a better value for $g$ and match the decay time. We'll define our own loss function using L1 loss on the normalized log magnitudes of the spectrum:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "cZkkt9DA84hx" + }, + "outputs": [], + "source": [ + "def to_log_mag(freq_response, rel_to_max=True, eps=1e-7):\n", + " mag = torch.abs(freq_response)\n", + " if rel_to_max:\n", + " div = torch.max(mag)\n", + " else:\n", + " div = 1.0\n", + " return 10 * torch.log10(mag / div + eps)\n", + "\n", + "\n", + "def loss_fn(y, y_hat):\n", + " y_mags = to_log_mag(y)\n", + " y_hat_mags = to_log_mag(y_hat)\n", + "\n", + " return torch.mean((y_mags - y_hat_mags).abs())" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "MSr5Y5Ag84hx" + }, + "source": [ + "We're all set for optimization!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "tShBo6DD84hx", + "outputId": "f7894bb5-5272-4b66-ce0b-dfb3e39ff2b2", + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Audio after optimization:\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# calculate truncated fft\n", + "target = torch.fft.rfft(torch.tensor(audio), n=nfft)\n", + "\n", + "fftfreqs = torch.fft.rfftfreq(nfft, 1 / sr)\n", + "\n", + "plt.plot(fftfreqs, to_log_mag(target.detach()), label=\"target\")\n", + "plt.plot(fftfreqs, to_log_mag(karplus_model().detach()), label=\"initial synthesis\")\n", + "\n", + "optim = torch.optim.Adam(karplus_model.parameters(), lr=1e-2)\n", + "for i in range(1000):\n", + " optim.zero_grad()\n", + " loss = loss_fn(target, karplus_model())\n", + " loss.backward()\n", + " optim.step()\n", + "\n", + "\n", + "plt.plot(fftfreqs, to_log_mag(karplus_model().detach()), label=\"optimized synthesis\")\n", + "plt.legend()\n", + "plt.ylabel(\"Magnitude (dB)\")\n", + "plt.xlabel(\"Frequency (Hz)\")\n", + "plt.show()\n", + "\n", + "print(\"Audio after optimization:\")\n", + "td_out = karplus_model.time_domain_synth(audio.shape[0]).detach()\n", + "ipd.display(ipd.Audio(td_out, rate=sr))" + ] + } + ], + "metadata": { + "colab": { + "provenance": [], + "gpuType": "T4", + "include_colab_link": true + }, + "kernelspec": { + "display_name": "Python 3", + "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.10.10" + }, + "accelerator": "GPU" + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file