DeepBioLCNet.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "view-in-github"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Singular-Brain/DeepBioLCNet/blob/main/DeepBioLCNet.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7fTSvrK3T_GA"
      },
      "source": [
        "#Notebook setups"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lXtgP_iEPE0G",
        "outputId": "06a24a23-965e-4b64-b8e3-c3749d8d3054"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "^C\n"
          ]
        }
      ],
      "source": [
        "!pip install -q git+https://github.com/Singular-Brain/DeepBioLCNet"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OW7m3ugEHZP_",
        "outputId": "53e5e654-b46e-4eef-8c38-be8188477ed2"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "--2021-10-10 09:26:16--  https://data.deepai.org/mnist.zip\n",
            "Resolving data.deepai.org (data.deepai.org)... 138.201.36.183\n",
            "Connecting to data.deepai.org (data.deepai.org)|138.201.36.183|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 11597176 (11M) [application/x-zip-compressed]\n",
            "Saving to: ‘mnist.zip’\n",
            "\n",
            "mnist.zip           100%[===================>]  11.06M  10.9MB/s    in 1.0s    \n",
            "\n",
            "2021-10-10 09:26:17 (10.9 MB/s) - ‘mnist.zip’ saved [11597176/11597176]\n",
            "\n",
            "Archive:  mnist.zip\n",
            "  inflating: ../data/MNIST/TorchvisionDatasetWrapper/raw/train-labels-idx1-ubyte.gz  \n",
            "  inflating: ../data/MNIST/TorchvisionDatasetWrapper/raw/train-images-idx3-ubyte.gz  \n",
            "  inflating: ../data/MNIST/TorchvisionDatasetWrapper/raw/t10k-images-idx3-ubyte.gz  \n",
            "  inflating: ../data/MNIST/TorchvisionDatasetWrapper/raw/t10k-labels-idx1-ubyte.gz  \n"
          ]
        }
      ],
      "source": [
        "!wget https://data.deepai.org/mnist.zip\n",
        "!mkdir -p ../data/MNIST/TorchvisionDatasetWrapper/raw\n",
        "!unzip mnist.zip -d ../data/MNIST/TorchvisionDatasetWrapper/raw/"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KXcXvvsXcOlv",
        "outputId": "e30613a5-6a4d-428e-d74c-3366a96df7ae"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Cloning into 'DeepBioLCNet'...\n",
            "remote: Enumerating objects: 128, done.\u001b[K\n",
            "remote: Counting objects: 100% (128/128), done.\u001b[K\n",
            "remote: Compressing objects: 100% (101/101), done.\u001b[K\n",
            "remote: Total 128 (delta 32), reused 111 (delta 20), pack-reused 0\u001b[K\n",
            "Receiving objects: 100% (128/128), 29.62 MiB | 28.86 MiB/s, done.\n",
            "Resolving deltas: 100% (32/32), done.\n"
          ]
        }
      ],
      "source": [
        "!git clone https://github.com/Singular-Brain/DeepBioLCNet/"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "BFGNAecpT-Lj"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "ERROR: Could not install packages due to an OSError: [WinError 5] Access is denied: 'C:\\\\Users\\\\Mahbod\\\\AppData\\\\Roaming\\\\Python\\\\Python38\\\\site-packages\\\\~cipy\\\\.libs\\\\libansari.R6EA3HQP5KZ6TAXU4Y4ZVTRPT7UVA53Z.gfortran-win_amd64.dll'\n",
            "Consider using the `--user` option or check the permissions.\n",
            "\n",
            "WARNING: You are using pip version 21.1.3; however, version 21.3.1 is available.\n",
            "You should consider upgrading via the 'C:\\Users\\Mahbod\\anaconda3\\python.exe -m pip install --upgrade pip' command.\n"
          ]
        }
      ],
      "source": [
        "from bindsnet.network.nodes import Nodes\n",
        "import os\n",
        "import torch\n",
        "import random\n",
        "import math\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import collections\n",
        "from sklearn.metrics import confusion_matrix\n",
        "import seaborn as sn\n",
        "\n",
        "from abc import ABC, abstractmethod\n",
        "from typing import Union, Tuple, Optional, Sequence\n",
        "from tqdm.notebook import tqdm\n",
        "from torchvision import transforms\n",
        "from torch.nn.modules.utils import _pair\n",
        "import torch.nn.functional as fn\n",
        "\n",
        "from bindsnet.datasets import MNIST\n",
        "from bindsnet.encoding import PoissonEncoder\n",
        "from bindsnet.network import Network\n",
        "from bindsnet.network.nodes import Input, LIFNodes, AdaptiveLIFNodes\n",
        "from bindsnet.network.topology import LocalConnection, Connection, LocalConnectionOrig\n",
        "from bindsnet.network.monitors import Monitor, AbstractMonitor, TensorBoardMonitor\n",
        "from bindsnet.learning import PostPre, MSTDP, MSTDPET, WeightDependentPostPre, Hebbian\n",
        "from bindsnet.learning.reward import DynamicDopamineInjection, DopaminergicRPE\n",
        "from bindsnet.analysis.plotting import plot_locally_connected_weights_meh"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ULGGHW43UksI"
      },
      "source": [
        "## Sets up Gpu use and manual seed\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LiUmFrpcUfmR",
        "outputId": "76769980-c061-49dc-9b4c-f58e50601e73"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Running on Device =  cpu\n"
          ]
        }
      ],
      "source": [
        "if torch.cuda.is_available():\n",
        "    device =  torch.device(\"cuda\")\n",
        "    gpu = True\n",
        "else:\n",
        "    device =  torch.device(\"cpu\")\n",
        "    gpu = False\n",
        "\n",
        "def manual_seed(seed):\n",
        "    random.seed(seed)\n",
        "    torch.manual_seed(seed)\n",
        "    np.random.seed(seed)\n",
        "    if torch.cuda.is_available():\n",
        "        torch.cuda.manual_seed_all(seed)\n",
        "\n",
        "\n",
        "SEED = 2045 # The Singularity is Near!\n",
        "manual_seed(SEED)\n",
        "WANDB = True\n",
        "\n",
        "torch.set_num_threads(os.cpu_count() - 1)\n",
        "print(\"Running on Device = \", device)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MBKedMpIleMr"
      },
      "source": [
        "# Custom Monitors"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6tfqpsr2a1WV"
      },
      "source": [
        "## Reward Monitor"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "M44GJ65GleMs"
      },
      "outputs": [],
      "source": [
        "class RewardMonitor(AbstractMonitor):\n",
        "    # language=rst\n",
        "    \"\"\"\n",
        "    Records state variables of interest.\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(\n",
        "        self,\n",
        "        time: None,\n",
        "        batch_size: int = 1,\n",
        "        device: str = \"cpu\",\n",
        "    ):\n",
        "        # language=rst\n",
        "        \"\"\"\n",
        "        Constructs a ``Monitor`` object.\n",
        "\n",
        "        :param obj: An object to record state variables from during network simulation.\n",
        "        :param state_vars: Iterable of strings indicating names of state variables to record.\n",
        "        :param time: If not ``None``, pre-allocate memory for state variable recording.\n",
        "        :param device: Allow the monitor to be on different device separate from Network device\n",
        "        \"\"\"\n",
        "        super().__init__()\n",
        "\n",
        "        self.time = time\n",
        "        self.batch_size = batch_size\n",
        "        self.device = device\n",
        "\n",
        "        # if time is not specified the monitor variable accumulate the logs\n",
        "        if self.time is None:\n",
        "            self.device = \"cpu\"\n",
        "\n",
        "        self.recording = []\n",
        "        self.reset_state_variables()\n",
        "\n",
        "    def get(self,) -> torch.Tensor:\n",
        "        # language=rst\n",
        "        \"\"\"\n",
        "        Return recording to user.\n",
        "\n",
        "        :return: Tensor of shape ``[time, n_1, ..., n_k]``, where ``[n_1, ..., n_k]`` is the shape of the recorded state\n",
        "        variable.\n",
        "        Note, if time == `None`, get return the logs and empty the monitor variable\n",
        "\n",
        "        \"\"\"\n",
        "        # return_logs = torch.as_tensor(self.recording)\n",
        "        # if self.time is None:\n",
        "        #     self.recording = []\n",
        "        return self.recording\n",
        "\n",
        "    def record(self, **kwargs) -> None:\n",
        "        # language=rst\n",
        "        \"\"\"\n",
        "        Appends the current value of the recorded state variables to the recording.\n",
        "        \"\"\"\n",
        "        if \"reward\" in kwargs:\n",
        "            self.recording.append(kwargs[\"reward\"])\n",
        "        # remove the oldest element (first in the list)\n",
        "        # if self.time is not None:\n",
        "        #     self.recording.pop(0)\n",
        "\n",
        "    def reset_state_variables(self) -> None:\n",
        "        # language=rst\n",
        "        \"\"\"\n",
        "        Resets recordings to empty ``List``s.\n",
        "        \"\"\"\n",
        "        self.recording = []\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8clxN_npa1WY"
      },
      "source": [
        "## Plot Eligibility trace"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "SshGlRwpa1WZ"
      },
      "outputs": [],
      "source": [
        "class PlotET(AbstractMonitor):\n",
        "    # language=rst\n",
        "    \"\"\"\n",
        "    Records state variables of interest.\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(\n",
        "        self,\n",
        "        i,\n",
        "        j,\n",
        "        source,\n",
        "        target,\n",
        "        connection,\n",
        "    ):\n",
        "        # language=rst\n",
        "        \"\"\"\n",
        "        Constructs a ``Monitor`` object.\n",
        "\n",
        "        :param obj: An object to record state variables from during network simulation.\n",
        "        :param state_vars: Iterable of strings indicating names of state variables to record.\n",
        "        :param time: If not ``None``, pre-allocate memory for state variable recording.\n",
        "        :param device: Allow the monitor to be on different device separate from Network device\n",
        "        \"\"\"\n",
        "        super().__init__()\n",
        "        self.i = i\n",
        "        self.j = j\n",
        "        self.source = source\n",
        "        self.target = target\n",
        "        self.connection = connection\n",
        "\n",
        "        self.reset_state_variables()\n",
        "\n",
        "    def get(self,) -> torch.Tensor:\n",
        "        # language=rst\n",
        "        \"\"\"\n",
        "        Return recording to user.\n",
        "\n",
        "        :return: Tensor of shape ``[time, n_1, ..., n_k]``, where ``[n_1, ..., n_k]`` is the shape of the recorded state\n",
        "        variable.\n",
        "        Note, if time == `None`, get return the logs and empty the monitor variable\n",
        "\n",
        "        \"\"\"\n",
        "        # return_logs = torch.as_tensor(self.recording)\n",
        "        # if self.time is None:\n",
        "        #     self.recording = []\n",
        "        return self.recording\n",
        "\n",
        "    def record(self, **kwargs) -> None:\n",
        "        # language=rst\n",
        "        \"\"\"\n",
        "        Appends the current value of the recorded state variables to the recording.\n",
        "        \"\"\"\n",
        "        if hasattr(self.connection.update_rule, 'p_plus'):\n",
        "            self.recording['spikes_i'].append(self.source.s.ravel()[self.i].item())\n",
        "            self.recording['spikes_j'].append(self.target.s.ravel()[self.j].item())\n",
        "            self.recording['p_plus'].append(self.connection.update_rule.p_plus[self.i].item())\n",
        "            self.recording['p_minus'].append(self.connection.update_rule.p_minus[self.j].item())\n",
        "            self.recording['eligibility'].append(self.connection.update_rule.eligibility[self.i,self.j].item())\n",
        "            self.recording['eligibility_trace'].append(self.connection.update_rule.eligibility_trace[self.i,self.j].item())\n",
        "            self.recording['w'].append(self.connection.w[self.i,self.j].item())\n",
        "\n",
        "    def plot(self):\n",
        "\n",
        "        fig, axs  = plt.subplots(7)\n",
        "        fig.set_size_inches(10, 20)\n",
        "        for i, (name, p) in enumerate(self.recording.items()):\n",
        "            axs[i].plot(p[-250:])\n",
        "            axs[i].set_title(name)\n",
        "    \n",
        "        fig.show()\n",
        "\n",
        "    def reset_state_variables(self) -> None:\n",
        "        # language=rst\n",
        "        \"\"\"\n",
        "        Resets recordings to empty ``List``s.\n",
        "        \"\"\"\n",
        "        self.recording = {\n",
        "        'spikes_i': [],\n",
        "        'spikes_j': [],\n",
        "        'p_plus':[],\n",
        "        'p_minus':[],\n",
        "        'eligibility':[],\n",
        "        'eligibility_trace':[],\n",
        "        'w': [],\n",
        "        }\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R_YGE1XjvIkZ"
      },
      "source": [
        "## Kernel "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "-4hp2V46vOUv"
      },
      "outputs": [],
      "source": [
        "class AbstractKernel(ABC):\n",
        "    def __init__(self, kernel_size):\n",
        "        \"\"\"\n",
        "        Base class for generating image filter kernels such as Gabor, DoG, etc. Each subclass should override :attr:`__call__` function.\n",
        "        Instantiates a ``Filter Kernel`` object.\n",
        "        :param window_size : The size of the kernel (int)\n",
        "        \"\"\"\n",
        "        self.window_size = kernel_size\n",
        "\n",
        "    def __call__(self):\n",
        "        pass\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "PL2L6_ABwBH4"
      },
      "outputs": [],
      "source": [
        "class DoGKernel(AbstractKernel):\n",
        "    def __init__(self, kernel_size: Union[int, Tuple[int, int]], sigma1 : float, sigma2 : float):\n",
        "        \"\"\"\n",
        "        Generates DoG filter kernels.\n",
        "        :param kernel_size: Horizontal and vertical size of DOG kernels.(If pass int, we consider it as a square filter) \n",
        "        :param sigma1 : The sigma parameter for the first Gaussian function.\n",
        "        :param sigma2 : The sigma parameter for the second Gaussian function.\n",
        "        \"\"\"\n",
        "        super(DoGKernel, self).__init__(kernel_size)\n",
        "        self.sigma1 = sigma1\n",
        "        self.sigma2 = sigma2\n",
        "        \n",
        "    def __call__(self):\n",
        "        k = self.window_size//2\n",
        "        x, y = np.mgrid[-k:k+1:1, -k:k+1:1]\n",
        "        a = 1.0 / (2 * math.pi)\n",
        "        prod = x*x + y*y\n",
        "        f1 = (1/(self.sigma1*self.sigma1)) * np.exp(-0.5 * (1/(self.sigma1*self.sigma1)) * (prod))\n",
        "        f2 = (1/(self.sigma2*self.sigma2)) * np.exp(-0.5 * (1/(self.sigma2*self.sigma2)) * (prod))\n",
        "        dog = a * (f1-f2)\n",
        "        dog_mean = np.mean(dog)\n",
        "        dog = dog - dog_mean\n",
        "        dog_max = np.max(dog)\n",
        "        dog = dog / dog_max\n",
        "        dog_tensor = torch.from_numpy(dog)\n",
        "        # returns a 2d tensor corresponding to the requested DoG filter\n",
        "        return dog_tensor.float()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "zBUT0IUZDXxW"
      },
      "outputs": [],
      "source": [
        "class Filter():\n",
        "    \"\"\"\n",
        "    Applies a filter transform. Each filter contains a sequence of :attr:`FilterKernel` objects.\n",
        "    The result of each filter kernel will be passed through a given threshold (if not :attr:`None`).\n",
        "    Args:\n",
        "        filter_kernels (sequence of FilterKernels): The sequence of filter kernels.\n",
        "        padding (int, optional): The size of the padding for the convolution of filter kernels. Default: 0\n",
        "        thresholds (sequence of floats, optional): The threshold for each filter kernel. Default: None\n",
        "        use_abs (boolean, optional): To compute the absolute value of the outputs or not. Default: False\n",
        "    .. note::\n",
        "        The size of the compund filter kernel tensor (stack of individual filter kernels) will be equal to the \n",
        "        greatest window size among kernels. All other smaller kernels will be zero-padded with an appropriate \n",
        "        amount.\n",
        "    \"\"\"\n",
        "    # filter_kernels must be a list of filter kernels\n",
        "    # thresholds must be a list of thresholds for each kernel\n",
        "    def __init__(self, filter_kernels, padding=0, thresholds=None, use_abs=False):\n",
        "        tensor_list = []\n",
        "        self.max_window_size = 0\n",
        "        for kernel in filter_kernels:\n",
        "            if isinstance(kernel, torch.Tensor):\n",
        "                tensor_list.append(kernel)\n",
        "                self.max_window_size = max(self.max_window_size, kernel.size(-1))\n",
        "            else:\n",
        "                tensor_list.append(kernel().unsqueeze(0))\n",
        "                self.max_window_size = max(self.max_window_size, kernel.window_size)\n",
        "        for i in range(len(tensor_list)):\n",
        "            p = (self.max_window_size - filter_kernels[i].window_size)//2\n",
        "            tensor_list[i] = fn.pad(tensor_list[i], (p,p,p,p))\n",
        "\n",
        "        self.kernels = torch.stack(tensor_list)\n",
        "        self.number_of_kernels = len(filter_kernels)\n",
        "        self.padding = padding\n",
        "        if isinstance(thresholds, list):\n",
        "            self.thresholds = thresholds.clone().detach()\n",
        "            self.thresholds.unsqueeze_(0).unsqueeze_(2).unsqueeze_(3)\n",
        "        else:\n",
        "            self.thresholds = thresholds\n",
        "        self.use_abs = use_abs\n",
        "\n",
        "    # returns a 4d tensor containing the flitered versions of the input image\n",
        "    # input is a 4d tensor. dim: (minibatch=1, filter_kernels, height, width)\n",
        "    def __call__(self, input):\n",
        "\n",
        "        # if input.dim() == 3:\n",
        "        #     input2 = torch.unsqueeze(input, 0)\n",
        "        input.unsqueeze_(0)\n",
        "        output = fn.conv2d(input, self.kernels, padding = self.padding).float()\n",
        "        if not(self.thresholds is None):\n",
        "            output = torch.where(output < self.thresholds, torch.tensor(0.0, device=output.device), output)\n",
        "        if self.use_abs:\n",
        "            torch.abs_(output)\n",
        "        return output.squeeze(0)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nL0giSqUUvz6"
      },
      "source": [
        "# Design network"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {},
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "WARNING: You are using pip version 21.1.3; however, version 21.3.1 is available.\n",
            "You should consider upgrading via the 'C:\\Users\\Mahbod\\anaconda3\\python.exe -m pip install --upgrade pip' command.\n",
            "wandb: Currently logged in as: mahbod (use `wandb login --relogin` to force relogin)\n"
          ]
        }
      ],
      "source": [
        "if WANDB:\n",
        "    !pip install -q wandb\n",
        "    !wandb login\n",
        "    import wandb"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "8bZpJmlrJDa9"
      },
      "outputs": [],
      "source": [
        "compute_size = lambda inp_size, k, s: int((inp_size-k)/s) + 1\n",
        "def convergence(c):\n",
        "    if c.norm is None:\n",
        "        return 1-torch.mean((c.w-c.wmin)*(c.wmax-c.w))/((c.wmax-c.wmin)/2)**2\n",
        "    else:\n",
        "        mean_norm_factor = c.norm / c.w.shape[-1]\n",
        "        return  1-(torch.mean((c.w-c.wmin)*(c.wmax-c.w))/((c.wmax-c.wmin)/2)**2)\n",
        "        \n",
        "class LCNet(Network):\n",
        "    def __init__(\n",
        "        self,\n",
        "        n_classes: int,\n",
        "        neuron_per_class: int,\n",
        "        in_channels : int,\n",
        "        n_channels1:int,\n",
        "        n_channels2:int,\n",
        "        filter_size1: int,\n",
        "        filter_size2: int,\n",
        "        stride1: int,\n",
        "        stride2: int,\n",
        "        maxPool1: bool,\n",
        "        maxPool2: bool,\n",
        "        online: bool,\n",
        "        time: int,\n",
        "        reward_fn,\n",
        "        n_neurons: int,\n",
        "        pre_observation: bool,\n",
        "        has_decision_period: bool,\n",
        "        local_rewarding: bool,\n",
        "        nu_LC: Union[float, Tuple[float, float]],\n",
        "        nu_LC2: Union[float, Tuple[float, float]],\n",
        "        nu_Output: float,\n",
        "        dt: float = 1.0,\n",
        "        crop_size:int = 20,\n",
        "        nu_inh_LC: float=0.01,\n",
        "        nu_inh: float=0.0,\n",
        "        inh_type = None,\n",
        "        inh_LC: bool=False,\n",
        "        inh_LC2: bool=False,\n",
        "        inh_factor_LC: float=100,\n",
        "        inh_factor_LC2: float=100,\n",
        "        inh_factor:float = 0.25,\n",
        "        single_output_layer:bool = False,\n",
        "        NodesType_LC = LIFNodes,\n",
        "        NodesType_Output = AdaptiveLIFNodes, \n",
        "        update_rule_LC = PostPre,\n",
        "        update_rule_LC2 = PostPre,\n",
        "        update_rule_Output = MSTDPET,\n",
        "        update_rule_inh = PostPre,\n",
        "        update_rule_inh_LC = PostPre,\n",
        "        wmin: float = 0.0,\n",
        "        wmax: float = 1.0,\n",
        "        soft_bound = False,\n",
        "        theta_plus: float = 2.0,\n",
        "        tc_theta_decay: float = 250,\n",
        "        tc_trace:int = 20,\n",
        "        normal_init:bool = False,\n",
        "        mu: float=0.5,\n",
        "        std:float=0.01,\n",
        "        norm_factor_inh_LC: bool= None,\n",
        "        norm_factor_LC = None,\n",
        "        norm_factor_LC2 = None,\n",
        "        norm_factor_out = None,\n",
        "        norm_factor_inh = None,\n",
        "        trace_additive = False,\n",
        "        load_path = None,\n",
        "        save_path = None,\n",
        "        LC_weights_path = None,\n",
        "        LC2_weights_path = None,\n",
        "        confusion_matrix = False,\n",
        "        wandb_active = False,\n",
        "        **kwargs,\n",
        "    ) -> None:\n",
        "        # language=rst\n",
        "        \"\"\"\n",
        "        Constructor for class ``BioLCNet``.\n",
        "\n",
        "        :param n_inpt: Number of input neurons. Matches the 1D size of the input data.\n",
        "        :param n_neurons: Number of excitatory, inhibitory neurons.\n",
        "        :param exc: Strength of synapse weights from excitatory to inhibitory layer.\n",
        "        :param inh: Strength of synapse weights from inhibitory to excitatory layer.\n",
        "        :param dt: Simulation time step.\n",
        "        :param nu: Single or pair of learning rates for pre- and post-synaptic events,\n",
        "            respectively.\n",
        "        :param reduction: Method for reducing parameter updates along the minibatch\n",
        "            dimension.\n",
        "        :param wmin: Minimum allowed weight on input to excitatory synapses.\n",
        "        :param wmax: Maximum allowed weight on input to excitatory synapses.\n",
        "        :param norm: Input to excitatory layer connection weights normalization\n",
        "            constant.\n",
        "        :param theta_plus: On-spike increment of ``(adaptive)LIFNodes`` membrane\n",
        "            threshold potential.\n",
        "        :param tc_theta_decay: Time constant of ``(adaptive)LIFNodes`` threshold\n",
        "            potential decay.\n",
        "        :param inpt_shape: The dimensionality of the input layer.\n",
        "        \"\"\"\n",
        "        manual_seed(SEED)\n",
        "        super().__init__(dt=dt, reward_fn = None, online=online)\n",
        "        kwargs['single_output_layer'] = single_output_layer\n",
        "        kwargs['dt'] = dt\n",
        "        kwargs['n_labels'] = n_classes\n",
        "        kwargs['neuron_per_class'] = neuron_per_class\n",
        "        \n",
        "\n",
        "        self.reward_fn = reward_fn(**kwargs)\n",
        "        self.reward_fn.network = self\n",
        "        self.reward_fn.dt = self.dt\n",
        "        self.n_classes = n_classes\n",
        "        self.neuron_per_class = neuron_per_class\n",
        "        self.save_path = save_path\n",
        "        self.load_path = load_path\n",
        "        self.dt = dt\n",
        "        self.time = time\n",
        "        self.crop_size = crop_size\n",
        "        self.clamp = kwargs['clamp']\n",
        "        self.single_output_layer = single_output_layer\n",
        "        self.pre_observation = pre_observation\n",
        "        self.has_decision_period = has_decision_period\n",
        "        self.local_rewarding = local_rewarding\n",
        "        self.soft_bound = soft_bound\n",
        "        self.confusion_matrix = confusion_matrix\n",
        "        self.in_channels = in_channels\n",
        "        self.wandb_active = wandb_active\n",
        "\n",
        "        if kwargs['variant'] == 'scalar':\n",
        "            assert self.has_decision_period == True, ''\n",
        "\n",
        "        if self.online == False:\n",
        "            assert self.has_decision_period == True, ''\n",
        "        \n",
        "        if self.has_decision_period == True:\n",
        "            assert self.online == False, \"Decision period is not compatible with online learning.\"\n",
        "            self.observation_period = kwargs['observation_period']\n",
        "            assert self.observation_period >= 0, \"\"\n",
        "            self.decision_period = kwargs['decision_period']\n",
        "            assert self.decision_period > 0, \"\"\n",
        "            self.learning_period = self.time - self.observation_period - self.decision_period\n",
        "\n",
        "        elif self.pre_observation == True:\n",
        "            self.observation_period = kwargs['observation_period']\n",
        "            assert self.observation_period >= 0, \"\"\n",
        "            self.learning_period = self.time - self.observation_period\n",
        "            self.decision_period = self.time - self.observation_period\n",
        "\n",
        "        else:\n",
        "            self.observation_period = 0\n",
        "            self.decision_period = self.time\n",
        "            self.learning_period = self.time\n",
        "\n",
        "        ### nodes\n",
        "        inp = Input(shape= [self.in_channels,crop_size,crop_size], traces=True, tc_trace=tc_trace,traces_additive = trace_additive)\n",
        "        in_channels = inp.shape[0]\n",
        "        self.add_layer(inp, name=\"input\")\n",
        "\n",
        "        ## First hidden layer\n",
        "        main1 = NodesType_LC(shape= [n_channels1, compute_size(crop_size, filter_size1, stride1), \n",
        "                                        compute_size(crop_size, filter_size1, stride1)], \n",
        "                                        traces=True, tc_trace=tc_trace,traces_additive = trace_additive,\n",
        "                                        tc_theta_decay = tc_theta_decay, theta_plus = theta_plus)\n",
        "        \n",
        "        self.add_layer(main1, name=\"main1\")\n",
        "\n",
        "        ### connections \n",
        "        if mu == None:\n",
        "            mu = (wmin + wmax) / 2\n",
        "        if std == None:\n",
        "            std = (wmax - wmin) / 8\n",
        "\n",
        "        LC1 = LocalConnection(inp, main1, filter_size1, stride1, in_channels, n_channels1, nu = _pair(nu_LC), update_rule = update_rule_LC,wmin = wmin, wmax= wmax, soft_bound = soft_bound, norm = norm_factor_LC)\n",
        "        \n",
        "        # if normal_init:\n",
        "        #     w_lc_init = torch.normal(mu,std, size = (in_channels, n_channels1 * compute_size(crop_size, filter_size1, stride1)**2, filter_size1**2))\n",
        "        #     LC1.w.data = w_lc_init\n",
        "        \n",
        "        if LC_weights_path:\n",
        "            a = torch.load(LC_weights_path)\n",
        "            LC1.w.data = a['state_dict']['input_to_main1.w']\n",
        "            print(\"Weights loaded ...\")\n",
        "\n",
        "        self.add_connection(LC1, \"input\", \"main1\")\n",
        "\n",
        "        if inh_LC:\n",
        "            main_width = compute_size(crop_size, filter_size1, stride1)\n",
        "            w_inh_LC = torch.zeros(n_channels1,main_width,main_width,n_channels1,main_width,main_width)\n",
        "            for c in range(n_channels1):\n",
        "                for w1 in range(main_width):\n",
        "                    for w2 in range(main_width):\n",
        "                        w_inh_LC[c,w1,w2,:,w1,w2] = - inh_factor_LC\n",
        "                        w_inh_LC[c,w1,w2,c,w1,w2] = 0\n",
        "        \n",
        "            w_inh_LC = w_inh_LC.reshape(main1.n,main1.n)\n",
        "                                                             \n",
        "            LC_recurrent_inhibition = Connection(\n",
        "                source=main1,\n",
        "                target=main1,\n",
        "                w=w_inh_LC,\n",
        "            )\n",
        "            self.add_connection(LC_recurrent_inhibition, \"main1\", \"main1\")\n",
        "        \n",
        "        conv_size1 = compute_size(crop_size, filter_size1, stride1)\n",
        "        self.final_connection_source_name = 'main1'\n",
        "        self.final_connection_source = main1\n",
        "        hidden2 = main1\n",
        "        hidden2_name = 'main1'\n",
        "        if maxPool1:\n",
        "            maxPool_kernel = 2\n",
        "            maxPool_stride = 2\n",
        "            conv_size1 =compute_size(conv_size1, maxPool_kernel, maxPool_stride)\n",
        "            self.final_connection_source_name = 'maxPool1'\n",
        "            maxPool1 = LIFNodes(shape= [self.in_channels, conv_size1, conv_size1], refrac = 0)\n",
        "            self.final_connection_source = maxPool1\n",
        "            maxPoolConnection = MaxPool2dLocalConnection(main1, maxPool1, maxPool_kernel, maxPool_stride)\n",
        "\n",
        "            self.add_layer(maxPool1, name=\"maxPool1\")\n",
        "            self.add_connection(maxPoolConnection, \"main1\", 'maxPool1')\n",
        "            \n",
        "            hidden2 = maxPool1\n",
        "            hidden2_name = 'maxPool1'\n",
        "        \n",
        "        # # Second hidden layer\n",
        "        conv_size2 = compute_size(conv_size1, filter_size2, stride2)\n",
        "\n",
        "        main2 = NodesType_LC(shape= [n_channels2, conv_size2, conv_size2],\n",
        "                                        traces=True, tc_trace=tc_trace,traces_additive = trace_additive,\n",
        "                                        tc_theta_decay = tc_theta_decay, theta_plus = theta_plus)\n",
        "        \n",
        "        self.add_layer(main2, name=\"main2\")\n",
        "\n",
        "        ### connections \n",
        "        if mu == None:\n",
        "            mu = (wmin + wmax) / 2\n",
        "        if std == None:\n",
        "            std = (wmax - wmin) / 8\n",
        "\n",
        "        lc2_input_shape = (conv_size1,conv_size1)\n",
        "        LC2 = LocalConnection(hidden2, main2, filter_size2, stride2, n_channels1, n_channels2, input_shape= lc2_input_shape,\n",
        "         nu = _pair(nu_LC2), update_rule = update_rule_LC2, wmin = wmin, wmax= wmax, soft_bound = soft_bound, norm = norm_factor_LC2)\n",
        "        \n",
        "        # if normal_init:\n",
        "        #     w_lc_init = torch.normal(mu,std,size = (in_channels, n_channels * compute_size(crop_size, filter_size, stride)**2, filter_size**2))\n",
        "        #     LC2.w.data = w_lc_init\n",
        "\n",
        "        self.add_connection(LC2, \"hidden2\", \"main2\")\n",
        "\n",
        "        if LC2_weights_path:\n",
        "            a = torch.load(LC2_weights_path)\n",
        "            LC2.w.data = a['state_dict']['main1_to_main2.w']\n",
        "            print(\"Weights loaded ...\")\n",
        "\n",
        "        self.final_connection_source_name = 'main2'\n",
        "        self.final_connection_source = main2\n",
        "\n",
        "\n",
        "       \n",
        "\n",
        "        if inh_LC2:\n",
        "            main_width = conv_size2\n",
        "            w_inh_LC2 = torch.zeros(n_channels2,main_width,main_width,n_channels2,main_width,main_width)\n",
        "            for c in range(n_channels2):\n",
        "                for w1 in range(main_width):\n",
        "                    for w2 in range(main_width):\n",
        "                        w_inh_LC2[c,w1,w2,:,w1,w2] = - inh_factor_LC2\n",
        "                        w_inh_LC2[c,w1,w2,c,w1,w2] = 0\n",
        "        \n",
        "            w_inh_LC2 = w_inh_LC2.reshape(main2.n,main2.n)\n",
        "                                                             \n",
        "            LC_recurrent_inhibition2 = Connection(\n",
        "                source=main2,\n",
        "                target=main2,\n",
        "                w=w_inh_LC2,\n",
        "            )\n",
        "            self.add_connection(LC_recurrent_inhibition2, \"main2\", \"main2\")\n",
        "\n",
        "\n",
        "        if maxPool2:\n",
        "            maxPool_kernel = 2\n",
        "            maxPool_stride = 2\n",
        "            conv_size_pool =compute_size(conv_size2, maxPool_kernel, maxPool_stride)\n",
        "            self.final_connection_source_name = 'maxPool2'\n",
        "            maxPool2 = LIFNodes(shape= [self.in_channels2, conv_size_pool, conv_size_pool], refrac = 0)\n",
        "            self.final_connection_source = maxPool2\n",
        "            maxPoolConnection2 = MaxPool2dLocalConnection(main2, maxPool2, maxPool_kernel, maxPool_stride)\n",
        "\n",
        "            self.add_layer(maxPool2, name=\"maxPool2\")\n",
        "            self.add_connection(maxPoolConnection2, \"main2\", 'maxPool2')\n",
        "\n",
        "\n",
        "        ### main2 to output\n",
        "        out = NodesType_Output(n= n_neurons, traces=True,traces_additive = trace_additive, tc_trace=tc_trace, tc_theta_decay = tc_theta_decay, theta_plus = theta_plus)\n",
        "        self.add_layer(out, \"output\")\n",
        "        last_main_out = Connection(self.final_connection_source, out, nu = nu_Output, update_rule = update_rule_Output, wmin = wmin, wmax= wmax, norm = norm_factor_out)\n",
        "        if normal_init:\n",
        "            w_last_main_init = torch.normal(mu,std,size = (self.final_connection_source.n,out.n)) \n",
        "            last_main_out.w.data = w_last_main_init\n",
        "            \n",
        "        self.add_connection(last_main_out, self.final_connection_source_name, \"output\")\n",
        "        ### Inhibitory:\n",
        "\n",
        "        if inh_type == 'between_layers':\n",
        "            w = -inh_factor * torch.ones(out.n, out.n)\n",
        "            for c in range(n_classes):\n",
        "                ind = slice(c*neuron_per_class,(c+1)*neuron_per_class)\n",
        "                w[ind, ind] = 0\n",
        "\n",
        "            out_recurrent_inhibition = Connection(\n",
        "                source=out,\n",
        "                target=out,\n",
        "                w=w,\n",
        "                update_rule = update_rule_inh,\n",
        "                wmin=-inh_factor,\n",
        "                wmax=0,\n",
        "                nu = nu_inh,\n",
        "                norm = norm_factor_inh,\n",
        "            )\n",
        "            self.add_connection(out_recurrent_inhibition, \"output\", \"output\")\n",
        "\n",
        "        # Diehl and Cook\n",
        "        elif inh_type == 'DC':\n",
        "            raise NotImplementedError('Diehl and cook not implemented yet fo r 10 classes')\n",
        "\n",
        "        # Directs network to GPU\n",
        "        if gpu:\n",
        "            self.to(\"cuda\")\n",
        "\n",
        "\n",
        "    def fit(\n",
        "        self,\n",
        "        dataloader,\n",
        "        val_loader,\n",
        "        reward_hparams,\n",
        "        hparams = None,\n",
        "        online_validate = True,\n",
        "        n_train = 2000,\n",
        "        n_test = 250,\n",
        "        n_val = 250,\n",
        "        val_interval = 250,\n",
        "        running_window_length = 250,\n",
        "        verbose = True,\n",
        "    ):\n",
        "        manual_seed(SEED)\n",
        "        self.verbose = verbose\n",
        "        if self.wandb_active:\n",
        "            wandb.watch(self)\n",
        "        # add Monitors\n",
        "        #main_monitor = Monitor(self.layers[\"main\"], [\"v\"], time=None, device=device)\n",
        "        reward_monitor = RewardMonitor(time =self.time)\n",
        "        #Plot_et = PlotET(i = 0, j = 0, source = self.layers[\"main\"], target = self.layers[\"output\"], connection = self.connections[(\"main\",\"output\")])\n",
        "        #tensorboard = TensorBoardMonitor(self, time = self.time)\n",
        "        #self.add_monitor(main_monitor, name=\"main\")\n",
        "        self.add_monitor(reward_monitor, name=\"reward\")\n",
        "        #self.add_monitor(Plot_et, name=\"Plot_et\")\n",
        "        #self.add_monitor(tensorboard, name=\"tensorboard\")\n",
        "\n",
        "            \n",
        "        acc_hist = collections.deque([], running_window_length)\n",
        "\n",
        "        #if self.single_output_layer:\n",
        "        self.spikes = {}\n",
        "        for layer in set(self.layers):\n",
        "            self.spikes[layer] = Monitor(self.layers[layer], state_vars=[\"s\"], time=None)\n",
        "            self.add_monitor(self.spikes[layer], name=\"%s_spikes\" % layer)\n",
        "            self.dopaminergic_layers = self.layers[\"output\"]\n",
        "        # else:\n",
        "        #     output_layers = set([layer for layer in self.layers if layer.startswith('output')])\n",
        "        #     self.output_spikes = {}\n",
        "        #     for layer in output_layers:\n",
        "        #         self.output_spikes[layer] = Monitor(self.layers[layer], state_vars=[\"s\"], time=self.time)\n",
        "        #         self.add_monitor(self.output_spikes[layer], name=\"%s_spikes\" % layer)\n",
        "        #         self.dopaminergic_layers = {name: layer for name, layer in self.layers.items() if name.startswith('output')}\n",
        "\n",
        "        val_acc = 0.0\n",
        "        acc = 0.0\n",
        "\n",
        "        reward_history = []\n",
        "        if self.load_path:\n",
        "            # try:\n",
        "            self.model_params = torch.load(self.load_path)\n",
        "            self.load_state_dict(torch.load(self.load_path)['state_dict'])\n",
        "            iteration =  self.model_params['iteration']\n",
        "            hparams = self.model_params['hparams']\n",
        "            train_accs = self.model_params['train_accs']\n",
        "            val_accs = self.model_params['val_accs']\n",
        "            acc_rewards = self.model_params['acc_rewards']\n",
        "            print(f'Previous model loaded! Resuming training from iteration {iteration}..., last running training accuracy: {train_accs[-1]}, last validation accuracy: {val_accs[-1]}\\n') if self.verbose else None\n",
        "        else:\n",
        "            print(f'Previous model not found! Training from the beginning...\\n') if self.verbose else None\n",
        "            val_accs = []\n",
        "            train_accs = []\n",
        "            acc_rewards = []\n",
        "            # except:\n",
        "            #     pass\n",
        "        pbar = tqdm(total=n_train)\n",
        "        self.reset_state_variables()\n",
        "\n",
        "\n",
        "\n",
        "        for (i, datum) in enumerate(dataloader):\n",
        "            if self.load_path:\n",
        "                #try:\n",
        "                if i <= iteration:\n",
        "                    n_train += 1\n",
        "                    continue\n",
        "                # except:\n",
        "                #     pass\n",
        "            if i > n_train:\n",
        "                break\n",
        "\n",
        "\n",
        "            image = datum[\"encoded_image\"]\n",
        "            label = datum[\"label\"]\n",
        "\n",
        "            # Run the network on the input.\n",
        "            if gpu:\n",
        "                inputs = {\"input\": image.cuda().view(self.time, 1, self.in_channels, self.crop_size, self.crop_size)}\n",
        "            else:\n",
        "                inputs = {\"input\": image.view(self.time, 1, self.in_channels, self.crop_size, self.crop_size)}\n",
        "            #print(self.spikes['output'].get('s'))\n",
        "\n",
        "            self.run(inputs=inputs, \n",
        "                    time=self.time, \n",
        "                    **reward_hparams,\n",
        "                    one_step=True,\n",
        "                    true_label = label.int().item(),\n",
        "                    dopaminergic_layers= self.dopaminergic_layers,\n",
        "                    clamp = self.clamp\n",
        "                     )\n",
        "\n",
        "\n",
        "            # Get voltage recording.\n",
        "            #main_voltage = main_monitor.get(\"v\")\n",
        "            reward_history.append(reward_monitor.get())\n",
        "            #tensorboard.update(step= i)\n",
        "            # Add to spikes recording.\n",
        "            #if self.single_output_layer:\n",
        "            #print(self.monitors['output_spikes'].get('s').shape)\n",
        "            lc_spikes1 = self.spikes['main1'].get('s')\n",
        "            lc_spikes2 = self.spikes['main2'].get('s')\n",
        "            out_spikes = self.spikes[\"output\"].get(\"s\").view(self.time, n_classes, neuron_per_class)\n",
        "            sum_spikes = out_spikes[self.observation_period:self.observation_period+self.decision_period,:,:].sum(0).sum(1)\n",
        "            predicted_label = torch.argmax(sum_spikes)\n",
        "            # else:\n",
        "            #     spikes_record = torch.zeros(self.n_classes, self.time, self.neuron_per_class)\n",
        "            #     for c in range(self.n_classes):\n",
        "            #         spikes_record[c] = self.output_spikes[f\"output_{c}\"].get(\"s\").squeeze(1)\n",
        "            #     sum_spikes = spikes_record.sum(1).sum(1)\n",
        "            #     predicted_label = torch.argmax(sum_spikes)    \n",
        "\n",
        "            if predicted_label == label:\n",
        "                # if reward_hparams['two_pass']:\n",
        "                #     reward_hparams['dopamine_for_correct_pred'] = 0.1\n",
        "                #     print(' => Second pass with dopamine_for_correct_pred:', reward_hparams['dopamine_for_correct_pred'], end = '')\n",
        "                #     self.run(inputs=inputs, time=self.time, **reward_hparams, labels =  label.int().item(),dopaminergic_layers= dopaminergic_layers)\n",
        "                acc_hist.append(1)\n",
        "            else:\n",
        "                # if reward_hparams['two_pass']:\n",
        "                #     reward_hparams['dopamine_for_correct_pred'] = 0.0\n",
        "                #     print(' => Second pass with dopamine_for_correct_pred:', reward_hparams['dopamine_for_correct_pred'], end = '')\n",
        "                #     self.run(inputs=inputs, time=self.time, **reward_hparams, labels =  label.int().item(),dopaminergic_layers= dopaminergic_layers, train=True)\n",
        "                acc_hist.append(0)\n",
        "\n",
        "            #reward_hparams['dopamine_for_correct_pred'] = 0.0\n",
        "            #w_lc1 = self.connections[('input', 'main1')].w\n",
        "            w_last_main_out = self.connections[(self.final_connection_source_name,'output')].w\n",
        "            #w_lc2 = self.connections[('main1', 'main2')].w\n",
        "            #w_inh = self.connections[('output','output')].w\n",
        "\n",
        "            print(\"\\routput\", sum_spikes, 'pred_label:',\n",
        "                predicted_label.item(), 'GT:', label.item(),\n",
        "                ', Acc Rew:', round(sum(reward_monitor.get()).item(),4),\n",
        "                f\"Pos dps: {self.reward_fn.dps:.5f}, Neg dps: {self.reward_fn.neg_dps:.5f}, Rew base: {self.reward_fn.rew_base:.5f}, Pun base: {self.reward_fn.punish_base:.5f}, RPe: {self.reward_fn.reward_predict_episode:.3f}\",\n",
        "                f\"input_mean_fire_freq: {torch.mean(image.float())*1000:.1f},main_mean_fire_freq:{torch.mean(lc_spikes1.float())*1000:.1f}, main2_mean_fire_freq:{torch.mean(lc_spikes2.float())*1000:.1f}\",\n",
        "                f\"output_mean_fire_freq:{torch.mean(out_spikes.float())*1000:.1f}\",\n",
        "                f\"mean_fc_w:{torch.mean(w_last_main_out):.5f}\",\n",
        "                f\"std_fc_w:{torch.std(w_last_main_out):.5f}\",\n",
        "                f\"convergence: {torch.mean(w_last_main_out*(1-w_last_main_out)):.5f}\",\n",
        "                end = '')\n",
        "\n",
        "            # print(f'\\rmean_lc_w: {torch.mean(w_lc1):.5f},std_lc_w: {torch.std(w_lc1):.5f},convergence: {torch.mean(w_lc1*(1-w_lc1)):.5f}',end = '')\n",
        "\n",
        "            if self.wandb_active:\n",
        "                wandb.log({\n",
        "                        **{' to '.join(name) + ' convergence': convergence(c).item() for name, c in self.connections.items() if name[0]!=name[1]},\n",
        "                        **{' to '.join(name) + ' std': c.w.std().item() for name, c in self.connections.items() if name[0]!=name[1]},\n",
        "                        **{name + ' spikes': monitor.get('s').sum().item() for name, monitor in self.spikes.items()},\n",
        "                        **{' to '.join(name) + \" gradients\": wandb.Histogram(c.w.cpu()) for name, c in self.connections.items() if name[0]!=name[1]},\n",
        "                    },\n",
        "                    step = self.epochs_trained)\n",
        "                      \n",
        "            acc = 100 * sum(acc_hist)/len(acc_hist)\n",
        "            self.reward_fn.update(accumulated_reward= sum(reward_monitor.get()), ema_window = reward_hparams['ema_window']) \n",
        "\n",
        "            if online_validate and i % val_interval == 0 and i!=0:\n",
        "                self.reset_state_variables()\n",
        "                val_acc = self.evaluate(val_loader, n_val, val_interval, running_window_length)\n",
        "                #tensorboard.writer.add_scalars(\"accuracy\", {\"train\": acc, \"val\" : val_acc}, i)\n",
        "                train_accs.append(acc)\n",
        "                val_accs.append(val_acc)\n",
        "                acc_rewards.append(sum(reward_monitor.get()))\n",
        "                if self.save_path is not None:\n",
        "                    model_params = {'state_dict': self.state_dict(), 'hparams': hparams, 'iteration': i, 'val_accs': val_accs, 'train_accs': train_accs, 'acc_rewards': acc_rewards}\n",
        "                    torch.save(model_params, self.save_path)\n",
        "            # else:\n",
        "            #     pass\n",
        "                #tensorboard.writer.add_scalars(\"accuracy\", {\"train\": acc}, i)\n",
        "            #tensorboard.writer.add_scalar(\"reward\", sum(reward_monitor.get()), i)\n",
        "\n",
        "            # if  i % val_interval == 0 and i!=0:\n",
        "            #     fig = create_plot(self.output_spikes, reward_monitor.get(), label)\n",
        "            #     tensorboard.writer.add_figure('reward', fig, i)\n",
        "            \n",
        "            #Plot_et.plot()    \n",
        "            self.reset_state_variables()  # Reset state variables.\n",
        "            \n",
        "            pbar.set_description_str(\"Running accuracy: \" + \"{:.2f}\".format(acc) + \"%, \" + \"Current val accuracy: \" + \"{:.2f}\".format(val_acc) + \"%, \")\n",
        "            pbar.update()\n",
        "\n",
        "        result_metrics = {'train_acc': acc, 'val_acc': val_acc}\n",
        "        # tensorboard.writer.add_hparams(\n",
        "        #     {k:(v if type(v) in (int, float, bool, str, torch.Tensor) else str(v)) for k,v in {**train_hparams, **data_hparams, **network_hparams, **reward_hparams}.items() },\n",
        "        #     result_metrics\n",
        "        # )\n",
        "\n",
        "\n",
        "\n",
        "    def evaluate(self, val_loader, n_val, val_interval, running_window_length):\n",
        "        manual_seed(SEED)\n",
        "        acc_hist_val = collections.deque([], running_window_length)\n",
        "\n",
        "        spikes_val = {}\n",
        "\n",
        "        self.train(False)\n",
        "        self.learning = False\n",
        "\n",
        "        GT, y_pred = [], []\n",
        "        for (i, datum) in enumerate(val_loader):\n",
        "            if i > n_val:\n",
        "                break\n",
        "\n",
        "            image = datum[\"encoded_image\"]\n",
        "            label = datum[\"label\"]\n",
        "\n",
        "            # Run the network on the input.\n",
        "            if gpu:\n",
        "                inputs = {\"input\": image.cuda().view(self.time, 1, self.in_channels, self.crop_size, self.crop_size)}\n",
        "            else:\n",
        "                inputs = {\"input\": image.view(self.time, 1, self.in_channels, self.crop_size, self.crop_size)}\n",
        "\n",
        "            self.run(inputs=inputs, \n",
        "                    time=self.time, \n",
        "                    **reward_hparams,\n",
        "                    one_step = True,\n",
        "                    true_label = label.int().item(),\n",
        "                    dopaminergic_layers= self.dopaminergic_layers,\n",
        "                     )\n",
        "            # # Add to spikes recording.\n",
        "            # #if self.single_output_layer:\n",
        "            out_spikes = self.spikes[\"output\"].get(\"s\").view(self.time, n_classes, neuron_per_class)\n",
        "            sum_spikes = out_spikes[self.observation_period:self.observation_period+self.decision_period,:,:].sum(0).sum(1)\n",
        "            predicted_label = torch.argmax(sum_spikes)\n",
        "            # # else:\n",
        "            # #     spikes_record = torch.zeros(self.n_classes, self.time, self.neuron_per_class)\n",
        "            # #     for c in range(self.n_classes):\n",
        "            # #         spikes_record[c] = self.output_spikes[f\"output_{c}\"].get(\"s\").squeeze(1)\n",
        "            # #     sum_spikes = spikes_record.sum(1).sum(1)\n",
        "            # #     predicted_label = torch.argmax(sum_spikes)\n",
        "\n",
        "            if predicted_label == label:\n",
        "                acc_hist_val.append(1)\n",
        "            else:\n",
        "                acc_hist_val.append(0)\n",
        "            \n",
        "            GT.append(label)\n",
        "            y_pred.append(predicted_label)\n",
        "            \n",
        "            print(\"\\r*validation: output\",sum_spikes,\n",
        "                'predicted_label:', predicted_label.item(), 'GT:', label.item(),\n",
        "                end = '') if self.verbose else None\n",
        "            \n",
        "            self.reset_state_variables()  # Reset state variables.\n",
        "\n",
        "        if self.confusion_matrix:\n",
        "            self.plot_confusion_matrix(GT, y_pred)\n",
        "        self.train(True)\n",
        "        self.learning = True\n",
        "        #plot_locally_connected_weights_meh(net1.connections[('main1', 'main2')].w,64,16,0,12,5,4)\n",
        "        plt.show()\n",
        "        val_acc = 100 * sum(acc_hist_val)/len(acc_hist_val)\n",
        "        return val_acc\n",
        "\n",
        "    @staticmethod\n",
        "    def plot_confusion_matrix(GT, y_predicted):\n",
        "        cm = confusion_matrix(GT, y_predicted)\n",
        "        plt.figure(figsize = (10,7))\n",
        "        sn.heatmap(cm, annot=True)\n",
        "        plt.xlabel('Predicted')\n",
        "        plt.ylabel('Truth')\n",
        "        plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6zuUBU9pU3vE"
      },
      "source": [
        "# Load Dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "2DW7dB11jdqi"
      },
      "outputs": [],
      "source": [
        "class ClassSelector(torch.utils.data.sampler.Sampler):\n",
        "    \"\"\"Select target classes from the dataset\"\"\"\n",
        "    def __init__(self, target_classes, data_source, mask = None):\n",
        "        if mask is not None:\n",
        "            self.mask = mask\n",
        "        else:\n",
        "            self.mask = torch.tensor([1 if data_source[i]['label'] in target_classes else 0 for i in range(len(data_source))])\n",
        "        self.data_source = data_source\n",
        "\n",
        "    def __iter__(self):\n",
        "        return iter([i.item() for i in torch.nonzero(self.mask)])\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.data_source)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "DlCXBY0DU3Mc"
      },
      "outputs": [],
      "source": [
        "kernels = [DoGKernel(7,1,2),]\n",
        "\t\t\t# DoGKernel(7,2,1),]\n",
        "filter = Filter(kernels, padding = 3, thresholds = 50/255)\n",
        "\n",
        "# Load MNIST data.\n",
        "def load_datasets(network_hparams, data_hparams, mask=None, test_mask=None):\n",
        "    manual_seed(SEED)\n",
        "    dataset = MNIST(\n",
        "        PoissonEncoder(time=network_hparams['time'], dt=network_hparams['dt']),\n",
        "        None,\n",
        "        root=os.path.join(\"..\", \"..\", \"data\", \"MNIST\"),\n",
        "        download=True,\n",
        "        transform=transforms.Compose(\n",
        "            [transforms.ToTensor(),\n",
        "             #filter,\n",
        "            transforms.Lambda(lambda x: (\n",
        "                x.round() if data_hparams['round_input'] else x\n",
        "            ) * data_hparams['intensity']),\n",
        "            transforms.CenterCrop(data_hparams['crop_size'])]\n",
        "        ),\n",
        "    )\n",
        "\n",
        "    # Create a dataloader to iterate and batch data\n",
        "    dataloader = torch.utils.data.DataLoader(dataset, batch_size=1,\n",
        "                                            sampler = ClassSelector(\n",
        "                                                    target_classes = target_classes,\n",
        "                                                    data_source = dataset,\n",
        "                                                    mask = mask,\n",
        "                                                    ) if target_classes else None\n",
        "                                            )\n",
        "\n",
        "    # Load test dataset\n",
        "    test_dataset = MNIST(   \n",
        "        PoissonEncoder(time=network_hparams['time'], dt=network_hparams['dt']),\n",
        "        None,\n",
        "        root=os.path.join(\"..\", \"..\", \"data\", \"MNIST\"),\n",
        "        download=True,\n",
        "        train=False,\n",
        "        transform=transforms.Compose(\n",
        "            [transforms.ToTensor(),\n",
        "             #filter,\n",
        "            transforms.Lambda(lambda x: (\n",
        "                x.round() if data_hparams['round_input'] else x\n",
        "            ) * data_hparams['intensity']),\n",
        "            transforms.CenterCrop(data_hparams['crop_size'])]\n",
        "        ),\n",
        "    )\n",
        "\n",
        "    val_loader = torch.utils.data.DataLoader(test_dataset, batch_size=1,\n",
        "                                            sampler = ClassSelector(\n",
        "                                                    target_classes = target_classes,\n",
        "                                                    data_source = test_dataset,\n",
        "                                                    mask = mask_test,\n",
        "                                                    ) if target_classes else None\n",
        "                                            )\n",
        "    \n",
        "\n",
        "    return dataloader, val_loader"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kCqAFucAUDb8"
      },
      "source": [
        "# Set up hyper-parameters"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "I0Wh_eJIFkO-"
      },
      "outputs": [],
      "source": [
        "train_hparams = {\n",
        "    'n_train' : 2000,\n",
        "    'n_test' :3000,\n",
        "    'n_val' : 1,\n",
        "    'val_interval' : 200,\n",
        "    'running_window_length': 250,\n",
        "}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "MVOqxcYtFd5T"
      },
      "outputs": [],
      "source": [
        "# Dataset Hyperparameters\n",
        "target_classes = None #(0,1)\n",
        "if target_classes:\n",
        "    npz_file = np.load(f'bindsnet/mask_{\"_\".join([str(i) for i in target_classes])}.npz')\n",
        "    # npz_file = np.load('bindsnet/mask_0_1.npz') ##### KESAFAT KARI !!!\n",
        "    mask, mask_test = torch.from_numpy(npz_file['arr_0']), torch.from_numpy(npz_file['arr_1'])\n",
        "    n_classes = len(target_classes)\n",
        "    \n",
        "else:\n",
        "    mask = None\n",
        "    mask_test = None\n",
        "    n_classes = 10\n",
        "\n",
        "data_hparams = { \n",
        "    'intensity': 128,\n",
        "    'crop_size': 28,\n",
        "    'round_input': False,\n",
        "}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "3TerGeJoFdzg"
      },
      "outputs": [],
      "source": [
        "n_neurons = 500 #100\n",
        "clamping_intensity = None #20\n",
        "neuron_per_class = int(n_neurons/n_classes)\n",
        "single_output_layer = True\n",
        "\n",
        "network_hparams = {\n",
        "    # net structure\n",
        "    'crop_size': 28,\n",
        "    'neuron_per_class': neuron_per_class,\n",
        "    'in_channels':1,\n",
        "    'n_channels1': 16,\n",
        "    'n_channels2': 64,\n",
        "    'filter_size1': 5,\n",
        "    'filter_size2': 5,\n",
        "    'stride1': 2,\n",
        "    'stride2': 2,\n",
        "    'n_neurons' : n_neurons,\n",
        "    'n_classes': n_classes,\n",
        "    'single_output_layer': True,\n",
        "    'maxPool1': False,\n",
        "    'maxPool2': False,\n",
        "    \n",
        "    # time & Phase\n",
        "    'dt' : 1,\n",
        "    'pre_observation': False,\n",
        "    'has_decision_period': True,\n",
        "    'observation_period': 0,\n",
        "    'decision_period': 256,\n",
        "    'online': False,\n",
        "    'local_rewarding': False,\n",
        "    \n",
        "    # Nodes\n",
        "    'NodesType_LC': AdaptiveLIFNodes,\n",
        "    'NodesType_Output': LIFNodes, \n",
        "    # 'theta_plus': 0.05,\n",
        "    # 'tc_theta_decay': 1000000,\n",
        "    'tc_trace':20,\n",
        "    'trace_additive' : False,\n",
        "    \n",
        "    # Learning\n",
        "    'update_rule_LC': None,\n",
        "    'update_rule_LC2': None,\n",
        "    'update_rule_Output': MSTDPET,\n",
        "    'update_rule_inh': None,\n",
        "    'update_rule_inh_LC' : None,\n",
        "    'nu_LC': (0.0,0.0),\n",
        "    'nu_LC2': (0.0,0.0),\n",
        "    'nu_Output':0.1,\n",
        "    'nu_inh': 0.0,\n",
        "    'nu_inh_LC': 0.0,\n",
        "    'soft_bound': False,\n",
        "\n",
        "    # weights\n",
        "    'normal_init': True,\n",
        "    'mu' : 0.8,\n",
        "    'std' : 0.05,\n",
        "    'wmin': 0.0,\n",
        "    'wmax': 1.0,\n",
        "    \n",
        "    # Inhibition\n",
        "    'inh_type': True,#'between_layers',\n",
        "    'inh_factor': 100,\n",
        "    'inh_LC': True,\n",
        "    'inh_factor_LC': 100,\n",
        "    'inh_LC2': True,\n",
        "    'inh_factor_LC2': 100,\n",
        "    \n",
        "    # Normalization\n",
        "    'norm_factor_LC': None,\n",
        "    'norm_factor_LC2': None,\n",
        "    'norm_factor_out': 0.9,\n",
        "    'norm_factor_inh': None,\n",
        "    'norm_factor_inh_LC': None,\n",
        "    \n",
        "    # clamp\n",
        "    'clamping_intensity': clamping_intensity,\n",
        "\n",
        "    # Save\n",
        "    'save_path': None,\n",
        "    'load_path': None,#'/content/drive/My Drive/LCNet/LCNet_phase2_baseline2_gpu.pth',\n",
        "\n",
        "    # Plot:\n",
        "    'confusion_matrix' : False,\n",
        "\n",
        "}\n",
        "\n",
        "\n",
        "\n",
        "reward_hparams= {\n",
        "    'n_labels': n_classes,\n",
        "    'neuron_per_class': neuron_per_class,\n",
        "    \n",
        "    'variant': 'scalar',  #true_pred, #pure_per_spike (Just in phase I, online : True) , and #scalar \n",
        "    'tc_reward':0,\n",
        "    'dopamine_base': 0.0,\n",
        "    'reward_base': 1,\n",
        "    'punishment_base': 1,\n",
        "    \n",
        "\n",
        "    'sub_variant': 'static', #static, #RPE, #pred_decay\n",
        "    'td_nu': 0.0001,  #RPE\n",
        "    'ema_window': 10, #RPE\n",
        "    'tc_dps': 20,     #pred_decay\n",
        "    'dps_factor': 20, #pred_decay, #RPE\n",
        "    }\n",
        "\n",
        "### Spike clamping (baseline activity)\n",
        "main_n_neurons = network_hparams['n_channels1'] * compute_size(network_hparams['crop_size'], network_hparams['filter_size1'], network_hparams['stride1'])\\\n",
        "* compute_size(network_hparams['crop_size'], network_hparams['filter_size1'], network_hparams['stride1'])\n",
        "clamp = {}\n",
        "if clamping_intensity is not None:\n",
        "    encoder = PoissonEncoder(time=network_hparams['time'], dt=network_hparams['dt'])\n",
        "    clamp['output'] = encoder.enc(datum = torch.ones(n_neurons)*clamping_intensity, time=network_hparams['time'], dt=network_hparams['dt'])\n",
        "\n",
        "network_hparams['clamp'] = clamp"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "id": "3Rz1wmKKYuVg"
      },
      "outputs": [],
      "source": [
        "time = 512\n",
        "network_hparams.update(\n",
        "    {\n",
        "     'time': time,\n",
        "    }\n",
        ")\n",
        "dataloader, val_loader = load_datasets(network_hparams, data_hparams, mask, mask_test)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PQARyBxAToS7"
      },
      "source": [
        "# Training \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U_eR_KaATz8D"
      },
      "source": [
        "## Hyperparameters 1 "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "id": "J9ynC3-dTz8T"
      },
      "outputs": [],
      "source": [
        "network_hparams.update(\n",
        "    {\n",
        "    'save_path': '/content/drive/My Drive/LCNet/deepLCNet_test1.pth',\n",
        "    'LC_weights_path': '/content/drive/My Drive/LCNet/DeepLCNet_layer1_ch16_f5_s2_norm3.pth',\n",
        "    'LC2_weights_path': '/content/drive/My Drive/LCNet/DeepLCNet_layer2_ch64_f5_s2_norm3.pth',\n",
        "\n",
        "    }\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eZxh703vTz8T",
        "outputId": "38710557-f753-4b21-fbf5-0c0e46177765"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ]
        }
      ],
      "source": [
        "if network_hparams['save_path'] :\n",
        "    from google.colab import drive\n",
        "    drive.mount('/content/drive')\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 507,
          "referenced_widgets": [
            "2104745379e74e51a41a16b22e315734",
            "0df7107bce1b4d679178a74fe2f9dd93",
            "24bc1bfec3a8477faa42e85fe563f184",
            "ad8ef238bff24876a8739aec82d9e612",
            "5086821eb005406eafb39075bb040309",
            "9204786852bf413c84acfe172accfcea",
            "ec834afa74114d25abb93418442f7009",
            "b9eadc721c9f480695a59dee57546db4",
            "7d35cd9e2a6c4df1840100606d7a9761",
            "30605c0314904de2837b30da65693584",
            "cf3c48dafcf447ce88986553aee5a59a"
          ]
        },
        "id": "UpjEiu7qTz8U",
        "outputId": "5fc083cc-d680-4add-b103-8e37c640704b"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "Failed to detect the name of this notebook, you can set it manually with the WANDB_NOTEBOOK_NAME environment variable to enable code saving.\n",
            "wandb: Currently logged in as: mahbod (use `wandb login --relogin` to force relogin)\n"
          ]
        },
        {
          "data": {
            "text/html": [
              "\n",
              "                    Syncing run <strong><a href=\"https://wandb.ai/singularbrain/DeepBioLCNet/runs/3nef43xr\" target=\"_blank\">rare-glade-1</a></strong> to <a href=\"https://wandb.ai/singularbrain/DeepBioLCNet\" target=\"_blank\">Weights & Biases</a> (<a href=\"https://docs.wandb.com/integrations/jupyter.html\" target=\"_blank\">docs</a>).<br/>\n",
              "\n",
              "                "
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "ename": "TypeError",
          "evalue": "__init__() missing 1 required positional argument: 'input_shape'",
          "output_type": "error",
          "traceback": [
            "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[1;32m<ipython-input-18-81bd3cc5d463>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mWANDB\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m     \u001b[0mwandb\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0minit\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mproject\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'DeepBioLCNet'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mentity\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'singularbrain'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mconfig\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mnetwork_hparams\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mnet1\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mLCNet\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m**\u001b[0m\u001b[0mhparams\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mreward_fn\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mDynamicDopamineInjection\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mwandb\u001b[0m\u001b[1;33m=\u001b[0m \u001b[0mWANDB\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      6\u001b[0m \u001b[0mnet1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdataloader\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdataloader\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mval_loader\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mval_loader\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mreward_hparams\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mreward_hparams\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mtrain_hparams\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      7\u001b[0m \u001b[1;31m# plot_locally_connected_weights_meh(net1.connections[('main1', 'main2')].w,64,16,0,12,5,4)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
            "\u001b[1;32m<ipython-input-10-3684ad4ab354>\u001b[0m in \u001b[0;36m__init__\u001b[1;34m(self, n_classes, neuron_per_class, in_channels, n_channels1, n_channels2, filter_size1, filter_size2, stride1, stride2, maxPool1, maxPool2, online, time, reward_fn, n_neurons, pre_observation, has_decision_period, local_rewarding, nu_LC, nu_LC2, nu_Output, dt, crop_size, nu_inh_LC, nu_inh, inh_type, inh_LC, inh_LC2, inh_factor_LC, inh_factor_LC2, inh_factor, single_output_layer, NodesType_LC, NodesType_Output, update_rule_LC, update_rule_LC2, update_rule_Output, update_rule_inh, update_rule_inh_LC, wmin, wmax, soft_bound, theta_plus, tc_theta_decay, tc_trace, normal_init, mu, std, norm_factor_inh_LC, norm_factor_LC, norm_factor_LC2, norm_factor_out, norm_factor_inh, trace_additive, load_path, save_path, LC_weights_path, LC2_weights_path, confusion_matrix, wandb_active, **kwargs)\u001b[0m\n\u001b[0;32m    167\u001b[0m             \u001b[0mstd\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mwmax\u001b[0m \u001b[1;33m-\u001b[0m \u001b[0mwmin\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m/\u001b[0m \u001b[1;36m8\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    168\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 169\u001b[1;33m         \u001b[0mLC1\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mLocalConnection\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minp\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmain1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfilter_size1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mstride1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0min_channels\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mn_channels1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnu\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_pair\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnu_LC\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mupdate_rule\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mupdate_rule_LC\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mwmin\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mwmin\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mwmax\u001b[0m\u001b[1;33m=\u001b[0m \u001b[0mwmax\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msoft_bound\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msoft_bound\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnorm\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnorm_factor_LC\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    170\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    171\u001b[0m         \u001b[1;31m# if normal_init:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
            "\u001b[1;31mTypeError\u001b[0m: __init__() missing 1 required positional argument: 'input_shape'"
          ]
        }
      ],
      "source": [
        "manual_seed(SEED)\n",
        "hparams = {**reward_hparams, **network_hparams, **train_hparams, **data_hparams}\n",
        "if WANDB:\n",
        "    wandb.init(project='DeepBioLCNet', entity='singularbrain', config=network_hparams)\n",
        "net1 = LCNet(**hparams, reward_fn = DynamicDopamineInjection, wandb_active= WANDB)\n",
        "net1.fit(dataloader = dataloader, val_loader = val_loader, reward_hparams = reward_hparams, **train_hparams)\n",
        "# plot_locally_connected_weights_meh(net1.connections[('main1', 'main2')].w,64,16,0,12,5,4)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8Umbn4LOUjGO"
      },
      "source": [
        "## Hyperparameters 2 "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FhDMefdMUjGP"
      },
      "outputs": [],
      "source": [
        "network_hparams.update(\n",
        "    {\n",
        "    'n_channels1':4,#10,#30\n",
        "    'filter_size1':11,\n",
        "    'stride1':3,\n",
        "    'NodesType_LC': LIFNodes, #LIF\n",
        "    # 'theta_plus': 0.05,\n",
        "    # 'tc_theta_decay': 1000000,\n",
        "    'nu_LC': (0.0001,0.01),#(0.0001,0.01),(0.0003,0.0004)\n",
        "    'norm_factor_LC': 0.4*11*11,#0.4*11*11,None \n",
        "    'inh_LC': True,\n",
        "    'inh_factor_LC': 100, #0.5 \n",
        "    'save_path':'/content/drive/My Drive/LCNet/LCNet_phase2_baseline_gpu_2.pth',\n",
        "    }\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pZKhm9tIUjGP",
        "outputId": "6b2c9db1-abf7-4c73-d7d2-7b2f5d30c7ef"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ]
        }
      ],
      "source": [
        "if network_hparams['save_path'] :\n",
        "    from google.colab import drive\n",
        "    drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 451,
          "referenced_widgets": [
            "a1f684d6e38a407f80e47f8157a7a997",
            "af9455669a5145c7aa6ae44fd65744f8",
            "b4408dce6c3949bc80f1d708df832f47",
            "28b208e0b2304e68a2325990fca0038c",
            "6ad02c2ca8184f379c9463b56a0af4d4",
            "a88657936d7c4b00b746ab4d6104cdc3",
            "f660c4ad654644898f56f12378d627e9",
            "d2842b1ddd6445eba782b6af1dad2162",
            "34dcf71e9fc046fa81c10880b9b6c0c5",
            "8693cd3284334a96b53c5f1ed67c92a1",
            "27a75e8c579244eb9322f682a3522d2d"
          ]
        },
        "id": "hBnwiYrlUjGS",
        "outputId": "a44d0035-d666-4355-8ef7-d25e230f36d7"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Previous model not found! Training from the beginning...\n",
            "\n"
          ]
        },
        {
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "a1f684d6e38a407f80e47f8157a7a997",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "  0%|          | 0/2000 [00:00<?, ?it/s]"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "mean_lc_w: 0.40000,std_lc_w: 0.24464,convergence: 0.18016"
          ]
        },
        {
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7f27990a49d0>"
            ]
          },
          "execution_count": 25,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWAAAAFgCAYAAACFYaNMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOxde3wV1dVdQyAQHtGYEIMBDKBBRDRKQAQftGALCK2K4tumL6jUVj61/YpFa5Vq+1Vbalut2Frqo1YUWwWBVlC0CijBxgcqUTTyqMhDNEICgTDfHzOTWWfdzL0JBm/uzVm/X37Zc2ffuWfe56yz9t6O67qwsLCwsPj80S7ZDbCwsLBoq7APYAsLC4skwT6ALSwsLJIE+wC2sLCwSBLsA9jCwsIiSbAPYAsLC4skwT6ALSwsLJoAx3HudRxni+M4r0esdxzHucNxnHccx3nVcZyTEm3TPoAtLCwsmoY5AMbEWT8WwNH+32QAdyXaoH0AW1hYWDQBrus+B+CjOC5fBXCf62ElgEMdx+kRb5vtm9OAvLw8t6ioqAmeNWQ7sq4D2fvJ3iV+20Kzujq0t4jbUYOb0J7mwI2w94gf79deAMDa7RsAAP1ze9M6fsdlyDb2kb2bbNnJfTWRqwx0Y5vbpyOhvRFt2Cd+vM/1ZOtlw/vIv6tRlp0AAGu3VwFoh/65xY20BzDOPT6mJtSabtxc3oQeZm5uB74fOosjt5c3+InpVk/XI7dBuzMdsmkhJ87v8v7uBACs3b4HqN+P/l0i3PRy7Eh2FtldxK/LYbTQlWw9p4eSTef0jdWG1z46JXzE9FB07B7Rplz1LIpoUyfx854jVVVV2LZtW0MD2zvOAcf27gfWwLwRZ7uuO7sZmygEsIGWN/qffRD1hWY9gIuKilBeXt4ET/bRA1dA9k6yV4vfn0LzqUWh/Ttxe7wp7WkO+Pjz3VUlfnzoNgMARs6ZBsDBsrLf0rquETZg3lFryb5D3F5ufJU+aM4geyS/6PQYbY5owzbxW0c2PQiRJ36dImx9oPf3mjbn6wCysKzsX420BwDuJfvx0NzxqunGfRHeRDfTDXzz95hCCyXiyO3lDT5pulXT9bidPtdLvccIWphI9gniyPv7AgBg5Jx1QPUuLBtKq/5M9ruyib5kH0f2EPEb9mVa4AtGz+lZZNOOlZgdqi2vhPaH9Lm+YvpNooVSssv0nriF7MPJPkb8vOdIaWmp8akL8/3THOwCdruuW5rYs+XQrAewhYWFRWtHEnnVTQB60XJP/7NI2AdwC2LhJT+HPaSJsfCSOwH0S3YzWjUWXtIHeKnRyXaLOHAQOzD8HPEEgCsdx/kbgJMBfOK6biT9ALTo06KK7B+Srdwu+a0jQvNMcSPas4rGNjPF7Y9NbJ0JHmq+Jet4GM7Do93ixy827zudOwDAneJHQ9kdwt+/SPbDZH9RNsGs0hMRnwPAr8m+ti60Z4ifMbweFZr3S/s+JZspYB1q8/CXqcPB2hfxhpHecbo7/Hj9aaYbMS5GU2fJ5rgdVWTrsJvHw+NvDO0vix9vj8/Hs+LHLBpf3npcTiaqoiyKzmls2T9GF5qf3bsxtJXarSL7f/mwHyaOVzwU2qeRfeZQcWT6hHZYmvo22dymfspoLCd7Idl7q02/b19MC3wvbTf9Gtqn8wcHD47jPARgJIA8x3E2AvgJfDLadd0/wNuzcQDegfcE+3qibdruWgvizlXeJOnUIXrVWzDuXPURgL9j6pBzkt2UVos7V9UDA4Cpbya7JamHg0VBuK57UYL1LoDvNmebVobWgpi75mXMXVOd2LGNY+6aasxd83Sym9GqMXfNfsztm9jPwkRAQRzIXzLQgj3gS8hm7kqH7uHwf9dR4adXtVxDIsDtqCD7CfHjmVceR4kygZUFLsnp6gHsfCNcZkWesjE0AnTvo5bOMd2yuKNIzELM9hg0wseMd2QlDe0yQtph3X7Tqx+/y1lJ0Mv0M9SETBkslQ0e6x+XOgA7KoD7fephuelmUCs02799renGvQcWfLVbYvo5rApgOqHe9AMxBsZQW1UVx5LN9MZ/xI8UArinMrQPFT/exrjQfG8PMINoBx5sK2nBm5hJh/0KEbbkcpv42qx/yXQcw9QcURByLAaRbWhZCkw/o/GZZOttVU+N/85UWnGLOAb3qerxksoBNxu2B2xhYWGRJFgO2MLCIm3gILV6lfYBbGFhkVZIJQriMzyANcrpJrK/Epof1JluWxv/xoHjdrKJVMbJ4sdkGEmvflVjul0fmm/Rqn/L1liwFcScfQXA1R/C5NaqyGZ5FWBwwHRYIMwpsvgQFoVmhcyQ808NJ+4wH/9nOpbc02DOpx9TVZYReXWDriQwP8wBeKoc8ingZf1gSuY+FT+aQthEB7pQuja7qO0ZLDxREcpXI9qaKX4cMMhTBpeL36lkH09h58esN/3o/Br8soaJMafs88PLjgbuERETU+8L0DTkniof8MTeEWQfrd8c1vgGq8zFbJr6yc6lFYfI954nm6P4Oojf38k+g07wAI0IDkhmkwNOsg642bA9YAsLi7RCKlEQqdTWVo9nhgO3VST2a+u4bSNwm86SWxi47X3gX8OT3QqLgw37AG5BvFkMLHg/2a1o/VjwEbBAh6gWBhZsBV4tTuxnYaIN6YA1hJfvKMru1ONi0+3lkNdheWtTQ4pVQmmmCpwcmo9I3kbS/d/5h9BWvpXpVqYIVXLbpZF1+wGgwxFAPpGOWykns+pnfx6a+UyIa5xpIdkkAC05UfxIh5rPEubqewy3CtKCMves+5jJvOB5ZPf7gngSD7eFRL3Kxf7M/3+I/5WApxaumHlf48Y41vTrwtwuN0mPH4tmuU16Poj/N7hiDQ0/fjotUEa/YUtNvwrSg3No85GyPT7OgV7W9SKbi2gVU7Yc7A+YtCrnODNk7YC5LzxNkq+hyJypkGKszxM3vjZ5Cqa7+DH3/C+y9THC3Dtz8odK+rcewaNL092mVq/ScsAWFhZpg1SbhEull4WFhYVFWsH2gFsQHfYCWR1S6f2bHGQBsWHAFgay2gG7Pr9EX2mDVOsBf4YHsObe42Um5xaabmed22AOIcFsPA6YOa1jY9ZSSaKVxPuK9HUh8UnM+2rqHN4L5oP1ecHrAinjlAeBqx+QmPqBxIEPXGeuO7MstJkXVH0q/zhriSV7JC8+TbLnL15v+nHMPt/jOceZfvg+2f0eoIUR4kia8HxONiCVJKo8YfEiwMtMOdr//LHo9g1m4vNPph+GMqFL2m6DjATMK4hJUanGcAqRsXwXxwikeXssfhXt+YRLG8wdV4Qf13xouhWyDtrf9KLjgfWSIKU3V5WQ26830c0Gt32/6YcsPo88o6LEOZ9H2t8icetPNhetUO6Z9b68vzrxwFQv5/44Qvx6BCs110xqDettD9jCwiJtkGo94FR6WbR6PHU6cPOzv0p2M1o9bu4B3Ky9fAsDN78P/Ob0ZLciNdFGZGg6zIuqrvsL0+3akHagcosxqhW+PwsjbA80BKTiv6ukDqWWfWwKeHieHekV4p2+QO17L+L6M1gDxmNFEdFlfju0h5BUTBvLB4N1xlWmGy8aWQP/YvpxpPSUU2hBo7cNyRGXENICqlyZms/qP023/3r/lvYBsA+4Pkg7KVynIQ1krkc11icR6dJ+IK3QQo9Rl7kMX88lm4fMmWPle1VkMwUhZSCIcWLWQVNJFjYS1770Y2BvX+B/n4v4YjyZFzMzMVw773NTb3/6Yb1GONS5K0eOqNaOKI1ziS/RbLB8LbxGtkouGzSNKiRNLVgKwsLCIm1gs6FZWFhYJBGpxAHbB7CFhUXawPaAAZhklfCFVAmYqU7NzcJs6ReZWouZvCFPCmnVKFhuUTxul1UxRWRfcII4Msnq/+4zGQA65yIaWiqW+LjeFPjfW9z+RuVsOHZYuGJW7Ywnu+IT089gPpkjFFkbspn75JIwskEjbJXsOjMcfLEfKr3vaODwDmigiKtlcyfxAqfB1PSWnJOx242hPUqLffYkuyPZcj5Yk/gdJlV1voMrYvNJkB0hSRVXSepoemEYn1OfA87tCOAwIJ+lZyzfkjJOr70X2oM4LPtF0w+jeH6GrwRNL8s6MprHOEPcsjhhBacj0O0RL0+VhtZI+Si+N0t4RWwOgrSA7QG3IOYtB/DHucluRqvHjLnAGJuMJy7mnQTgmWS3IjVhKQgLCwuLJMDqgNswpg8Cpi/5cbKb0erx51HAdA2mszAwfS0wPT/ZrUhNtDvAv2TgM/SANQSwU+Pr7jWDfVc+36hXjKyRg5mZ933tv6bfIOaWJobmItMtljr2oZGQHPF4AaWLxBXimE13x06P61zxMICNK2DyX8yP6jH7auPr1j9iurGI9NbQ3C4SSKalWa75rOlm0MjbKXI6V9MzGlwn64C1j0EM+04iPr9kegUy3v/0Aj500LDLWvXdGUALHJqq0e9cjYaJ1U5/N/2OoOU+N9KKs6K3Z0B/mGcUOGTX5D3rqKQQf0Ojao0SRX549Yo3qoH9+0wtLJ84OQV8Zb1G1MUgzScxirXZdMPE6HYjeP0sTVLMszd8N20y3Z57NbRpskI10RwQXUl+xVq2qiH0fKXxqe0BW1hYWFg0CZYDtrCwSCukUg/YPoAtLCzSBm1YB/wO2aSNfCPGsdFVygNy2slM4n2lyD2AB0OTiOTR4sVcE0sjLxW//B/Qwv/OooU4Gt6uHsvaM+d5eJpTPqzMHyrjRSWU1pEI91bTawulYeS3u26NucVMEkJ3Fn0vq3uNquCqGf0a8XYnka1XOPFzdTQH+YC4BZLjQ6uBntloyF/gbBVHTvjBbVcekIXPrNNWKTYfqPdvDO2Ra0w/5ptvoYXDfmn68fb59P7ZdONC6syOKqNsVICv9Ha4Z/Al5nB1ooSwm+YJjJmGzuL4G+LDr+L0qJK/NVLTq/pe1kFTDtSdctHRtVW3FpFgWboxbxOz70YhMAO2B9xG8cC5p8Koh2fRKMoeA6YOSOzXlvHAcIT5ZizSFvYBbGFhkTZoQxSEfpUHPveFpqhbHkbj6CfLPIBhoUusnIxKrFJqvGM0rJaG5MM4i/+V4teb4zjj9WZp6LXJk6FNWwGg62GYNYapCx5w3iHboHVv08eiouIhVbxKPgaNQ44jlD2hY7ODR3A6muMh/2sRnwOopeA/Vgmqqi3IPvnQGKDyRGBWrf+B6rJOI5vDjyXFaOTB0GE3nwJuu8r9eNTN0r/nTTdj+xxKW2O6MV3G51CLLBt8m88JTVsFYBQwaz2ti1NJ4sgINwyS3+LbdCnRSqP0zuQyIBzKrTH5LMO7JDQ7/dZ0I0Ynk56QIyTEeA1dm0V8PmJK4VT5/01SMtVkaLYH3IKo2A5gZ0Wym9HqsaEA2JtKd0kSUPERYqsEWTQJqXRp2QewhYVF2iDVKIhUaquFhYVFWsFxXbfJzqWlpW55uRJxiaCylah16sclcF8IzU3C2xUyecpkZ7wiRCrgYvCggEvbSEVjo86PF6o5cs6LAAZhWdmyONuPQlT4MgBsjFinx4xjaavI/uYBtAcwjxPvr1Q7fump0F4R0QTCyK4A+p2EZWV3+5/oflwTmisp76JUTzboR+avJ4ofD+W5ak6/b4vjbDQNTKT+nmzNl8n7xfeNprfk69bTuI2ccyeAI7CsjIPqWSr2umyDSWu+hvXYVkX87sXiV0o2V5y+W/xIemaQ7VoWijWOfC9J+3bS+e7KkwMq3vNOcmnpfSgv3+wEn+Y6jjsOB4YHgNWu65Ym9mw5WAqiBVGc2wWAxspbKIrrAeRq0mMLRnFud8Q+qC0SwU7CtWHMnnAcmt6LaruYXQtggs0aFw+zJ5wPYEqym5GSSCVeNZXaamFhYZFWSEIPmJMjMo8lmtv3SKPIIaIaHfQ081gcDq08Km+fOa2e4kdtWjcttB8XN9ag+uGik/cBOHEyZk84kF4w1d5ZLbHITMUyFaYyJdZNcjhv5oFywMz3cRpDiVm+nmwWI0vq0IA6nXwCgPk3YvaEa/0VkjDzOeIBWdQq+miDimXZqpavZz/Wz26+x/QbwWp0Li+ktwlz8hzOrDwlSRI/oLSsb0upCxa6+8dv8nMAOs/D7AkXhOu23RzamjqTz31XEr27IojnKZN6OkEDzpUN8j4yT6tzKxEpKNffZbqxlpovn7dkcxyWfg+1b7CKu4M5IrMMlKUg2jAqAWB7ZSK3No/KrgC2b0zo15ZR+QmA2i0J/SxikUrDevsAtrCwSBvYHrCFhYVFEmEfwAZUh0h6yHU/Cm1NhcgRvZRaov5D0y3D4KRWky1aVdYevnd/aE8SN057x3yUjmu4PPcBh4ySYnE+6T0fFTfmQU8hW+sucdw/l+jRTIOR+L4s0zHcRkT8d8WN9Lh1dH44JSaAkC4sATzuztd3b7vR9ON0j5w+Q9MQ8LXAklHNA8L0IeuUNbHICNLxupSCUkqnG/w/V69Xjpp/l9NKFohfY/Wy6gF8sA64h+Yh+DrT9Iy8//V0ACJ4eADA0WRX32j6Zf+RFvgxcYts8LjQ/NbLob1B3LgdnAP1XdPNJUrX4YpRcyXRxtH+spZcSjHYHnALogQACkqS3YxWj5ItAAp6JLsZrRolhyK2YKFFQqRaKLJ9ALcgZgGAkQnNojHMWgJgwVkJ/doyZg1GrJDHokmwFISBB83FvxHtwEoVGYrsoklyFkBpisMhPP794DuhrVn3p4bmW2+G9jF9xI/LCfOP6ZCPh56G+kgpF5bGiTxtXMghvEV0go4aecR7Jsnhdkj6yByS+myhoVl+XAqCdH07JIUgp6B8iNoz13TL6IjGoekijZNHskChlYyoZx55Dkc04nV7oioryzWHe4h2+HVorn/TdGPGgFkWHXX34zbxvsejvYi22DEZnxk5HeQDDrTl7WvjxwykBeItCqQmTQbRDsTg7BCZHLNoetgZrGIczFSS0kCB1NAsup5yk3Cp1Ftv9bh0M3DpY5cnuxmtHpeOAC59zEqs4uHScmCKSnMtmoR2B/iXDFgKogWxcR+A6k0J/do6NnYGUB0vSZPFxlpgX3ayW2FxsGEfwBYWFmmDVKMgDtIDmDRkO75lrNl1UWgzxagBjkwh8fBAC+hi5YWhfRt9HqeC7jHMi2lI53iymS/LUwKSyWKfI5vzODx5FZGxLpU4knDmeuJ9iUmLSZbJFXpAJVxyZNxUR5kBmVbNh4LCrZ+bEdrC7TL5XkdUdqbyioRMUiUZhwgIZU97AGzYDfzSZwPfET8Ol+VzoKWzef+5TXrueZmlYVpim+7cSuJ9NbKZy/9wAkqt6LSSPuhLG8nX48yXVsB5x6s91QzsEJlWDt9AHBGtCkQ8QXZYtrlC+HqmtvkejrlPmwg9dQ14SJaf8//fpo6pxavaHrCFhUXawPaA2zBO6Xk4AFtvPRFOaQfvTrGIxCmHArtVmWCRdrAP4BbEraOHIVZjZKG4tQNSa5yYBNxaDOxYmuxWpB7acA+YeN+dJzaYmyUclXlfpqeUimVpKVeuHjlaHJk0IknwOuEVObByBnFzXS4x/TCGSaWvkq3MLM/is7hUUj9yWPHT5ipejFckaVAZLTBfKFXuM4kjHWSE437JdPwHlRDiSjl65e5G03Ae2Vxz/Ujx4xBcPiFviB/zyHzy9aHNnDCLc5V7Zk04R5cdIX4kwC6mdcWaCZG/R6LW1yTBGx8+bkJ+f9ke8730Wzkaeh2H596huvcIGFw+l3pX8fnglbQQvgn0Oo133TL4kBXzfhwijny+Odz/VPHr4UtEOsRGq6TSuz2V2trqMXHuNZg4N57M3AIAJq4AJupDzcLAxBeBiUOT3YrUQ9ADPpC/ZMBSEC2I7TWfIH4RUgsA2L4H9tWfANvr0HiSHouESCUKwt4GFhYWFk2A4zhjHMdZ6zjOO47j/KiR9b0dx3nGcZz/OI7zquM4CQs0t2APmNI9Uga918SLeV+msVRayppKI4WAajf1B3woEcC/a6Ru+D/N/cjltPnwaJYzVj0GAt9PgJqdwJuk6iVubt0fzC0wbcecd0wEKjeYD5RyiQwWr37wlLmOU38yV6ziTUp/aMhSlTvlfA38SlfpdJa/ctV+oBbhSTpc/LicUpcIW5f5dzVFIXOdfL1o2kqmPZkiGSR+zM1Sd+sw4YB5E8b1fY5sj7nOIBXny/D4UF7Hx4lL/ADIpotJ0iMYiOwdxqWEXo+3sgGcRXSQ5rHgm5iFQnqu+EDxdaW5WNb7eynPg4OVDc1xnAwAvwdwJrx6Tascx3nCdV2ewZgBYK7runc5jnMsgIUAiuJt11IQFhYWaYWDREEMBfCO67rvAoDjOH+DN0vPD2AXQBBAfghipzZjYB/ALYhRffoDWzWsy0Ixqo8DrHCT3YxWjVF9ALyZ0M1C8Bl7wHmO47AuaLbrukEKw0KYOeM2IlZvcyOAfzmO8z144zPVbMXgMzyAtUzwN0JT5FYMZRAC6EiE1Wv9eMj3ijiytIk2ogU2mJLI4ELKDdVVA1xDdjyRDetlPMHR9Wd8AXjqSbOg7KrQ1BE0HwsKWEbuF8Txh2Tzjlwpfqx7Ys5AigkYVANtr1aK9WbRcDCLr2odDvIyv/M1fHS8RyxdP8D8XVXJGYeWbT0dfNGwnElDllmux/2VQ8WP287VIk5BNCi0vlBlY0xx8PaU0shjuUMVAOD6MwC8JxnjmFaS2P2o3O3aG8zg81hEth4z49EQcmC6izkcwvwbDnofLJ6sLXyBzOWmG5+DqIoiQHhsW3bOe5vruqWJ3SJxEYA5ruve7jjOKQDudxznONd1NUq9AbYHbGFhkVY4SBTEJphMdk//M8Y3AYwBANd1VziO0wlAHoDI3KtWBdGCGPvgPRirQQUWMRi7ABh7bGK/toyxD36MsZqo3iIhDqIOeBWAox3H6eM4TiaAC2FmLAKA9QBGAYDjOAPgDR3i5iWyPeAWRO3evbEpsSxiUFuP1BJrJgG1e11vSsei2TgYvUrXdfc5jnMlvByBGQDudV13jeM4NwEod133CXj85T2O4/wPvLNX5rpu3LPYzAdwDcLY1evMVYtD8cuy98KPlZvSkOMAWtXGUDBRzr/6T0y/jCtogSRGb5tuRju+SmkbH+8rpYVvoeULf0Ar+skWbwrNLT5xtRceD1tF7aV3JAn1AJjP6oFMet8vjoW0k32o8vOrL5l+PH3AkiXlTpn7JAouru6fH5jxqHHm6lQLGJT5yYTH7wW9YK0zxTI3PkidxC+Kz1wlfry/3B+JF2rNPfTTZB3TmdxLVVkbt53Pb5H+GAsPA8La8e5Obnuc0VVU9kr9vI7alMmh4noOwDdaSLTmPCtup3+bFljCOUIc+aKhx84ImbSeQaN1bp/y9RE7fDBzQbiuuxCetIw/u4HsNxC743FhKQgLCwuLJMFSEBYWFmmFVGK37AO4BTH+SNhS4k3A+HrEyoosDIwv7gTURYk2LaJwsCLhDhaa+QD+BGaReAJJlJmq0/uMuV6myJR/ZHVgKelqdY4rl/SVW0i4rppb/h5nT7znPdOvE+k6u18UlimPR1Pm9PT+XwsA02HsNHPPug1jn6kiOgpniudRZD8ZmgXixnrcyNhrmOGeJOzM0Lgd3gZTePq7HFPOPKjGxPon4VrAlLDnih/zfcfz7aTh4LRjO5Y3+jGAaK5XJyT4ZA2I+BwwS/n8m2zdD53YCFDYVz7gxL/eG/za4QAeBrCGVvHzWLp5OcSX7iC9sFKnTk9aiPsS5DuIxLYnqR+3na7NGIEuk+V0MVWKQotPN+vXVacccMAyxZVq+YBT6WVhYWFhkVawD+AWxMizgJFNzVDdhjGyhz1OiTByzi6MjIlOs2gK2h3gXzJgOWALC4u0QapREM18AHdASAAKx0Mc8DB6nWTECUzgt47SioWXN77tGA1q4ZkN5n6EaReVZeMAb6YE9WQxLbY1wgbMMvL3+Rz1K3uAEzJg8FXZVEolW7jI3sxVGukA15iOnNli5/rGGwGY+lfmWDVtJa9jPaXWX2dO+YeIBut9eR+1xniQIyTD/92AW9WT1Y858CKylVekHcuh/AI115puzHkPIVv1wl8jm/nwQvHjWvR8Yejx4+vWyP+QJ46U4MQl4rwjzBwXfJzHyiZ4HbVDad7MIlrga06F8z340UC2ntMM+uEszhTxVXHk2l+0/5q0JUpvrilLA769kSdYGj+ALSwsLFovUk0FkUpttbCwsEgrOAlClQ1069PNHfwTM83cpIGTMHXIVNTsrca4Byf4n4Yxk2Ubt6GsHbDNBc6rB/aS7KtDe+CK14AL3gY2nAhcxiGe/rDvmjxgQm9gbQ0w5R3E9NlnnPUURvcdjYrNFZi2eBoUt4y6BcN7DcfyDc/huqXX+5+G4+RZYzqhpOAQLHl3K2Y+9zawlsaXO4C7lwP9q4FHOwJ3UHx0MBL78WPAkdXAUwOBP3wR6Hh0OxR2C99rj9bvQ14GMGcnMKdKGucCC98GOu8H7swD5gbDKoroXFbnNfe2jsCCDgB6hOuyDnGw6BJvfH3zs/VYypK6ffXI7QTMOwtAzl5MX/JjrNgYlHzw9Ew9s3vgAT8KdtriV1HxshksXVwNzPZ1zZNrgUpfmVTv7/zxm4H/W+y9xb9xLrAp21RKlW4ApvsqpW9PAmp8amZTVwBFwOUDgOuHAigHxr4B1AZ0lf+b4zOAa33V48gTEcNATFoLTH0DqMkAxnFKS//wl631/rYdBZwXyKeIjriiGrigGtjQHrisEKakaS9wzXpgwnZg7ZvAlLPCVYF67arngH7vApUFwK/GxKrdrlgKHLcBeL0X8NdR4eeZ/vmd9RpQUg0sGQzMDEKVg2O0H7j4feCnG4H5OcDtR8AcW+8F7n8d6LUHePhw4C4eotd6/x6dB+TtA+Yc5/0B8LqIPhb+C+hcD9x5LDBXqw4f6WBZmXewbls+Hgsq/Tj/9z2uIgvAIgCYDtz8PLBU6JfcdsA8Pxvu9FXAig9o5Wagpws8sBfAYcC0OqAiOPc+7VWcDcz2JXOT3wIqM80S2yUFX8SsMTegtPQrKC9/tWGvjnIc93YcGM4GVn/GdJTNhqUgWhDdPwW6dbODikQo3AkzbYBFDArbAbTxXB4AACAASURBVBdvS+xnYSLVJuGa1QMuLS11y8vLI9Zy92RSaN7yd8Nr+49DO5cTlGh6Qu7MsppcpTlDm9p+bl8V2Vebbl+fH9okuK+VNzwfhWAubXcHYPCuHHTuQN2MORSZYB4KcwKMJys16zV3rbjW1gANX+HABJrMydGpGM7mTRm175QGcvIXmrDaJTmA+JXDcnut81foP3Rr2gNYC3QOHPSSqiB7AdmSiMmYAOOgD43C4c4TB0tEift121J/bROdK56rq5LN8RzmMWQXnCiOfO37k4Q1LoB/eqOjRturqSp5YpDz2+hJ4JOVTfYV4jeDry3KaP/T75h+09E4dNaar+E/kn2Y+HGUFE9inn6jOHozptoDPtpx3N9ENCkRzkpCD9h211oQ0y4Bxj2o08QWinETgXGaSdXCwLidwLgBif0sUhvNpCBchD1JlQSxZoR6YkLIcIjxydQ5zNfn1jCyC0kvs0/r60RB28fdgv8LzZPmG16r/hPazGeqmo7fXEEnw3sN9wTwrXDl1hmhraV8oioSa/woy4W4F+hKroDdtMwStVFap456NN+iXu99plcddZxZ5aSdKu6YFbFsSuVvRf7/w+B1He/yl1VayD1v7rxrCkLePvekVNPIY1LexnHid3NovkZd2w3ixp05Dkk/X0OPOY0l107QMTJfF8GPZfk/FHXg422Dj5mmyOSwau41a6rL+XQtTaCSyz/RPht1GF0aGm0XNx7RcmVqLQHO6S6NUbF2+YOzYN6ZqUZBWA7YwsIirZBKw3r7ALawsEgb2B6whYWFRRKR5g/gKA6YYwrnNVgVwkExBWdk71P+rJAJoL+EZnsN041Chbm4hmJQLyOv/5huUaVdFDzRXuLP7l/5JoCrToBxbDgEVfNR8jKnOFRu8iyakd5H3JzydgMppvd9Ig+3yWzON8l+mmwZu2WSVKwz5TnW3XA4ypRDfZUs9g9u2R54nHewK5oGk9KPGpzll8WPLxEO6z5S/DjUme/OzuJH8xUsq9WI5XFkF5xDC8rxR7XhEFnHXLF/7svegTdVwRckX3SqHuB5Aw6dfkv8mG9n+lTPFd/OE+bRgp4EqsDj0I4NesrwqqXr2xCzzDa3ZihEhnK89fchnv5/bXhqwfaAWxBlawCUqMbIQlHWEeYMp0UMyo5CbBFBi4RItVBk+wBuQWzLAlCzC3mdVYhqwdi2H4AD5Nmqv5HYthtARyAvqoqtRSTSnIKIQlVoXht2b3RIz8O3DB4C6sgGD5LNzVSNVhSkavPDoam0A4MVPDy4iVdtvtofnp9zHpAx95dYVkbvYN7Ho2GiimymBXoMFUcaN7YnXmCXpkMjnoB7mAvEjYqabKYbvEBHc8R88CvF0SE+67J4iPsF8fOphfM2AnCAZcHwWHVeVWQztaCZs/hkfSXic8CsrKBZtRhEhfBXdLRfwFF84+M4skbtlYjPAZO2yfdWnjdnGzC2DstYssXUhdIdLL1j2k+DephPYS5AaSC+zeZQBr6yM8SRM7tRBjTHLEuSCVPuGQmDlzTCV8Qx2L7Z3021SbhU6q1bWFhYpBUsBWFhYZFWSKVepX0AW1hYpA1SjYJowQcwVUd9LDS1SMDgxmJ4AeCmr4unlrYNcIMsc+b9x0OzwpTBICL3gNKF3Dzmr+OJXYJt7AeQUQPgzf2xK4HYBCV8pfT4OS2MEMe/hub6u0Jbo7KfpAqzr9Pnwk1uJ96X97FSDkYx8bm5zHsql80cMMvGlLMNUkJ+CI9/DCoK65wln3pep+GtTIEzj3yO+NVH2KKne4SOJxcNOVtP/r1kjyY7R8tUEI5dFNp6abdnjVpwS+7wYrw5NQyfR02e05XnDapCs0KqDvNx4utHjy2fR+O60PuPyWKWpt5pePGlT9MxMVHoP3mUFs7nA9X0R5XtAbdRfH0V0O3CZLei9eOKHjDnWC1icEXpocDbtcluRsqhDfeALc5ZA+T2TnYrWj8u6A5gbUK3No0LjusG7P8gsaNFSsM+gFsQm7KBmhqgl0ZYWRjYsAdAN6CXzdwZiQ2feON+jTq0iI821APebC4+F+r8/v0eIvEC0aMjjCOlJRJ4+0RIVb5quhVTNu/Ks0P7WdOtlnSYTFkqB8xgBkrzxXdhLadfDmdiAYDngWXM2zHJpVpLQw/KOkclCanF8dIz/inOJgi59IJ4i3jAGO6M6b2jEO3InDA/MbRGz0Pev8u6AxgHLAv4Pj0JnSJs1b52iLA18T2392Ky5U5lrXdvvhxnmH7GecthwvkYcaSLkPexqx5AFsF7F+plf38dOApYdj6tyj6JFvQEcyx/UWh2Fw6YSw+xPlzPQWHUOk1BwLHONKwZZMbJ84wM88ExD0uDRud0AvqoCvbfgcJywBYWFhZJQKr1gFPpZWFhYWGRVrA9YAsLi7RCKvWAD+ABHHxF0kJS/DlTfzqJwJToDvpOzr2/NR370jJPav1INvg0lRfimXVJ1cj8Xjx9L9NdQ5jr0/wHZzSy7iN4VZt4I0Vka15D5oR3lDX+uTaK8jgoz22Ur2GuTycFafkYriekB+MCsvnEKSEelYZRlQ7B+c6Bl2dCw/sD8OQclx1S/THvF6fz1P3gtt9G9rdMtwuY5/4h2aorNqSvRDi3LxZH4ksNHlX529Vk0y2ZUQhka82eAIWyzIkdqJxyB6mgygVGWfurKVb4JuHzsVJSm/I5uCk017xuusliA1T9b/yW0cCmPapsNrQ2jGu6IPa+sIjBNVsBrE/o1qZxzSlHwJz5tGgq0rwHbBGFCR1hJoeyaBQTqhHby7cwMKH/YQD6JLsZKYc07wE79JUqcxUNN3m0ruoWHtnwiLnkm6Yfp6qsJKmUjmoncLVUpgxklNfllNA+dkVo5yi1wDGow8m+SnMI9oz5sbXbaoCN5ejPaQO1IDGDh8bfI1uH0BzPzeG3GorMlSn4QH9V/LLJ5t1QSoCPzYDLEA0aQlcT96NpMH0KZm0nABOA/kE+YB2Rc5htIYfpiq7Npaf4pfT5TYgGh+L+U9bdT/YwHlufJY7cDgrBX1ZpunEoNtMY+brDLLkMrqU6ABPQP69HzDoPGq7OujlKxarUgmYwDaD5Vvl7fCi+Z7rtIhUoy8sWmW6RD8V+o+UD4zajjadpXzGVXhatHlMWvI0pK5PditaPKf2AKXF0yhbAlAUfYsqCOcluRkoi4wD/koH0fK1YWFi0SaSaDtg+gC0sLNIKqTSsb+YDeD/CsjebzFUkZ4pXvDWL+M2niCBWRdUu4jd5e7EjV+LPuBSLSqNID5fD2jjNIFjGxC8nztNDxctBq8YCGc+bDeaSMMqJclpD5nPjaONqiavLukj8uJwL04p6Erh8z/FMCP9KHFmH1kTOIJv0Wxc/bq7r4LP+VQC69wPKAkJxlGyE+Uw+zhL+7pDMq5h42VukFtLvyObJPw3lHsbHgtukM6tU+skII5YYaE7peB/ZM3eafsb2AlLeBZAFoB+ti3MsDF6aUs0tFzfe53hh7SwHo2tuU7npxpcqhxtrFDrDkKaeKit5kue39MPfU8I+4MDjFQtr/bA9YAsLi7SBpSDaMGac/kPg4+cTO7ZxzMgDcPqXkt2MVo0Zpx8K4GvJbkbKwT6A2zBG9/0CsCWxX1vH6K4A+vZP6NeWMbpvZ5jlMCyaijTngAN2R+pdk1aw8LuhXfd7020h8U5MO+lbi7kl9otlImkXOKxWeU+mdlkL+kXd3tVksxhS02UyPLFvxeY3AGSjpIDa9FsiphdGb2ELUVmd9pjrWC7cm3WSu0w/cAlzDsX+pfgZBB2nUFRtKYMvFU1JuJHsfhE2gPM9v4rN+4HNhSgpCH5bOVY+1txYTffI6yjfaO8fmG6ZdAD47owJBuHts0B6nvgR/1pJJ26DuPFFzfrbf9SZfmcz9+yFEVdsrgfwNkoKOP6a93ed/Bjx92uqQ1vLYHHEMrevm/jxHAq9B1RWzBLhzMa/AsCMFJ/KAX4a1n4H2XyuTh5j+g1d7Bsmn55qPeBUelm0ekxb/DNMW6zRERaKaYvrMW3xL5LdjFaNaYt3Y9riOxI7WqQ0LAVhYWGRVkilXqV9AFtYWKQNUo2C+AwP4IHmIktGS0IzU6jicSTnqyZq7W3Z+mDW53JOAq1zzwwpU2sfidvhZPMr8lHxu3oqLbAW9GpxZCIr4ATrgF37gDX048xxae49Ohb5rH/sa7plK08WQI4tfkY288NKnDMvWEnpCouniCNPlF0Q8Tlg5gXZFGEDmFcX/n73rQDm+iuEK8ZgspmXVe6ZtbAkUP1ASG/mzfnu1EQl1XQsdpOdr2kmibNeS7OukgIVT1NLaXMF6rebONsLg7JDlX5jmQ/n/ac0rABwJ+Wh4MOivHQV2cz76rXJHPCIUFfd5Y1nTL/JoXkECYCWyOa4mBIGka2a96hcsTHMXpDgMrZydBt5AFtYWFi0QhwoB5GEmA77AG5B3DJqMvDu1MSObRy3FAAY+YWEfm0Zt4w6AsCVyW6GxUGG47puYi8fpaWHuOXlgVRJJUsTyebn+nWm27xHQpvT5EuY7mYaUc6nzzNNN3wtsv0SM4kbyKY8gatNroIrGmvwY1Nwq6vjWh42aoAmHcNNNC6VlH9GjCcPDZVm4bBOytKJVVeII0m2WEI2Q7Kk3x2ab1GRhWNOl82xxI8n7nV3WZvE31E52OVk8/4O1dhrBtEdHzxnruJri+WJZ8om/ti4velN063wRFrgoftc089oO5+bq2eKI+cLJaFXrtSTIbZtu/TWoiSdWgwlixV/3D6NQh+zgxZCGuRSx+QMmCBipZ2qQM/jTf85YgUAdGVJHjdWniP+M6a09EaUl7/XUBq5tJ3jlh9gt9LZi9Wu636u4utUmjBs9djYC1i+QYPvLRTLDwWWpxJRlwQs31CO5VElmyziI4XyUdoHcAvi2VHAdUuvT3YzWj2u6w9cl5XsVrRuXLf0F7hueGI/C0FQEuNA/pIA+wC2sLCwSBKayZbUoUEHVilFR743o8Gs+Ff4sVZAYQUUU4RdxI/XMb8Vf6IyXgmTq8gmkvFT04uLHTeVAw5Yu8YPJu/Jx+aqWuJ9qXm7JKthF6bdOOWkytNYzWVUEJ4sjiypo1YrVfzr0DQ4vUHixyup17ZQtEjjAq63Dp5MLtj9eGGwQ/+HFgaLI1fmptBcUUoZlDczfK+JH5c1ourbSrUX8rFledQppp9LajjHKH11r+loJN0J+NaM2AJnJCfM1ZhgBhO/WkmLpyhYWXiG+Bnh12H7csWLN38c2RoBPYQXWHLZVdliDgE/POJzIJSINhItmEL0llVBWFhYpA9SLBLDUhAWFhbphYPEATuOM8ZxnLWO47zjOM6PInwmOY7zhuM4axzH+WuibdoecAtiwmLg67fenuxmtHrMWoGYaD8LE7PG3Ar8QvV+FglxkHrAjuNkAPg9PPHiRgCrHMd5wnXdN8jnaADTAYxwXXeH4zj5ibbbzAdwNzSQRdPMeMp7/xXrDcQWTtGtBVB9L7OlHEmrHJQJJsZ01zh0+JuhOdIsY+ycRQTik9G/xNXrzw44t2oABcfB1P6SgFYLL5FibSVRblodZgQ/rDimUzlg1qeynDKGP+MX8wuhuU5EmSRPzT+k8c8BePsdQBtP2ORLjrtvBApH0grtfQy9jBY45F2JStaiU1x2xYWmG19MTBmq9pUvyEtCc9CH4sdcMbddOG+HD7shS9e7gvVm3nVbUnBabG5pJlmHyDqeJ+DNCS9t3CK8vzF5XnmeIJxc0NmEgXTYXeLatcQYT7XkGqfxBvHkhpxFtl7DAZyIz1scQwG847ruuwDgOM7f4N0J/CD8NoDfu667AwBc102YHdxSEC2IJUcCS959OrFjG8e/+wJL7NgrLpa8uwRLeiX2s2gEB05B5DmOU05//L4phJlZY6P/GaMYQLHjOC84jrPScRxJYhwLexu0IGaeAuC5n2N035gs7xaE35wOdMwCRn+a2LetYuZzM4EhwGhNpmMRH5+Ngtj2GSPh2sPTH42E12V/znGcQa7rfhzvCxYWFhbpg4OjgtgEs6BzT8Sk+8NGAC+6rrsXwHuO41TCeyCvitpoMx/A7dCgUxwvq0gWzFJD5XZ3R6xTLoTpqQ4RdiyOirMuIifDP0Q0SnkJKKsmKmRrBgUXcLFdAG/vmfel/JnrvmVuhHjGd+njmFcwn2bexXPErzcnJmAuTUWjb5FNuSCUU2Y9LvPLJ4sfR18TB3y4uAUtahf4BdyxcsrGD3Dqy3hloehS1ouOWTrW7ar+OIvI9pPpjOjEwwT6gZWUA1W3x8vMoaNIHBu/DffuA7azCJlSWuaq0PbiRjcRm76V+WEW1Tt6B/L1E+qtByqnTBywQ/28k+V3s1gwbET4nWU6Gr8bW4AsiVgF4GjHcfrAuyMvROxR/weAiwD82XGcPHiUxLuIA9sDtrCwSB9o8EoLwXXdfY7jXAkvPisDwL2u665xHOcmAOWu6z7hr/uS4zhvwOti/MB13e3xtmsfwBYWFumFgxSI4bruQkhpXdd1byDbhScf0eoNkWjmAzgTDRN/8pbhITnXa403quXozKyh4sjDI5ZeaTWBAwLJgJ431zz1n9BmuuRS0w2FLMP2h3V31wMY/1P55tLQlOobC0nexAGZR0PwU7Kv5oOh57mKbC5/q6eZ20fDes2kyUzAqYgGV+agn31F3Ab7cr17lwC4DOFw+GyNgeYkh0zIaH5LppUoxehTptdqOqd8WQ2RFKg4iUaLX6bP+6homYbGw6pC+2GzbMN2SmOZy8dyvVzEvRGDu8ffje3XHhOZZnLLe9IiqoaSPZpWaPESnvjkqjPVEuSfzeeA9venppsRi0yH732hII5hPoo1ahP02vyMfcIUi4SzPeAWRP8MAHk2wiAR+n8EoOlpqNsk+uf1x5a4g1eLSKSQuDaFmtr6MX8vMH/t0sSObRzz+wHz7ZUXF/PXzsc/tRSdRdrB3gYtiNt3A7ev0ExXForbhwC327FXXNy+4nb8weYDbj4CCiJFErI38zbIQgPht9FcM+hLZDOXqDvGchwmOzXKlMli3p5mrzPAHGE8CQv1Un9trokqKBtDgTJ/GMhvzgLQcycM9nPHraEtudqZ3+PtO9+R3zIihL9P9sOmXy0Vb8riMHSpoGvo2laHZndx42NdRbamo+RqMaRwU8Y2Bg3XhnryRfMO2RoTTHK/e8Lcj6tfMr34WxzNa/C8AOBQHsf9xOdWi5Iom7qm95Of5F7lSku5fL8o125cddFlMOJLMENsoZDoDhIenTOJFpgt02Nh3OCkL9OCL3yT0GGqErdjWDZn7Mg28YwKOW4GUqhbafshFhYW6YMUm4RLoXeFhYWFRXrB9oAtLCzSBynWA27mA7grGtjKmdJ5fol0hBwxrSXHObSSic+sseLIGhzioyp0g1HYKcu0q3WUJU4yML6hpcV91MjyW6/H+vzkIeCoX0yBwWlS+ZVq4f6YCmOKLBuCx8nuXhbaJ4gfk53daR8Hip9x2qn0t1LFTH0yNfn76PbV7wntGD2zrxm9vxye9jW4hOb82fQbRMtRMekAsILsH4Smxn4ytd27Dy1oopvXahpfp7TsR5Wh/Zfo7RnVgDqSHaNUfJBsr9TO/ef8CPjBs8iP+p6ER+8gPTs/f7SE13a6vnN5vzT+PY/rW4Wh7DtuNN1IYm0w+TF8NTfK0CbrpDXHpWsJqiYihcb1tgfcguhRDfQ6JH7GYgugl77NLGLQ65CCmHqFFk1AivWAU+hd0fqxcCDw8OsrEzu2cTx8ZIx+w0Lw8Ov/xMMDkt2KFEUKydDsA7gF8bchwF3lSxI7tnHcVQzclexGtHLcVf4I7joxsZ9FauMzUBBfMxeHcoD3D0Ozxz7TD7Mjfv5F080lstghQWod4oC3p9rSpY2u2iGcbxHZHFLfT19VRHK9tYdXbIXRv6sKzWzm8wB0o+/143VKYsboRn1I+Xoj8UaMrpNBpXw2UV5R7QUwVfA22Sqxpu9lEL936FrxC/TDXeCdxyBvhP4uS3/5fC8SPzqPT1MOCiWBjCuBOX9NH8nTC3wOlCvm/ec5DUl8chgTpEyIO9+TDXLejkCX/alXBIe1413IlhTfOZxegio6bZepEKNiFOcm0Yd9GS+E93BOnunWjmS8fKrkbsaZnAuiD4f46fOBE7+yRlh+OOoCP0jZ0A4WLAdsYWGRXkghDtg+gC0sLNIH6d0DdugrKhFhTQuHE6ocjDVRcUIwnbzG/WabbjDSWMYLRab6eUQf5GgaTApj5VHdbtHzdCL64Bi/qZ07BL9bFK7k751rbmMEh3XyEFWLMTIVwOM8lUfxEJqla8PEj49N4ZmhfYLkcXyIbIrSjWF3OGSZ2jdER43BkD8DwC4Ar/nLOl6NDFs1sZ2oCh796zSoETnNaSG1ODFHaPPwPF4MMJdlFErD4eol3Cvb9lvTMY+TPgTcwkagUynQhyV6lOMxn/kIAMV0QS4Oa0HmTjPdtnN1Zj6PMTQX80fhjqyTyOGRlFrgL8Sk6CFbR/dVv/tJxndZvLrpfADvlnWBDrQ2zvdbP2wPuAXx6CIAs1TPbKF49EPE8qoWBh6d1BPAr5LdjNSEpSDaJvJ2A+iclexmtHrk7Uf0xKIFACCvc3sAOcluRurB6oDbLuYcA8ypeDOxYxvHnK7AnOikXxYA5lR8jDkV/0h2M1IT7Q7wLwn4DD3gY2SZN1VFtlay5Qq9zA9/YrrtpNx+xIGu/pPpNviPvMSSFt01Wse0k/CynYirYrpMMg0a4a01Pi9211FAr4q3UVZCMdZMhsWrz8R5EnV4zmQ086Pl4nckDgA3hObTwgHz7zIHrJFsHSL8tCfic75zRgDoDpQFNKOWT+bt8TakGnPus2gUw+S4FEymBa7oJNcSl6d6jSjVo/aYbkaAGlGl+VqknGla5rl1HmM3TQZM9/7NeRlAu8UoK7mSHIsQDToYI04P7W7PRX5jC0no8rU807f5Pg0P/D/FbS/dtqxUFJWckfX1p5eHdu6SatPx52T34Hs46n6W0iq2B2xhYWFh0RRYDtjCwiK9kEI9YPsAtrCwSB+ktw6YcYgsM9fLDJCKRlk/fBbZQmB2fSG0M8IaPZpeLzaUMYCWOqHSO0xvSWpACszFA2SrrpFTDQZZIL0Xbw6ClIIAgHNuDO2mcrtHiN84slmfKrS5kY6StxfDyPGxoUtAUnMaIcG8iUPFj3XAzHXqqQ++1x7eTRLIxc8UPy6b04PCVtdVmn5VoVk3L7QLVH+spdkDaLaxi0JzkIaDE7L4UmX9tk4UFETYelxY9x1cI3sAZLWDqWfnL+o5pbyYfyXetzMiYSjldX5ix6uhnRNqcPUSYek5t04vYc7eysrma98WR95gDy6/pfd5xKMrxThg2wNuQXzvQeCbs3+Z2LGNY+FriPtgsAAWngHgaKuCSHfYB3ALInMv0LlDvGKgFgDQeT8aG8pYEDq3B9DBvqUOCClEQTiu6yb28tGtTzd38E/MEORJAydh6pCpqNn7PYx70H9jfxJWsCirAMo+ArZlAOf1hTFOcXcB31kFTFoDrM0GpogkDAC+vxwYXwlU5gLfmwC0c8z1M2b8HaP7jkTF5tcwbfGF4Yod3ljmliJgeDbw1NeBm3xmoIq+/+XFQMFm4L2+wPOnm8+FdgDGzQdytwMnXwPczs9W376/E9CrA/BwHTCjFkBOZxR2Cx0f3fkR8toBc3YDf3oNBj4BcNODQKe9wDNDgCV+lHY3kqQtKwYw4TDctrwWCyr3AggrFWR1qMKiS7zcXzc/+ymWvktj6reA3P3AvA8APPA2pi+5DSs2Bum5vJxYPbMPxwPnerqnaYvvQMVmyhgHoLj6I8z2Q20nbwYqg3OX643xSgoyMGtMJ+Clalz6CrBxNwAqxDFkBXCTv8mLJgEf+6zVpi4A+nbC5cd3x/Vn9AKeWo6xbwC1wcH3nzvjewPXjj0fADByzjJgr8GrYFIFMPUToMYBRlFXoqNvl73p/W17DzgvoCic0xr8rij9Li447gJs+GQDLvv7ZUA5Sbl2A9e8DEx4F1jbCZjCNJB/eme8Boz+GKg4BJhWghjF5S1HAsM7Asv3ANcxXeRnvpvVFyjpCiypB2YG7Ip/fW+qBS4uAH56FDB/C3B7FcxQ5/3A/WOBXtnAw28Bdz0Rrtri0xhXzQX61wCLS7w/ADiU6JmFQ4HO7YA7twNzMzWAqBTLyv4FALht+R1YUPmk9/Fyj97I2gcsmg+gL3DzUcDSXKCWLr/CGuARP9PgdaOAF4+nTR+fi57ZnfDAuScBuAPTFt+Eis0BH+cdnOLcozF7gqcxnTx/Miq3m/RTSUEJZo2ZhdLSUpSXlzc8FUpzHbc8bibAaDgPYbXrulob5KAihd4VrR9bXWDrrrj5Mi0AbM0Ctu6yoXDxsHUPsGhrYj+LRpBCCdmb1QMuLS11y8tV/R/g6tB8gWTXWmeM8onUvxLau8SNjwe/JbJ0NqxuBy1cF5pLzZTf1ZTc9yb6XAmDqHQ+M78vjjwR4zd25KcAeh6GZWUUMXBnmMR213fNTfybbM5hO+QJ0w8TeJaL8wNcZ/rtoxmMMvr8AZ3p2Blh32K6zaMEvHwwzpKqdS+RmJ4S+NTOMt2y/ICLkV8BMDwby8r8rv5Ty01HnhAqPD+0tz1i+lGimfVUVq33YaabMTnZnpO3yNkvoeFVFX2ugSd87nkTJ4nfGWTzRazJlnJj/Ub+G0A9sIyTRXHfTCfy6KL+K01D6GTYyIm0QJOOmFgsnnRzMlPZXW5AmsTmhDtFsrUMTq791ARauEM8OZFXYoY0pgec57jlZ8X7RjSc+2wP2MLCwqLN4DNMwklQ4jbq9bKER6oi1NJyvEEoZ+7nToYrX3KMXSCpyoem388ithevDTM5G95oWcnhs0GV4B4A9nwEbKKeI8nGVsX5rSG308IpupY0kzixIQAAIABJREFUVsaQosh020094LjDVyYreRvSrTqN7HxOmSiSoKFvhfassDesY6XTAilWJmCkNj0zUzyl2kqAPJmU+m/YNeVLrrdKqljud3ycS55DifkiqRc/Xv40wgbME87zG1qyQ7cPeBG22ZnAMNXU+egq+5G5vsHksxhT15NPSgmv0OMSMZn8U1mm3ny/n9DnWjX8HF54kuw7xbEFdAFWhmZhYWGRBFgdcNvFsg8AaLkvixgsex7A705IdjNaNZadCqAkovdrER8pRKymUFMtLCws0gvN7AHvQkPBl51jzFXMuVKau2qtjBsBFTdk9aEFnnSPKdXNXFU4c1t/ielVH2HHBWcCPE7W8Uy2P9V8WwaAR4Brqb2bnwltjT0woqCZY86bKZ4c+8v7u8504wrPRthzvDBOCtHWI2OEHDN5KAfjXlJBEO9ZJb962nbv/22DACzfhmuHB5rmnuLJMdAUw3uDyBGI+DUof1UIGAeew7AlKTEPXVlze7TpZoRe8yZUgcgTDFQoO+Ziv4Bs/xTcthFATT6uHT6AVvJ5k1D734UcMPO+EmlvruRNYyOaBJ3I4NDzePMOxmTLqCgvxE8p2wSkGAVhe8AtiAUZwAK9+S1isKA3sKDyw8SObRgLPgIWVP43saNFLNpGQnYLCwuLVoYU6wHbB7CFhUV6IX0fwB+iIRLrI1nFwVYkC5Xi2QbLmMlyVE1JyEMCLkWjUUTGLoR2hmppV+j3PKja0eDMpEKPAebxghIz5/rtIy6Mqw4p01nMk9wGdbFdPEk3ue/voa3pDzXgrQHxNJ7Euf1Nytcwj9yFCM6P5Yd/H5rradSs1GmD/rU9gE+2Ay/M97cnfgVE7rKG9z7xo+N8Kn+upZlKeBKB6xhJnkrmc/lC0OEp62f5HOrF/jTZzKcrs3Ar2UP8/xkAcvbAFCd3DM3VcnFSyFtGnPLwsRrzADujVhiYP8dc5tPDzz1NW1lknGMOEXxRPPlm1zsm/WB7wC2IrH1oSKZiEY2seqRULyUZyAKADnaKptloOwnZLRSLngDww2S3ovVj0QoAlya7Fa0bi+oBXDIo2c1ITaTQy72ZD+A9aJA+qeSEl0nCkzHJdMvgMdHRETYAXMzJQZqaX46GL+PMBC8XRVAQWh2dmZUqGvkX6feJMlhJ6qhhMubLoFFUsSZ14ZBZjqU96demHwsGWHmm4Z5LyDaie7UyNTW+juSESgXwPrN8SeRWW2hI3ZuG5J20KAnHXvBvacwy81R8XPSao+0V8jaGi5+RwIgveVFicPVkjnou07y8LMNj3kGoo4uoqsSN9LlWFOFxPNMW1c9F+0kV41+9Gdp86mMOBVN93I4dIpLM0S960PAZZr1YafYX8fuJce5Ym3qUeLIcjqrixJCFX228gSk2CZdCnfXWj3tPB27ek9ivrePmQ4GbrcIqLm7uC9y8MtmtSFGkkAzNPoBbEOV9gaVNjvJou1iaBSytTuzXlrE0F1iqNQQt0g6WA7awsEgfpBgF0cwHcD0a5CrKx7GMKh4JxQqUEs5cc7U4sr6HOcyqOD9M+iOhlgZzaDNzsXKydtHQmGnKF0R2x8xfwH25gMersSaKeVmttBuV/V2VOcwrc9vfED/maQ0uWk8zLXOPfYnptYYUb3yY4hX15XOfr3KwYLkdvP0I2v878WOKmtRRmYeLHzeKyUn9XSPpN8uc5EBP/TktMMeoHDqTp5vJlpDv9rQ8k5P0y2QA874cAv0OgKtombRdtZxfFeYtx8NaR5vOukgqjhAjKz2/ihbCiQxV2vFR4gS1mgjeKDH+hftDe+Ir6kngxuvsdlA+KybhZkqN620P2MLCIn2Q3j1gi3jIrgFyNbe4RQxyAauXToDcvWhG1iiLVIV9ALcgZs4FTpue7Fa0fszbDyOoyyIW8yoQE6hn0QSkdw/YRSwD6IM5R07XFxPGyR9w9TxNPq3kVYAiWeb2EBGoZWlYCsr1Op8x3fqRncEPCc0lSetWchRnyY2m30m0XCXbYOEkz3hrCk/uCTF9+HfTzSX+mim9XE1dyPrKrLGhXb7I8GJ2jk+vVtRhavtkakOhymd587SuUprHSj6mRD8W2W4Jz0Mw7/sgBKTH/S/Z38sXvxFk8/UXLzF6vHBZisnn0juHlZlufH5Znqd64R+HptZtZRiK2RJZyQ91psBjSlFyqaCpDZYythwozZezTk9MofDo8cRlT7j8VdPxT2S315u4iUghDjiFmtr6cecoYPqSJYkd2zimHwNMj0lUa8GYPhiYHpP3xCIhgh5wipSltxREC+L1XsD6jVa8mQgrcmBf/QmwojtiJQcWTUMKURD2NrCwsLBIEprZA64DXL/0ieoGOW8ADy815PQWIlOv+watkBpCxDuZvK+mzWOubmRoHn+O6XY8JXYYT8kMhAPO+Cst8D6eJD9LmtRhPjeX3R7wGDhq70WNfweAKZzk46Sz36zdZN5TyjMtom0wDZ9rCD4VRBKONjngE4iPYw64ULbQ5ZDQXk9cX0z4fsDTdoRH7vopPoolF0Qd8dxGytJ+pp/BqXNvUYfuzN/ztbl+i+nXm0hW0E7FaFBZZB5Po0486gf3hLbmBGEEUxr7AeTD5HCvC01NWMqXhZGvQbtYTNR+geyY3KE8txLmZ/iibG8dHVtWWyvDxAlMWfY94d/iyMklBkykBZ3HCB5dMjljs6FZWFhYJBEpREHYB3ALoudOANmHJfRr6+i5N7FPW0fPXbB354EgvXvA7QDHH1e+LOMo1p3wsEKHWxym+1saM4/7pel3GC2zHOdx2d7ZbkRbNdEkDWfa0wbPFFndmVwxgQMtNcEeDUs/+hEAP9ry3GtMt4E0zvtU+A6Oih16fGhvEWlOPlV0eISy2Mw23Zi5MBkTnc1hWdW80JRxozIIDVtTDS/9cG+uuKA9kfHevwcA85xK6HAmF0VW2qGR7cX81kTx42F8BdndxO8FSv/INMZh802/rnQ+ttD5eMt0M+4Jplk0jJ/ldT5N9cAKGJQDAIMV0HcYX8W7eMUF4sgytJwf0ILmIr2cbKJZ5Fz1Iwbg68R0VcnWWB7/PK/QYsyscxsQE1NOYK7m84HjOGMA/Abe1fZH13V/HuE3EcCjAIa4rqvJVg3Yd6yFhUV64SBQEI7jZMArvnUmvNfGKsdxnnBd9w3x6wYvg4dmdGkUKdRZb/2YVg9MW/znZDej1WPaR8C0TYn92jKmDQGmVST2sxAcPB3wUADvuK77ruu6dQD+hsazwt8M4BeIjFgzYXvALYgKF8Dm95LdjFaPijp8niPHlETFYYhlBSyahgPvVuY5jsOUwWzXdQOirxBmvOpGmCQiHMc5CUAv13WfdByH+Z1INPMB3AnAMZ6plXFpp116BmmyuA5EOWYx3XqHOPJcFhNeWvm3kWx0HqbKModW8m4PFL/BZHN6wTtNt+oLQzvIvbcZ8A4Es6cU4znMYOeAbS+F9g7iffNVxEMpD/s3/jFg0qqvkT04hs3ll/Pq0JQSZP2Yzx1C9rOmXz3xdhlMN4sSsCGGeTu8/IkBz3qa+M0geyHZWoKJDxOnOdVYaU6FyOR4jmgLb6Jrmq+57qYb9hLvyz15nXZg9R8fcuWA+YERHOdu8K7tVY23Y7OoslgmyBQ6HpLfmsopYPm60LJf7Rv1Wyn9C34i8fV3toah0/5v5ZevzlkbL2aWnEZdwzIH9NlyQWxzXTcmKLspcBynHbyEB2XN+Z6lICwsLCwSYxPMqdmeMF+/3eAVC1zmOE4VgGEAnnAcJ+4D3VIQFhYW6YWD061cBeBox3H6wHvwXgjg4mCl67qfgORFjuMsA3CtVUF8jijuACBX48QsFMUdYfMcJEBxHaSqiUWTcJDSUbquu89xnCvhxa9mALjXdd01juPcBKDcdd14Ceoi0cwHcA8AN3jmD882V00LTYd1olIlmKm1vcRjZQinxS8xPp6qfzTvYybaNJcflzzi8FFNsMdCY97eDaYb86C+jnM2AEz4m2yPycl55qq8cRFtkkDTN28N7eOJXLvUFFmf9igtGGHPmk5R8joG0HlbLidFksztwtfz1wr5d1Vn62P2kQg5TsA8RIDJ7bKYRzXlPCDk0y1Uu5Ga1MhwKLNcmkMxgEx3GL/FXKdyu3ztcxFSffkwrz/a+zcbAG433WopTanS0rxs0KhfF0fjlme2eFwcv6IGS++qYXxpfY1sHXhTksDz76PPVadscMJcll7uvwZkmYsHMR+w67oLYc5KwHXdRhvmuu7IpmzTcsAWFhYWSYJ9ALcgJu8FJs+fltixjWPy+8DkymS3onVj8sfA5CGJ/SwaQbsD/EsCLAfcgqjcD2D7Own92joq9yCmgLCFicp9iKRwLOIgvUsSEYqF6zSYkVCzlx2Tg5EJOubgfmW6rV4e2sQLZWp6SwOsFVRRJgfWE7n2NTMiYDXxU1LxxwDTlN8IdvErADq+ANyfE67kkuOcqhEAaBfriJbVbJRZ/HY+lIhQ5dm+S3bcm5fyWmyhlIzKgRLPvZrmcgePFr/JZHN+hqyh4ugnS5izC3XP1mPz/3iLKhnNvp4W/kH2QOmm1NG544OmP8sTB18h+9x3Tb9ryaayVaskX8EQJlwpyyRG6J5wXhDOa1AkfkwK+9ftnAuBTS8aE3FZlFbkaj2/fLmzNl7P6Um/Dm3m0PeKYJi58uNCM6bcPDedD6c6crpLngrRunfGfnG+Vq3T9X3/vxL+aCMPYAsLC4vWhhTLhpZCTbWwsLBIL3yGqsj6VQ7hZbGKVjfmnH0cW3qx6TaYlrddGdrKLDQZJJbaR0NXGaLFox0Y36BhWSDXKsmGNxRmORLTDhxWCmAH0Q7xRk1ZrAflYaMeCx4CMhUQQ7h+3KgZE7ZK+zGYC0RoIWA+Flm96WdfMv3ae2kcSwoy8NHm+oafLphsuhlRsYbeSuR0mbT8AZ1IGZVWU/hsNqsORbK9meZPmTgbouk355A94jJa0B3hYTOHvOu9E5u3paTgWKDjiybNxMfif+QLPZj+oPtvpXB2vLiO7EzZHlM6dA0r81FH4dYfc+i13Ej5HJYeT9/M2RX2kXavvQrg4sBSEG0Ts6rhSaUt4mLWmE54a2xdYsc2jFljbgAetpn1mo0UoyDsA9jCwiK9kEI94BR6V7R+XHoocGltslvR+nHpY7X44bnJbkXrxqWPTcOlGsBokXZoZg+4PUIeTnlFXmZiUasYMy/G39E6r5SNmkM6I9NPKvR3qU0U3vpC3FQZIYbrB5wW0+deN14IT1PFIbOUL6lO5Ez8os7mm00r1LK6LqYhERtkDm6o8vCkV1vwVGirYpBOSRVViC4S9ZbBPe9dH9pajLmbx+ltXA8gHzimj/+5Uqes2DKyECrpTdwpndNNkjLRiG7lY3Sc6cdXIH8nU2V3RkVw5nZVZ8jx6kw+a+pH1nJ5O7yxeouX+fV8WpXN2i59OvMcDOUpPU44YJKX1RLnrxRwBs81kObSEf72Y5L4xUvxvJmux25kd7lRHHkX87lV2q2NKEnUZnTAFhYWFq0RKTSutw9gCwuL9IHtAVtYWFgkEen7AO6CUKinBauqyGY27RDxoxI4eDI066QUO5eR4bonylOWIAKqGyTxKulblVJdRDbTj0IXYr2k2QSAge8D2f1hSp+JolL5Yyb7MS2o1Vc4XLOI7F7ix2HPhrRU+XrSYp9AH28QN+JVWS694TnT7TBaZgovR7nTS7x/p7jw6NwgfaGGo3YlTavLhLrUJFpPB7epcwNchUi+M5Au1Tqmc5V6Zin71h81vm3A3K+s42lBa7HzheDVeTylZwGAU4FsPYhRjeJt0DzL/kWm279DM17VyCzWAXMot1SKz+fTQydf05BzAlTjsN9o+nXh3z2WpIpZ+qgKbpIU4hsage0BtyD+dynQ287uJ8StOTDz41rE4NbRlyC2CJ5FQlgdsIWFhUUSkUIURAq9K1o/pkwCJqoSySIGE7cCE5PdiFaOiXN/iYlzH052M1IPQQ84PfMBt0PINT0u66rIJs1j7SOmG6et3BjxuWzCCEDXdJTfaaSZjYJ2lXir5bGODWAKT2PgG6McP+4M1HZDpFbXuVw+4Ic1yzq/o1cDM9BMEL9luvWlcf3veMULph+ophDvmHLPVCpoHGl9NeUxU88sj85dYvqd5otrtx8J4CgAE/wVXXV/ibPmqYZy0XxStsJNlGFUd8NI53kKN1Ac6VhkcpmkY8WP28R6a71Iisj+Jc1xZKtGnbXEHu2wvWYzvD3hjfCeaR0n5vmX0m/JsV0bHkOmdvWYGR+w4x/Ej08J5apwXjPdCijFaD3pw7WKU5e5tPBFskfqPEZwPztIZVgKwsLCIr2QQhSEfQBbWFikD9JbB7wb4bBXS+/QuGIf0Q7PihsNw1cSFTBb3DijYHfSsJwnfiMbb2gjmBSa59zcYI44x/T6kIaUvMo50fTL4SGaPzzv2AFeTCdL5VhFVFwsbeJKzUx4aE0MvqL4yEgp6Xwapl37LVohgqN9xOMwpaP0Du9jUWjmitzqfNKoraGJe41YrvKHl7vLgE4DEA5Ztwi1sIvkR/HiWxeEJivotOhwLisSOaWjVotgDR1vREtx8+ngum1vix8Pw6eSfaccmezG6jPthMdpMDfFJ+RF053Dj9dRFrU4HBvLImOeWXwJ8iU36npxZB5xVGiWVJluh80If4urPT8jm2Nuz5BFauWL4H6JIU9SambL9oBbEKM2IZBxWsTB8HeBHOXDLQyM6pMHU6Rt0SSkdw/YIh6uX41YMb5FDL7/HFB0WrJb0bpx/RnFAC5KdjMsDjLsA9jCwiJ9kN494J0IJU3KvZAmiAqv1v7Q9GLa7VGyNSzy44h1j4rfyMaa2SiIS2Nd0niTZCwlDpjjkLr9x9waF4AJKOorLgG6LQAWMe9rEJIac8tSIq7zUyV+fDT4lOlRo+XsK+hz4Rg5fJRTKyr1zMss3/pI/C4IzYEUqnr0k6Zb0LqJlwDt7wcWBTK0fEmGuI84YOaltYgGaZhYARYTYssqPg7fVpK6iOwT4vgpdxxAaUo+9yzJ+1/xu4FSePbwCOuxD74H4L9YdMlPyZGfLMIBb7o1tLn0lYaXUxv5MsjRjAHMm7McLCa1AEvoBiMSZ50Z2n96KtJtC53v/OdpxWUSA91Qq0krUcNywG0VezoA7fUhZhGD3R2AjMbmnSwaULt3P8xE2BZNQor1gFPoXWFhYWGRXrA9YAsLi/RCCnUrm/kArkfIR642V71H5A2JeuNlCeR1OnIfRjbLav+JAwWPeanW96lm6fTeJP5dR3ywppJsrEh2JuDpVpmEZIr5zfnmFwbw4Wf7+7Jl5ofXkL1O/Ch3wAvEK45403TLHhvaJ1G6QqXZeD+4TFJxHC3ozlCDmik0ZebZ3v+MDHg3SQP1W2Q6tqfa5L1p3e6bTT/S7dYQLx3DAvGFxvs0XvyY22Xet7v4UUUncNpF5YqpIetIy/6RhPMOYS3xNzjNYnuYnCud+0rifAHgOrLj5COpJ+l4IT+orhTHo8geSfytnivj7uR7bK3ptpJ4Xz2eBGNGhnn4nZLSoGugORYtfIpRELYH3II4sxLo+pVkt6L1Y/w6ABcnuxWtG+OLD0X8AoAWkbAP4LaJqcuB/GOS3YrWj2vLYQxCLGJx7fAesDrgA0CK5QNOoaZaWFhYpBea2QN2EOp/5atcc4S4uXwJzd1PceDM1WkAGVfoYXmlVmyPhuqcOHcF8VaSNo9XaQoARib55ft61JGXA5gHLGNRKpPHMZJFIpmZF+sifFdWfmi/uiW0Nc8G7yLnJViop5n4OW6fSrt5P4w8FlqpgfKARGlfAWzyszCeVwZ0fKwzlpUV+WvuMB0NXo8O9FbhgAlM7Z6sK1mXzeR911mmX5dpoc3nQ7lxJiq5fv0C8SPumTW3Mb0entg4w5uTGPkvAFljsKysX7jut5TSUg5ZHZ17lSMzWHHdhROraCpN44bkTC16dEmjvomE2prK+GWyVZtMMFTGfGy7Hi+ecXJBWArCwsLCIgmwk3AWFhYWSUQKEavNfAB3QBjSuybajapZVEoFXU54z6PBL5tuKCEZzEwaXr0ifmcaS0w7aNXmH4fmFsrRp7kLaTjI2fqVqfiUKJdgpPkegD6fwBxu8UZ4SAWYqfiYj6kRv61EO/C2Vc7Du2z0AoSr+ID0UnxAN5tu6Et2RWVod640/aKGl5LestCnpjpmAl5llUBn9KD88AiypyISRLMwuyMCKAzi0Omcr9OCBC3zjcvqqgdMN6Z6OHRWC2xkUAj0keSnkdxGGsxgDN4eQPku4PaQdnCJ+dFtMO3Ap17lkl14Xo9DtDVK/ngqn8zSszO2mH7cEL5e5IapfS+041XtymKJ3yBeo0+Ikf5/5U5SC7YHbGFhkT6wFETbxYA1wFdsCteEmPQugG/1TnYzWjUmHYXYST2LpiF9KQiLeChdBUztmdivrWPqGwCGNF3P0hYxdRBiI+ssEqPt9IAllOkIkshwNZzbTTeWdjFFeJds/Qbi2Zjfa3qgmfCK64j35Qv7ZdONG3UaaWL6C3F1H9mT/f+1HYCaXUBnliltiLABk/fl74iOyKXfdjrS1983/TI6IgJShbfH6aG9lUh6rQs1mWy+qFX5w6G+HJorMcG7/GNb0wHosvcZdO4QdFWEgFxNJXWYS5QqWKsoWRg3KSbS1aAJu5ItJ5XJY1Zblcj26PrJ52N0hPjRcjalVtRCxZhOdp4n96vZux//XfsOsuiG4d2Il/mSlYVdJonjqWRPZdL2AnEchsZQLXM6fFl8qurEJqBAOyw8gowTshyJFHsAp1BnvfWj7BJg3MDEfm0d514CjHswZirKgjDuwU247JJkt8LiYMNSEBYWFumFFOpWNusBvHb7fzFyTpCh35PwTBp4PKYOOQU1+4BxQcKjrPA7Y0qAcyuAjzoDV00yA+ZqARy1CjhyDbAzG3jm3HBdQGhMWQ6gEtiSCzw6ITYrWY93l2B039Go2FyBaYuvojWbAAC3jBqP4b36YPlW4LqgqgWpj2a5QIkDLNkPzNwPk1lpB9y9FOi/A/hnMfAHyo0SKLYuegxANTB/ILCmAGjXHhhJ8plH1wN5e4A5R3l/ioWLgc71wJ3HAnODESEN3Zf5JUBuGw48WQxviOWjUx3wpM+0zDwdeIaCpgAgtxaY5wfbTV8yHys2VvlrvEizntkdGxRW02qAii+a3y/eDcz2x/aT3wcqgyG/f4GXdAFm9fHsS3cAG+thRI2dsgu41T/hE3sDW8o8+9UCwNm8Fzc/+ymuP8MbWI998BU/CTkaKI3xhwPX+tsauRkxQ8uThwDnrfISvE+l3mJwjVxQ4f1tc4DzgjH6nMca/K4oLcUFxx2LDZ9U47K/zzeHvNuAa7oCEzoBa9sBU3iMf5b3b8Z/vCC7ivbANC0UAeCWOmB4JrC8DriuB63wz+Gsj4CSOmDJRmBmkFywg8dTVWzegz7+3flUMXD3cPNm3Qfg148BR/jX3l8po1rw/LlvLpANYM4hwJxAj0ZSxYV796Nzh3a4c9UnmLtGpYAvYFnZUgDAbctvw4JKb0awvsxb22kvMM//ys9PB5b1NRmnnBrgT77m9GejgNVciQRAj2rg9/6pmDYMqAg0fH4QZHH7kBGbvAyorPmb8f2SgjrMGiORjAGcA+UgPv9qCs3sAbcHEITFuv7/UQCuAHpdBHT0RYb9Qs6xYOqrKD4U2LYPyNoIFFGU6adbvGv5THiZAJnu6+gTv7m9gLICYG1nYOUhwK4YEeH18OIyPwFqiKAK+NHnfuM9cN9CWEKcS9u8BGA7gEJ4FVU4VjMXXgPrgUOzgQ60rpcvh55yKdBrOJD3JtDuXwDQFehHGXlmjgU6dwEqyoEKKai0GcAMeHdMFoBAYkkvMNwMOBsA5114mmKic53NQIYfZtuuF7DTDdd17QrvSXQsAEyBlzIy2PEd/v/2wFXZnrl4N5AtNX8+QHjDZiF8+AdtqAXwJFD1BLDzXGB3tnQ+jkBITnYEMvwXkPMxgDoXWP0pUPkp8OJ/PXl5sP2A7NyDUBfrwjtPhCMLgSF1QE0G0IW5Q//7h0wGCgYC29pnAXODtweHOWd4xwAZ3o8zPZwJT7d9KDw6lMu7Bxrhs+FNatTAO7xawOIh/+fyYFafCl60X4B3O235AdDhCf/DgM1+Bx2KdqHwLiB3D9BxF7zjHbR8K1DYE+i1C8jrbl6bgSC52+Xw0kxWIaxy1YVv+S/4+/8GYus91SHsZnzcsHMZfvPatwey+wBPv+ftuqadrQZwr2+/CvPRlpUHZB0CFJwDYB487X2DBr3I34c8IN+vrZQ1GagR7XkkHBz4wP7zfwA7rusm9vJRWlrqlpcHsyyaa4GjAEjd/8ho0+3x0FxFL92tphfGDaAF6pmskUmAge6EcIHz7WraAIpFcGmizTlc/LiLzfliNWCD8gYHcfMjHwLQrhTLymgSCVQYzf2RuQ12496xCgR48o4DJ+aabhWUe6HkRFrxcq3pCBpqNNT4A/BqtenGAQg8yyXRMFVPNO5W8AP5WT8GYuQzAD4BlgUxPZI32MhDwOdDU0ZwR4c7Q5pYJJuncak2IL5m+v2WLhqenxpkuhkXK88kbxI/bhPfBj8Xv65zaMEbQoycMw347ytYxsE7PAmpxRF5dpuvW00tPZA3OJHsq7VRaBR9za7s0xRgwS/f5TDBU3z9+N6ZJ47OTFr4MRKhtLQU5eXlTric4ZaXZ8X7SiQcZ9dq13U/1zx9lgNuQZQdByDzqwn92jrKimAmC7KIQVnJGGCHxn1apBs+wwNYv8o9i6rQ1B5mORqFdv43URGHQpL9xLI7axs1jcqwgDHCcrhDpL0bVkRxPuyLtTvHhKvX7ysbCjQQhA2gYNB4ob48hntG/LjTwr1Skf2wuq7EOFB60FnERDqgd6XcL2+De3qa5YyHm2U2AAAbv0lEQVTsEaRwi6k4McA78GUDANxZE/baNESbwcEIOs69hmzu9WZrF5j75dyNFN7zWLJZpKHXUgHZfyFbzscLdD2O4EjarhqEwqNHj0spK7kQ+PMvTDc699UiIuEiJ4ZeTaVxxm9xVRvRNBrXNw3PhALkAQozRKIYRD++r7gHrNLM3jScMgKp9XkzBY3js1AQnz9Sp6UpgG01nwLYjrzOmhXAgrGtxgX2A3kpNFv9eWNbzf+3d+5hUpRXGn8/hp0wAiPoiCIiIygYUCQCiuIFBbNqlngJirpB2RjXeEtQYzTGGIL3KMbsRll1dUlcjSDGFY1iREWNeAOduDGKC4giSgyCogiMkNo/unvqPW9fatCZ9NT0+T2Pj19NHbq/rqqurnrrPeesAQJQ13yF0GkiPae19Mw0BYyb+UsAv8G8ifcnxlYy42ZuBNYC8wo11nMAAONmXgB0AeaVaqroFCBdV8B+DeI4jlMmWvCngl0RlMdZLWEkGP6W/qwXQ6xUdSV7T34FARJWWcLUdFnWrlgj6ytx/OC153W0oJ0AdkA+BcygeWUxi6ziNGDVRDcUHi8THZAlTPu5tFEdedmeoo02RcLqadxAY/nZHsk6/100VmdT0zZ8GXj/w7j0p/iPjR+RNULVM7mTb0kHEeVor6dyikultCJvs8kl3rdI6dA1UgezFy8YrVNSw42dJffgbUVGh348XhPR/jaaL2BlfX7WoDn+Aynn/WPKw9/7cBs3iMX8+Lh+SI45PlT566c1qTbTtqni7an6+jLqUn4Qi+pqMcmdb1SjSdcVcHpm6jiOk4ifgB3HccpIeqrx+Am4BTlj2Eko0HnTEc4YtiPwuxLSjIMzhg0A7lLfopNMxV4Bdyw8fl3CKJFm6WsoCleJ1CQ05vbGtYVXSLcZ40fmnP9/kbie59IC6771Esiad+bzjt/jG8jPICJ3ZM8edtXDpEGyhietfFhoe4MkMvVamua9piWMRK6grftyPPzgZRv2JC1z/pPKrSN4JWdoqWz+64zBeTwAPEd/l0y4daT582bp8VV5Pe68yzL3Sqkxytruk0X+Dliddj8aa48jYvPDxcP4UUMjNcCuvkmE1JMpb6xL5rgavwdw66PArRRmPiK9L2CPTv5pU0f0tpznxd5ctQG/Symnh8UXFarE8nOcYs2iAZMAi2Op+TTGSSAfxHuTwJ6XmJc7xwRdkSrcBdGCLP/oXSz/6J1yT6PNsxzA8lK/qg6Wf7QRq2vLPYs0krsC/jz//f3xE3ALMuG+72HCfd8p9zTaPBMATBhV7lm0bSbctxS3H5sc5yitdwIOIRweQlgUQlgcQriowPrzQgh/DiG8EkJ4LITQp9DrMH4CdhynHdE6J+AQQhWAGwEcgYzj88QQwkAJexnAsCiKBiMjxv0sabat5AOm3u7qA66ncQkNmNH2KwZ+TsEFXvQZD/uCWR++WeJG8B+W0fhSCeReKrlJbELmA7NgxW5Qrj4FYB2ZNEkHXS9lDWuoshnL13+xYVYrNybUx2wg/+w+Gg8/s1FGh+dNqyUeDFwQ4HFZtyz7/x2QEQyz++Eu+bxcX+C4Yto9YB92s36r3lLSX80uVYGUNVFWkrQINcF6uD4yYyl/EFvEVSzuwt/jXP2HSViPP5r6HqVaxHG1D34MrIXm9qLAsfwdUSM+7/CDYy1WNxk/XeCkPfUh7MELvKEOkECuv1LD5eTUO537Qv/dcrX3AbA4iqKlABBCuBvAUSD7cxRFXMXlOQDfTHrR9DwudBzHaRaf+7RWF0Lg37JboijKpUj1gv2Zfwf5j5mZUwE8XGI9AD8BO47TrvhCNrRVLVEPOITwTQDDYMvwF6SVTsBkVjlGVpEqwnd2evvbbPhFyLUSrbJhoUh96Tzuohfpe1/hMWB9Ntkbj/NrAAyROFNpXdoOU0omW686q4eHtIZSrSyX0bje6DZLbCDfK/4NzYI386ASt+RG6tFSg9nPcf5GZGxP2Vi9XTVJ3px7rtZCLoxeSn6ijbb+9/G45lOJ0/TeHFrcjqyVvCnUtGCmwVrFWfoGLE1lPv35+52O+VedCeo0ZKyAXJVUX57npMeLydBn2UFvljmXuESaN0sLLFlpgwWjMl1JY83or+E8Za7hqaeqYqeuVvMBr4DdBTsh35WHEMIYZAoaHBxFkfZIycOvgFuQsdsAGFBSIXWQ1R7fLvcs2jZjBxyCz5rbhcchWu0E/CKA3UIIuyBz4j0BtoMkQghfQeap0uFRFL2f/xL5uAuiBVm0Hli0qoRr3wEALOoELCpUt8hpYtGqN7HCy0q3GaIo2oRM+adHkLEPzIyi6NUQwpQQwtezYdci8wT+nhBCQwhhdpGXa8KvgFuQ05cAWH1mUzdZpzCn7wKgBzDvd4mhFcvpD/4Eq8YCU6aXeyZpo/VSkaMoegjAQ/K3S2k8Ju8fJdBKqciE6oVkqRpOLa+0iV+z9eGe1JRzQ9yUM3zJhjWSi8U44zQF82kak0UL0lbbeIJyRpSRAIbqAUDC5SZp+UOpsJ25k5GUZ2yk1jt/oL+rK+tIdsaxeKi1OTlHlnTPHcS+1Yd0dL4YWy87pIa1WfbCabunnNjbCRldMfv5+0ryoJGv2UelH5jdW/U01oOJ9nENd87SNHTO9eWvkmryDxYc5lVAPZaPwQNp/KQE9uc72dzDiipsi4zPKUcV+cs2i37NOjpn/w+3YdidrXb8GfXRU8czaCE+EJ7APSZMjugm9NGPKRjA/T8/1top1xd5RTX55RT2QjJreq4r0zNTx3GcRNJVjMc1YMdxnDKRnp8Kx3GcRNJ1BdxKMyX/cUfp1d0vTg75Nv35KBtlZMozaZxv8iJj8W2xBqya1gbSAT8jPXiltIDvSsssdapSxZpbbfY+4pK1AM79AaxhtUSyDL8Ba6ei77GzmHXGI/X+hTeOKbUoDWJ6clt08oPJTjiN9XHy2Taqbs4lBfl91T+anfwlG5DZgEMzy8MPlDjWcFmX1tKFrDHzttCDhHfW12msO5VrK/JhO8CGPUc5xnycjtL9cSSNWb8+TcqSmr2a0YAvOehCYNYxqOKymOSfHVHCi83PVvKkUz4c2WPdUYXuM1GIP4sGzLAnWP3HPI2RvF2M1xewJQ34XzW3g6ufgCuWMW8C6KsNzhxlTCeUrK/gAGP6jiqddeMUIV0nYNeAW5CG7YGGlX9MDqxwGhqBhsQcocqmYeX/oqFrcpyjeD3gimXSPwKT5lxQ7mm0eSZ9CEz6IDmukpk054eYpM2snXZHK5WjHE3jXjbsR7EG3Jna0nReYMPeoPoHpZN7SSequzoeL7OlOGsPje/nNpPOq6noxUrqadkA05k8W0+hEUB1qVugjgfZ5W7U9oUlrp8X/ud5qO37Ehr36k8Lu0rgd+Phid+Px/qF559n2lDVWuOQpTrWbLXrBUvjfaqACdmA9dJWius48utpbQkuOMBzVUMul87mOai3u5jYPrX42/Lxkrc/aDObMovQu6Qix8teAOiQRg19yIVSxIMlHf7CaElQvqo2zwmkVGpz5iewmjtIfPjGsz3jh7QwWgL5oOHjtg6F0Z0NeFNOx3GcspAuDTg9M3Ucx0mkYk/AxV5Kbh0Ctdo9hfKSRYLg7FS+OxdDFewtCM/hdBt271VNwyq6pewsbQY6UyryWpqE3k2zhNkjmwJcrbddeXO6za4aSD4gahv7hjz95jvF4fwe0+WtTEdnthHpbRp9sLrT4vF+t9ow3jbsUtLShXxbX7tzkRUAXskWiHoaALqjKT+3Rmpn9KNt1o/riOoxxuVWWQeR14sa43HgDyK3v93IYkWffY3Y7uppvCcXFfqBTG8Ul1bkwheFbpt1XQegw7ZADWsXlGs+9F75d+StbCDB7GMJG0LjjoNp4bsS2K3I2MJNzwYdTwvnSuAITtoeSmPdFs21m7UP0vNTkQKufBHAjy4r9zTaPFcOBLCrttNymCtH/xTAj8s9jRRSsVfAzv7vA+i9f2JcpbP/tgB6e63FUuzfez/kVwFymkd6TmtuQ2tB5vcA5i/XUlyOMv8DYP5y96GVYv7yZzF/uWdibDnp8gG30rvyy6rRiziOPDbbX2RWHfpVWuCaenltY0bQmH1UkoPZnXSnyxfSCtEL736haVjL1h65YDPJpNk03YtXAXjsUsybOI9Wsg4qdReHnhOPT/z3pmH/Z22YyfG8ncY91XPMeaa8D9TCw4Yh0hW7iP42mLcNN9jZZOPWUTrzCzTWjtjZDscXPwfgrbWYN/GK7AptncXvxSdqqePY+F/xmPdVkCvHwHU6WX/8Nxt3PGnAVNOxVrpM7UmPLpqaGAPA6ONsoLFRldI283Xuix/7KYBPMG/i5bSO/H/vScMF9saxLr2jDUMt519zbyCd304oxGRZ3plKpeI6flqhKcacz83vVUoP/zykS4LwK2DHcZwykZ6fCsdxnETSdQWcnpk6juMkkq4TcIiiqNnBw4YNixYsWJAciJPj4f/cYVdNiYcNZAl+CJ+Pi6M18cKm7k3DZ6Ta1u/RPFhlZEVrP4lj5Srn7m2YCAzZAZjHehyX/ONeMQBWTI/HvVir09Y79FlW0ObXdjD8z7jS5fBpEngLjTkrVjM4D0FhtM/N9jTem8aineYEr1GdAKwE5uXW6+uxMMZzetiGcWukGpY2t7dxYBn1JNaHpf3NwInxmOekZTX5wOD9qzIqW1/5UYA+f2SvbtanO6orgCpgHr8372A1SDxCYz6I37Vh6yiDuTNr2Vo1lWvFDo3f7J5gHwzyLuFdoOUD2HS4Mz+6UKl4ND0XMb2L6lGIYcOGYcGCBSFe7hUtWHBWwdgkQvjRwiiKtDlTq5Ken4oUsOsc4Iajyz2Lts8NjbC995w8bvgU+fWKnXaHn4BbkC4rgSElO4g6ADDkb+A+j04BhuhVt9NM0iVBuAuiBVnTF5hbMB3ZYeZ2AOYWdjk5WeZ2BOaG5DhHcR8wTMWGo+4oGjWEbJx7zrbr+A6VXaEiacGosZQDUVt6gk1oh3BmaZFxMd46CLi8HhjDGuFiGou/1zik+YpH9b2X4iHLqn+VsCU05u49w/tJILeE4QYeasnkW+CzaVyrLXXYZ7wsHg6QIp43Zv53OQCMAMbkdEu9DOAykfTZF8rdxUc03kBvdcSbNi6YkhS81T+0gdymnvXWibpDuCIJe3gX2bD93ojHk+nvepfEtSayB+TlBwDYsyvGTPwyreQdJA8UBpAvmA9WqVq5nL5AnegZTH2J5w4sbtdLmw6W23lvy9fZfOSd6X0xXgJNLyg2vZ8nccV81em6Ak7PTB3HcRJJ1wnYJQjHcZwy0fpdkYM87j6aWl0cHXetqFr4ggkbxV0X2KbzfxDoaQ6lC5et52NnWM8Nd+5dZkM30x1rFesJqouQFYsMfpglYexuYgfU0fo0ncsGDi5hyzLSwqYiY8B6rGhcJ+Uo/zWrYzyAzG7L3UVqyQPWFiideah0J15C24/vuqXRNQ6lips4hsx73ZfYwAtuoIVSHSJYCuCniZL+Xkcf5Gqyx9xiw4yf0Dx8GwSYLsT8+tKWZB+ax7WT4/EVNow1PHP1pS1fjEwSF50cvqMV44avi8cL6eP+Rl6OD+lOc+PxYeqlHMp6DKdyPyKBedoFkZ4r4PTM1HEcJ5F0SRDpmWkK6P8AcPN3yj2Lts/NBwL473LPom1z80IAk69OjHOUAO8JV6Fs9QEwoLn2iwpmQDeYBg5OPgM+AVCn9hWnvdGCJ2DW+1QjZNg+Q41+RN8zchfLTnn1zqnE46C463BvPGWiTqSx9qRlStnSkljVH3igwxCMHUCenjWPxmOZezW9WeNrxV93A1mJakkW+1ZXG7cd2XtMFnDJut5cwlPzUdmsy/tNc2nZisWaqNi8si2THli0BNh3NsbmdEdxVBk9kjRGTdHudyqNSfR+9S82bhltv/r/pBUXyPxM3U/WebtIHB/rOxX5O2C2UxfqBLzNVTaMm0JvzPzvgZ0BLHoUYwccRiv566rvtSIejqR88D4vmSjWfY3sq/vAdEzmfGFR2OmYHkpdoYdOsWF3kD5strpWVJ2wjBZY59bPmztWG+Xv6ZIg3AXRgryzPzD12beSAyucqc++hKlbJ8dVMlMHA1Of1ad1TjKeiOE4jlNG0nNaS89MHcdxEkmXBNGCM+X2JpzruofEsQJLaaFd+tqwrxXT4KStj9GbY4Nr5yetBrw71c3bnfOZrUSGxykTku+Sh9gwVJFmvSzrRz0BQMaBTP7Z7qQ+T+DW5AC6xeJfNWvevW1YNfuKWQcVa+RY0kTvZ2/tRhtnJNxPKX97qKZ7sj58ZpG/A3afcO71r23Ya69k3xOZ6oKnZ/+uXlB+iM2fXbYLp55zWchOtruV+bj1fFgtkTT5ftyCaSSNtd98PY35BVV+ujkevkHPAjQVmZdzmvdmIJNHXMRjDfEwr7k1HvMDAHkvyUyOOVCW+WHI0c/EY32AUsflI++Ph3u+bcLqqcXYi7xCpd1TaIa/4nRjPVXl2oqtQ5pJz0+F4zhOIhV7Bexc/1ug9w0jkgMrnDv2BeBV40pyxxwAU68r9zRSiJ+AK5Yd1wK9t+6cHFjh9N4KLd8Mt53R+xMAW/cs9zRSSMWcgL8ly6Rvrr0sHmvNRNbxqvN6zBOs7TbEwxfE97cPfwTSjPa0YUbjYl1suQ07lI15u1BPnrXif6yNDZD1/5ERI2dsAJ7/UzeM34P9tOx6FJ/tWNYMuV36/TbOlOKjAghHX2nDZsXlD8++s8TLsWzG1Rk3SM+fgbTc/Re0Qtrcr6BSiPxeWrcj68+d0RXAOYdi/B7ZRINdNOGAxe3v0XixDRtJx9w/xPun3xgb1ki1B0xJ0HPk+LuXPu8QqsGw3T02rpaM1W+S2C7lGYxeyt8D2S6bSUKvyj54mNEfQMNuGM8aOBf/YP1b34sswVq/lQ99U5JZi6eYNlG0D+rkmDPf05Pi4WEHm6gDj4i/tx/QZn7mIxOGkcfwEt8m7WUDm05dhYomp+cE7D7gFmTap8C0BY+XexptnmndgGkLSmSeOJg2GJj2cnKck27S81PhOI6TSLuWID5CLDWIB+o9ug2dTH9/0IZx5uDaVfG9SK1ke66kWgF8I6Ldjcebps50P919sg1cT8usCoj7DYHvgUjSqP2xBJJfLVcysQOQ2aTFqvUrbEvjW7ZSdjDy7Xzyhg0j+xY3681rOc138pymPFfiuDRiFdmDNr9v4/jWmyVwqc7YxMkAvvwpYjlltARcSGO+9VThmOSY7UgiknZH1VyO0zz8k5R53sX8VnqMdCLZoVRXaf78fO8vGdBmM+eksy4AngIiUvpYudAGFpJ9XfBtAdvkpPs+tKC9gHtxDU/eP9rMjw8mmsV6kQpJzVtNEkQ1BFOOk3fCDhKYqz2rp7B2fQJ2HMdpy6TrBOwasOM4TplIz09FCpi1LYDjL0yMq3Rm3QPgxoGJcZXMrFeASF0VTjNI1xXwFs50I2LNR/Q4ssVEVMRJkzNZOeYU0eoS9WG7Fl8lsAB5gF1VM4fGnDqrmhb7YnhSohduonzPrK2rDgC2OgbFkZp/myg9teNRtELzM9n2RfPTjUuaI7ueOmv2NmmQK0nO7CouL5bj2KWk6ays9m2k6WknpKZPtQ7osRVPXss9chI4b3fN3qD9w7UVtb0Ob062V733qAmLyJgR+K1KpUrz10B3G782zSnIx61ma2b2UUAdgNefyC/8maOY5quou6zfjrTA1kzNtS/6HEPrVvL+oV8MaRCNuPuYccYdKmGYSeNvfK3IHID4+63HDpCmE7BLEC3I9I3A9AZv9ZDE3UOA6Q16lnSY6QG4L++k6CSTrnKUfgJuQTIn4DuTAyucGX4CTmR6Bz8Bfz78BOw4juM0gy9w2pfUwNVx3yDuIi+Zvp8L9TJaWB9lPbdUY766ImPAalrdivwdQMdr4vHqokX+YHVk2dxmivzERfsz8TxeLzgEgJVkkuas1e9rFif97O5Agtwa+RhcxZL14FJlHFg61bicQp/ZChHibapPmwbRmP2fWleTxGyS5NfMtFG89QIfnB+jWayXt60pctmyXi7qa0gED3yY6fPHf6Jxzg7+PIC38YXZ/SvyB+7mTt5c7KPNDH+Gwpwly5xGTuU8z7FR19BXs4RUXqK6ZHOLh3hTTsdxnDKSntNaembqOI6TSLu2oTmleAgA/vneck+jzfPgnUDVLc1N165MHhoGLDq/3LNwWpstPAFvh7iPjJhQycZaS62/O71gw4opOdpcupi9Un2NAPVpN/9K/b38KtvSuF7ifkXjS2ncx4ZNjwXTpyfHfz7wJ6qlFSmXCdh2SA9TexztgMMCLJV7fPtEG3YFjY2/crq83s9pTLpldylb2Ui7mMsXqATanQ2/bL/WGgrZSXUFgNfIqfyHy2zcmf1pgbT3NUttHLU0X3dbPFZ/Be+RKp6rGMwDz5309ZpSDyFol9YcIuvY38s6vB4iXD6zx3EAMh7qms9sGUyebq8dYeFlPi60aARrwNVc76GZHZhPecUuf0jLlAtwiXz9+PjhqdarjXccL7D+fxSaR7qugN0F0YLcNxy46cWbkwMrnJtWAzctTY6rZG56cTHuGp4c5yhuQ6tYnhgEzHzVJYgkZq4FZq5IjqtkZr76DuYMSo5zlHSdgL/Au06xiz0obfDp+J5q+HE2bMDsePzLEq9ezKqiUoVlpyJjfcVSH/sUGnMi6AwbRsWycxnAmbl1gJVC2L4mdQiH0i3gSupqqw4gPlnRnaJmyHJlSWNk6yFb+qrbaYHKau5rt2513LQZPfhu0JQMBMBXs1w5cxuJG5mtfzj9NQDdgMGZPtLYcK2N+wWV2eRdIN0dQLXveRPpXXcVZ7Ty/HpKidHLSAph/6Te7rMkwTtB9TGeyAm8MQ6WQL79z/nVRmGrvk9idz4WuPSlfkhePo/fS2/dr6fxluvw86TRNTsX+ejW7y+rUefxZZ822Jg4gRaaKzswLkE4juO0O0IIh4cQFoUQFocQLiqw/kshhBnZ9c+HEOqTXtNPwI7jtDNaXoIIIVQBuBHAEcik0pwYQtCUmlMBrImiaFdkHnVfgwT8BOw4Tjui1TTgfQAsjqJoaRRFjQDuRr5GchRiG9UsAKNDCIW6hsazjaKo1HobHMJfkV8E0XEcp1z0iaKoSQEPIcxBfn2B5tIJVr6+JYoyxXVDCOMAHB5F0bezyxMA7BtF0dn03n/KxryTXV6SjVFPbBNbpFbzB3Ucx2lrRFF0eLnnsCW4BOE4jpPMCtjUmp1gzTcmJoTQEZnOAsVq6gPwE7DjOE5zeBHAbiGEXUII1QBOADBbYmYj9rGOA/B4lKDxpscw5ziOUyaiKNoUQjgbma5qVQBuj6Lo1RDCFAALoiiaDeA2AHeEEBYDWI3MSbokW/QQznEcx2k5XIJwHMcpE34CdhzHKRN+AnYcxykTfgJ2HMcpE34CdhzHKRN+AnYcxykTfgJ2HMcpE/8PC//An1QjlMgAAAAASUVORK5CYII=",
            "text/plain": [
              "<Figure size 360x360 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "manual_seed(SEED)\n",
        "hparams = {**reward_hparams, **network_hparams, **train_hparams, **data_hparams}\n",
        "net2 = LCNet(**hparams, reward_fn = None)#DynamicDopamineInjection)\n",
        "net2.fit(dataloader = dataloader, val_loader = val_loader, reward_hparams = reward_hparams, **train_hparams)\n",
        "plot_locally_connected_weights_meh(net2.connections[('input', 'main1')].w,4,1,0,20,11,4)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BtP7yFb0Ujys"
      },
      "source": [
        "## Hyperparameters 3"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nXaKKddtUjyt"
      },
      "outputs": [],
      "source": [
        "network_hparams.update(\n",
        "    {\n",
        "    'n_channels1':4,#10,#30\n",
        "    'filter_size1':11,\n",
        "    'stride1':3,\n",
        "    'NodesType_LC': LIFNodes, #LIF\n",
        "    # 'theta_plus': 0.05,\n",
        "    # 'tc_theta_decay': 1000000,\n",
        "    'nu_LC': (0.0001,0.01),#(0.0001,0.01),(0.0003,0.0004)\n",
        "    'norm_factor_LC': 0.5*11*11,#0.4*11*11,None \n",
        "    'inh_LC': True,\n",
        "    'inh_factor_LC': 100, #0.5 \n",
        "    'save_path':'/content/drive/My Drive/LCNet/LCNet_phase2_baseline_gpu_3.pth',\n",
        "    }\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xswk3R9kUjyt",
        "outputId": "9c26bd5f-26ed-42ae-81c4-e9f4159d33cb"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ]
        }
      ],
      "source": [
        "if network_hparams['save_path'] :\n",
        "    from google.colab import drive\n",
        "    drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 451,
          "referenced_widgets": [
            "be043f1b806342df9eb687b5542c8098",
            "e24c53fc14144c3fb1c7bf948f3a1a3e",
            "dba0bdcdd99541d9a4f3296f57300edd",
            "1dacde3ab9154e0abfbcbfe0bb472dbd",
            "6d86d648b14f4135a19e229e325afd78",
            "45af5da833924cfe912809f9d02f3169",
            "de0d238279eb4f0a98390fee7765dea7",
            "50efec520d4349258d445c597ca8c47c",
            "7e7a79dca32d499e9b0f7d776eaa78f4",
            "3ae10f748aa542acb899e67c0739421a",
            "d15bda73927543ee96d4cdd985bb817d"
          ]
        },
        "id": "9vlXFDyGUjyu",
        "outputId": "94f7a65f-2888-4caf-a149-9521c6d5914f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Previous model not found! Training from the beginning...\n",
            "\n"
          ]
        },
        {
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "be043f1b806342df9eb687b5542c8098",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "  0%|          | 0/2000 [00:00<?, ?it/s]"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "mean_lc_w: 0.50000,std_lc_w: 0.27626,convergence: 0.17369"
          ]
        },
        {
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7f27990016d0>"
            ]
          },
          "execution_count": 28,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 360x360 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "manual_seed(SEED)\n",
        "hparams = {**reward_hparams, **network_hparams, **train_hparams, **data_hparams}\n",
        "net3 = LCNet(**hparams, reward_fn = None)#DynamicDopamineInjection)\n",
        "net3.fit(dataloader = dataloader, val_loader = val_loader, reward_hparams = reward_hparams, **train_hparams)\n",
        "plot_locally_connected_weights_meh(net3.connections[('input', 'main1')].w,4,1,0,20,11,4)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PjIna_WbVue7"
      },
      "source": [
        "## Round Input = True, Intensity = 64"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ILQNZs3LVevT"
      },
      "outputs": [],
      "source": [
        "data_hparams.update(\n",
        "    { \n",
        "    'intensity': 64,\n",
        "    'crop_size': 22,\n",
        "    'round_input': True,\n",
        "    }\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GTUL07dUVrcG"
      },
      "outputs": [],
      "source": [
        "time = 256\n",
        "network_hparams.update(\n",
        "    {\n",
        "     'time': time,\n",
        "    }\n",
        ")\n",
        "dataloader, val_loader = load_datasets(network_hparams, data_hparams, mask, mask_test)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nXEJ2KGEV7v_"
      },
      "source": [
        "## Hyperparameters 4 "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SbxM8eWhV7wB"
      },
      "outputs": [],
      "source": [
        "network_hparams.update(\n",
        "    {\n",
        "    'n_channels1':4,#10,#30\n",
        "    'filter_size1':11,\n",
        "    'stride1':3,\n",
        "    'NodesType_LC': LIFNodes, #LIF\n",
        "    # 'theta_plus': 0.05,\n",
        "    # 'tc_theta_decay': 1000000,\n",
        "    'nu_LC': (0.0001,0.01),#(0.0001,0.01),(0.0003,0.0004)\n",
        "    'norm_factor_LC': 0.3*11*11,#0.4*11*11,None \n",
        "    'inh_LC': True,\n",
        "    'inh_factor_LC': 100, #0.5 \n",
        "    'save_path':'/content/drive/My Drive/LCNet/LCNet_phase2_baseline_gpu_4.pth',\n",
        "     'load_path':None,\n",
        "    }\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iBCgajW1V7wC",
        "outputId": "088dd114-c280-417c-e17e-4575fe36c542"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ]
        }
      ],
      "source": [
        "if network_hparams['save_path'] :\n",
        "    from google.colab import drive\n",
        "    drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 451,
          "referenced_widgets": [
            "d56fb3d995c14fdaba94fe570b2ba300",
            "8c43506c9549469ab6000914549da391",
            "f824082e26264ed7bdd02b8cde3db448",
            "6c7fb5c3225244d5b576a9c9c0ddc0a7",
            "5546b546b04d4d6183fc8d698149ac1a",
            "16aa028da51a458ba2ef3c7f0837580f",
            "dcf5e3d678f04cc1ad77b6bb1471f9d2",
            "76c10d065aaa4e4597b926ca58620aca",
            "38fc9e0688b0474a930ff25309285fa4",
            "b30a3c61272944c7ab5d46cd48384d0a",
            "580786b04e024b4db86af912532f7177"
          ]
        },
        "id": "hKTGzdUhV7wE",
        "outputId": "0d4fff36-b33d-43b4-e95f-e91f3400bec5"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Previous model not found! Training from the beginning...\n",
            "\n"
          ]
        },
        {
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "d56fb3d995c14fdaba94fe570b2ba300",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "  0%|          | 0/2000 [00:00<?, ?it/s]"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "mean_lc_w: 0.30000,std_lc_w: 0.21645,convergence: 0.16315"
          ]
        },
        {
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7f2798dc1f10>"
            ]
          },
          "execution_count": 48,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 360x360 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "manual_seed(SEED)\n",
        "hparams = {**reward_hparams, **network_hparams, **train_hparams, **data_hparams}\n",
        "net4 = LCNet(**hparams, reward_fn = None)#DynamicDopamineInjection)\n",
        "net4.fit(dataloader = dataloader, val_loader = val_loader, reward_hparams = reward_hparams, **train_hparams)\n",
        "plot_locally_connected_weights_meh(net4.connections[('input', 'main1')].w,4,1,0,22,11,4)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VwIeNRpOV7wF"
      },
      "source": [
        "## Hyperparameters 5 "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vP8cu84jV7wF"
      },
      "outputs": [],
      "source": [
        "network_hparams.update(\n",
        "    {\n",
        "    'n_channels1':4,#10,#30\n",
        "    'filter_size1':11,\n",
        "    'stride1':3,\n",
        "    'NodesType_LC': AdaptiveLIFNodes, #LIF\n",
        "    'theta_plus': 0.05,\n",
        "    'tc_theta_decay': 1000000,\n",
        "    'nu_LC': (0.0001,0.01),#(0.0001,0.01),(0.0003,0.0004)\n",
        "    'norm_factor_LC': 0.4*11*11,#0.4*11*11,None \n",
        "    'inh_LC': True,\n",
        "    'inh_factor_LC': 100, #0.5 \n",
        "    'save_path':'/content/drive/My Drive/LCNet/LCNet_phase2_baseline_gpu_5.pth',\n",
        "    'normal_init': True,\n",
        "    'mu' : 0.8,\n",
        "    'std' : 0.05, \n",
        "    }\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L6XvfSOVV7wG",
        "outputId": "b04175bb-11bd-46ff-e94d-77907ea12eb0"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ]
        }
      ],
      "source": [
        "if network_hparams['save_path'] :\n",
        "    from google.colab import drive\n",
        "    drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 451,
          "referenced_widgets": [
            "b9bd75be28d3491c8fa98f96e3a08798",
            "dc0d947061044a4ea09315f81e4f6374",
            "1f7d3855422046d6ab7f567767ac0df3",
            "a0363f0e686945938115bcb5b49fe8bf",
            "ad3842f9aa7448338377fb19f319940b",
            "44e9dfec4f844c85bd9149a88f4fe98f",
            "181bdea1690941538f1bf84b764bceff",
            "8ac9ce566d704908879830d677e6f2ea",
            "9861ea7a35f2472fa1e601f47c1b320b",
            "acfd9a91285f4fd0b4fd95cfa5eaf1c0",
            "b38fdbda3aed4b78b423bf38d45cc590"
          ]
        },
        "id": "peR7oscuV7wK",
        "outputId": "059f3872-470e-4d56-987b-95e92e10e589"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Previous model not found! Training from the beginning...\n",
            "\n"
          ]
        },
        {
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "b9bd75be28d3491c8fa98f96e3a08798",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "  0%|          | 0/2000 [00:00<?, ?it/s]"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "mean_lc_w: 0.40000,std_lc_w: 0.31153,convergence: 0.14296"
          ]
        },
        {
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7f2798c45c50>"
            ]
          },
          "execution_count": 68,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 360x360 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "manual_seed(SEED)\n",
        "hparams = {**reward_hparams, **network_hparams, **train_hparams, **data_hparams}\n",
        "net5 = LCNet(**hparams, reward_fn = None)#DynamicDopamineInjection)\n",
        "net5.fit(dataloader = dataloader, val_loader = val_loader, reward_hparams = reward_hparams, **train_hparams)\n",
        "plot_locally_connected_weights_meh(net5.connections[('input', 'main1')].w,4,1,0,20,11,4)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vgXughf6V7wL"
      },
      "source": [
        "## Hyperparameters 6 "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OdPwz4a4V7wL"
      },
      "outputs": [],
      "source": [
        "network_hparams.update(\n",
        "    {\n",
        "    'n_channels1':4,#10,#30\n",
        "    'filter_size1':11,\n",
        "    'stride1':3,\n",
        "    'NodesType_LC': AdaptiveLIFNodes, #LIF\n",
        "    'theta_plus': 0.05,\n",
        "    'tc_theta_decay': 1000000,\n",
        "    'nu_LC': (0.0001,0.01),#(0.0001,0.01),(0.0003,0.0004)\n",
        "    'norm_factor_LC': 0.5*11*11,#0.4*11*11,None \n",
        "    'inh_LC': True,\n",
        "    'inh_factor_LC': 100, #0.5 \n",
        "    'save_path':'/content/drive/My Drive/LCNet/LCNet_phase2_baseline_gpu_6.pth',\n",
        "    'normal_init': True,\n",
        "    'mu' : 0.8,\n",
        "    'std' : 0.05, \n",
        "    }\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_DwhVWMMWVLp",
        "outputId": "3e70a616-2fc6-4a35-e50e-03abdf0bdf06"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ]
        }
      ],
      "source": [
        "if network_hparams['save_path'] :\n",
        "    from google.colab import drive\n",
        "    drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 436,
          "referenced_widgets": [
            "6428fed86b0c403f859852c42cea4ece",
            "e8556ccb1e654b70b46f2b13635050f1",
            "7751323bae314fc49f1aca27cbe2df96",
            "b5ee3e10f5054da59f99cc0dc82d0b12",
            "0671429992f340cbb8795a5d6d791ab8",
            "07fc2da7756e4c29b2d50d9813c19410",
            "dce5647d08994f95a5dbaa511c3e888d",
            "0dafa721140a4e97b365b0f7c9eebe89",
            "9ae483cc204a43e78b729d967e248319",
            "c36d888fddae4b8a8ad80d50dc22d559",
            "298f8a00c7f94112a0e367f56694b638"
          ]
        },
        "id": "oqVNhh4FWVLr",
        "outputId": "7c6ff930-b948-47b2-e5f2-5764a3cfd816"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Previous model not found! Training from the beginning...\n",
            "\n"
          ]
        },
        {
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "6428fed86b0c403f859852c42cea4ece",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "  0%|          | 0/2000 [00:00<?, ?it/s]"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "mean_lc_w: 0.50000,std_lc_w: 0.34163,convergence: 0.13331"
          ]
        },
        {
          "ename": "KeyboardInterrupt",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-72-1bf4b9f49d6e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mhparams\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mreward_hparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mnetwork_hparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mtrain_hparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mdata_hparams\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mnet6\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mLCNet\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mhparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreward_fn\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;31m#DynamicDopamineInjection)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mnet6\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdataloader\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdataloader\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval_loader\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mval_loader\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreward_hparams\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mreward_hparams\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mtrain_hparams\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      5\u001b[0m \u001b[0mplot_locally_connected_weights_meh\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnet6\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconnections\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'input'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'main1'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mw\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m20\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m11\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-45-1c3d97492937>\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, dataloader, val_loader, reward_hparams, hparams, online_validate, n_train, n_test, n_val, val_interval, running_window_length, verbose)\u001b[0m\n\u001b[1;32m    353\u001b[0m                     \u001b[0mtrue_label\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlabel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitem\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    354\u001b[0m                     \u001b[0mdopaminergic_layers\u001b[0m\u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;31m#self.dopaminergic_layers,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 355\u001b[0;31m                     \u001b[0mclamp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclamp\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    356\u001b[0m                      )\n\u001b[1;32m    357\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/bindsnet/network/network.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, inputs, time, one_step, **kwargs)\u001b[0m\n\u001b[1;32m    394\u001b[0m             \u001b[0mcurrent_inputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    395\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mone_step\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 396\u001b[0;31m                 \u001b[0mcurrent_inputs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupdate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_inputs\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[1;32m    397\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    398\u001b[0m             \u001b[0;32mfor\u001b[0m \u001b[0ml\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlayers\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.7/dist-packages/bindsnet/network/network.py\u001b[0m in \u001b[0;36m_get_inputs\u001b[0;34m(self, layers)\u001b[0m\n\u001b[1;32m    260\u001b[0m                     \u001b[0minputs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconnections\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcompute_window\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msource\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    261\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--> 262\u001b[0;31m                     \u001b[0minputs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconnections\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcompute\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msource\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0ms\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    263\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    264\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0minputs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/bindsnet/network/topology.py\u001b[0m in \u001b[0;36mcompute\u001b[0;34m(self, s)\u001b[0m\n\u001b[1;32m    192\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[1;32m    193\u001b[0m             \u001b[0mpost\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mview\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m@\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mw\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 194\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mpost\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mview\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtarget\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\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    195\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    196\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcompute_window\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTensor\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mtorch\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;31mKeyboardInterrupt\u001b[0m: "
          ]
        }
      ],
      "source": [
        "manual_seed(SEED)\n",
        "hparams = {**reward_hparams, **network_hparams, **train_hparams, **data_hparams}\n",
        "net6 = LCNet(**hparams, reward_fn = None)#DynamicDopamineInjection)\n",
        "net6.fit(dataloader = dataloader, val_loader = val_loader, reward_hparams = reward_hparams, **train_hparams)\n",
        "plot_locally_connected_weights_meh(net6.connections[('input', 'main1')].w,4,1,0,20,11,4)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SokdidkrV2Z5"
      },
      "source": [
        "# Old Training"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RNJURL35NEcu"
      },
      "source": [
        "Plots : \n",
        "1. plot_ET (STDP and MSTDPEt) [Check Bindsnet]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7TvFWXQQQj45"
      },
      "source": [
        "## Hyperparameters 1 "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9dHzMUhYLIWh"
      },
      "outputs": [],
      "source": [
        "network_hparams.update(\n",
        "    {\n",
        "    'n_channels1':4,#10,#30\n",
        "    'filter_size1':7,#11 #9\n",
        "    'stride1':2,#3, #3\n",
        "    'NodesType_LC': AdaptiveLIFNodes, #LIF\n",
        "    'theta_plus': 0.05,\n",
        "    'tc_theta_decay': 1000000,\n",
        "    'nu_LC': (0.0001,0.01),#(0.0001,0.01),(0.0003,0.0004)\n",
        "    'norm_factor_LC': 0.2*7*7,#0.4*7*7,None \n",
        "    'inh_LC': True,\n",
        "    'inh_factor_LC': 100, #0.5 \n",
        "    'save_path':'/content/drive/My Drive/LCNet/LCNet_phase2_baseline_gpu_1.pth',\n",
        "    }\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Venb2KhSYrT_",
        "outputId": "08b628a9-83c3-47b5-d8b6-347994815392"
      },
      "outputs": [
        {
          "ename": "KeyboardInterrupt",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/ipykernel/kernelbase.py\u001b[0m in \u001b[0;36m_input_request\u001b[0;34m(self, prompt, ident, parent, password)\u001b[0m\n\u001b[1;32m    728\u001b[0m             \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 729\u001b[0;31m                 \u001b[0mident\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreply\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msession\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrecv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstdin_socket\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\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    730\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0mException\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.7/dist-packages/jupyter_client/session.py\u001b[0m in \u001b[0;36mrecv\u001b[0;34m(self, socket, mode, content, copy)\u001b[0m\n\u001b[1;32m    802\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 803\u001b[0;31m             \u001b[0mmsg_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msocket\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrecv_multipart\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmode\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcopy\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcopy\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    804\u001b[0m         \u001b[0;32mexcept\u001b[0m \u001b[0mzmq\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mZMQError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\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.7/dist-packages/zmq/sugar/socket.py\u001b[0m in \u001b[0;36mrecv_multipart\u001b[0;34m(self, flags, copy, track)\u001b[0m\n\u001b[1;32m    618\u001b[0m         \"\"\"\n\u001b[0;32m--> 619\u001b[0;31m         \u001b[0mparts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrecv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mflags\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcopy\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcopy\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrack\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtrack\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[1;32m    620\u001b[0m         \u001b[0;31m# have first part already, only loop while more to receive\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32mzmq/backend/cython/socket.pyx\u001b[0m in \u001b[0;36mzmq.backend.cython.socket.Socket.recv\u001b[0;34m()\u001b[0m\n",
            "\u001b[0;32mzmq/backend/cython/socket.pyx\u001b[0m in \u001b[0;36mzmq.backend.cython.socket.Socket.recv\u001b[0;34m()\u001b[0m\n",
            "\u001b[0;32mzmq/backend/cython/socket.pyx\u001b[0m in \u001b[0;36mzmq.backend.cython.socket._recv_copy\u001b[0;34m()\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/zmq/backend/cython/checkrc.pxd\u001b[0m in \u001b[0;36mzmq.backend.cython.checkrc._check_rc\u001b[0;34m()\u001b[0m\n",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m: ",
            "\nDuring handling of the above exception, another exception occurred:\n",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-19-da33ce36d418>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mnetwork_hparams\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'save_path'\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      2\u001b[0m     \u001b[0;32mfrom\u001b[0m \u001b[0mgoogle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolab\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mdrive\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m     \u001b[0mdrive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmount\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'/content/drive'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/google/colab/drive.py\u001b[0m in \u001b[0;36mmount\u001b[0;34m(mountpoint, force_remount, timeout_ms, use_metadata_server)\u001b[0m\n\u001b[1;32m    262\u001b[0m       \u001b[0;32mwith\u001b[0m \u001b[0m_output\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0muse_tags\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'dfs-auth-dance'\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    263\u001b[0m         \u001b[0;32mwith\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfifo\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'w'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mfifo_file\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 264\u001b[0;31m           \u001b[0mfifo_file\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwrite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mget_code\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mauth_prompt\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'\\n'\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    265\u001b[0m       \u001b[0mwrote_to_fifo\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    266\u001b[0m     \u001b[0;32melif\u001b[0m \u001b[0mcase\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m5\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.7/dist-packages/ipykernel/kernelbase.py\u001b[0m in \u001b[0;36mraw_input\u001b[0;34m(self, prompt)\u001b[0m\n\u001b[1;32m    702\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_parent_ident\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    703\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_parent_header\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 704\u001b[0;31m             \u001b[0mpassword\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\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    705\u001b[0m         )\n\u001b[1;32m    706\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/ipykernel/kernelbase.py\u001b[0m in \u001b[0;36m_input_request\u001b[0;34m(self, prompt, ident, parent, password)\u001b[0m\n\u001b[1;32m    732\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0mKeyboardInterrupt\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    733\u001b[0m                 \u001b[0;31m# re-raise KeyboardInterrupt, to truncate traceback\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 734\u001b[0;31m                 \u001b[0;32mraise\u001b[0m \u001b[0mKeyboardInterrupt\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    735\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[1;32m    736\u001b[0m                 \u001b[0;32mbreak\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
          ]
        }
      ],
      "source": [
        "if network_hparams['save_path'] :\n",
        "    from google.colab import drive\n",
        "    drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "IavVVHrvYVoI"
      },
      "outputs": [],
      "source": [
        "manual_seed(SEED)\n",
        "hparams = {**reward_hparams, **network_hparams, **train_hparams, **data_hparams}\n",
        "if WANDB:\n",
        "    wandb.init(project='DeepBioLCNet', entity='singularbrain', config=network_hparams)\n",
        "net = LCNet(**hparams, reward_fn = None)#DynamicDopamineInjection)\n",
        "net.fit(dataloader = dataloader, val_loader = val_loader, reward_hparams = reward_hparams, **train_hparams)\n",
        "plot_locally_connected_weights_meh(net.connections[('input', 'main1')].w,4,1,0,20,7,7)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x2C4tNhoQsxG"
      },
      "source": [
        "## Hyperparameters 2 "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZF68G-gfQsxH"
      },
      "outputs": [],
      "source": [
        "network_hparams.update(\n",
        "    {\n",
        "    'n_channels1':4,#10,#30\n",
        "    'filter_size1':7,#11 #9\n",
        "    'stride1':2,#3, #3\n",
        "    'NodesType_LC': AdaptiveLIFNodes, #LIF\n",
        "    'theta_plus': 0.05,\n",
        "    'tc_theta_decay': 1000000,\n",
        "    'nu_LC': (0.0001,0.01),#(0.0001,0.01),(0.0003,0.0004)\n",
        "    'norm_factor_LC': 0.2*7*7,#0.4*7*7,None \n",
        "    'inh_LC': True,\n",
        "    'inh_factor_LC': 0.5,#100, #0.5 \n",
        "    'save_path':'/content/drive/My Drive/LCNet/LCNet_phase2_baseline_gpu_2.pth',\n",
        "    }\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Q3vJWNbJQsxH"
      },
      "outputs": [],
      "source": [
        "if network_hparams['save_path'] :\n",
        "    from google.colab import drive\n",
        "    drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dYFUnDBJQsxI"
      },
      "outputs": [],
      "source": [
        "manual_seed(SEED)\n",
        "hparams = {**reward_hparams, **network_hparams, **train_hparams, **data_hparams}\n",
        "if WANDB:\n",
        "    wandb.init(project='DeepBioLCNet', entity='singularbrain', config=network_hparams)\n",
        "net = LCNet(**hparams, reward_fn = None)#DynamicDopamineInjection)\n",
        "net.fit(dataloader = dataloader, val_loader = val_loader, reward_hparams = reward_hparams, **train_hparams)\n",
        "plot_locally_connected_weights_meh(net.connections[('input', 'main1')].w,4,1,0,20,7,7)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Lt_ZWi1MRJGp"
      },
      "source": [
        "## Hyperparameters 3 "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dHyEQutxRJGp"
      },
      "outputs": [],
      "source": [
        "network_hparams.update(\n",
        "    {\n",
        "    'n_channels1':4,#10,#30\n",
        "    'filter_size1':7,#11 #9\n",
        "    'stride1':2,#3, #3\n",
        "    'NodesType_LC': LIFNodes,#AdaptiveLIFNodes, #LIF\n",
        "    'theta_plus': 0.05,\n",
        "    'tc_theta_decay': 1000000,\n",
        "    'nu_LC': (0.0001,0.01),#(0.0001,0.01),(0.0003,0.0004)\n",
        "    'norm_factor_LC': 0.2*7*7,#0.4*7*7,None \n",
        "    'inh_LC': True,\n",
        "    'inh_factor_LC': 100,#100, #0.5 \n",
        "    'save_path':'/content/drive/My Drive/LCNet/LCNet_phase2_baseline_gpu_3.pth',\n",
        "    'load_path':None,\n",
        "    }\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "52m8yEpaRJGq"
      },
      "outputs": [],
      "source": [
        "if network_hparams['save_path'] :\n",
        "    from google.colab import drive\n",
        "    drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PkACp_XZRJGq"
      },
      "outputs": [],
      "source": [
        "manual_seed(SEED)\n",
        "hparams = {**reward_hparams, **network_hparams, **train_hparams, **data_hparams}\n",
        "net = LCNet(**hparams, reward_fn = None)#DynamicDopamineInjection)\n",
        "net.fit(dataloader = dataloader, val_loader = val_loader, reward_hparams = reward_hparams, **train_hparams)\n",
        "plot_locally_connected_weights_meh(net.connections[('input', 'main1')].w,4,1,0,20,7,7)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q-vYLsQrWtaj"
      },
      "source": [
        "## Hyperparameters 4"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9m_upmseWtar"
      },
      "outputs": [],
      "source": [
        "network_hparams.update(\n",
        "    {\n",
        "    'n_channels1':4,#10,#30\n",
        "    'filter_size1':7,#11 #9\n",
        "    'stride1':2,#3, #3\n",
        "    'NodesType_LC': LIFNodes,#AdaptiveLIFNodes, #LIF\n",
        "    'theta_plus': 0.05,\n",
        "    'tc_theta_decay': 1000000,\n",
        "    'nu_LC': (0.0001,0.01),#(0.0001,0.01),(0.0003,0.0004)\n",
        "    'norm_factor_LC': 0.2*7*7,#0.4*7*7,None \n",
        "    'inh_LC': True,\n",
        "    'inh_factor_LC': 0.5,#100, #0.5 \n",
        "    'save_path':'/content/drive/My Drive/LCNet/LCNet_phase2_baseline_gpu_4.pth',\n",
        "    }\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "co4CwnD4Wtar"
      },
      "outputs": [],
      "source": [
        "if network_hparams['save_path'] :\n",
        "    from google.colab import drive\n",
        "    drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DIBU8jcWWtas"
      },
      "outputs": [],
      "source": [
        "manual_seed(SEED)\n",
        "hparams = {**reward_hparams, **network_hparams, **train_hparams, **data_hparams}\n",
        "net = LCNet(**hparams, reward_fn = None)#DynamicDopamineInjection)\n",
        "net.fit(dataloader = dataloader, val_loader = val_loader, reward_hparams = reward_hparams, **train_hparams)\n",
        "plot_locally_connected_weights_meh(net.connections[('input', 'main1')].w,4,1,0,20,7,7)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fCiZRcdNXWQl"
      },
      "source": [
        "## Hyperparameters 5 "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "W68jZ50YXWQl"
      },
      "outputs": [],
      "source": [
        "network_hparams.update(\n",
        "    {\n",
        "    'n_channels1':4,#10,#30\n",
        "    'filter_size1':7,#11 #9\n",
        "    'stride1':2,#3, #3\n",
        "    'NodesType_LC': AdaptiveLIFNodes, #LIF\n",
        "    'theta_plus': 0.05,\n",
        "    'tc_theta_decay': 1000000,\n",
        "    'nu_LC': (0.0001,0.01),#(0.0001,0.01),(0.0003,0.0004)\n",
        "    'norm_factor_LC': 0.4*7*7,#0.4*7*7,None \n",
        "    'inh_LC': True,\n",
        "    'inh_factor_LC': 100, #0.5 \n",
        "    'save_path':'/content/drive/My Drive/LCNet/LCNet_phase2_baseline_gpu_5.pth',\n",
        "    }\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-MO_qUoeXWQm"
      },
      "outputs": [],
      "source": [
        "if network_hparams['save_path'] :\n",
        "    from google.colab import drive\n",
        "    drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lTdONZ73XWQm"
      },
      "outputs": [],
      "source": [
        "manual_seed(SEED)\n",
        "hparams = {**reward_hparams, **network_hparams, **train_hparams, **data_hparams}\n",
        "net = LCNet(**hparams, reward_fn = None)#DynamicDopamineInjection)\n",
        "net.fit(dataloader = dataloader, val_loader = val_loader, reward_hparams = reward_hparams, **train_hparams)\n",
        "plot_locally_connected_weights_meh(net.connections[('input', 'main1')].w,4,1,0,20,7,7)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9wTzREzpXWQm"
      },
      "source": [
        "## Hyperparameters 6 "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zjEJ6MZTXWQm"
      },
      "outputs": [],
      "source": [
        "network_hparams.update(\n",
        "    {\n",
        "    'n_channels1':4,#10,#30\n",
        "    'filter_size1':7,#11 #9\n",
        "    'stride1':2,#3, #3\n",
        "    'NodesType_LC': AdaptiveLIFNodes, #LIF\n",
        "    'theta_plus': 0.05,\n",
        "    'tc_theta_decay': 1000000,\n",
        "    'nu_LC': (0.0001,0.01),#(0.0001,0.01),(0.0003,0.0004)\n",
        "    'norm_factor_LC': 0.4*7*7,#0.4*7*7,None \n",
        "    'inh_LC': True,\n",
        "    'inh_factor_LC': 0.5,#100, #0.5 \n",
        "    'save_path':'/content/drive/My Drive/LCNet/LCNet_phase2_baseline_gpu_6.pth',\n",
        "    }\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Im__jyOLXWQm"
      },
      "outputs": [],
      "source": [
        "if network_hparams['save_path'] :\n",
        "    from google.colab import drive\n",
        "    drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2HpURNWxXWQm"
      },
      "outputs": [],
      "source": [
        "manual_seed(SEED)\n",
        "hparams = {**reward_hparams, **network_hparams, **train_hparams, **data_hparams}\n",
        "net = LCNet(**hparams, reward_fn = None)#DynamicDopamineInjection)\n",
        "net.fit(dataloader = dataloader, val_loader = val_loader, reward_hparams = reward_hparams, **train_hparams)\n",
        "plot_locally_connected_weights_meh(net.connections[('input', 'main1')].w,4,1,0,20,7,7)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FDY23koZXWQn"
      },
      "source": [
        "## Hyperparameters 7 "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UyM4eHI7XWQn"
      },
      "outputs": [],
      "source": [
        "network_hparams.update(\n",
        "    {\n",
        "    'n_channels1':4,#10,#30\n",
        "    'filter_size1':7,#11 #9\n",
        "    'stride1':2,#3, #3\n",
        "    'NodesType_LC': LIFNodes,#AdaptiveLIFNodes, #LIF\n",
        "    'theta_plus': 0.05,\n",
        "    'tc_theta_decay': 1000000,\n",
        "    'nu_LC': (0.0001,0.01),#(0.0001,0.01),(0.0003,0.0004)\n",
        "    'norm_factor_LC': 0.4*7*7,#0.4*7*7,None \n",
        "    'inh_LC': True,\n",
        "    'inh_factor_LC': 100,#100, #0.5 \n",
        "    'save_path':'/content/drive/My Drive/LCNet/LCNet_phase2_baseline_gpu_7.pth',\n",
        "    }\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gvgMynHWXWQn"
      },
      "outputs": [],
      "source": [
        "if network_hparams['save_path'] :\n",
        "    from google.colab import drive\n",
        "    drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Cd0mzq9KXWQn"
      },
      "outputs": [],
      "source": [
        "manual_seed(SEED)\n",
        "hparams = {**reward_hparams, **network_hparams, **train_hparams, **data_hparams}\n",
        "net = LCNet(**hparams, reward_fn = None)#DynamicDopamineInjection)\n",
        "net.fit(dataloader = dataloader, val_loader = val_loader, reward_hparams = reward_hparams, **train_hparams)\n",
        "plot_locally_connected_weights_meh(net.connections[('input', 'main1')].w,4,1,0,20,7,7)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JnDegAs2XWQn"
      },
      "source": [
        "## Hyperparameters 8"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wEqitEs-XWQn"
      },
      "outputs": [],
      "source": [
        "network_hparams.update(\n",
        "    {\n",
        "    'n_channels1':4,#10,#30\n",
        "    'filter_size1':7,#11 #9\n",
        "    'stride1':2,#3, #3\n",
        "    'NodesType_LC': LIFNodes,#AdaptiveLIFNodes, #LIF\n",
        "    'theta_plus': 0.05,\n",
        "    'tc_theta_decay': 1000000,\n",
        "    'nu_LC': (0.0001,0.01),#(0.0001,0.01),(0.0003,0.0004)\n",
        "    'norm_factor_LC': 0.4*7*7,#0.4*7*7,None \n",
        "    'inh_LC': True,\n",
        "    'inh_factor_LC': 0.5,#100, #0.5 \n",
        "    'save_path':'/content/drive/My Drive/LCNet/LCNet_phase2_baseline_gpu_8.pth',\n",
        "    }\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4ya72eDDXWQn"
      },
      "outputs": [],
      "source": [
        "if network_hparams['save_path'] :\n",
        "    from google.colab import drive\n",
        "    drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Fk8J8oVQXWQn"
      },
      "outputs": [],
      "source": [
        "manual_seed(SEED)\n",
        "hparams = {**reward_hparams, **network_hparams, **train_hparams, **data_hparams}\n",
        "net = LCNet(**hparams, reward_fn = None)#DynamicDopamineInjection)\n",
        "net.fit(dataloader = dataloader, val_loader = val_loader, reward_hparams = reward_hparams, **train_hparams)\n",
        "plot_locally_connected_weights_meh(net.connections[('input', 'main1')].w,4,1,0,20,7,7)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "--fSINpll7Dx"
      },
      "source": [
        "## Hyperparameters 9 "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XftE2u14l7Dx"
      },
      "outputs": [],
      "source": [
        "network_hparams.update(\n",
        "    {\n",
        "    'n_channels1':4,#10,#30\n",
        "    'filter_size1':7,#11 #9\n",
        "    'stride1':2,#3, #3\n",
        "    'NodesType_LC': AdaptiveLIFNodes, #LIF\n",
        "    'theta_plus': 0.05,\n",
        "    'tc_theta_decay': 1000000,\n",
        "    'nu_LC': (0.0001,0.01),#(0.0001,0.01),(0.0003,0.0004)\n",
        "    'norm_factor_LC': 0.2*7*7,#0.4*7*7,None \n",
        "    'inh_LC': True,\n",
        "    'inh_factor_LC': 1,#100, #0.5 \n",
        "    'save_path':'/content/drive/My Drive/LCNet/LCNet_phase2_baseline_gpu_9.pth',\n",
        "    }\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kyqVdPMol7Dy"
      },
      "outputs": [],
      "source": [
        "if network_hparams['save_path'] :\n",
        "    from google.colab import drive\n",
        "    drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UHVSyrfql7Dz"
      },
      "outputs": [],
      "source": [
        "manual_seed(SEED)\n",
        "hparams = {**reward_hparams, **network_hparams, **train_hparams, **data_hparams}\n",
        "net = LCNet(**hparams, reward_fn = None)#DynamicDopamineInjection)\n",
        "net.fit(dataloader = dataloader, val_loader = val_loader, reward_hparams = reward_hparams, **train_hparams)\n",
        "plot_locally_connected_weights_meh(net.connections[('input', 'main1')].w,4,1,0,20,7,7)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JEZZvNWjl7Dz"
      },
      "source": [
        "## Hyperparameters 10"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "15ob29h0l7Dz"
      },
      "outputs": [],
      "source": [
        "network_hparams.update(\n",
        "    {\n",
        "    'n_channels1':4,#10,#30\n",
        "    'filter_size1':7,#11 #9\n",
        "    'stride1':2,#3, #3\n",
        "    'NodesType_LC': LIFNodes,#AdaptiveLIFNodes, #LIF\n",
        "    'theta_plus': 0.05,\n",
        "    'tc_theta_decay': 1000000,\n",
        "    'nu_LC': (0.0001,0.01),#(0.0001,0.01),(0.0003,0.0004)\n",
        "    'norm_factor_LC': 0.2*7*7,#0.4*7*7,None \n",
        "    'inh_LC': True,\n",
        "    'inh_factor_LC': 1,#100, #0.5 \n",
        "    'save_path':'/content/drive/My Drive/LCNet/LCNet_phase2_baseline_gpu_10.pth',\n",
        "    }\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Q0u5E46hl7Dz"
      },
      "outputs": [],
      "source": [
        "if network_hparams['save_path'] :\n",
        "    from google.colab import drive\n",
        "    drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "L-nIfCQTl7D0"
      },
      "outputs": [],
      "source": [
        "manual_seed(SEED)\n",
        "hparams = {**reward_hparams, **network_hparams, **train_hparams, **data_hparams}\n",
        "net = LCNet(**hparams, reward_fn = None)#DynamicDopamineInjection)\n",
        "net.fit(dataloader = dataloader, val_loader = val_loader, reward_hparams = reward_hparams, **train_hparams)\n",
        "plot_locally_connected_weights_meh(net.connections[('input', 'main1')].w,4,1,0,20,7,7)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kHDF_59ql7D0"
      },
      "source": [
        "## Hyperparameters 11 "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DtpHR66ml7D0"
      },
      "outputs": [],
      "source": [
        "network_hparams.update(\n",
        "    {\n",
        "    'n_channels1':4,#10,#30\n",
        "    'filter_size1':7,#11 #9\n",
        "    'stride1':2,#3, #3\n",
        "    'NodesType_LC': AdaptiveLIFNodes, #LIF\n",
        "    'theta_plus': 0.05,\n",
        "    'tc_theta_decay': 1000000,\n",
        "    'nu_LC': (0.0001,0.01),#(0.0001,0.01),(0.0003,0.0004)\n",
        "    'norm_factor_LC': 0.4*7*7,#0.4*7*7,None \n",
        "    'inh_LC': True,\n",
        "    'inh_factor_LC': 1,#100, #0.5 \n",
        "    'save_path':'/content/drive/My Drive/LCNet/LCNet_phase2_baseline_gpu_11.pth',\n",
        "    }\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "AyGeEJTPl7D1"
      },
      "outputs": [],
      "source": [
        "if network_hparams['save_path'] :\n",
        "    from google.colab import drive\n",
        "    drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RIXXPQ5Dl7D1"
      },
      "outputs": [],
      "source": [
        "manual_seed(SEED)\n",
        "hparams = {**reward_hparams, **network_hparams, **train_hparams, **data_hparams}\n",
        "net = LCNet(**hparams, reward_fn = None)#DynamicDopamineInjection)\n",
        "net.fit(dataloader = dataloader, val_loader = val_loader, reward_hparams = reward_hparams, **train_hparams)\n",
        "plot_locally_connected_weights_meh(net.connections[('input', 'main1')].w,4,1,0,20,7,7)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jU_ySfnFl7D2"
      },
      "source": [
        "## Hyperparameters 12"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "04Ojw4fjl7D3"
      },
      "outputs": [],
      "source": [
        "network_hparams.update(\n",
        "    {\n",
        "    'n_channels1':4,#10,#30\n",
        "    'filter_size1':7,#11 #9\n",
        "    'stride1':2,#3, #3\n",
        "    'NodesType_LC': LIFNodes,#AdaptiveLIFNodes, #LIF\n",
        "    'theta_plus': 0.05,\n",
        "    'tc_theta_decay': 1000000,\n",
        "    'nu_LC': (0.0001,0.01),#(0.0001,0.01),(0.0003,0.0004)\n",
        "    'norm_factor_LC': 0.4*7*7,#0.4*7*7,None \n",
        "    'inh_LC': True,\n",
        "    'inh_factor_LC': 1,#100, #0.5 \n",
        "    'save_path':'/content/drive/My Drive/LCNet/LCNet_phase2_baseline_gpu_12.pth',\n",
        "    }\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "e0aWhnOjl7D4"
      },
      "outputs": [],
      "source": [
        "if network_hparams['save_path'] :\n",
        "    from google.colab import drive\n",
        "    drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Wwo93y_pl7D4"
      },
      "outputs": [],
      "source": [
        "manual_seed(SEED)\n",
        "hparams = {**reward_hparams, **network_hparams, **train_hparams, **data_hparams}\n",
        "net = LCNet(**hparams, reward_fn = None)#DynamicDopamineInjection)\n",
        "net.fit(dataloader = dataloader, val_loader = val_loader, reward_hparams = reward_hparams, **train_hparams)\n",
        "plot_locally_connected_weights_meh(net.connections[('input', 'main1')].w,4,1,0,20,7,7)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vkz7skWaiWj7"
      },
      "source": [
        "## Tensorboard"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nAKGbShj7kOM"
      },
      "outputs": [],
      "source": [
        "# Load the TensorBoard notebook extension\n",
        "%load_ext tensorboard"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "EXv13w317oW7"
      },
      "outputs": [],
      "source": [
        "%tensorboard --logdir '/content/runs'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Ialx9dX8l5nJ"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IGe49P4-q9zp"
      },
      "source": [
        "## Save/Load Sessions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1Ow_r8C5qzwu"
      },
      "source": [
        "Save tensorBoard Session "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XdHDClhIqUlW"
      },
      "outputs": [],
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "!cp -a /content/runs/. /content/drive/MyDrive/LCNet/logs/"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6NOgZCamq4p-"
      },
      "source": [
        "Read Saved Sessions"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DlItthjkq4S5"
      },
      "outputs": [],
      "source": [
        "%tensorboard --logdir /content/drive/MyDrive/LCNet/logs/"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QZtdOQm4oAu1"
      },
      "source": [
        "## Optuna"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hcLDxcrwithj"
      },
      "source": [
        "install and import optuna"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "CGik9_MeQfaI"
      },
      "outputs": [],
      "source": [
        "!pip install optuna\n",
        "import optuna"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bsM-Y9CZiv15"
      },
      "source": [
        "Define objective function"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Yj_n_rwWDrdV"
      },
      "outputs": [],
      "source": [
        "STUDY_NAME  = ''\n",
        "DATA_PATH = ''\n",
        "N_TRIALS = ''\n",
        "\n",
        "def objective(trial):\n",
        "    ### Suggest parameters: \n",
        "    num_layers = trial.suggest_int('Number of Layers', 1, 4)\n",
        "    dropout_rate  = trial.suggest_float('Dropout', 0, .99)\n",
        "    activation = trial.suggest_categorical('activation', ['relu', 'selu', 'sigmoid', 'elu'])\n",
        "    lr = trial.suggest_float('Learning rate', 1e-6, 1)\n",
        "    network_hparams.update({\n",
        "        \n",
        "    })\n",
        "    ###Define your model\n",
        "    manual_seed(SEED)\n",
        "    hparams = {**reward_hparams, **network_hparams, **train_hparams, **data_hparams}\n",
        "    net = LCNet(**hparams, reward_fn = DynamicDopamineInjection)\n",
        "    va_acc = net.fit(dataloader = dataloader, val_loader = val_loader, reward_hparams = reward_hparams, **train_hparams)\n",
        "    ### Define objective value\n",
        "    objective_value = min(va_acc)\n",
        "\n",
        "    \n",
        "    return objective_value\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ywzhxB84jthL"
      },
      "source": [
        "Run the study"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "IDFttXEkjv4f"
      },
      "outputs": [],
      "source": [
        "study = optuna.create_study(study_name = STUDY_NAME , storage=f\"sqlite:////content/drive/MyDrive/LCNet/optuna/optuna_study.db\", load_if_exists=True)\n",
        "study.optimize(objective, n_trials=N_TRIALS )"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Azp25HveO77U"
      },
      "outputs": [],
      "source": [
        "study.best_params"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "epsdhrYujy4f"
      },
      "source": [
        "Visualization"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lYgaOQZBaPJk"
      },
      "outputs": [],
      "source": [
        "plot_parallel_coordinate(study, params=[\"Learning rate\", \"Number of Layers\", \"Dropout\"])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ya3ZmsSUqtd3"
      },
      "source": [
        "## Izhikevich 2007 - Task 2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "20cGq2nLAKj1"
      },
      "outputs": [],
      "source": [
        "### Spike clamping (baseline activity)\n",
        "main_n_neurons = network_hparams['n_channels'] * compute_size(network_hparams['crop_size'], network_hparams['filter_size'], network_hparams['stride'])\\\n",
        "* compute_size(network_hparams['crop_size'], network_hparams['filter_size'], network_hparams['stride'])\n",
        "out_n_neurons = n_neurons\n",
        "clamping_intensity = None\n",
        "clamp = {}\n",
        "if clamping_intensity is not None:\n",
        "    encoder = PoissonEncoder(time=network_hparams['time'], dt=network_hparams['dt'])\n",
        "    clamp['output'] = encoder.enc(datum = torch.ones(out_n_neurons)*clamping_intensity, time=network_hparams['time'], dt=network_hparams['dt'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "AWZmB0mAIOod"
      },
      "outputs": [],
      "source": [
        "if target_classes:\n",
        "    # npz_file = np.load(f'bindsnet/mask_{\"_\".join([str(i) for i in target_classes])}.npz')\n",
        "    npz_file = np.load('bindsnet/mask_1.npz') ##### KESAFAT KARI !!!\n",
        "    mask, mask_test = torch.from_numpy(npz_file['arr_0']), torch.from_numpy(npz_file['arr_1'])\n",
        "    n_classes = len(target_classes)\n",
        "else:\n",
        "    mask = None\n",
        "    mask_test = None\n",
        "    n_classes = 10\n",
        "\n",
        "dataloader, val_loader = load_datasets(network_hparams, data_hparams, mask, mask_test)\n",
        "\n",
        "\n",
        "train_hparams.update(\n",
        "    {\n",
        "    'n_train' : 2000,\n",
        "    'n_val' : 250,\n",
        "    'val_interval' : 250,\n",
        "    'running_window_length': 50,\n",
        "    }\n",
        ")\n",
        "\n",
        "network_hparams.update(\n",
        "    {  \n",
        "    'pre_observation': True,\n",
        "    'has_decision_period': True,\n",
        "    'observation_period': 250,\n",
        "    'decision_period': 250,\n",
        "    'local_rewarding': True,\n",
        "    'nu_LC': (0.0001,0.01),#(0.0001,0,01)\n",
        "    'nu_Output': 0.05,#0.01\n",
        "    'nu_inh': 0.0,\n",
        "    'normal_init': True,\n",
        "     'mu': 0.5,\n",
        "     'std':0.05,\n",
        "    'update_rule_LC': PostPre,\n",
        "    'update_rule_Output': MSTDPET,\n",
        "    'update_rule_inh': None,\n",
        "    'inh_type': None,\n",
        "    'inh_factor': 0.25,\n",
        "    'norm_factor_LC':  None,#network_hparams['filter_size'] * network_hparams['filter_size'] * 0.5,\n",
        "    'norm_factor_out': None,#main_n_neurons * 0.5,\n",
        "    'norm_factor_inh': None,\n",
        "    'NodesType_LC': LIFNodes,\n",
        "    'NodesType_Output': AdaptiveLIFNodes, \n",
        "    'theta_plus': 0.05,\n",
        "    #'tc_theta_decay': 250,\n",
        "    'tc_trace':20,\n",
        "    'trace_additive' : False,\n",
        "    'single_output_layer': True,\n",
        "    'wmin': 0.0,\n",
        "    'wmax': 1.0,\n",
        "    'soft_bound': True,\n",
        "    'online': False,\n",
        "    'clamp': clamp,\n",
        "    'save_path': None,#'/content/drive/My Drive/LCNet/LCNet_var5_td_error_LIF_1_to_3_2c_gpu.pth',\n",
        "    'load_path': None,#'/content/drive/My Drive/LCNet/LCNet_baseline_2c.pth',\n",
        "    }\n",
        ")\n",
        "\n",
        "\n",
        "reward_hparams.update(\n",
        "    {\n",
        "    'tc_reward':0,\n",
        "    'variant': 'scalar',\n",
        "    'reward_base': 1,\n",
        "    'punishment_base': 1,\n",
        "    'dopamine_base': 0.0,\n",
        "    'td_nu': 0.0001,\n",
        "    'tc_dps': 20,\n",
        "    'dps_factor': 20,\n",
        "    'sub_variant': 'RPE'\n",
        "    }\n",
        ")\n",
        "\n",
        "manual_seed(SEED)\n",
        "hparams = {**reward_hparams, **network_hparams, **train_hparams, **data_hparams}\n",
        "if WANDB:\n",
        "    wandb.init(project='DeepBioLCNet', entity='singularbrain', config=network_hparams)\n",
        "net = LCNet(**hparams, reward_fn = DynamicDopamineInjection, wandb_active = WANDB)\n",
        "net.fit(dataloader = dataloader, val_loader = val_loader, reward_hparams = reward_hparams, **train_hparams)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qy7-iAETvuPH"
      },
      "outputs": [],
      "source": [
        "if target_classes:\n",
        "    # npz_file = np.load(f'bindsnet/mask_{\"_\".join([str(i) for i in target_classes])}.npz')\n",
        "    npz_file = np.load('bindsnet/mask_0.npz') ##### KESAFAT KARI !!!\n",
        "    mask, mask_test = torch.from_numpy(npz_file['arr_0']), torch.from_numpy(npz_file['arr_1'])\n",
        "    n_classes = len(target_classes)\n",
        "else:\n",
        "    mask = None\n",
        "    mask_test = None\n",
        "    n_classes = 10\n",
        "dataloader, val_loader = load_datasets(network_hparams, data_hparams, mask, mask_test)\n",
        "\n",
        "net.fit(dataloader = dataloader, val_loader = val_loader, reward_hparams = reward_hparams, hparams = hparams, **train_hparams)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YnKlKiwj_j1g"
      },
      "source": [
        "## Plotting the feature maps"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zEzmSJdk_j1h"
      },
      "outputs": [],
      "source": [
        "n_filts = (int((network_hparams['crop_size']-network_hparams['filter_size'])/network_hparams['stride'])+1)\n",
        "n_filts"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6RT7rV9g_j1h"
      },
      "outputs": [],
      "source": [
        "\n",
        "\n",
        "print(net.connections[('input', 'main')].w.shape)\n",
        "\n",
        "in_chans = 2\n",
        "n_chans = 100\n",
        "k = 12\n",
        "\n",
        "reshaped_w = net.connections[('input', 'main')].w.view(in_chans, n_chans, n_filts, n_filts, k, k)\n",
        "\n",
        "print(reshaped_w.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jkvOa2a-_j1i"
      },
      "outputs": [],
      "source": [
        "chan_idx = 20 # 0 to N_channels \n",
        "fig, axs = plt.subplots(n_filts, n_filts)\n",
        "for i in range(n_filts):\n",
        "    for j in range(n_filts):\n",
        "        axs[i][j].imshow(reshaped_w[0,chan_idx,i,j].view(k, k).cpu(), cmap='Greys')\n",
        "        axs[i][j].axis('off')\n",
        "plt.show()"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "collapsed_sections": [
        "7fTSvrK3T_GA",
        "MBKedMpIleMr",
        "6zuUBU9pU3vE",
        "8Umbn4LOUjGO",
        "BtP7yFb0Ujys",
        "nXEJ2KGEV7v_",
        "SokdidkrV2Z5",
        "7TvFWXQQQj45",
        "x2C4tNhoQsxG",
        "Lt_ZWi1MRJGp",
        "fCiZRcdNXWQl",
        "9wTzREzpXWQm",
        "FDY23koZXWQn",
        "vkz7skWaiWj7",
        "IGe49P4-q9zp"
      ],
      "include_colab_link": true,
      "machine_shape": "hm",
      "name": "DeepBioLCNet.ipynb",
      "provenance": []
    },
    "interpreter": {
      "hash": "8b51a6187922e1c805af8ddd20d0a4091ecd17bebcd7deb5956ab101caf2f88f"
    },
    "kernelspec": {
      "display_name": "Python 3.8.5 64-bit ('base': conda)",
      "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.8.5"
    },
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "0671429992f340cbb8795a5d6d791ab8": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_298f8a00c7f94112a0e367f56694b638",
            "placeholder": "​",
            "style": "IPY_MODEL_c36d888fddae4b8a8ad80d50dc22d559",
            "value": " 495/2000 [04:03&lt;12:15,  2.05it/s]"
          }
        },
        "07fc2da7756e4c29b2d50d9813c19410": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "0dafa721140a4e97b365b0f7c9eebe89": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ProgressStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "0df7107bce1b4d679178a74fe2f9dd93": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "16aa028da51a458ba2ef3c7f0837580f": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "181bdea1690941538f1bf84b764bceff": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "1dacde3ab9154e0abfbcbfe0bb472dbd": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "FloatProgressModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_7e7a79dca32d499e9b0f7d776eaa78f4",
            "max": 2000,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_50efec520d4349258d445c597ca8c47c",
            "value": 2000
          }
        },
        "1f7d3855422046d6ab7f567767ac0df3": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_181bdea1690941538f1bf84b764bceff",
            "placeholder": "​",
            "style": "IPY_MODEL_44e9dfec4f844c85bd9149a88f4fe98f",
            "value": ""
          }
        },
        "2104745379e74e51a41a16b22e315734": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HBoxModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_24bc1bfec3a8477faa42e85fe563f184",
              "IPY_MODEL_ad8ef238bff24876a8739aec82d9e612",
              "IPY_MODEL_5086821eb005406eafb39075bb040309"
            ],
            "layout": "IPY_MODEL_0df7107bce1b4d679178a74fe2f9dd93"
          }
        },
        "24bc1bfec3a8477faa42e85fe563f184": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_ec834afa74114d25abb93418442f7009",
            "placeholder": "​",
            "style": "IPY_MODEL_9204786852bf413c84acfe172accfcea",
            "value": "Running accuracy: 10.17%, Current val accuracy: 0.00%, :   3%"
          }
        },
        "27a75e8c579244eb9322f682a3522d2d": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "28b208e0b2304e68a2325990fca0038c": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "FloatProgressModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_34dcf71e9fc046fa81c10880b9b6c0c5",
            "max": 2000,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_d2842b1ddd6445eba782b6af1dad2162",
            "value": 2000
          }
        },
        "298f8a00c7f94112a0e367f56694b638": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "30605c0314904de2837b30da65693584": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "34dcf71e9fc046fa81c10880b9b6c0c5": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "38fc9e0688b0474a930ff25309285fa4": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "3ae10f748aa542acb899e67c0739421a": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "44e9dfec4f844c85bd9149a88f4fe98f": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "45af5da833924cfe912809f9d02f3169": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "5086821eb005406eafb39075bb040309": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_cf3c48dafcf447ce88986553aee5a59a",
            "placeholder": "​",
            "style": "IPY_MODEL_30605c0314904de2837b30da65693584",
            "value": " 59/2000 [01:08&lt;37:35,  1.16s/it]"
          }
        },
        "50efec520d4349258d445c597ca8c47c": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ProgressStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "5546b546b04d4d6183fc8d698149ac1a": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_580786b04e024b4db86af912532f7177",
            "placeholder": "​",
            "style": "IPY_MODEL_b30a3c61272944c7ab5d46cd48384d0a",
            "value": " 2001/? [15:01&lt;00:00,  1.78it/s]"
          }
        },
        "580786b04e024b4db86af912532f7177": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "6428fed86b0c403f859852c42cea4ece": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HBoxModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_7751323bae314fc49f1aca27cbe2df96",
              "IPY_MODEL_b5ee3e10f5054da59f99cc0dc82d0b12",
              "IPY_MODEL_0671429992f340cbb8795a5d6d791ab8"
            ],
            "layout": "IPY_MODEL_e8556ccb1e654b70b46f2b13635050f1"
          }
        },
        "6ad02c2ca8184f379c9463b56a0af4d4": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_27a75e8c579244eb9322f682a3522d2d",
            "placeholder": "​",
            "style": "IPY_MODEL_8693cd3284334a96b53c5f1ed67c92a1",
            "value": " 2001/? [15:06&lt;00:00,  1.80it/s]"
          }
        },
        "6c7fb5c3225244d5b576a9c9c0ddc0a7": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "FloatProgressModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_38fc9e0688b0474a930ff25309285fa4",
            "max": 2000,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_76c10d065aaa4e4597b926ca58620aca",
            "value": 2000
          }
        },
        "6d86d648b14f4135a19e229e325afd78": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_d15bda73927543ee96d4cdd985bb817d",
            "placeholder": "​",
            "style": "IPY_MODEL_3ae10f748aa542acb899e67c0739421a",
            "value": " 2001/? [15:03&lt;00:00,  1.76it/s]"
          }
        },
        "76c10d065aaa4e4597b926ca58620aca": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ProgressStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "7751323bae314fc49f1aca27cbe2df96": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_dce5647d08994f95a5dbaa511c3e888d",
            "placeholder": "​",
            "style": "IPY_MODEL_07fc2da7756e4c29b2d50d9813c19410",
            "value": " 25%"
          }
        },
        "7d35cd9e2a6c4df1840100606d7a9761": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "7e7a79dca32d499e9b0f7d776eaa78f4": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "8693cd3284334a96b53c5f1ed67c92a1": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "8ac9ce566d704908879830d677e6f2ea": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ProgressStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "8c43506c9549469ab6000914549da391": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "9204786852bf413c84acfe172accfcea": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "9861ea7a35f2472fa1e601f47c1b320b": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "9ae483cc204a43e78b729d967e248319": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "a0363f0e686945938115bcb5b49fe8bf": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "FloatProgressModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_9861ea7a35f2472fa1e601f47c1b320b",
            "max": 2000,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_8ac9ce566d704908879830d677e6f2ea",
            "value": 2000
          }
        },
        "a1f684d6e38a407f80e47f8157a7a997": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HBoxModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_b4408dce6c3949bc80f1d708df832f47",
              "IPY_MODEL_28b208e0b2304e68a2325990fca0038c",
              "IPY_MODEL_6ad02c2ca8184f379c9463b56a0af4d4"
            ],
            "layout": "IPY_MODEL_af9455669a5145c7aa6ae44fd65744f8"
          }
        },
        "a88657936d7c4b00b746ab4d6104cdc3": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "acfd9a91285f4fd0b4fd95cfa5eaf1c0": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "ad3842f9aa7448338377fb19f319940b": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_b38fdbda3aed4b78b423bf38d45cc590",
            "placeholder": "​",
            "style": "IPY_MODEL_acfd9a91285f4fd0b4fd95cfa5eaf1c0",
            "value": " 2001/? [16:14&lt;00:00,  1.66it/s]"
          }
        },
        "ad8ef238bff24876a8739aec82d9e612": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "FloatProgressModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_7d35cd9e2a6c4df1840100606d7a9761",
            "max": 2000,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_b9eadc721c9f480695a59dee57546db4",
            "value": 59
          }
        },
        "af9455669a5145c7aa6ae44fd65744f8": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "b30a3c61272944c7ab5d46cd48384d0a": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "b38fdbda3aed4b78b423bf38d45cc590": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "b4408dce6c3949bc80f1d708df832f47": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_f660c4ad654644898f56f12378d627e9",
            "placeholder": "​",
            "style": "IPY_MODEL_a88657936d7c4b00b746ab4d6104cdc3",
            "value": ""
          }
        },
        "b5ee3e10f5054da59f99cc0dc82d0b12": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "FloatProgressModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_9ae483cc204a43e78b729d967e248319",
            "max": 2000,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_0dafa721140a4e97b365b0f7c9eebe89",
            "value": 495
          }
        },
        "b9bd75be28d3491c8fa98f96e3a08798": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HBoxModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_1f7d3855422046d6ab7f567767ac0df3",
              "IPY_MODEL_a0363f0e686945938115bcb5b49fe8bf",
              "IPY_MODEL_ad3842f9aa7448338377fb19f319940b"
            ],
            "layout": "IPY_MODEL_dc0d947061044a4ea09315f81e4f6374"
          }
        },
        "b9eadc721c9f480695a59dee57546db4": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ProgressStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "be043f1b806342df9eb687b5542c8098": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HBoxModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_dba0bdcdd99541d9a4f3296f57300edd",
              "IPY_MODEL_1dacde3ab9154e0abfbcbfe0bb472dbd",
              "IPY_MODEL_6d86d648b14f4135a19e229e325afd78"
            ],
            "layout": "IPY_MODEL_e24c53fc14144c3fb1c7bf948f3a1a3e"
          }
        },
        "c36d888fddae4b8a8ad80d50dc22d559": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "cf3c48dafcf447ce88986553aee5a59a": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "d15bda73927543ee96d4cdd985bb817d": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "d2842b1ddd6445eba782b6af1dad2162": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ProgressStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "d56fb3d995c14fdaba94fe570b2ba300": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HBoxModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_f824082e26264ed7bdd02b8cde3db448",
              "IPY_MODEL_6c7fb5c3225244d5b576a9c9c0ddc0a7",
              "IPY_MODEL_5546b546b04d4d6183fc8d698149ac1a"
            ],
            "layout": "IPY_MODEL_8c43506c9549469ab6000914549da391"
          }
        },
        "dba0bdcdd99541d9a4f3296f57300edd": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_de0d238279eb4f0a98390fee7765dea7",
            "placeholder": "​",
            "style": "IPY_MODEL_45af5da833924cfe912809f9d02f3169",
            "value": ""
          }
        },
        "dc0d947061044a4ea09315f81e4f6374": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "dce5647d08994f95a5dbaa511c3e888d": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "dcf5e3d678f04cc1ad77b6bb1471f9d2": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "de0d238279eb4f0a98390fee7765dea7": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "e24c53fc14144c3fb1c7bf948f3a1a3e": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "e8556ccb1e654b70b46f2b13635050f1": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "ec834afa74114d25abb93418442f7009": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "f660c4ad654644898f56f12378d627e9": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "f824082e26264ed7bdd02b8cde3db448": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_dcf5e3d678f04cc1ad77b6bb1471f9d2",
            "placeholder": "​",
            "style": "IPY_MODEL_16aa028da51a458ba2ef3c7f0837580f",
            "value": ""
          }
        }
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}