{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Setup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This example script requires a number of extra packages to be installed:\n",
    "\n",
    "<list>\n",
    "    <li><a href=\"https://github.com/SeanNaren/deepspeech.pytorch\">deepspeech_pytorch</a></li>\n",
    "    <li><a href=\"https://github.com/omry/omegaconf\">omegaconf</a>\n",
    "    <li><a href=\"https://github.com/PyTorchLightning/pytorch-lightning\">pytorch_lightning</a></li>\n",
    "</list>\n",
    "\n",
    "The $\\mathrm{DeepSpeech}$ class defined below is a slightly modified version of the similarly named class in the <a href=\"https://github.com/SeanNaren/deepspeech.pytorch/blob/master/deepspeech_pytorch/model.py\">models.py</a> module of the $\\mathrm{deepspeech\\_pytorch}$ package.\n",
    "\n",
    "To replicate the results in this notebook, the following additional resources are provided:\n",
    "\n",
    "<list>\n",
    "    <li>Pretrained DeepSpeech model: $\\text{deepspeech2-pretrained.ckpt}$</li>\n",
    "    <li>Sample 4-second 16KHz audio clips extracted from the <em>test-clean</em> and <em>dev-clean</em> subsets of the LibriSpeech corpus: $\\text{segments-librispeech-*}$</li>\n",
    "</list>\n",
    "\n",
    "To replicate the results here, extract $\\text{Examples/resources.tar}$ and place the contents in a folder named $\\text{resources/}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import math\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torchaudio\n",
    "from torch.cuda.amp import autocast\n",
    "torchaudio.set_audio_backend(\"sox_io\")\n",
    "\n",
    "from omegaconf import OmegaConf\n",
    "from deepspeech_pytorch.configs.train_config import SpectConfig, BiDirectionalConfig, AdamConfig, SGDConfig\n",
    "from deepspeech_pytorch.decoder import GreedyDecoder\n",
    "from deepspeech_pytorch.utils import load_model\n",
    "from deepspeech_pytorch.validation import CharErrorRate, WordErrorRate\n",
    "from deepspeech_pytorch.model import SequenceWise, MaskConv, InferenceBatchSoftmax, Lookahead\n",
    "from deepspeech_pytorch.enums import RNNType, SpectrogramWindow\n",
    "import pytorch_lightning as pl\n",
    "\n",
    "import PyTCI.tci as tci\n",
    "import PyTCI.audio as fx\n",
    "\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "\n",
    "LABELS = list(\"_'ABCDEFGHIJKLMNOPQRSTUVWXYZ \")\n",
    "MODEL_CFG = BiDirectionalConfig(rnn_type=RNNType.lstm, hidden_size=1024, hidden_layers=7)\n",
    "OPTIM_CFG = AdamConfig(learning_rate=0.00015, learning_anneal=0.99, weight_decay=1e-05, eps=1e-08, betas=[0.9, 0.999])\n",
    "SPECT_CFG = SpectConfig(sample_rate=16000, window_size=0.02, window_stride=0.01, window=SpectrogramWindow.hamming)\n",
    "PRECISION = 16\n",
    "\n",
    "\n",
    "class SpectrogramParser(nn.Module):\n",
    "    def __init__(self, audio_conf: SpectConfig, normalize: bool = False):\n",
    "        \"\"\"\n",
    "       \tParses audio file into spectrogram with optional normalization\n",
    "       \t:param audio_conf: Dictionary containing the sample rate, window and the window length/stride in seconds\n",
    "       \t:param normalize(default False):  Apply standard mean and deviation normalization to audio tensor\n",
    "       \t\"\"\"\n",
    "        super().__init__()\n",
    "        self.window_stride = audio_conf.window_stride\n",
    "        self.window_size = audio_conf.window_size\n",
    "        self.sample_rate = audio_conf.sample_rate\n",
    "        self.window = audio_conf.window.value\n",
    "        self.normalize = normalize\n",
    "        \n",
    "        n_fft = int(self.sample_rate * self.window_size)\n",
    "        win_length = n_fft\n",
    "        hop_length = int(self.sample_rate * self.window_stride)\n",
    "        if self.window == 'hamming':\n",
    "            window = torch.hamming_window\n",
    "        else:\n",
    "            raise NotImplementedError()\n",
    "        \n",
    "        self.transform = torchaudio.transforms.Spectrogram(\n",
    "            n_fft, win_length, hop_length, window_fn=window, power=1, normalized=False)\n",
    "\n",
    "    @torch.no_grad()\n",
    "    def forward(self, audio):\n",
    "        if audio.shape[-1] == 1:\n",
    "            audio = audio.squeeze(dim=-1) # mono\n",
    "        else:\n",
    "            audio = audio.mean(dim=-1) # multiple channels, average\n",
    "        \n",
    "        # trim final samples if extra samples left out from downsampling doing conversion\n",
    "        audio = audio[:-round(len(audio) % self.transform.hop_length)-1]\n",
    "        \n",
    "        spect = self.transform(audio)\n",
    "        spect = torch.log1p(spect)\n",
    "        \n",
    "        if self.normalize:\n",
    "            mean = spect.mean()\n",
    "            std = spect.std()\n",
    "            spect.add_(-mean)\n",
    "            spect.div_(std)\n",
    "        \n",
    "        # reshape to [time x frequency]\n",
    "        spect = spect.T.contiguous()\n",
    "        \n",
    "        return spect\n",
    "\n",
    "\n",
    "class BatchRNN(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size, rnn_type=nn.LSTM, bidirectional=False, batch_norm=True):\n",
    "        super(BatchRNN, self).__init__()\n",
    "        self.input_size = input_size\n",
    "        self.hidden_size = hidden_size\n",
    "        self.bidirectional = bidirectional\n",
    "        self.batch_norm = SequenceWise(nn.BatchNorm1d(input_size)) if batch_norm else None\n",
    "        self.rnn = rnn_type(input_size=input_size, hidden_size=hidden_size,\n",
    "                            bidirectional=bidirectional, bias=True)\n",
    "        self.num_directions = 2 if bidirectional else 1\n",
    "\n",
    "    def flatten_parameters(self):\n",
    "        self.rnn.flatten_parameters()\n",
    "\n",
    "    def forward(self, x, output_lengths):\n",
    "        if self.batch_norm is not None:\n",
    "            x = self.batch_norm(x)\n",
    "        x = nn.utils.rnn.pack_padded_sequence(x, output_lengths, enforce_sorted=False)\n",
    "        x, h = self.rnn(x)\n",
    "        x, _ = nn.utils.rnn.pad_packed_sequence(x)\n",
    "        if self.bidirectional:\n",
    "            x = x.view(x.size(0), x.size(1), 2, -1).sum(2).view(x.size(0), x.size(1), -1)  # (TxNxH*2) -> (TxNxH) by sum\n",
    "        return x\n",
    "\n",
    "\n",
    "class DeepSpeech(pl.LightningModule):\n",
    "    def __init__(self, labels=LABELS, model_cfg=MODEL_CFG, precision=PRECISION, optim_cfg=OPTIM_CFG, spect_cfg=SPECT_CFG):\n",
    "        super().__init__()\n",
    "        self.save_hyperparameters()\n",
    "        self.model_cfg = model_cfg\n",
    "        self.precision = precision\n",
    "        self.optim_cfg = optim_cfg\n",
    "        self.spect_cfg = spect_cfg\n",
    "        self.bidirectional = True if OmegaConf.get_type(model_cfg) is BiDirectionalConfig else False\n",
    "\n",
    "        self.labels = labels\n",
    "        num_classes = len(self.labels)\n",
    "\n",
    "        self.conv = MaskConv(nn.Sequential(\n",
    "            nn.Conv2d(1, 32, kernel_size=(41, 11), stride=(2, 2), padding=(20, 5)),\n",
    "            nn.BatchNorm2d(32),\n",
    "            nn.Hardtanh(0, 20, inplace=True),\n",
    "            nn.Conv2d(32, 32, kernel_size=(21, 11), stride=(2, 1), padding=(10, 5)),\n",
    "            nn.BatchNorm2d(32),\n",
    "            nn.Hardtanh(0, 20, inplace=True)\n",
    "        ))\n",
    "        # Based on above convolutions and spectrogram size using conv formula (W - F + 2P)/ S+1\n",
    "        rnn_input_size = int(math.floor((self.spect_cfg.sample_rate * self.spect_cfg.window_size) / 2) + 1)\n",
    "        rnn_input_size = int(math.floor(rnn_input_size + 2 * 20 - 41) / 2 + 1)\n",
    "        rnn_input_size = int(math.floor(rnn_input_size + 2 * 10 - 21) / 2 + 1)\n",
    "        rnn_input_size *= 32\n",
    "\n",
    "        self.rnns = nn.Sequential(\n",
    "            BatchRNN(\n",
    "                input_size=rnn_input_size,\n",
    "                hidden_size=self.model_cfg.hidden_size,\n",
    "                rnn_type=self.model_cfg.rnn_type.value,\n",
    "                bidirectional=self.bidirectional,\n",
    "                batch_norm=False\n",
    "            ),\n",
    "            *(\n",
    "                BatchRNN(\n",
    "                    input_size=self.model_cfg.hidden_size,\n",
    "                    hidden_size=self.model_cfg.hidden_size,\n",
    "                    rnn_type=self.model_cfg.rnn_type.value,\n",
    "                    bidirectional=self.bidirectional\n",
    "                ) for x in range(self.model_cfg.hidden_layers - 3)\n",
    "            )\n",
    "        )\n",
    "\n",
    "        self.lookahead = nn.Sequential(\n",
    "            # consider adding batch norm?\n",
    "            Lookahead(self.model_cfg.hidden_size, context=self.model_cfg.lookahead_context),\n",
    "            nn.Hardtanh(0, 20, inplace=True)\n",
    "        ) if not self.bidirectional else None\n",
    "\n",
    "        fully_connected = nn.Sequential(\n",
    "            nn.BatchNorm1d(self.model_cfg.hidden_size),\n",
    "            nn.Linear(self.model_cfg.hidden_size, num_classes, bias=False)\n",
    "        )\n",
    "        self.fc = nn.Sequential(\n",
    "            SequenceWise(fully_connected),\n",
    "        )\n",
    "        self.inference_softmax = InferenceBatchSoftmax()\n",
    "        self.criterion = nn.CTCLoss(blank=self.labels.index('_'), reduction='sum', zero_infinity=True)\n",
    "        self.evaluation_decoder = GreedyDecoder(self.labels)  # Decoder used for validation\n",
    "        self.wer = WordErrorRate(\n",
    "            decoder=self.evaluation_decoder,\n",
    "            target_decoder=self.evaluation_decoder\n",
    "        )\n",
    "        self.cer = CharErrorRate(\n",
    "            decoder=self.evaluation_decoder,\n",
    "            target_decoder=self.evaluation_decoder\n",
    "        )\n",
    "\n",
    "    def forward(self, x, lengths):\n",
    "        lengths = lengths.cpu().int()\n",
    "        output_lengths = self.get_seq_lens(lengths)\n",
    "        x, _ = self.conv(x.transpose(1,2).unsqueeze(1).contiguous(), output_lengths)\n",
    "\n",
    "        sizes = x.size()\n",
    "        x = x.view(sizes[0], sizes[1] * sizes[2], sizes[3])  # Collapse feature dimension\n",
    "        x = x.transpose(1, 2).transpose(0, 1).contiguous()  # TxNxH\n",
    "\n",
    "        for rnn in self.rnns:\n",
    "            x = rnn(x, output_lengths)\n",
    "\n",
    "        if not self.bidirectional:  # no need for lookahead layer in bidirectional\n",
    "            x = self.lookahead(x)\n",
    "\n",
    "        x = self.fc(x)\n",
    "        x = x.transpose(0, 1)\n",
    "        # identity in training mode, softmax in eval mode\n",
    "        x = self.inference_softmax(x)\n",
    "        return x, output_lengths\n",
    "    \n",
    "    def unpack_batch(self, batch):\n",
    "        inputs = batch.get('inputs', None)\n",
    "        input_lengths = batch.get('input_lengths', None)\n",
    "        labels = batch.get('labels', None)\n",
    "        label_lengths = batch.get('label_lengths', None)\n",
    "        \n",
    "        return inputs, labels, input_lengths, label_lengths\n",
    "\n",
    "    def training_step(self, batch, batch_idx):\n",
    "        inputs, targets, input_sizes, target_sizes = self.unpack_batch(batch)\n",
    "        if inputs is None: # skip step\n",
    "            return None\n",
    "        \n",
    "        out, output_sizes = self(inputs, input_sizes)\n",
    "        out = out.transpose(0, 1)  # TxNxH\n",
    "        out = out.log_softmax(-1)\n",
    "\n",
    "        loss = self.criterion(out, targets, output_sizes, target_sizes)\n",
    "        self.log('train_loss', loss)\n",
    "        return loss\n",
    "\n",
    "    def validation_step(self, batch, batch_idx):\n",
    "        inputs, targets, input_sizes, target_sizes = self.unpack_batch(batch)\n",
    "        if inputs is None: # skip step\n",
    "            return\n",
    "        \n",
    "        inputs = inputs.to(self.device)\n",
    "        with autocast(enabled=self.precision == 16):\n",
    "            out, output_sizes = self(inputs, input_sizes)\n",
    "        decoded_output, _ = self.evaluation_decoder.decode(out, output_sizes)\n",
    "        \n",
    "        self.wer(preds=out, preds_sizes=output_sizes, targets=targets, target_sizes=target_sizes)\n",
    "        self.cer(preds=out, preds_sizes=output_sizes, targets=targets, target_sizes=target_sizes)\n",
    "        self.log('wer', self.wer.compute(), prog_bar=True, on_epoch=True)\n",
    "        self.log('cer', self.cer.compute(), prog_bar=True, on_epoch=True)\n",
    "    \n",
    "    def test_step(self, *args):\n",
    "        return self.validation_step(*args)\n",
    "\n",
    "    def configure_optimizers(self):\n",
    "        if OmegaConf.get_type(self.optim_cfg) is SGDConfig:\n",
    "            optimizer = torch.optim.SGD(\n",
    "                params=self.parameters(),\n",
    "                lr=self.optim_cfg.learning_rate,\n",
    "                momentum=self.optim_cfg.momentum,\n",
    "                nesterov=True,\n",
    "                weight_decay=self.optim_cfg.weight_decay\n",
    "            )\n",
    "        elif OmegaConf.get_type(self.optim_cfg) is AdamConfig:\n",
    "            optimizer = torch.optim.AdamW(\n",
    "                params=self.parameters(),\n",
    "                lr=self.optim_cfg.learning_rate,\n",
    "                betas=self.optim_cfg.betas,\n",
    "                eps=self.optim_cfg.eps,\n",
    "                weight_decay=self.optim_cfg.weight_decay\n",
    "            )\n",
    "        else:\n",
    "            raise ValueError(\"Optimizer has not been specified correctly.\")\n",
    "\n",
    "        scheduler = torch.optim.lr_scheduler.ExponentialLR(\n",
    "            optimizer=optimizer,\n",
    "            gamma=self.optim_cfg.learning_anneal\n",
    "        )\n",
    "        return [optimizer], [scheduler]\n",
    "\n",
    "    def get_seq_lens(self, input_length):\n",
    "        \"\"\"\n",
    "        Given a 1D Tensor or Variable containing integer sequence lengths, return a 1D tensor or variable\n",
    "        containing the size sequences that will be output by the network.\n",
    "        :param input_length: 1D Tensor\n",
    "        :return: 1D Tensor scaled by model\n",
    "        \"\"\"\n",
    "        seq_len = input_length\n",
    "        for m in self.conv.modules():\n",
    "            if type(m) == nn.modules.conv.Conv2d:\n",
    "                seq_len = torch.div(\n",
    "                    seq_len + 2 * m.padding[1] - m.dilation[1] * (m.kernel_size[1] - 1) - 1,\n",
    "                    m.stride[1], rounding_mode='floor'\n",
    "                ) + 1\n",
    "        return seq_len.int()\n",
    "    \n",
    "    @torch.no_grad()\n",
    "    def activation_fx(self, layer, log=True):\n",
    "        # waveform 2 spectrogram parser\n",
    "        spect_parser = SpectrogramParser(audio_conf=SPECT_CFG, normalize=True).to(self.device)\n",
    "        \n",
    "        def activation(x, /, layer=layer):\n",
    "            # convert to spectrogram\n",
    "            x = spect_parser(x)\n",
    "            lengths = torch.tensor([x.shape[0]], dtype=int)\n",
    "            output_lengths = self.get_seq_lens(lengths)\n",
    "            \n",
    "            # make into 4D tensor of [batch x channel x frequency x time]\n",
    "            # and move to same device as the model\n",
    "            x = x.T[np.newaxis, np.newaxis, ...].contiguous().to(device)\n",
    "            \n",
    "            for module in self.conv.seq_module:\n",
    "                x = module(x)\n",
    "                mask = torch.BoolTensor(x.size()).fill_(0)\n",
    "                if x.is_cuda:\n",
    "                    mask = mask.cuda()\n",
    "                for i, length in enumerate(output_lengths):\n",
    "                    length = length.item()\n",
    "                    if (mask[i].size(2) - length) > 0:\n",
    "                        mask[i].narrow(2, length, mask[i].size(2) - length).fill_(1)\n",
    "                x = x.masked_fill(mask, 0)\n",
    "                \n",
    "                if isinstance(module, torch.nn.Hardtanh):\n",
    "                    layer -= 1\n",
    "                    if layer < 0:\n",
    "                        break\n",
    "            \n",
    "            sizes = x.size()\n",
    "            x = x.view(sizes[0], sizes[1] * sizes[2], sizes[3])  # Collapse feature dimension\n",
    "            x = x.transpose(1, 2).transpose(0, 1).contiguous()  # TxNxH\n",
    "            if layer < 0:\n",
    "                #import pdb; pdb.set_trace()\n",
    "                return x.squeeze(dim=1).cpu()\n",
    "            \n",
    "            for rnn in self.rnns:\n",
    "                x = rnn(x, output_lengths)\n",
    "                layer -= 1\n",
    "                if layer < 0:\n",
    "                    return x.squeeze(dim=1).cpu()\n",
    "            \n",
    "            if not self.bidirectional:  # no need for lookahead layer in bidirectional\n",
    "                x = self.lookahead(x)\n",
    "            \n",
    "            x = self.fc(x)\n",
    "            \n",
    "            # identity in training mode, softmax in eval mode\n",
    "            if log:\n",
    "                x = torch.nn.functional.log_softmax(x, dim=-1)\n",
    "            else:\n",
    "                x = torch.nn.functional.softmax(x, dim=-1)\n",
    "            layer -= 1\n",
    "            if layer < 0:\n",
    "                return x.squeeze(dim=1).cpu()\n",
    "            \n",
    "            return None\n",
    "        \n",
    "        return activation\n",
    "\n",
    "\n",
    "# Pretrained DeepSpeech2 model\n",
    "model = DeepSpeech().to(device).eval()\n",
    "model.load_state_dict(torch.load('resources/deepspeech2-pretrained.ckpt')['state_dict'])\n",
    "\n",
    "# Model output sampling rate\n",
    "out_sr = 50"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Measuring integration windows"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This section demonstrates how to measure integration windows for a more complex deep neural network with multiple layers. To do this, we need to define a function that takes in input $\\mathrm{x}$ and returns output $\\mathrm{y}$, which in this case is the activations at a specific layer $\\mathrm{layer}$. The shape of both $\\mathrm{x}$ and $\\mathrm{y}$ should be of form $[ time \\times channels ]$.\n",
    "\n",
    "We first define a wrapper function to estimate integration windows of all nodes in a layer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Wrapper function to estimate integration windows of a layer\n",
    "def estimate_layer_intwin(layer, stimuli, segment_durs, in_sr, out_sr):\n",
    "    sequence_pairs = tci.generate_sequence_pair(\n",
    "        stimuli, in_sr, segment_durs\n",
    "    )\n",
    "    \n",
    "    response_pairs = tci.infer_sequence_pair(\n",
    "        model.activation_fx(layer), sequence_pairs, segment_durs,\n",
    "        in_sr=in_sr, out_sr=out_sr, block_size=48.0, context_size=8.0, device=device\n",
    "    )\n",
    "    \n",
    "    SAR_pairs = tci.rearrange_sequence_pair(\n",
    "        response_pairs, out_sr, segment_durs\n",
    "    )\n",
    "    \n",
    "    cross_context_corrs = tci.cross_context_corrs(\n",
    "        SAR_pairs, batch_size=100\n",
    "    )\n",
    "    \n",
    "    integration_windows = tci.estimate_integration_window(\n",
    "        cross_context_corrs, segment_durs, threshold=0.75\n",
    "    )\n",
    "    \n",
    "    return integration_windows"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now analyze the first, fourth and sixth layers of the model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "> Conv1... Done.\n",
      "> LSTM2... Done.\n",
      "> LSTM4... Done.\n"
     ]
    }
   ],
   "source": [
    "stimuli, in_sr = tci.load_stimuli('resources/segments-librispeech-1k/')\n",
    "\n",
    "segment_durs = tci.SEGMENT_DURS\n",
    "\n",
    "print('> Conv1... ', flush=True, end='')\n",
    "intwin_conv1_norm = estimate_layer_intwin(0, stimuli, segment_durs, in_sr, out_sr)\n",
    "print('Done.')\n",
    "\n",
    "print('> LSTM2... ', flush=True, end='')\n",
    "intwin_lstm2_norm = estimate_layer_intwin(3, stimuli, segment_durs, in_sr, out_sr)\n",
    "print('Done.')\n",
    "\n",
    "print('> LSTM4... ', flush=True, end='')\n",
    "intwin_lstm4_norm = estimate_layer_intwin(5, stimuli, segment_durs, in_sr, out_sr)\n",
    "print('Done.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The results show increasing integration windows as we look deeper in the network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAakAAAEWCAYAAADcsGj7AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAnXklEQVR4nO3de5wU1Zn/8c/DdUBABEUU5SoiIBhckhBiBJV4C4gGFFRcNSgRo5JsNCquCWrU/UVkE4kx8BNkg/CDAJsol7BGBAQiGlRE5bKaCMhFBBG5iALy/P6oGujp6Znpnunpru7+vl+vfvX0qVNVT09N9zOn6tQ55u6IiIhEUY1sByAiIlIWJSkREYksJSkREYksJSkREYksJSkREYksJSkREYmsjCYpMxtoZrPMbIOZ7TezdWb2qJk1jKt3nJk9bWY7zGyfmb1oZl0SbK/IzB4zs63h9l4xs3Mz945ERKQ6WSbvkzKz5cBG4DlgE9ANGAWsBXq6+2EzM2AJ0Bq4C/gUuBfoDHzN3TfFbG8K8L2w3j+BHwGXAN9y95UZeVMiIlJtMp2kTnD37XFl/wr8F3CBu79kZv2BPwPnu/vCsM6xwAfAs+5+R1h2FrAS+IG7PxOW1QLeBda5+2WZeVciIlJdMnq6Lz5Bhf4ePrcIny8DthQnqHC9z4DZQP+Y9S4DDgLTY+odAqYBF5lZ3TSGLiIiWRCFjhO9wuc14XNn4J0E9d4FWppZg5h6H7j75wnq1QFOS3egIiKSWbWyuXMzawE8CLzo7ivC4ibA+gTVd4bPxwF7w3qfllOvSTn7HQYMAzjmmGP+5Ywzzkg5dhGRQvX666/vcPcTMrGvrCWpsEX0HHAIuDGT+3b38cB4gO7du/uKFSsqWENERIqZ2YZM7Ssrp/vMrB7BNaa2wEWxPfYIWkfHJVitSczyZOrtTLBMRERySMaTlJnVBmYC3YFL3f3tuCrvElxvitcJ2Ojue2PqtTGz+gnqHQDeT1/UIiKSDZm+mbcGMAU4H7jc3ZcnqPY80MLMesWs1wjoFy4rNhuoDVwZU68WMAh4wd2/TP87EBGRTMr0NaknCZLKw8A+M+sRs2xTeNrveeAV4Fkzi72Z14BfFVd29zfNbDrw67B19gEwHGgDXJuJNyMiItUr06f7Lgmf7yNIRLGPmwDc/TDQF/gr8DvgT8BXwHnu/mHc9m4EngF+CcwFTgUudvc3qvdtiIhIJmR0xIkoKq933+HDh9m0aRP79u3LcFSFrXbt2jRr1oxGjRplOxQRScDMXnf37pnYV1bvk4q6HTt2YGZ06NCBGjWicN9z/nN39u/fz+bNmwGUqEQKnL55y7Fr1y5OPPFEJagMMjPq169PixYt+Pjjj7Mdjohkmb59y/HVV19Ru3btbIdRkOrVq8fBgwezHYaIZJmSVAWCmUMk0/R7FxFQkhIRkQhTkhIRkchS774U9Ru7NKP7m337ORndn4hIlKgllae2bdvGiBEjaNeuHXXr1qVFixZccsklzJs3L2MxfPHFF9xwww107dqV2rVr07t374ztW0Tyg1pSeWj9+vV8+9vfpmHDhjz66KOcddZZHD58mAULFnDLLbewcePGjMTx1VdfUVRUxG233ca8efPYtWtXRvYrIvlDLak8dOuttwKwYsUKrrrqKjp06EDHjh257bbbWLVqFQAbN27kiiuuoGHDhjRs2JDvf//7bNp0dMaUUaNGceaZZzJt2jTatWtHw4YNufzyy9mxYwcAL7zwAnXq1OGTTz4pse+RI0fStWtXAI455hh+//vfM2zYME455ZRMvHURyTNKUnlm586dzJ8/nx/96Ec0aNCg1PLGjRtz+PBh+vfvz7Zt21i4cCELFy5ky5YtXH755cQOk7V+/XqmT5/On/70J1544QXefPNN7rvvPgAuuOACjj/+eGbMmHGkvrszdepUhgwZUv1vVEQKgk735Zn3338fd6djx45l1lmwYAGrVq3iH//4B61btwZg6tSpnHbaaSxYsIA+ffoAcOjQISZNmsSxxx4LwLBhw3jmmWcAqFmzJoMHD2bKlCnccsstACxbtowPP/yQa665phrfoYgUkoJvSb3/8d6M99irTskMGLxmzRpOPvnkIwkKoG3btpx88smsXr36SFmrVq2OJCiAk08+ucRQRUOGDGHZsmVs2BDMJD1lyhR69eqlU3sikjYFn6TyTfv27TEz1qxZU6n1Y0d6iB8Sysw4fPjwkddnn302Z5xxBlOnTuXgwYPMmDFDp/pEJK2UpPJMkyZNuOiii/jtb3/L3r17Sy3ftWsXHTt2ZMuWLaxfv/5I+T//+U+2bNlCp06dUtrfkCFDmDJlCvPnz2ffvn0MHDiwqm9BROQIJak89OSTT+LudO/enRkzZrBu3TrWrl3LU089RdeuXenTpw9du3bl2muvZcWKFaxYsYJrr72Ws88+m/PPPz+lfV177bWsXr2a+++/n379+pWaWmP16tWsXLmSHTt2sHfvXlauXMnKlSvT+G5FJJ+p40SKcmEEiLZt2/LGG2/wyCOPcPfdd7N582aaNm3KWWedxfjx4zEznnvuOe644w7OO+88APr06cPYsWNTHti1VatWnHPOOSxZsoQHH3yw1PJLL730yDUrgG7dugHJXTsTESn4mXkbtzzDv3PX0wmTz5o1a8rtJSfVS79/kWjK5My8Ot0nIiKRpSQlIiKRpSQlIiKRpSQlIiKRpSQlIiKRpSQlIiKRpSQlIiKRpSQlIiKRpSQlIiKRpWGRUjWuV2b398PFmd2fiEiEqCWVh2644Qb69u2bcNlbb71F//79ad68OUVFRbRs2ZIBAwawYcMGJk2ahJmV+1i0aNGReu3bty+1/b/85S+YWYlZgRctWkT//v056aSTqF+/Pl27dmXixInV9v5FJH8oSRWQ7du3c8EFF9CgQQPmzp3L2rVrmTx5Mu3atWP37t0MGjSIrVu3Hnn06dOHq666qkRZz549ASgqKmLXrl0sXlyypTdhwgRatmxZouxvf/sbXbp0YebMmbzzzjsMHz6cYcOGMXXq1Iy9dxHJTTrdV0CWLVvGp59+yjPPPEOdOnUAaN26Nb16HT2FWa9evSM/161bl3r16tG8efNS26pZsybXXXcdEydOPLL+jh07mDNnDj/72c8YM2bMkbojR44sse7w4cNZuHAhs2bN0lTzIlIutaQKSPPmzTl8+DAzZ85My1QZQ4cOZdasWezZsweAyZMn07NnT9q2bVvhurt37+a4446rcgwikt+UpApIjx49GDlyJNdffz1NmjThwgsv5JFHHikx31MqOnfuTOfOnZk2bRoQnOr7wQ9+UOF6c+bMYcGCBQwbNqxS+xWRwqEkVWAefvhhPvroI8aPH0+XLl2YMGECnTp1YsGCBZXa3tChQ5k4cSKvvvoqmzZtYsCAAeXWX7ZsGddccw1PPPEE3/jGNyq1TxEpHEpSBahp06ZceeWVPP7446xZs4bWrVvz0EMPVWpbgwcPZtWqVdxzzz1cffXVJa5pxVu6dCmXXHIJDz74IMOHD69s+CJSQJSkClydOnVo164de/furdT6jRo1YuDAgSxatIihQ4eWWe/ll1/mkksuYdSoUfz4xz+uZLQiUmjUuy9P7d69m5UrV5YoW7p0KcuXL2fw4MGcfvrpuDuzZ89m3rx5PPDAA5Xe17hx4xgzZgxNmzblvW172PbZFyWWL1q0iO9973vceuutXHPNNXz00UdA0EPwhBNOqPR+RST/KUmlKkdGgFiyZAndunUrUXbFFVfQrFkz7rzzTj788ENq1apFmzZtGD16NCNGjKj0voqKiigqKipz+aRJk/j8888ZPXo0o0ePPlLeqlUr1q9fX+n9ikj+s3R0Rc5ljVue4d+562lm335OqWVr1qyhY8eOWYgqd723LeiO3v7EhlXeln7/ItFkZq+7e/dM7EvXpEREJLKUpEREJLKUpEREJLKUpEREJLKUpEREJLKUpEREJLKUpEREJLKUpEREJLKUpEREJLI0LFKKBs0ZlNH9Te87PaP7ExGJErWk8tANN9xA3759Ey5766236N+/P82bN6eoqIiWLVsyYMAANmzYwKRJkzCzch+LFi06Uq99+/altr94wQuc3rwRDRo0SLj/9957j4YNG5a5XEQklpJUAdm+fTsXXHABDRo0YO7cuaxdu5bJkyfTrl07du/ezaBBg9i6deuRR58+fbjqqqtKlPXs2RMIBpXdtWsXixeXHHB35tTJnNzi1IT7P3DgAIMHD+bcc8+t9vcqIvlBp/sKyLJly/j000955plnqFOnDgCtW7emV69eR+rETlpYt25d6tWrR/PmzUttq2bNmlx33XVMnDjxyPo7duxg4YvzufnWEUwa/2Spde6++266du1Kr169SiU3EZFE1JIqIM2bN+fw4cPMnDmTdIx+P3ToUGbNmsWePcHI55MnT+bs7t/k1FZtStWdO3cuc+bMYezYsVXer4gUDiWpAtKjRw9GjhzJ9ddfT5MmTbjwwgt55JFH2LBhQ6W217lzZzp37sy0adMAmDBhAgOuHlKq3pYtW7j55pt59tlndS1KRFKiJFVgHn74YT766CPGjx9Ply5dmDBhAp06dWLBggWV2t7QoUOZOHEir776Kps2beKi7/UvVee6665j+PDhfPOb36xq+CJSYJSkClDTpk258sorefzxx1mzZg2tW7fmoYceqtS2Bg8ezKpVq7jnnnu4+uqrKYq5plXspZde4oEHHqBWrVrUqlWLoUOHsm/fPmrVqsX48eOr+nZEJI+p40SBq1OnDu3atWPLli2VWr9Ro0YMHDiQP/zhDzz22GMJ67z99tslXj/33HM8/PDDvPbaa7Ro0aJS+xWRwqAklad2797NypUrS5QtXbqU5cuXM3jwYE4//XTcndmzZzNv3jweeOCBSu9r3LhxjBkzhqZNmx6ZPj7WmWeeWeL1ihUrqFGjRqlyEZF4SlIpypURIJYsWUK3bt1KlF1xxRU0a9aMO++8kw8//JBatWrRpk0bRo8ezYgRIyq9r6KiIoqKiqoasohIKZaOrsi5rHHLM/w7dz3N7NvPKbVszZo1dOzYMQtR5a7illT7ExtWeVv6/YtEk5m97u7dM7EvdZwQEZHIUpISEZHIUpISEZHIUpISEZHIUpKqQKF3LMkW/d5FBJSkylWzZk0OHjyY7TAK0v79+6ldu3a2wxCRLFOSKkfjxo3Ztm0bhw8fznYoBcPd+fzzz9m8eTPNmjXLdjgikmW6mbccxx9/PJs2bWLdunXZDiVnfLz7CwAO7az8zb21a9fmxBNPpFGjRukKS0RylJJUOWrUqEHLli2zHUZO+dnYpQDMvr1bBTVFRCqm030iIhJZaklJWvQLW1AiIumklpSIiESWkpSIiESWkpSIiERWSknKzC6srkBERETipdqSmm9m75vZXWZ2fLVEJCIiEko1SZ0P/B14CNhkZlPNrFf6w5Io6Td2qXrviUhWpJSk3H2Ru18NnALcD3QHFprZGjMbYWbHVUeQIiJSmCrVccLdd7j7Y+5+OvBdYAcwhqB1NcnMuqQzSBERKUxV6t1nZpcCdwA9gI+ByUAv4A0zG1718EREpJClPOKEmTUHhgI3Aa2AJcAQYJa7HzKzmsBvgJ8DT6UxVpGqGZfg8ukPF2c+DhFJWkpJysxmAX2BL4Bngd+5+7uxddz9KzObCtyatihFRKQgpdqSag/8GJjs7nvLqfc2cF5lg5Jo6ndkhPNzshyJiBSKVJNUX2Cru5eartbMagEnu/tGd98D6DyKiIhUSaodJz4Aypoo6KxwuYiISFqk2pKycpbVBjTPegGIvbE350/9JepMAepQIRIRFSYpM2sMNIkpamFmbeOq1QOuBz5KX2giIlLokmlJjQB+AXj4mFlGPQvrSQ6rzs4R6nghIqlKJkn9GVhPkIQmAr8E/hFX50tgtbuvSmdwkj0aq09EoqDCJOXubwFvAZiZA3PdfUd1ByYiIpJSxwl3/6/qCkQkrcrqECEiOSWZjhMvAbe6+9rw5/K4u1+QntBERKTQJdOSiu12XoOg80QydUVERKokmWtS58X83Ltao5GMU487EYmyKk3VISIiUp1SSlJm1t/Mbox53crMXjGzPWY208wapD9EEREpVKm2pP4dOCHm9RiCqeTHA+cCo9ITloiISOpJqh2wCsDM6gGXAv/m7j8FRgJXpDc8EREpZKkmqSJgf/hzT4KOFy+Er9cBJ6cpLhERkZST1HqguBtYf+B1d/8sfN0M+CzRSiIiIpWR6lQd44DRZnYF8DVgeMyybwGr0xSXiIhIysMi/cbMdgA9gCfc/Q8xixsCk9IYm0j2JDuskuadEqlWqbakcPcpwJQE5T9MS0SSUyIxWrrG6RPJWyknqWJm1oygI0UJ7r6xShGJiIiEUkpSZtYI+A0wCKhbRrWaVQ1KREQEUm9JPQkMACYAbxNMdigiIlItUk1SFwN3ufuT1RGMiIhIrMoMMLsu7VGIiIgkkGqSmgb0q45ARERE4qV6uu8F4Ndm1hCYB+yMr+DuFc3eKyIikpRUk9Rz4XMb4IaYcieYlddR7z4REUmTVJPUeRVXERERSY9Uh0XSGDAiIpIxlRpxwsyOJxi/rykw2913mlkRcMDdD6czQBERKVypTh9vZvYYsAl4HpgItA4XPwfcl9boRESkoKXaBf1e4DbgQeCbBJ0lis0G+qYpLhERkZRP990EPOjuj5pZfC++9wmmlxcREUmLVFtSLYDlZSw7ABxTtXBERESOSrUltRk4E1iYYNlZwAdVjkiqXSTmgBIRSUKqLakZwM/N7NsxZW5mpwM/JRg2SUREJC1SbUmNAnoCLwMbwrIZwKnA34D/SFtkkrdiW3Kzbz8ni5GISNSlejPvfjPrDVxNMG3H+8AnwEPAFHc/lO4ARUSkcKU6M28R0J1gssM/A1uB1939i/SHJiK5aNCcQQBM7zs9y5FIPkgqSZlZXeBXwM2Unjb+CzN7Chjp7gfSHJ+I5IDixCSSbsm2pOYA5xOMKjEP2EhwI++pBDfw/gToBFxaDTGKiEiBqjBJmdmVBKOfD3T3PyWo8rSZDQCmm9n33f2/0x2kiIgUpmRaUlcDfywjQQHg7rPMbAZwLaAkJZKnYk/r6ZqTZEIy90l1A+YmUW8OcHbVwhERETkqmZbUCQTXoCqyEWhWtXAkVcX3HEXtfiPdCyUi6ZBMS6o+QZfzihwAiqoWjoiIyFHJ9u5rYWZtK6hzSlWDkfyksQJFpLKSTVIzk6hjgFchFhERkRKSSVI3VnsUIiIiCVSYpNz9vzIRiIhEl0aUkGxJdaoOERGRjEl1qg4RkaToxl9JB7WkCkC/sUvVw05EcpKSlIiIRJaSlIiIRJaSlIiIRJaSlIiIRJaSlIiIRJaSlIiIRJbuk5JIiOqUI1I2jUIhmaCWlIiIRJZaUiJS7TT6hFSWkpSIZJ2SmJRFp/tERCSy1JKSrNKYgiJSHrWkREQkspSkREQkspSkIkbTaoiIHKUkJSIikaUkJSIikaUkJSIikaUu6CKSUbpxV1KhlpSIiESWkpSIiESWkpSIiESWkpSIiESWOk6IVMW4XqXLfrg483GI5CklKRHJGs3uKxVRkpLckqjlIiJ5S0lKAE2ZISLRpCRVQJSIJBXZOhWnm30llpJUnilORLNvPyfLkaSBTu2JFDx1QRcRkchSS0pEjlBvO4kataRERCSylKRERCSylKRERCSydE0qT6h7eYRoqCSRtFGSEskEJS6RSlGSykFqNYlIoVCSyoLYJJMXN92KiFQTdZwQEZHIUpISEZHIUpISKVCD5gzSCBMSeUpSEin9xi5VxxAROUJJSkREIku9+yJCrQcRkdLUkhIRkchSSyqidC+ViIiSlEjBUw8/iTKd7hMRkchSSypP5XpHjH5jlzJm114A2jdrkOVoJFtiW3nT+07PYiSSLUpSItmSaGT0sqRpxHSd2pNcoyRVRcUtlvjODYk6PlS1dZPrraOyjNk1ItshiEhEKUlJRikhiUgqlKSyLF9bRyLpVnyqUtemCot694lIXtCAuflJSUpERCJLp/tSUFYniWTXExGR1ChJ5QAlOREpVDrdJyIikaWWlETeex9r5ImqyLfOBBqForAoSVVCeaffdGruKN0TJSJVpSQlIjkr31qJUpquSYmISGSpJZUEncKTSKpggNpBdT4LfjihQwaCEakeSlJxKnsvlEi1SnLE9COJSSRPKElJzlAvP0mGev/lFyWpkE7pVY168mWPWk+Sz5SkJKepdSXJUgsrNylJichR29eVLkvU8SLZeiJVlPNJysxOBf4T+C5gwIvAj919Y1YDy2PZPrVX3HqSJBVwQinrPirNTZU7cvo+KTOrD7wEnAFcD1wHtAcWmtkx2YxNRESqLtdbUjcDbYEO7v4+gJmtAt4DfgiMyWJsIpJDdM0qmnI9SV0GLC9OUADu/oGZLQP6oyQleSZtPfkSnQJMR93Kbi+V048ZOH2ZzoSl5Fc1uZ6kOgPPJSh/F7gyw7FkXaJrRf/W+DdJ1ROpFskmuHQnwjSqcHzAqiTNuJu0Y0cJKZXQxvUq8U/K9APHllpv+oFj4YeLk9t3jjB3z3YMlWZmB4Ax7n5PXPkvgXvcPWESNrNhwLDw5ZnAO9UaqFSX44Ed2Q5CKk3HL3d1cPeGmdhRrrekKsXdxwPjAcxshbt3z3JIUgk6drlNxy93mdmKTO0rp3v3AZ8CxyUobxIuExGRHJbrSepdgutS8ToBqzMci4iIpFmuJ6nngR5m1ra4wMxaA98OlyVjfDXEJZmhY5fbdPxyV8aOXa53nDgGeAvYD/w74MBDQEOgq7traAIRkRyW0y0pd98HnA/8LzAZmAJ8AJyvBCUikvtyuiUlIiL5LadbUhUxs4FmNsvMNpjZfjNbZ2aPmlnDuHrHmdnTZrbDzPaZ2Ytm1iVbcRciMzvFzMaa2Stm9rmZeXh9Mb5ekZk9ZmZbw2P6ipmdm6BeDTO718zWm9kXZvaWmQ3IyJspMGbWOzxe8Y9dcfWS+pwle4wlNcl8H5pZ6zKOpZtZ47jtZeSzmNdJCrgT+AoYCVwMPAUMB/5qZjUAzMyA2eHy24EBQG2CQWpPyUbQBeo04CqCWweWlFNvAsGYjT8H+gJbgf8xs6/F1XsIGAX8FrgEWA7MMLNL0xq1xLoD+FbMo0/xghQ/Z8keY0lNhd+HMR6l5LH8FrAnrk5mPovunrcP4IQEZf9K0MHi/PB1//D1eTF1jgV2Ak9k+z0UygOoEfPzTeExaR1X56yw/MaYslrAOuD5mLJmwJfAA3HrLwBWZfu95tsD6B0elz7l1Enqc5bsMdajUscpme/D1uHrmyrYVsY+i3ndknL37QmK/x4+twifLwO2uPvCmPU+I/ivr3/1RijF3P1wEtUuAw4CRwY1c/dDwDTgIjOrGxZfBNQBno1b/1mgi5m1qXrEkqJkP2fJHmNJUZLfh8nK2Gcxr5NUGYpHdFwTPncm8dh97wItzUzzkkdHZ+ADd/88rvxdgg/CaTH1vgTeT1APgpu9Jf2mmNlXZvaJmU01s5Yxy5L9nCV7jCU94r8Piz1qZofM7DMzez7BtcOMfRYLauw+M2sBPAi86O7FY081AdYnqL4zfD4OUHf2aChruKudMcuLn3d5eF6hnHqSHp8BjwOLgd1AN4LrHq+YWTd3/5jkP2fJHmOpojK+D78ExgEvANsJJpQdCfzNzL7h7sXJLGOfxYJJUuF/as8Bh4AbsxyOSN5w9zeBN2OKFpvZy8BrBJ0p/j0rgUmZyvo+dPetwC0xVZeY2XyCls99wJBMxgkFcrrPzOoRnPtuC1zk7ptiFpc3SG3xcomGio7Vzph6jcMeZeXVk2ri7m8Q3GT/9bAo2c9ZssdYKqmC78NS3P1DYClHjyVk8LOY90nKzGoDM4HuwKXu/nZclfIGqd3oGrkiSt4F2phZ/bjyTsABjp73fheoC7RLUA80+HAmFZ/mSfZzluwxlkpI4vuwPLGn7DL2WczrJBX2/Z9CMHTS5e6+PEG154EWZtYrZr1GQD+SH6RWMmM2wb01R2ZdNrNawCDgBXf/MiyeT9Dz6Nq49YcA77j7BxmItaCZWXegA8EpP0j+c5bsMZYUJfl9mGi9lsA5HD2WkMHPYr5fk3qS4Jf4MLDPzHrELNsUNnOfB14BnjWzuwiap/cCBvwqw/EWNDMbGP74L+HzJWa2Hdju7ovd/U0zmw78OvyP8AOCmxHbEPMhcPePzWwMcK+Z7QHeIPjwnE/QdVbSyMyKx8x8A9hF0HHiXmAz8ERYLanPWbLHWCqlwu9DM3ucoPHyCkHHiQ4Ex+lwuB6Q/HFKy2cx2zeYVeeDoDeRl/EYFVOvCTCR4Pzo5wQ3mp2V7fgL7VHOsVoUU6ceMAb4CPgCeBXonWBbNQku2G8g6LG0ChiY7feYj4/wS2wVQS+/g8CHBFM5nBRXL6nPWbLHWI+Uj1OF34fADwjunfo0PJYfAVMJpouv1HGq6mdRA8yKiEhk5fU1KRERyW1KUiIiEllKUiIiEllKUiIiEllKUiIiEllKUiIiEllKUpKQmd0QThmd8tQIZna5mf1bdcSVbmXFakenRO+d+ahSY2ajzCyt95KE731UOrdZyTieMLM5Gdzf5Wa2TVP0RIeSlFSHy4GcSFKUHesbBFNmv5HRaCrnaYJY84qZtSMYkXtUBnf7HME06HdlcJ9SDiUpyStmVjvBiMspc/fd7r7c3XenI67q5O6bPMlx2HLMj4G3/OhcR9XOg9ENxgO3mVlRpvYrZVOSkqSZ2SIzW2pmfczsDTP73MzeMbMrYupMAq4nGEzUw8f6mOUnmNnvzWyzmX1pZmvNbFiCffUxszfN7Asze9/MbjKzSXHbah1u/1Yz+5WZbSEYdqVxuJ9xZva/YZwfhrPFtohZv8xYE53us8BPzGydmR0ws61m9ttwoNTY2N3Mfmlmd5jZB2a2x8wWm1miUcBj1xsQrntKTNnjYdlNMWXfDcs6h69Lne5LNgYzqxnW2xr+nhaVFaeZXWxmr5jZfgtmbP2zmXWIWf7TcBt1YspmhbH0iSm72YJZXxvF7yOmTl2CQUinxpUXH5fLw+O708x2mdmvw/fy9fBvdJ+ZvWtmF8Wt/3Uz+6sFswfvN7N/mtnv4nb/R6Ax8P2y4pMMyvZ4UnpE8wHcQDCm12kxZYsIToW8S/AFcjHwV4KJ004L67QD5gIfAz3CR7dwWSNgHbARuBnoAzwGfAXcHrOfTgTJZgnB6birgLfD9dbH1GsdxrgZ+DPQF+hPMKZYB+A3wADgXGAwwZhk64GiJGLtHW67d8z+HgnLfgtcBPyEYDbZJUCNmHoe7ud/CAbRHEgwAOf7QK1yfufHEwzk+a8xZW8SjHM3NabsUeCjmNejCBsBqcYAPBTuczRwIcEsrP+g9PiWF4fH6a/h9q4Jt7UdaBHWOTtc79zwtQGfhPE/ErOt/we8WsHfX69wW93jyouPy3qCceO+G74HB8YSTIP+g/D4LAH2AceH6zYgGDdwPsHo670J/s7HJ9j/O8Afsv051MOVpPRI/KDsJHUQaB9T1iz88hoZUzaJYFTl+G3eTzAQZfu48v8L7Cj+8iT473k7UD+mzknhuutjylqHMb4BwTiU5byfmsCpYf0rkoi1+Muwd/i6CUHinBRXb0hY77KYMgfeA2rHlA0My3tWEOdbwDMx+zxMMDX7lpg6y4FpMa9HkThJlRsDR6ds/33cundTOkmtCLcXm+DahH8PY8LXNcIk8Ivw9dfC+McAr8SstxX4jwp+D3eH69Yp47hMjCt/Iyw/J6asa1h2ffi6e/i6axJ//5OB/83251AP1+k+Sdl77v5e8Qt3/5igJdIyiXUvJhgp+QMzq1X8IPhvvylHJ0LrAcxz989j9rMV+FsZ2/2zh98sscxsuJm9ZWZ7CVp7G8NFHeLrJqEHUAd4Nq58WrjtXnHlf3X3gzGviyeXq+j39BJwXvhzb4KpL/4TOMnMOppZQ4KpTBYmEXNFMXQBjiE4vRVrWuwLMzuGoJU03d0PFZd7MBfQMsL37u6HgcUE0zAQPq8CZgDdzayhmXUCmicR/8nAbnc/UMbyv8S9Xgvsc/elcWUQ/HMCQZLdBYwzsyFmdipl2x7GIFmmJCWpSjTd85dAMheZmxGcejsY95gRLm8aPp9EkPjibStju1vjC8zsduB3wIsE1xa+QZBoSDLWeMXTXZfYV/il/UnM8mLxv6fiSeAq2vdCoJWZtSVIVos9mPdsXfj6XIJ54F5KIuaKYjgpfI7/vca/Po7g1F2p3zPBNA2x730h0MOCKcrPC1//naAV/J2w7CDBdOTlKYqJN5FP414fIEhAR8QkuKLw9Wfh/rcQ/G1stOCa6oAE299P5f5OJM3yfdJDiZZPCJLPiDKWrwuftxIktHgnlrFeonuEBgML3P2nxQVm1ibJOBMp/sJvTnBNrnibtQiSa6LkXRkvE5w+PT98/D4sfyl8vQHYHNuarYLipHMiMe+J0r/nTwl+x80TbKM5Jd/7QoIW57nhY7y7HzKzJQTxtwFec/d9FcT2CUHnhbRy95XAgPC4dSeYC+uPZnaWu78TU7VJGINkmVpSUh2+JOi8EG8+cAaw0d1XJHjsCestBy41s/rFK5rZScC3U4ihPsF/7LFuTCHWeMsJ/lsfHFc+iOCfvUUpxFYmd99F0FliMMHpz+IW00sEp9UuILlTfclYRdCx4Kq48hLvMUworwNXmlnN4nIzawX0pOR7f4fgVNldBKcSF8fEf0H4HpKJfy1QJ7anYzq5+yEPuu3fT/A92DGuShuO/tMkWaSWlFSH1UATMxtOcMH9C3d/m+DayiBgiZn9J8GXwDEEies77t4/XP+XBBf5/8fMRgN1Cb5MthFcTE/GfOBuMxsJvEbwX/zABPXKirUEd99pwdTa95rZPmAewRfbLwlOXc1NMq5kLCT4kv/Y3YtbOIsIWmzHE/RarDJ33xUeh/ssmNr7BeDrwNAE1e8neI9zwi7bDYAHCGbjfTxmm25miwimKf+7H73PbCFBT05I7lTly+HzN4BNqbyvsphZX2AYQU/QDwj+9u4A9hBMl15cz8L9xndNlyxQkpLq8DTB9Z9HCE7ZbABau/tnZtYT+DlB760WBNcR1gGzild299Vm9j2CL7U/EnQx/z8EHS9aJxnDg+G+f0JwbWExQbfkfyYTaxnbvI+glXALcCvB6aA/APeGnQbSpThJHWlxuPsOM3uboMdaulpSEPQMNOAm4DaCji39KHn6D3efHx6TXxAckwMEifNn7r4lQfxXUjIZvUlw2rA+MQmhLO6+3sxeC2P571TfVBneI7jWdD/B9bg9BNfLvhte9yvWk+A63LRSW5CM0/TxkhMsGEvtfWCuuyf6T1/yjJndQNBqPCm2p2cG9vsUcKa7fydT+5SyKUlJJJnZWIIu51sIugKPALoBX3f3VdmMTTIj7NzwNjDB3UdnaJ/NCVrbF7v7yxXVl+qn030SVUUEp/hOJDi19BrQRwmqcIS9Am8kuEcrU1oDP1WCig61pEREJLLUBV1ERCJLSUpERCJLSUpERCJLSUpERCJLSUpERCLr/wMyIGm31FKGdAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(6, 4))\n",
    "plt.hist(np.log10(intwin_conv1_norm), bins=50, alpha=0.8, label='Conv1')\n",
    "plt.hist(np.log10(intwin_lstm2_norm), bins=50, alpha=0.8, label='LSTM2')\n",
    "plt.hist(np.log10(intwin_lstm4_norm), bins=50, alpha=0.8, label='LSTM4')\n",
    "plt.xticks(np.log10([0.02, 0.1, 0.5, 2.5]), [20, 100, 500, 2500], fontsize=16)\n",
    "plt.yticks([0, 200], fontsize=16)\n",
    "plt.xlabel('Integration window (ms)', fontsize=16)\n",
    "plt.ylabel('Density', fontsize=16)\n",
    "plt.legend(loc='upper left', fontsize=14)\n",
    "plt.xlim(np.log10([0.02, 2.5]))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Measuring adaptation indices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this section, we study whether the model adapts its integration window depending on the input speech rate, to match the length of abstract structures in speech, rather than fixed integration windows, i.e., a fixed duration of speech.\n",
    "\n",
    "To do this, we can either preprocess the stimuli independently or use the `process` parameter of `load_stimuli` and `process_stimuli`. There are a number of basic audio processing functions based on the SoX backend of the torchaudio library in the `PyTCI.audio` module, including audio stretching while preserving the audio pitch, named `tempo_fx`, which we use in this example.\n",
    "\n",
    "We then compute the adaptation index, as defined in the paper:\n",
    "\n",
    "\\begin{equation*}\n",
    "\\mathrm{adaptation\\;index} = \\frac{I_{mod}/I_{ref} - 1}{D_{mod}/D_{ref} - 1}\n",
    "\\end{equation*}\n",
    "\n",
    "where $I_{mod}$ and $I_{ref}$ are integration windows for modified (i.e., slowed-down) and reference (i.e., natural) stimuli, and $D_{mod}/D_{ref}$ is the ratio of the duration of the stimuli between modified and reference conditions. Given the definition, a non-adaptive model with a fixed window would have an adaptation index of ~0, and a fully-adaptive model with flexible integration would have an adaptation index of ~1.\n",
    "\n",
    "<strong>NOTE</strong>: the scaling factor input to the `temp_fx` and `speed_fx` functions are the scaling factor for the rate, not duration, so to increase stimuli duration by 60%, we have to set the rate scaling to $\\frac{1}{1.6}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "> Conv1 (slowed-down)... Done.\n",
      "> LSTM2 (slowed-down)... Done.\n",
      "> LSTM4 (slowed-down)... Done.\n"
     ]
    }
   ],
   "source": [
    "# Estimate integration periods for 60% longer stimuli\n",
    "time_stretch_factor = 1.6\n",
    "stimuli, in_sr = tci.load_stimuli(\n",
    "    'resources/segments-librispeech-1k/',\n",
    "    process=fx.tempo_fx(scale_factor=1/time_stretch_factor)\n",
    ")\n",
    "\n",
    "print('> Conv1 (slowed-down)... ', flush=True, end='')\n",
    "intwin_conv1_slow = estimate_layer_intwin(0, stimuli, segment_durs, in_sr, out_sr)\n",
    "print('Done.')\n",
    "\n",
    "print('> LSTM2 (slowed-down)... ', flush=True, end='')\n",
    "intwin_lstm2_slow = estimate_layer_intwin(3, stimuli, segment_durs, in_sr, out_sr)\n",
    "print('Done.')\n",
    "\n",
    "print('> LSTM4 (slowed-down)... ', flush=True, end='')\n",
    "intwin_lstm4_slow = estimate_layer_intwin(5, stimuli, segment_durs, in_sr, out_sr)\n",
    "print('Done.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We calculate the adaptation index as described in the paper, based on the two conditions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "adaptation_conv1 = (intwin_conv1_slow/intwin_conv1_norm - 1) / (time_stretch_factor - 1)\n",
    "adaptation_lstm2 = (intwin_lstm2_slow/intwin_lstm2_norm - 1) / (time_stretch_factor - 1)\n",
    "adaptation_lstm4 = (intwin_lstm4_slow/intwin_lstm4_norm - 1) / (time_stretch_factor - 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comparing the integration windows between the two conditions, demonstrates how the network layers transition from short and fixed integration windows (close to black dashed line) to long and flexible integrations (close to red dashed line):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(6, 6))\n",
    "plt.plot(np.log10([0.018, 1.28]), np.log10([0.018, 1.28]), 'k--', linewidth=1)\n",
    "plt.plot(np.log10([0.018, 1.28]), np.log10([0.018, 1.28])+np.log10(1.6), 'r--', linewidth=1)\n",
    "plt.scatter(\n",
    "    np.log10(intwin_conv1_norm),\n",
    "    np.log10(intwin_conv1_slow),\n",
    "    2, alpha=0.3, label='Conv1'\n",
    ")\n",
    "plt.scatter(\n",
    "    np.log10(intwin_lstm2_norm),\n",
    "    np.log10(intwin_lstm2_slow),\n",
    "    2, alpha=0.3, label='LSTM2'\n",
    ")\n",
    "plt.scatter(\n",
    "    np.log10(intwin_lstm4_norm),\n",
    "    np.log10(intwin_lstm4_slow),\n",
    "    2, alpha=0.3, label='LSTM4'\n",
    ")\n",
    "plt.xticks(np.log10([0.02, 0.08, 0.32, 1.28]), [20, 80, 320, 1280], fontsize=16)\n",
    "plt.yticks(np.log10([0.02, 0.08, 0.32, 1.28]), [20, 80, 320, 1280], fontsize=16)\n",
    "plt.xlabel('Integration window for\\nnatural speech (ms)', fontsize=16)\n",
    "plt.ylabel('Integration window for\\nslowed-down speech (ms)', fontsize=16)\n",
    "plt.xlim(np.log10([0.02, 1.28]))\n",
    "plt.ylim(np.log10([0.02, 1.28]))\n",
    "legend = plt.legend(loc='lower right', fontsize=14)\n",
    "for h in legend.legendHandles:\n",
    "    h.set_sizes([25])\n",
    "    h.set_alpha(1)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The adaptation indices quantify this transition in a clearer way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(6, 4))\n",
    "plt.hist(adaptation_conv1, bins=100, alpha=0.6, range=(-0.24, 1.24), label='Conv1')\n",
    "plt.hist(adaptation_lstm2, bins=50, alpha=0.6, range=(-0.24, 1.24), label='LSTM2')\n",
    "plt.hist(adaptation_lstm4, bins=50, alpha=0.6, range=(-0.24, 1.24), label='LSTM4')\n",
    "plt.legend(fontsize=14)\n",
    "plt.xticks([0, 0.25, 0.5, 0.75, 1.0], fontsize=16)\n",
    "plt.yticks([0, 100], fontsize=16)\n",
    "plt.plot([0, 0], [0, 150], 'k--')\n",
    "plt.plot([1, 1], [0, 150], 'r--')\n",
    "plt.xlabel('Adaptation index', fontsize=16)\n",
    "plt.ylabel('Density', fontsize=16)\n",
    "plt.xlim([-0.24, 1.24])\n",
    "plt.ylim([0, 150])\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:.conda-deepspeech]",
   "language": "python",
   "name": "conda-env-.conda-deepspeech-py"
  },
  "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.8.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}