LSM_supervised-2.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lyrIT-SEkNm0"
      },
      "source": [
        "#Initializations"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "oHIwq83DXiHF"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "from sklearn.datasets import fetch_openml\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.metrics import confusion_matrix\n",
        "import pickle\n",
        "import tensorflow as tf\n",
        "import matplotlib.pyplot as plt\n",
        "import pathlib\n",
        "import os\n",
        "import pickle as pkl"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z48Rra2intGu",
        "outputId": "ad7f26d7-5511-4014-89e3-8b188cf8d376"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7HmeaVpb_DaD"
      },
      "source": [
        "Load Lyon-BSA encoded spike data of shape (num samples, num iterations, num channels). For example, matlab converted TI46 dataset would have the shape (18000, 1000, 77) [num iterations = 1000, with decimation factor 12, to the best of my knowledge], and python converted google mini-speech dataset would have the shape (8000, 1378, 96)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mgPhr4YCoVRL"
      },
      "outputs": [],
      "source": [
        "data_path = '/content/drive/My Drive/Colab Notebooks/tf_LSM/'\n",
        "x_data = np.load(data_path + 'mini_speech_data_decimation_16_2.npy')\n",
        "y_data = np.load(data_path + 'mini_speech_label_decimation_16_2.npy')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bIpReJ9pzYbV",
        "outputId": "c65bed97-7222-4323-95ff-56b6c70783db"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(8000, 1378, 96)\n",
            "(8000,)\n",
            "no\n"
          ]
        }
      ],
      "source": [
        "print(x_data.shape)\n",
        "print(y_data.shape)\n",
        "print(y_data[1])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sJkSairaUyBl",
        "outputId": "c65b5327-128b-4e32-e218-bda5489aa1aa"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "int8\n"
          ]
        }
      ],
      "source": [
        "print(x_data.dtype)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QnwDsurbCQ5g",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "72951511-d969-4fd7-ea82-cdf91a702fa1"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(8000, 1378, 96)\n"
          ]
        }
      ],
      "source": [
        "data_size_test = x_data.shape[0]//5\n",
        "\n",
        "x_test=np.array(x_data[-data_size_test:])\n",
        "y_test=np.array(y_data[-data_size_test:])\n",
        "x_in_train=np.array(x_data[:-data_size_test])\n",
        "y_in_train=np.array(y_data[:-data_size_test])\n",
        "\n",
        "data_size = x_in_train.shape[0]\n",
        "\n",
        "print(x_data.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3VMKypVPqdVP"
      },
      "outputs": [],
      "source": [
        "a = 20\n",
        "b = 20\n",
        "c = 1\n",
        "depth = 2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ONSnxvqt-HRA",
        "outputId": "2e3941c8-c5e7-49c8-a28f-44a946ea9b07"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "8\n"
          ]
        }
      ],
      "source": [
        "print(len(np.unique(np.array(y_test))))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6eSNh5qTOhvw"
      },
      "source": [
        "#Training"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JvoWryj04hFu"
      },
      "outputs": [],
      "source": [
        "import math\n",
        "import random\n",
        "\n",
        "#FLAG_global = \"sup_stdp\"\n",
        "FLAG_global = \"full_stdp\"\n",
        "\n",
        "Nx = a\n",
        "Ny = b\n",
        "Nz = c\n",
        "N = Nx*Ny*Nz\n",
        "LqW = 3\n",
        "in_conn_density = 0.15\n",
        "inh_fr = 0.2\n",
        "lam = 9\n",
        "\n",
        "in_size = x_data.shape[2]\n",
        "labels = np.unique(np.array(y_test))\n",
        "\n",
        "\n",
        "W_lsm = np.zeros((N,N))\n",
        "W_lsm_sign = np.zeros((N,N))\n",
        "W_in = np.zeros((in_size,N))\n",
        "W_out = np.zeros((1,len(labels)))\n",
        "W_lsm_mask = np.ones((N,N))\n",
        "\n",
        "in_conn_range = np.int32(N*in_conn_density)\n",
        "input_perm_i = np.arange(N)\n",
        "random.shuffle(input_perm_i[in_conn_range:])\n",
        "\n",
        "pos_conn = input_perm_i[:in_conn_range]\n",
        "output_neurons = input_perm_i[-len(labels):]\n",
        "for i in output_neurons:\n",
        "  for j in output_neurons:\n",
        "    if i!=j:\n",
        "      W_lsm[i,j] = -LqW\n",
        "output_dict = {}\n",
        "for j in range(len(labels)):\n",
        "  output_dict[labels[j]] = output_neurons[j]\n",
        "\n",
        "\n",
        "for i in range(in_size):\n",
        "  input_perm_i = np.arange(N)\n",
        "  random.shuffle(input_perm_i[in_conn_range:-len(labels)])\n",
        "  neg_conn = input_perm_i[-in_conn_range-len(labels):-len(labels)]\n",
        "  for j in range(len(pos_conn)):\n",
        "    W_in[i,pos_conn[j]] = 5*LqW*math.exp(-(j-(i*len(pos_conn)/in_size))**2/(5**2))\n",
        "  for j in range(len(neg_conn)):\n",
        "    #W_in[i,neg_conn[j]] = -2*LqW*math.exp(-(j-(i*len(neg_conn)/in_size))**2/(5**2))\n",
        "    W_in[i,neg_conn[j]] = -LqW\n",
        "\n",
        "for i in range(len(labels)):\n",
        "  W_out[0,i] = LqW\n",
        "\n",
        "input_perm = np.arange(N)\n",
        "np.random.shuffle(input_perm) # first 0.2*N indices are inhibitory\n",
        "inh_range = np.int32(inh_fr*N) # indices 0 to inh_range-1 are inhibitory\n",
        "\n",
        "for i in range(N):\n",
        "  posti = input_perm[i] # input_perm[i] is the post-neuron index\n",
        "  zi = posti//(Nx*Ny)\n",
        "  yi = (posti-zi*Nx*Ny)//Nx\n",
        "  xi = (posti-zi*Nx*Ny)%Nx\n",
        "  for j in range(N):\n",
        "    prej = input_perm[j] # input_perm[j] is the pre-neuron index\n",
        "    zj = prej//(Nx*Ny)\n",
        "    yj = (prej-zj*Nx*Ny)//Nx\n",
        "    xj = (prej-zj*Nx*Ny)%Nx\n",
        "    D = ((xi-xj)**2 + (yi-yj)**2 + (zi-zj)**2)\n",
        "    if i<inh_range and j<inh_range: # II connection, C = 0.3\n",
        "      P = 0.3*np.exp(-D/lam)\n",
        "      Pu1 = np.random.uniform()\n",
        "      if Pu1<P:\n",
        "        W_lsm[prej,posti] = -LqW\n",
        "        W_lsm_sign[prej,posti] = -1\n",
        "    if i<inh_range and j>=inh_range: # EI connection, C = 0.1\n",
        "      P = 0.1*np.exp(-D/lam)\n",
        "      Pu1 = np.random.uniform()\n",
        "      if Pu1<P:\n",
        "        W_lsm[prej,posti] = LqW\n",
        "        W_lsm_sign[prej,posti] = 1\n",
        "    if i>=inh_range and j<inh_range: # IE connection, C = 0.05\n",
        "      P = 0.05*np.exp(-D/lam)\n",
        "      Pu1 = np.random.uniform()\n",
        "      if Pu1<P:\n",
        "        W_lsm[prej,posti] = -LqW\n",
        "        W_lsm_sign[prej,posti] = -1\n",
        "    if i>=inh_range and j>=inh_range: # EE connection, C = 0.2\n",
        "      P = 0.2*np.exp(-D/lam)\n",
        "      Pu1 = np.random.uniform()\n",
        "      if Pu1<P:\n",
        "        W_lsm[prej,posti] = 4*LqW\n",
        "        W_lsm_sign[prej,posti] = 1\n",
        "\n",
        "W_lsm_mask = np.where(W_lsm == 0, 0, 1) #Ensure that neuron can only connect to others in some fixed neighbourhood vicinity.\n",
        "\n",
        "for i in range(N):\n",
        "  W_lsm[i,i] = 0\n",
        "  W_lsm_mask[i,i] = 0\n",
        "  W_lsm_sign[i,i] = 0\n",
        "\n",
        "\n",
        "for i in range(N):\n",
        "  for j in range(N):\n",
        "    a2 = i//Nx\n",
        "    b2 = i%Nx\n",
        "    c2 = j//Nx\n",
        "    d2 = j%Nx\n",
        "    sumdist = (a2-c2)**2 + (b2-d2)**2\n",
        "    if sumdist <= 2:\n",
        "      W_lsm_mask[i,j] = 1\n",
        "\n",
        "\n",
        "\n",
        "num_iter = x_data.shape[1]\n",
        "W_lsm_tf = tf.constant(W_lsm, dtype=tf.float32)\n",
        "W_in_tf = tf.constant(W_in, dtype=tf.float32)\n",
        "\n",
        "#print(N)\n",
        "\n",
        "#eta = 0.1\n",
        "#eta1 = 0.1\n",
        "eta = 0.02\n",
        "eta1 = 0.1\n",
        "eta2 = 0.1\n",
        "a1 = 0.1\n",
        "a2 = 0.1\n",
        "th = 0.4\n",
        "#flags = [\"no_stdp\", \"ll_stdp\", \"il_stdp\", \"full_stdp\"]\n",
        "flag = FLAG_global\n",
        "\n",
        "batch_size = 200\n",
        "A_new = 0.005\n",
        "num_batches = data_size//batch_size\n",
        "num_batches_test = data_size_test//batch_size\n",
        "num_partitions = 4\n",
        "LSM_out_train = np.zeros((x_in_train.shape[0],num_partitions*N))\n",
        "LSM_out_test = np.zeros((x_test.shape[0],num_partitions*N))\n",
        "#LSM_out_train2 = np.zeros((x_in_train.shape[0],num_iter, N))\n",
        "#LSM_out_test2 = np.zeros((x_test.shape[0],num_iter,N))\n",
        "#print(\"hi\")\n",
        "w_scale = 1\n",
        "partition = num_iter//num_partitions"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "q2-DnrWymzcr"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "J8CKxMaw4n-I"
      },
      "outputs": [],
      "source": [
        "from tqdm import tqdm\n",
        "\n",
        "\n",
        "def run_LSM(Vm, SI, Sin, SinI, eta, eta1, a1, a2, in_W, W, sc_W, th, n_iter):\n",
        "  Sliq = []\n",
        "  global N\n",
        "  count = np.zeros((batch_size, N))\n",
        "  for i in range(n_iter):\n",
        "    Vm = (1-eta)*Vm + a1*(tf.matmul(SI, sc_W*W) + tf.matmul(SinI, in_W))\n",
        "    Sout = tf.cast(Vm>=th, dtype=tf.float32)\n",
        "    toadd = Sout.numpy()\n",
        "    count = np.add(count, toadd)\n",
        "    Vm = Vm*tf.cast(Vm<th, dtype=tf.float32)\n",
        "    SinI = (1-eta1)*SinI + a2*Sin[:,i,:]\n",
        "    SI = (1-eta1)*SI + a2*Sout\n",
        "    Sliq.append(Sout)\n",
        "  return tf.stack(Sliq, axis=1), count\n",
        "\n",
        "# LSM with STDP in Liquid-Liquid (LL) connections\n",
        "def run_LSM_LL_STDP(Vm, SI, Sin, SinI, spT, eta, eta1, a1, a2, in_W, W, th, n_iter, batch_s, Nin=0, Nrev=0, Ap=0.01, An=0.02, a3=0.1, eta2=0.1):\n",
        "  Sliq = []\n",
        "  for i in range(n_iter):\n",
        "    Vm = (1-eta)*Vm + a1*(tf.matmul(SI, W) + tf.matmul(SinI, in_W))\n",
        "    Sout = tf.cast(Vm>=th, dtype=tf.float32)\n",
        "    Vm = Vm*tf.cast(Vm<th, dtype=tf.float32)\n",
        "    SinI = (1-eta1)*SinI + a2*Sin[:,i,:]\n",
        "    SI = (1-eta1)*SI + a2*Sout\n",
        "    spT = (1-eta2)*spT + a3*Sout\n",
        "\n",
        "    dwp = Ap*tf.matmul(tf.transpose(spT), Sout)/batch_s\n",
        "    dwn = -An*tf.matmul(tf.transpose(Sout), spT)/batch_s\n",
        "    W = W + dwp + dwn\n",
        "\n",
        "    tau_astro = 10\n",
        "    eta_astro = 1/tau_astro\n",
        "    w_astro = 0.01\n",
        "    An = An*(1-eta_astro) + (w_astro/tau_astro)*(tf.reduce_mean(tf.reduce_sum(Sout, axis=1)) - tf.reduce_mean(tf.reduce_sum(Sin[:,i,:], axis=1))) + Ap/tau_astro\n",
        "\n",
        "    Sliq.append(Sout)\n",
        "  return tf.stack(Sliq, axis=1), W, An\n",
        "\n",
        "# LSM with STDP in Input-Liquid (IL) connections\n",
        "def run_LSM_IL_STDP(Vm, SI, Sin, SinI, spT, spT_in, eta, eta1, a1, a2, in_W, W, th, n_iter, batch_s, Nin=0, Nrev=0, Ap=0.01, An=0.02, a3=0.1, eta2=0.1):\n",
        "  Sliq = []\n",
        "  for i in range(n_iter):\n",
        "    Vm = (1-eta)*Vm + a1*(tf.matmul(SI, W) + tf.matmul(SinI, in_W))\n",
        "    Sout = tf.cast(Vm>=th, dtype=tf.float32)\n",
        "    Vm = Vm*tf.cast(Vm<th, dtype=tf.float32)\n",
        "    SinI = (1-eta1)*SinI + a2*Sin[:,i,:]\n",
        "    SI = (1-eta1)*SI + a2*Sout\n",
        "    spT = (1-eta2)*spT + a3*Sout\n",
        "    spT_in = (1-eta2)*spT_in + a3*Sin[:,i,:]\n",
        "\n",
        "    dwp = Ap*tf.matmul(tf.transpose(spT_in), Sout)/batch_s\n",
        "    dwn = -An*tf.matmul(tf.transpose(Sin[:,i,:]), spT)/batch_s\n",
        "    in_W = in_W + dwp + dwn\n",
        "\n",
        "    tau_astro = 10\n",
        "    eta_astro = 1/tau_astro\n",
        "    w_astro = 0.01\n",
        "    An = An*(1-eta_astro) + (w_astro/tau_astro)*(tf.reduce_mean(tf.reduce_sum(Sout, axis=1)) - tf.reduce_mean(tf.reduce_sum(Sin[:,i,:], axis=1))) + Ap/tau_astro\n",
        "\n",
        "    Sliq.append(Sout)\n",
        "  return tf.stack(Sliq, axis=1), in_W, An\n",
        "\n",
        "# new version\n",
        "# LSM with STDP in all (LL and IL) connections\n",
        "def run_LSM_full_STDP(Vm, SI, Sin, SinI, spT, spT_in, eta, eta1, a1, a2, in_W, W, W_mask, th, n_iter, batch_s, W_sign, in_W_sign=1, Nin=0, Nrev=0, Ap=0.01, An=0.02, dw_in_scale=1, dw_lsm_scale=1, a3=0.1, eta2=0.1):\n",
        "  Sliq = []\n",
        "  global N\n",
        "  count = np.zeros((batch_size, N))\n",
        "  for i in tqdm(range(n_iter)):\n",
        "    Vm = (1-eta)*Vm + a1*(tf.matmul(SI, W) + tf.matmul(SinI, in_W))\n",
        "    Sout = tf.cast(Vm>=th, dtype=tf.float32)\n",
        "    toadd = Sout.numpy()\n",
        "    count = np.add(count, toadd)\n",
        "    Vm = Vm*tf.cast(Vm<th, dtype=tf.float32)\n",
        "    SinI = (1-eta1)*SinI + a2*Sin[:,i,:]\n",
        "    SI = (1-eta1)*SI + a2*Sout\n",
        "    spT = (1-eta2)*spT + a3*Sout\n",
        "    spT_in = (1-eta2)*spT_in + a3*Sin[:,i,:]\n",
        "\n",
        "    #dwp = Ap*tf.matmul(tf.transpose(spT_in), Sout)/batch_s\n",
        "    #dwn = -An*tf.matmul(tf.transpose(Sin[:,i,:]), spT)/batch_s\n",
        "    #in_W = in_W + dw_in_scale*(dwp + dwn)\n",
        "\n",
        "    #in_W_check = in_W*in_W_sign\n",
        "    #in_W = in_W*tf.cast(in_W_check>=0, dtype=tf.float32)\n",
        "\n",
        "    dwp = Ap*tf.matmul(tf.transpose(spT), Sout)/batch_s\n",
        "    dwn = -An*tf.matmul(tf.transpose(Sout), spT)/batch_s\n",
        "    W = (W + dw_lsm_scale*(dwp + dwn))*W_mask\n",
        "\n",
        "    W_check = W*W_sign\n",
        "    W = W*tf.cast(W_check>=0, dtype=tf.float32)\n",
        "\n",
        "    tau_astro = 10\n",
        "    eta_astro = 1/tau_astro\n",
        "    w_astro = 0.01\n",
        "    spike_mult = 1\n",
        "    An = An*(1-eta_astro) + (w_astro/tau_astro)*(tf.reduce_mean(tf.reduce_sum(Sout, axis=1)) - spike_mult*tf.reduce_mean(tf.reduce_sum(Sin[:,i,:], axis=1))) + Ap/tau_astro\n",
        "\n",
        "    Sliq.append(Sout)\n",
        "  return tf.stack(Sliq, axis=1), in_W, W, An, count\n",
        "\n",
        "\n",
        "def run_LSM_supervised_STDP(Vm, SI, Sin, SinI, spT, spT_in, eta, eta1, a1, a2, in_W, W, W_mask, th, n_iter, batch_s, W_sign, y_labels, in_W_sign=1, Nin=0, Nrev=0, Ap=0.01, An=0.02, dw_in_scale=1, dw_lsm_scale=1, a3=0.1, eta2=0.1):\n",
        "  Sliq = []\n",
        "  global N\n",
        "  global output_neurons\n",
        "  global output_dict\n",
        "  count = np.zeros((batch_size, N))\n",
        "  batch_outputs = []\n",
        "  indic_matrix = []\n",
        "  for i in range(len(y_labels)):\n",
        "    zeros_vec = np.zeros(Vm.shape[1])\n",
        "    batch_outputs.append(output_dict[y_labels[i]])\n",
        "    zeros_vec[output_dict[y_labels[i]]] = 1\n",
        "    indic_matrix.append(zeros_vec)\n",
        "  indic_matrix = np.array(indic_matrix)\n",
        "  #print(indic_matrix) #1s wherever single output neuron spikes\n",
        "  indic2_matrix = 1 - indic_matrix #0s wherever single output neuron spikes\n",
        "  #print(indic2_matrix)\n",
        "  for i in tqdm(range(n_iter)):\n",
        "    Vm = (1-eta)*Vm + a1*(tf.matmul(SI, W) + tf.matmul(SinI, in_W))\n",
        "    Vm = np.multiply(Vm,indic2_matrix) + np.multiply(th,indic_matrix)\n",
        "    Sout = tf.cast(Vm>=th, dtype=tf.float32)\n",
        "    toadd = Sout.numpy()\n",
        "    count = np.add(count, toadd)\n",
        "    Vm = Vm*tf.cast(Vm<th, dtype=tf.float32)\n",
        "    SinI = (1-eta1)*SinI + a2*Sin[:,i,:]\n",
        "    SI = (1-eta1)*SI + a2*Sout\n",
        "    spT = (1-eta2)*spT + a3*Sout\n",
        "    spT_in = (1-eta2)*spT_in + a3*Sin[:,i,:]\n",
        "\n",
        "    #dwp = Ap*tf.matmul(tf.transpose(spT_in), Sout)/batch_s\n",
        "    #dwn = -An*tf.matmul(tf.transpose(Sin[:,i,:]), spT)/batch_s\n",
        "    #in_W = in_W + dw_in_scale*(dwp + dwn)\n",
        "\n",
        "    #in_W_check = in_W*in_W_sign\n",
        "    #in_W = in_W*tf.cast(in_W_check>=0, dtype=tf.float32)\n",
        "\n",
        "    dwp = Ap*tf.matmul(tf.transpose(spT), Sout)/batch_s\n",
        "    dwn = -An*tf.matmul(tf.transpose(Sout), spT)/batch_s\n",
        "    W = (W + dw_lsm_scale*(dwp + dwn))*W_mask\n",
        "\n",
        "    W_check = W*W_sign\n",
        "    W = W*tf.cast(W_check>=0, dtype=tf.float32)\n",
        "\n",
        "    tau_astro = 10\n",
        "    eta_astro = 1/tau_astro\n",
        "    w_astro = 0.01\n",
        "    spike_mult = 1\n",
        "    An = An*(1-eta_astro) + (w_astro/tau_astro)*(tf.reduce_mean(tf.reduce_sum(Sout, axis=1)) - spike_mult*tf.reduce_mean(tf.reduce_sum(Sin[:,i,:], axis=1))) + Ap/tau_astro\n",
        "\n",
        "    Sliq.append(Sout)\n",
        "  return tf.stack(Sliq, axis=1), in_W, W, An, count\n",
        "\n",
        "\n",
        "def run_LSM_symsup_STDP(Vm, SI, Sin, SinI, spT, spT_in, eta, eta1, a1, a2, in_W, W, W_mask, th, n_iter, batch_s, W_sign, y_labels, in_W_sign=1, Nin=0, Nrev=0, Ap=0.01, An=0.02, dw_in_scale=1, dw_lsm_scale=1, a3=0.1, eta2=0.1):\n",
        "  Sliq = []\n",
        "  global N\n",
        "  global output_neurons\n",
        "  global output_dict\n",
        "  count = np.zeros((batch_size, N))\n",
        "  batch_outputs = []\n",
        "  indic_matrix = []\n",
        "  for i in range(len(y_labels)):\n",
        "    zeros_vec = np.zeros(Vm.shape[1])\n",
        "    batch_outputs.append(output_dict[y_labels[i]])\n",
        "    zeros_vec[output_dict[y_labels[i]]] = 1\n",
        "    indic_matrix.append(zeros_vec)\n",
        "  indic_matrix = np.array(indic_matrix)\n",
        "  #print(indic_matrix) #1s wherever single output neuron spikes\n",
        "  indic2_matrix = 1 - indic_matrix #0s wherever single output neuron spikes\n",
        "  #print(indic2_matrix)\n",
        "  for i in tqdm(range(n_iter)):\n",
        "    Vm = (1-eta)*Vm + a1*(tf.matmul(SI, W) + tf.matmul(SinI, in_W))\n",
        "    Vm = np.multiply(Vm,indic2_matrix) + np.multiply(th,indic_matrix)\n",
        "    Sout = tf.cast(Vm>=th, dtype=tf.float32)\n",
        "    toadd = Sout.numpy()\n",
        "    count = np.add(count, toadd)\n",
        "    Vm = Vm*tf.cast(Vm<th, dtype=tf.float32)\n",
        "    SinI = (1-eta1)*SinI + a2*Sin[:,i,:]\n",
        "    SI = (1-eta1)*SI + a2*Sout\n",
        "    spT = (1-eta2)*spT + a3*Sout\n",
        "    spT_in = (1-eta2)*spT_in + a3*Sin[:,i,:]\n",
        "\n",
        "    #dwp = Ap*tf.matmul(tf.transpose(spT_in), Sout)/batch_s\n",
        "    #dwn = Ap*tf.matmul(tf.transpose(Sin[:,i,:]), spT)/batch_s\n",
        "    #in_W = in_W + dw_in_scale*(dwp + dwn)\n",
        "\n",
        "    dwp = Ap*tf.matmul(tf.transpose(spT), Sout)/batch_s\n",
        "    dwn = Ap*tf.matmul(tf.transpose(Sout), spT)/batch_s\n",
        "    W = (W + dw_lsm_scale*(dwp + dwn))*W_mask\n",
        "\n",
        "    W_check = W*W_sign\n",
        "    W = W*tf.cast(W_check>=0, dtype=tf.float32)\n",
        "    \"\"\"\n",
        "    #in_W = tf.linalg.normalize(in_W, ord=1, axis=0, name=None)[0]\n",
        "    W = tf.linalg.normalize(W, ord=1, axis=0, name=None)[0]\n",
        "    #in_W_Nin = tf.cast(tf.math.count_nonzero(in_W, 0), dtype=tf.float32)\n",
        "    W_Nin = tf.cast(tf.math.count_nonzero(W, 0), dtype=tf.float32)\n",
        "    #in_W = LqW*(in_W_Nin*in_W)\n",
        "    W = LqW*(W_Nin*W)\n",
        "    \"\"\"\n",
        "    #in_W = tf.linalg.normalize(in_W, ord=1, axis=1, name=None)[0]\n",
        "    W = tf.linalg.normalize(W, ord=1, axis=0, name=None)[0]\n",
        "    #in_W_Nin = tf.cast(tf.math.count_nonzero(in_W, 1, keepdims = True), dtype=tf.float32)\n",
        "    W_Nin = tf.cast(tf.math.count_nonzero(W, 0, keepdims = True), dtype=tf.float32)\n",
        "    #print(in_W_Nin.shape)\n",
        "    #in_W = LqW*(in_W_Nin*in_W)\n",
        "    W = LqW*(W_Nin*W)\n",
        "    Sliq.append(Sout)\n",
        "  return tf.stack(Sliq, axis=1), in_W, W, An, count\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "mJUfevkG0aM2",
        "outputId": "02fd3d45-70a8-4347-c3ce-fc85c2d9b974"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 1378/1378 [00:10<00:00, 137.06it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "batch 1\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "completed:  0.03125\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 1378/1378 [00:10<00:00, 136.45it/s]\n",
            "100%|██████████| 1378/1378 [00:09<00:00, 151.72it/s]\n",
            "100%|██████████| 1378/1378 [00:09<00:00, 137.80it/s]\n",
            "100%|██████████| 1378/1378 [00:10<00:00, 137.76it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "batch 5\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "completed:  0.15625\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 1378/1378 [00:10<00:00, 136.27it/s]\n",
            "100%|██████████| 1378/1378 [00:09<00:00, 148.83it/s]\n",
            "100%|██████████| 1378/1378 [00:10<00:00, 136.34it/s]\n",
            "100%|██████████| 1378/1378 [00:10<00:00, 136.83it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "batch 9\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAGwCAYAAABPSaTdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABbu0lEQVR4nO3deVxU5f4H8M8szLAOCMiiApI7uaSWhpaVmmul6b1lWZltt7LFLCvLtGyx269bN4uy7aottlm2WJq7piIquO8oCioDCsKwzX5+fwxzmAHMOTAb4+f9evkKzgwzzxzG5uP3+T7nkQmCIICIiIgoQMl9PQAiIiIiT2LYISIiooDGsENEREQBjWGHiIiIAhrDDhEREQU0hh0iIiIKaAw7REREFNCUvh6AP7BarThz5gwiIiIgk8l8PRwiIiJygSAIqKioQJs2bSCXX7h+w7AD4MyZM0hKSvL1MIiIiKgJCgoK0K5duwvezrADICIiAoDtZGk0Gh+PhoiIiFyh0+mQlJQkfo5fCMMOIE5daTQahh0iIqIW5mItKGxQJiIiooDGsENEREQBjWGHiIiIAhrDDhEREQU0hh0iIiIKaAw7REREFNAYdoiIiCigMewQERFRQGPYISIiooDGsENEREQBjWGHiIiIAhrDDhEREQU0hh0/ZDRbYbUKvh4GERFRQGDY8TPacj16z1mJJ7/b5euhEBERBQSGHT+zM/88qowW/Lb7DLKOl/h6OERERC0ew46fcZy9+s/KIxAETmcRERE1B8OOn9GbLOLX206UIie/zHeDISIiCgAMO35Gb7Y4fX+ypMpHIyEiIgoMDDt+psboHHZ0NSYfjYSIiCgwMOz4GYPZ6vR9hd7so5EQEREFBoYdP+PYswMAOj0rO0RERM3BsONn6k9jsbJDRETUPAw7fsbeoBwVGgSAlR0iIqLmYtjxM3qTrWcnPiIYACs7REREzcWw42dqant24jRqAFyNRURE1FwMO37GUBt2WofXhh1WdoiIiJqFYcfP2KexWtdWdirYs0NERNQsDDt+xr70PK62Z0dXw8oOERFRczDs+BmxZyfCVtkxWqwNrr1DRERErmPY8TP2YBMTpoJMZjvG5edERERNx7DjZ+w9O6FqJcLVSgBcfk5ERNQcDDt+xl7ZCQ6SQxNce2FBLj8nIiJqMoYdPyOGHaUCmhD7VZRZ2SEiImoqhh0/o6/d9TxEpUBEsH0ai5UdIiKipmLY8SMmixUWqwCgtrIjTmOxskNERNRUDDt+pMZhibk6SA4NKztERETNxrDjR+z9OjIZoFbKHXp2GHaIiIiaimHHjxhql50HKxWQyWQOPTucxiIiImoqhh0fyz55Hu+vOQqzxSpOYwUH2X4tXHpORETUfEpfD+BSN/ePg9hx8jz6pLQSKznBQQoAgCaElR0iIqLmYtjxsUqDLciU15gQpLBVdEJqw05EMHt2iIiImovTWD5mX2quN1nEaSy1GHZsWZRLz4mIiJqOYcfH6sKO1WmrCKCuwqM3c9dzIiKipmLY8TGT1bYCS2+yiGHHHnLsvTt6E8MOERFRUzHs+JjFYqvs1JgsdUvPxbBj+/UYareQICIiIukYdnzMXDuNZXDo2bGHHLWSlR0iIqLmYtjxMbFnx2x12vEcsG0ZAdgqO4Ig+GaARERELRzDjo+ZHVZj6e3TWCrnnh1BAIwWTmURERE1BcOOjzW29Fys7Cjrfj32IERERETSMOz4mFlcjdVw6blKIYdMZrufgcvPiYiImoRhx8fMlrrKjj3Q2Jeey2QyscpjYGWHiIioSRh2fEgQBLFnp8axZ6c27Ni+tv2KuCKLiIioaRh2fMjqsMDKYLKixug8jQXULT/ntXaIiIiahmHHh+z9OoBtSwj7thBqVnaIiIjchmHHhywOpZ3GtosAHLeMYGWHiIioKfwm7Lz55puQyWSYOnWqeEyv12PKlCmIiYlBeHg4xo8fj6KiIqefy8/Px+jRoxEaGoq4uDhMnz4dZnPL2CXc7BR2rKhppGfHvvycq7GIiIiaxi/Czvbt2/Hxxx+jZ8+eTsefeuop/Pbbb/jhhx+wYcMGnDlzBuPGjRNvt1gsGD16NIxGI7Zs2YJFixZh4cKFmDVrlrdfQpPYV2IBtspOhd4EAIgIVorH1azsEBERNYvPw05lZSUmTpyITz/9FK1atRKPl5eX4/PPP8c777yDwYMHo2/fvliwYAG2bNmCrVu3AgBWrlyJAwcO4KuvvsIVV1yBkSNH4tVXX0VGRgaMRuMFn9NgMECn0zn98QWnnh2TBZV6W0UqXF0XduxVnmqjGf/35yGsP1zs3UESERG1cD4PO1OmTMHo0aMxdOhQp+PZ2dkwmUxOx7t27Yrk5GRkZmYCADIzM9GjRw/Ex8eL9xk+fDh0Oh32799/weecO3cuIiMjxT9JSUluflWusdSbxqqoDTua4CDxuH0aK/N4CTLWHcPcPw55d5BEREQtnE/DzrfffoucnBzMnTu3wW1arRYqlQpRUVFOx+Pj46HVasX7OAYd++322y5kxowZKC8vF/8UFBQ085U0jeM0ltFiFbeLcJzGsld2tOV6AECloWX0IxEREfkL5cXv4hkFBQV48sknsWrVKgQHB3v1udVqNdRqtVefszGOlR1H4Y5hp7ayc67SAICNykRERFL5rLKTnZ2N4uJi9OnTB0qlEkqlEhs2bMC8efOgVCoRHx8Po9GIsrIyp58rKipCQkICACAhIaHB6iz79/b7+DNzI2EnOEiOIIXDRQVrr7NTUmnrQWKjMhERkTQ+CztDhgzB3r17sWvXLvHPlVdeiYkTJ4pfBwUFYc2aNeLPHD58GPn5+UhPTwcApKenY+/evSgurmvaXbVqFTQaDdLS0rz+mqRqrLIT4dCvA9TtgF5abQs7rOwQERFJ47NprIiICHTv3t3pWFhYGGJiYsTj999/P6ZNm4bo6GhoNBo8/vjjSE9Px9VXXw0AGDZsGNLS0nD33XfjrbfeglarxcyZMzFlyhS/mKa6GJOlYZXGsV8HqOvZEQT7zwiwWAUo5DKPj4+IiCgQ+CzsuOLdd9+FXC7H+PHjYTAYMHz4cHz44Yfi7QqFAsuWLcMjjzyC9PR0hIWFYdKkSZgzZ44PR+06Vyo79tVYjgxmC0JVfv2rIyIi8ht+9Ym5fv16p++Dg4ORkZGBjIyMC/5MSkoK/vjjDw+PzDMa69mJUDde2XFkMFkRqvLYsIiIiAKKz6+zcylrvLJTP+w0VtlhkzIREZGrGHZ8yPEKynb1w466scoOm5SJiIhcxrDjQ03t2eHycyIiItcx7PiQ4xWU7cJd6dlhZYeIiMhlDDs+1GiD8gWWnjtizw4REZHrGHZ8yNJIz47GpWksVnaIiIhcxbDjQ02u7LBnh4iIyGUMOz7UWINyOJeeExERuRXDjg811qDccDUWG5SJiIiag2HHh1y5zk5jlR0uPSciInIdw44PubRdBCs7REREzcKw40MuXVSQPTtERETNwrDjQ/V7dpRyWYNpq0YrO5zGIiIichnDjg/Vr+xEBCshk8mcjsnlMqgUzr8mPaexiIiIXMaw40P2np0wla16U3/ZuV39CwuyskNEROQ6hh0fsl9BOTLE1qcTFaJq9H71dz5ngzIREZHrGi8lkFeYant2BnSMBQAMS4tv9H72Ph65DLAKXHpOREQkBcOOD9l7dsLVSrx8y+UXvJ99Gis6TI1zlQZWdoiIiCTgNJYP2Xt2FHLZ397Pvj9WbLhtmotLz4mIiFzHsOND9p4dpcthRw2AYYeIiEgKhh0fcrWy0yc5CiqlHH1TWgEA9CZOYxEREbmKYceH7D07SsXf/xpeGNUNu2cNQ4+2kQBY2SEiIpKCYceH7KuxLjaNJZPJEKJSiNNZBlZ2iIiIXMbVWD6Qk38e2/JKYbLYKjQXm8ays++TxcoOERGR6yRXdhYtWoTff/9d/P7ZZ59FVFQUBgwYgJMnT7p1cIFqzm8H8ObyQ8jKKwFw8cqOnX0JOis7RERErpMcdt544w2EhIQAADIzM5GRkYG33noLsbGxeOqpp9w+wEBUoTcBAEoqjQAkVHZqNwVlZYeIiMh1kqexCgoK0LFjRwDAzz//jPHjx+Ohhx7CwIEDcf3117t7fAHJvgqr2mir0ARdpEHZLpjTWERERJJJruyEh4ejpMQ2/bJy5UrceOONAIDg4GDU1NS4d3QBymxx3u1camWHS8+JiIhcJ7myc+ONN+KBBx5A7969ceTIEYwaNQoAsH//frRv397d4wtIRotzZUZqz47ZKsBssV50yToRERE1obKTkZGB9PR0nD17Fj/++CNiYmIAANnZ2bjjjjvcPsBAZK4XdqSuxgIaBiYiIiJqnOTKTlRUFD744IMGx1955RW3DOhSYKo3jaVUSJvGAgCDyYpQlVuHRUREFJCaNA/y119/4a677sKAAQNw+vRpAMCXX36JTZs2uXVwgcrUoLLj2q9BIZchqDYY6bnzORERkUskh50ff/wRw4cPR0hICHJycmAwGAAA5eXleOONN9w+wEBkX41lF+TiNBbgsPzcxGksIiIiV0gOO6+99hrmz5+PTz/9FEFBQeLxgQMHIicnx62DC0RWqyDuiWXnas8O4HBhQS4/JyIiconksHP48GEMGjSowfHIyEiUlZW5Y0wBzWRtGFJc7dkBIO6PxeXnRERErpEcdhISEpCbm9vg+KZNm3DZZZe5ZVCBrH5zMuB6zw7Ayg4REZFUksPOgw8+iCeffBJZWVmQyWQ4c+YMvv76azzzzDN45JFHPDHGgFJ/2Tng+nV2AEAlhh1WdoiIiFwheen5888/D6vViiFDhqC6uhqDBg2CWq3GM888g8cff9wTYwwojVd2JPTsBLFBmYiISArJYUcmk+HFF1/E9OnTkZubi8rKSqSlpSE8PNwT4ws49ZedAxCXk7siuLay47j0PO9cFWLCVdAEB13ox4iIiC5ZksOOnUqlQlpamjvHckmovy8WIK1nJ1Rlq+xUG2xhp7C8BkPf2YA+yVH44eEB7hkkERFRAJEcdqqqqvDmm29izZo1KC4uhrXe6qLjx4+7bXCBqLFtHqT07GhCbNUbnd4EADhZUg2LVUBBKTdhJSIiaozksPPAAw9gw4YNuPvuu5GYmAiZzPUPagLMjSw9l9KzY5+q0tXYwk610XzBxyUiIqImhJ3ly5fj999/x8CBAz0xnoDX2DSWtMqO7Vem09tCTrXRNp3VWOMzERERNWHpeatWrRAdHe2JsVwSGpvGklLZiQypV9mp7d1pbEk7ERERNSHsvPrqq5g1axaqq6s9MZ6A11hlJ0jh+q9BnMaq7dmpqp3GMllZ2SEiImqMS9NYvXv3durNyc3NRXx8PNq3b++0PxYA7o91EY0tPZfUsyNWdpynservt0VEREQ2LoWdsWPHengYl47Gwo6knp36lR2DLfRYrAIEQWDDOBERUT0uhZ3Zs2d7ehyXjMavs9OEBmVxNVbdxQVNFgEqJcMOERGRI8k9O9u3b0dWVlaD41lZWdixY4dbBhXIGq/sNKVnxz6NZRZv4/JzIiKihiSHnSlTpqCgoKDB8dOnT2PKlCluGVQga6yRWCFhuwh7z06lwQyzxYqqepUdIiIiciY57Bw4cAB9+vRpcLx37944cOCAWwYVyEzm5vXsRATXzTxWGsyoNjhUdrj8nIiIqAHJYUetVqOoqKjB8cLCQiiVTd5q65LR2FSTlLATpJCL+2PpasxOPTtmrsgiIiJqQHLYGTZsGGbMmIHy8nLxWFlZGV544QXceOONbh1cIGpsqklKgzJQ17dTXmOq16DMyg4REVF9kksxb7/9NgYNGoSUlBT07t0bALBr1y7Ex8fjyy+/dPsAA039QKKQyyQvF9eEKKHV2ZafVzk2KLNnh4iIqAHJYadt27bYs2cPvv76a+zevRshISGYPHky7rjjjgYXGKSG6gcSqVUdwHkzUPt2EQBXYxERETVGctjZuHEjBgwYgIceesjpuNlsxsaNGzFo0CC3DS4Q1d8bK6gJYUfcH0tvclp6ztVYREREDUnu2bnhhhtQWlra4Hh5eTluuOEGtwwqkLmlshPSeM8Op7GIiIgakhx2LrQlQUlJCcLCwtwyqEBWv2dHKWETUDtN7fLzkkqj0wosE6exiIiIGnB5GmvcuHEAAJlMhnvvvRdqtVq8zWKxYM+ePRgwYID7Rxhg6geS5lR2Csv1TsdZ2SEiImrI5bATGRkJwFbZiYiIQEhIiHibSqXC1VdfjQcffND9Iwww9QOJlGvs2NkblLUNwg4rO0RERPW5HHYWLFgAAGjfvj2eeeYZTlk1UWNLz6Wybwaq1TmHnca2oiAiIrrUSV6NxR3Qm8e+YiokSIEakwVBTerZYWWHiIjIVdI/aQEsWbIEt912G66++mr06dPH6Y8UH330EXr27AmNRgONRoP09HQsX75cvF2v12PKlCmIiYlBeHg4xo8f32Crivz8fIwePRqhoaGIi4vD9OnTYTab6z+V37BXdsJrm4yb07NTfxk7l54TERE1JDnszJs3D5MnT0Z8fDx27tyJfv36ISYmBsePH8fIkSMlPVa7du3w5ptvIjs7Gzt27MDgwYMxZswY7N+/HwDw1FNP4bfffsMPP/yADRs24MyZM2KjNGBrjB49ejSMRiO2bNmCRYsWYeHChZg1a5bUl+U19uqLfUPPpvTsxIarGz3OiwoSERE1JDnsfPjhh/jkk0/w/vvvQ6VS4dlnn8WqVavwxBNPOO2X5Yqbb74Zo0aNQqdOndC5c2e8/vrrCA8Px9atW1FeXo7PP/8c77zzDgYPHoy+fftiwYIF2LJlC7Zu3QoAWLlyJQ4cOICvvvoKV1xxBUaOHIlXX30VGRkZMBqNF3xeg8EAnU7n9Mdb7H01EbVTUU2p7LSPDUVjP8bVWERERA1JDjv5+fniEvOQkBBUVFQAAO6++2588803TR6IxWLBt99+i6qqKqSnpyM7OxsmkwlDhw4V79O1a1ckJycjMzMTAJCZmYkePXogPj5evM/w4cOh0+nE6lBj5s6di8jISPFPUlJSk8ctlclcW9lRN72yo1YqkBwd2uA4dz0nIiJqSHLYSUhIEK+gnJycLFZZ8vLyIAjSP2z37t2L8PBwqNVqPPzww1i6dCnS0tKg1WqhUqkQFRXldP/4+HhotVoAgFardQo69tvtt12Ifdd2+5+CggLJ424qeyC5sn0rxISpMKhz6yY9Tse48IaPzQZlIiKiBiSvxho8eDB+/fVX9O7dG5MnT8ZTTz2FJUuWYMeOHU79NK7q0qULdu3ahfLycixZsgSTJk3Chg0bJD+OFGq12umiiN5kb1BOjg7FjplDJe94btehdThWHyx2fmxWdoiIiBqQHHY++eQTWGsbYe0rpbZs2YJbbrkF//rXvyQPQKVSoWPHjgCAvn37Yvv27Xjvvfdw++23w2g0oqyszKm6U1RUhISEBAC2KtO2bducHs++Wst+H39jDztKhbzJQQcAOrCyQ0RE5BLJ01hyuRxKZV1GmjBhAubNm4fHH38cKpWq2QOyWq0wGAzo27cvgoKCsGbNGvG2w4cPIz8/H+np6QCA9PR07N27F8XFdRWOVatWQaPRIC0trdlj8QR7E3FTdjt31Pg0Fis7RERE9Umu7ADA+fPn8fnnn+PgwYMAgLS0NEyePBnR0dGSHmfGjBkYOXIkkpOTUVFRgcWLF2P9+vX4888/ERkZifvvvx/Tpk1DdHQ0NBoNHn/8caSnp+Pqq68GAAwbNgxpaWm4++678dZbb0Gr1WLmzJmYMmWKz6apLsZe2WnKxQQddWjdMOxwI1AiIqKGJH/ibty4EampqZg3bx7Onz+P8+fPY968eUhNTcXGjRslPVZxcTHuuecedOnSBUOGDMH27dvx559/4sYbbwQAvPvuu7jpppswfvx4DBo0CAkJCfjpp5/En1coFFi2bBkUCgXS09Nx11134Z577sGcOXOkviyvsV/4T6loXmUnsvbCgo5Y2SEiImpIJkhcQtWjRw+kp6fjo48+gkKhAGBbNv7oo49iy5Yt2Lt3r0cG6kk6nQ6RkZEoLy+HRqPx6HPd+M4GHC2uxOIH+mNAx9hmPVb75393+v6JwR0xbViXZj0mERFRS+Hq57fkyk5ubi6efvppMegAtgrLtGnTkJub27TRXkLsS8+VzZzGAoDlT16LaTd2xh39kgFwNRYREVFjJH/i9unTR+zVcXTw4EH06tXLLYMKZHU9O82bxgKAbokaPDGkEzS1W09wNRYREVFDLjUo79mzR/z6iSeewJNPPonc3FyxUXjr1q3IyMjAm2++6ZlRBhB3NSg7svf/uGMj0KzjJfjv6qOYM+ZydIqPaPbjERER+ZpLYeeKK66ATCZzukLys88+2+B+d955J26//Xb3jS4Amd3UoOxIKbcFJ3dsBLp052lkHi/B8n1ahh0iIgoILoWdvLw8T4/jkmH0QGXHPiXmjtVYxtq9u6qNlmY/FhERkT9wKeykpKR4ehyXjLqLCrpzGsv2WO6YxrKHMb2JYYeIiAKD+z5xySX2qaYgpTunsWROj90c9p6iaqO52Y9FRETkDxh2vEgQhLqLCrqxsmOfEnPHNJZ9fDUmruwiIqLA0KTtIki6SoMZp85Xi9+7Y+m5Xd1qLPdVdmrYs0NERAGCYcdLHv06BxuPnBW/d2uDsrgayx2VHfbsEBFRYGlS2MnPz0dhYSHkcjkuu+wyxMTEuHtcAedYcaXT925deu7Wyo59Gothh4iIAoOk8sKHH36IlJQUpKamYsCAAbj66qsRFxeHa665BtnZ2Z4aY0CoNDg3/LpzNZZC7r6l53UNygw7REQUGFz+xH377bfx+uuvY/r06fj444/RpUsXvPzyy/j9999x2WWXYdCgQdixY4cnx9piCYLgFHYUchnkcvdVduxTYha3TGPZHoPTWEREFChcnsbKyMjAZ599hpEjRwIABg0ahAEDBkCr1WLEiBFo1aoVXnjhBaxcudJjg22pqo0WpyCidGPQcXw8U+3S8593nsYnG48jY2IfpMaGSXosNigTEVGgcbmyU1xcjG7duonfd+rUCeXl5Th71tZ0e9999yEzM9P9IwwA9aewVG5sTgYaLj2f+t0uHCjU4dO/jkt+LDHssLJDREQBwuVP3c6dO2PVqlXi9+vWrYNKpUJCQgIAIDg4GDKZeysWgaJCb3L63p3NyY6PZ7JYUVplFI9HhQRJfiyTmWGHiIgCi8vTWDNmzMBdd92F1atXIzg4GD/99BOeeOIJMeCsX78e3bt399hAWzKd3rmy444l4o6UDkvPM4+ViMfDg6UvtjPVjs1otsJiFcTmZyIiopbK5crObbfdhl9++QVKpRJVVVV45513MHfuXPH2f/zjH/jtt988MsiWrqJe2Kn/fXPVbQRqxZZj58Tj9k09pXBcvs7qDhERBQJJ//QfOXKk2KBcH6+1c2GVbg439TluBOpY2WlS2HH4mRqjBeFqXneSiIhaNn6SeUH9nh13s6/GOl1W43S8aZWduik2Lj8nIqJAwI1AvcDd01b1XWjrCaPEKyoLgiAuXwc4jUVERIGBYccLKgyensZqvIlY6vYRFqsAwaF3mtfaISKiQMCw4wWensa60NYTBonTWKZ6201wywgiIgoEksKOyWSCUqnEvn37PDWegGSfxrpvYCoub6PBq2Pdu0T/QpUdqT079ae92LNDRESBQFKDclBQEJKTk2Gx8ENQCntlJ7V1GGbdnOb2x3dX2DHXCzvs2SEiokAgeRrrxRdfxAsvvIDS0lJPjCcg2beL0DThIn+uqD+NFVH7PFIblOtPY7Fnh4iIAoHkT98PPvgAubm5aNOmDVJSUhAW5rzRZE5OjtsGFyjs01gRHgo79Ss7rcPVqNCbJVd26jc0s7JDRESBQPKn79ixYz0wjMBWF3ak71XlivpLz2PD1Th+roo9O0RERGhC2Jk9e7YnxhHQ7GHHU1cjVtbbvyomXAVA+jSWmauxiIgoADVp6XlZWRk+++wzzJgxQ+zdycnJwenTp906uJZOb7Jg09FzYoOyp6ax6m/WGRuuBiC9QZnTWEREFIgkf/ru2bMHQ4cORWRkJE6cOIEHH3wQ0dHR+Omnn5Cfn48vvvjCE+NscUwWK66euwZl1XXX2PHUNJZMJoNSLhN3UxcrO82cxmKDMhERBQLJlZ1p06bh3nvvxdGjRxEcHCweHzVqFDZu3OjWwbVkQQo5erWLcjrmyU01HZuU7ZUdyRcVNLNnh4iIAo/ksLN9+3b861//anC8bdu20Gq1bhlUoBjSLU78OkylaDDd5E6Oy8/FaSypPTtW556dKqMFJ0uqIAjCBX6CiIjI/0kOO2q1GjqdrsHxI0eOoHXr1m4ZVKC4oUtd2LF4MTDEumka67fdZ3Dd/63H9CV7YLEy8BARUcskOezccsstmDNnDkwmWy+KTCZDfn4+nnvuOYwfP97tA2zJkqJDxa/1JmnBQyrHZuKYpjYoX+D+S7JP4cWle5s+OCIiIh+SHHb+85//oLKyEnFxcaipqcF1112Hjh07IiIiAq+//ronxtiidUvUeOV5HKegQoIUAJp/BWVH324vYMMyERG1SJI7ZiMjI7Fq1Sps3rwZu3fvRmVlJfr06YOhQ4d6YnwtXsadvTHxsyzck97ea8+pUtoyrMUqwGIVXO4Vqr/0HABCVQpYrAIMZiu0Oj1SY8Ma+UkiIiL/JTnsfPHFF7j99tsxcOBADBw4UDxuNBrx7bff4p577nHrAFu6y1qHI3PGEK8+pz3sALaprBCVwqWfs4edMJUCVbVVnO5tInGuyoDjZ6tQWF7DsENERC2O5GmsyZMno7y8vMHxiooKTJ482S2DouZRKZzDjqvs01iakLrrAfVsF4nESNslBrTlejeNkIiIyHskhx1BECCTNZwWOXXqFCIjI90yKGo6hVyGIIdr7hgsrvfZ2Cs7GoeLH/ZMikKCJgQAUMiwQ0RELZDL01i9e/eGTCaDTCbDkCFDoFTW/ajFYkFeXh5GjBjhkUGS60KCFJDJZFAp5TCarRIrO7b7hqrrpr16tYvEEW0FAFZ2iIioZXI57Nh3O9+1axeGDx+O8PBw8TaVSoX27dtz6bkfsPfnqBVNCTu2aazk6FBoy/UIVSmQHB2KhNpprItVdnR6E5bvLcTwyxMQFapq4isgIiJyL5fCzrhx47Bw4UJoNBq0b98eEyZMgFqt9vTYqAlCa8NOkFIOGKQtPxcrOyol1j59PZQKWyXP3rNTpPv7sPPV1pN4a8VhnC7TY9qNnZv4CoiIiNzLpZ6dZcuWoaqqCgBw3333NdqgTP7Bfo0de5NyU6axVAoZQlQKBNU+hquVnaLa20urDNIGTURE5EEuVXa6du2KGTNm4IYbboAgCPj++++h0TR+sTwuPfetDq1t04v25edSwo69ChSkcM7ACRpb2DlXaYDRbHVa2u6o0mBrhjaZubUEERH5D5fCzvz58zFt2jT8/vvvkMlkmDlzZqMrsmQyGcOOj3xxXz8szsrHy7dcDqBpYcdc27OjrBd2osNUUCnkMFqsKNLpnbbBcFRpsG0h0tjFCYmIiHzFpbAzYMAAbN26FQAgl8tx5MgRxMXFXeSnyJsGdW6NQZ3rNmK1T2MZmtCzo1I4B1mZTIaEyGDkl1ZD+zdhp6q2siN1mwoiIiJPknydnby8PO5u3gI0pbJjusA0FuBa306lwSz5OYmIiDxN8nYRKSkpAIDq6mrk5+fDaDQ63d6zZ0/3jIyapUk9O7W9NkGN9OTYV2QVltU4Hc86XoKXftmHOWO6i2GH01hERORPJIeds2fPYvLkyVi+fHmjt1skXLGXPEfdlJ4dq+2+ykY2Du1Y2/i89XgJ/nVdB/H4n/uLcKSoEsv3FqJKDDtsUCYiIv8heRpr6tSpKCsrQ1ZWFkJCQrBixQosWrQInTp1wq+//uqJMVIT2Ht2pFRZxJ6dRio7I3skAgD+OnoO56vqqnnVRlvAKa8x1U1jsbJDRER+RHJlZ+3atfjll19w5ZVXQi6XIyUlBTfeeCM0Gg3mzp2L0aNHe2KcJJE4jSUheIjTWI307HSMC0daogYHCnVYsV+LO/olA4C4O3pZjcmhssOwQ0RE/kNyZaeqqkpcidWqVSucPXsWANCjRw/k5OS4d3TUZO5uUAaAm3u1AQD8tvuMeKy6NuAU6Qyw1s5esUGZiIj8ieSw06VLFxw+fBgA0KtXL3z88cc4ffo05s+fj8TERLcPkJpGXHrehJ6dIEXDnh0AGF07lbX1eIkYaKpqp7HOODQus7JDRET+RPI01pNPPonCwkIAwOzZszFixAh8/fXXUKlUWLhwobvHR03UpMrO30xjAUC7ViGQyQCrYOvRaR2hRnXtNFZ5janucdigTEREfkRy2LnrrrvEr/v27YuTJ0/i0KFDSE5ORmxsrFsHR03XpJ6di0xjyeUyRKiV0OnNYtix9+k4PQ6nsYiIyI9IDjv1hYaGok+fPu4YC7lR83p2Gp/GAoDI0KDasGNbkWWv7DjiaiwiIvInknt2qGVQN2HXc/veWKoLVHYAIDIkCEDdtFVjlR327BARkT9h2AlQzans1N8I1JFj2BEEodHKjonTWERE5EcYdgJU83p2/mYayx52qk0wWqwwWxs2I7NBmYiI/AnDToBSNWEa62LX2QEcKztmVBsa3xrEaLFCEBh4iIjIP0gOOytWrMCmTZvE7zMyMnDFFVfgzjvvxPnz5906OGo6lVIBQOJ1duw9O41sF2GncZjGsl9jpzGs7hARkb+QHHamT58OnU4HANi7dy+efvppjBo1Cnl5eZg2bZqkx5o7dy6uuuoqREREIC4uDmPHjhUvWGin1+sxZcoUxMTEIDw8HOPHj0dRUZHTffLz8zF69GiEhoYiLi4O06dPh9l84Q/iS0FzprEa2wjULipEBcAWdhrr17FjkzIREfkLyWEnLy8PaWlpAIAff/wRN910E9544w1kZGRccCf0C9mwYQOmTJmCrVu3YtWqVTCZTBg2bBiqqqrE+zz11FP47bff8MMPP2DDhg04c+YMxo0bJ95usVgwevRoGI1GbNmyBYsWLcLChQsxa9YsqS8toNQ1KDcMJAs252Hlfm2D49KmsUyNrsSq/1hERES+Jvk6OyqVCtXV1QCA1atX45577gEAREdHixUfV61YscLp+4ULFyIuLg7Z2dkYNGgQysvL8fnnn2Px4sUYPHgwAGDBggXo1q0btm7diquvvhorV67EgQMHsHr1asTHx+OKK67Aq6++iueeew4vv/wyVCpVg+c1GAwwGAzi91LH3RJcqGenoLQar/x2AFGhQRh2eYLTbSYXprHsYUd3kcoOr7VDRET+QnJl55prrsG0adPw6quvYtu2beIu50eOHEG7du2aNZjy8nIAtuAEANnZ2TCZTBg6dKh4n65duyI5ORmZmZkAgMzMTPTo0QPx8fHifYYPHw6dTof9+/c3+jxz585FZGSk+CcpKalZ4/ZH6gtMY52vtl0MsKza5BSErFYBFuvfbxcBuF7Z4VWUiYjIX0gOOx988AGUSiWWLFmCjz76CG3btgUALF++HCNGjGjyQKxWK6ZOnYqBAweie/fuAACtVguVSoWoqCin+8bHx0Or1Yr3cQw69tvttzVmxowZKC8vF/8UFBQ0edz+6kLX2anU1wUUp/2srHX3c2np+UV7dtigTERE/kHyNFZycjKWLVvW4Pi7777brIFMmTIF+/btc1rp5SlqtRpqtdrjz+NLFwo7FQbHsGNE6wjbeXAMJy5XdmpXYynkMrEqZMeeHSIi8hdNus7OsWPHMHPmTNxxxx0oLi4GYKvsXGja6GIee+wxLFu2DOvWrXOaCktISIDRaERZWZnT/YuKipCQkCDep/7qLPv39vtcii7Us+NY2Tlf7VDZMTtWdi4edmpMFpTV/nx8RMPgyGksIiLyF5LDzoYNG9CjRw9kZWXhp59+QmVlJQBg9+7dmD17tqTHEgQBjz32GJYuXYq1a9ciNTXV6fa+ffsiKCgIa9asEY8dPnwY+fn5SE9PBwCkp6dj7969YugCgFWrVkGj0Yirxi5FoSrbdXZ0erNT1aXSobJT5hh2aisxcpmtUnMhEcFKyGpvPlNWAwBIjAppcD9WdoiIyF9IDjvPP/88XnvtNaxatcpppdPgwYOxdetWSY81ZcoUfPXVV1i8eDEiIiKg1Wqh1WpRU2P7EI2MjMT999+PadOmYd26dcjOzsbkyZORnp6Oq6++GgAwbNgwpKWl4e6778bu3bvx559/YubMmZgyZUrAT1X9ndTYMISrlag0mHGwsG61mXPYMeLY2Upoy/XYc6q2OTys4eo1R3K5DBFq2+xnYbkeAJAYGSzeHhwk/crNREREniS5Z2fv3r1YvHhxg+NxcXE4d+6cpMf66KOPAADXX3+90/EFCxbg3nvvBWDrBZLL5Rg/fjwMBgOGDx+ODz/8ULyvQqHAsmXL8MgjjyA9PR1hYWGYNGkS5syZI+2FBRilQo7+qdFYc6gYW46dQ/e2kQCACodprBMlVXjpl30wWQT0bGe7fVyfi6+oiwwNgk5vFis7bR0qOzFhapwuq2GDMhER+Q3JYScqKgqFhYUNppx27twprsxylSv7JwUHByMjIwMZGRkXvE9KSgr++OMPSc99KUjvEFMbdkrw0KAOAIBKQ93UVc7JMuhNtgrMzvwyAMDE/skXfdyoEBUKUCOGndYRajwzrDNMFgFrDxXXhh1WdoiIyD9InsaaMGECnnvuOWi1WshkMlitVmzevBnPPPOMeIFB8g8DOsQCALbllYrhw7FB+ZDW+WKK13VujZSYsIs+rnhhwdrHClUp8djgTnjqxs7isnVeVJCIiPyF5LDzxhtvoGvXrkhKSkJlZSXS0tIwaNAgDBgwADNnzvTEGKmJuiZEoFVoEKqNFuw5VQbAuWfHcTVW+5hQTB3ayaXHtYcduzC1Qvz6QkveiYiIfKVJ20V8+umnmDVrFvbu3YvKykr07t0bnTp1Qk1NDUJCGq7MId+Qy2XomxKN1QeLsO+0Dn1Top16duweuCYVM29yfeWapl7YCVXVvY3sy9Y5jUVERP5CcmXniSeeAAAkJSVh1KhRuO2229CpUydUVVVh1KhRbh8gNU9suG11la72asmVjWzxkOCwmsoVSdHOgTZM5VDZYdghIiI/Izns/P777w2up1NVVYURI0bAbL7wXknkGxHBtqqL/crJje1nlRgprRp3fec4p+9D1Q0rO0auxiIiIj8heRpr5cqVuPbaa9GqVStMnToVFRUVGD58OJRKJZYvX+6JMVIzRATbppwq9O6r7HRLjEBiZLB4nZ3wRnp2TOzZISIiPyE57HTo0AErVqzADTfcALlcjm+++QZqtRq///47wsIuvpKHvMte2dHV2EJOYz07iRLDjkwmww1d47A4Kx9A4z07XI1FRET+okl7Y/Xs2RPLli3DCy+8gNDQUCxfvpxBx09pgu3LxE0wmq0w1Ku4yGUQNwOVYlCn1uLXYQ5hR6W0LT1nZYeIiPyFS5Wd3r17QyZruF+SWq3GmTNnMHDgQPFYTk6O+0ZHzSb27OjNTv069q0kWkeo/3bjzwsZ1DkWKoUcrcKCEB7M1VhEROS/XAo7Y8eO9fAwyFMce3bs/TohQQrEhKtQaTAjQWJzsl2oSomsF4YAcN44VMUGZSIi8jMuhR2pu5mT/3Cs7Nj7dcKDlYgKVeFkSTUSNdL6dRy1amTT0CAlKztERORfmtSzQy2HRqzsmMXKToRaiajaCwNKXYl1MWKDMnt2iIjIT7hU2YmOjsaRI0cQGxuLVq1aNdq/Y1daWuq2wVHz2Ss7NSYLzlcbAdgqO3G1TclJ0aFufT5V7d5YrOwQEZG/cCnsvPvuu4iIiAAA/Pe///XkeMjNHJuHC2t3KQ9XK/HoDR2RGBWCf/Rp59bnE/fGYtghIiI/4VLYmTRpUqNfk/8LUsgRqlKg2mgRLwIYplYiNTYM027s7JHnAwATG5SJiMhPSL6oIABYLBYsXboUBw8eBACkpaVhzJgxUCqb9HDkYRHBSlQbLThTG3Yi1J77PdX17Fg89hxERERSSP7U279/P2655RZotVp06dIFAPDvf/8brVu3xm+//Ybu3bu7fZDUPBHBQSjSGeqmsYI9F3ZUrOwQEZGfkbwa64EHHsDll1+OU6dOIScnBzk5OSgoKEDPnj3x0EMPeWKM1Ez2JuW6vaw8GHa49JyIiPyM5E+9Xbt2YceOHWjVqpV4rFWrVnj99ddx1VVXuXVw5B72CwsWlnu+ssOl50RE5G8kV3Y6d+6MoqKiBseLi4vRsWNHtwyK3Mte2bHWzizFhkvfC8tVQVx6TkREfkZy2Jk7dy6eeOIJLFmyBKdOncKpU6ewZMkSTJ06Ff/+97+h0+nEP+Qf7BcWtOsSH+Gx5wri0nMiIvIzkuczbrrpJgDAbbfdJl5cUBBsJYObb75Z/F4mk8Fi4Yocf6CpN23VKT7cY8+ltjcom9mgTERE/kFy2Fm3bp0nxkEeFOEQdpKjQxGq8mDPDhuUiYjIz0j+1Lvuuus8MQ7yoAiHaazOHpzCAhwalBl2iIjIT0ju2VmxYgU2bdokfp+RkYErrrgCd955J86fP+/WwZF7OFZ2uiR4bgoLqGtQ5mosIiLyF5LDzvTp08Xm471792LatGkYNWoU8vLyMG3aNLcPkJrPm5UdNaexiIjIz0iexsrLy0NaWhoA4Mcff8TNN9+MN954Azk5ORg1apTbB0jN53gRwS4J3pnG4hWUiYjIX0iu7KhUKlRXVwMAVq9ejWHDhgEAoqOjudzcT8lldV9fFuvpaSz27BARkX+RXNm55pprMG3aNAwcOBDbtm3Dd999BwA4cuQI2rVr5/YBUvP1SWmFazrGIq2NRtzOwVPqKjtW8RIEREREviT5k++DDz6AUqnEkiVL8NFHH6Ft27YAgOXLl2PEiBFuHyA1X5BCjq8e6I8XRnXz+HPZw5QgAGYrp7KIiMj3JFd2kpOTsWzZsgbH3333XbcMiFo2+67ngK26E6TwbCWJiIjoYvhJRG6lUsphn7mqNJh9OxgiIiIw7JCbKeQytI0KAQCcOFft49EQEREx7JAHdIyzrfjKLa708UiIiIgYdsgDOrSuCzt6kwV6EzeEJSIi32HYIbezV3aOFFVgbMZmDPnPBlSxf4eIiHzEpdVY48aNc/kBf/rppyYPhgKDPexkHi+BpXb5+abccxh+eYIvh0VERJcol8JOZGSkp8dBAaRj7TSWxeE6O+sOFTPsEBGRT7gUdhYsWODpcVAAaRWmQnSYCqVVRvHY2kPFsFoFyOW8ojIREXkXe3bII+zVHbkMCAlSoLjCgP1nuHcaERF5n+QrKAPAkiVL8P333yM/Px9Go9HptpycHLcMjFq2DnHh2HaiFH2SWyEmXIU/9xdh3eFi9GjHKVEiIvIuyZWdefPmYfLkyYiPj8fOnTvRr18/xMTE4Pjx4xg5cqQnxkgt0C292iA6TIUHrk3F5W1sAaewvMbHoyIiokuR5LDz4Ycf4pNPPsH7778PlUqFZ599FqtWrcITTzyB8vJyT4yRWqD0DjHIeelGjOieCKXC1qdjtnBjUCIi8j7JYSc/Px8DBgwAAISEhKCiogIAcPfdd+Obb75x7+goIChrm5It3AWdiIh8QHLYSUhIQGlpKQDbDuhbt24FAOTl5UEQ+GFGDSnktreZmWGHiIh8QHLYGTx4MH799VcAwOTJk/HUU0/hxhtvxO23345bb73V7QOklo+VHSIi8iXJq7E++eQTWK1WAMCUKVMQExODLVu24JZbbsG//vUvtw+QWj5Fbdgx175viIiIvEly2Dl16hSSkpLE7ydMmIAJEyZAEAQUFBQgOTnZrQOklo+VHSIi8iXJ01ipqak4e/Zsg+OlpaVITU11y6AosCgYdoiIyIckhx1BECCTNbzkf2VlJYKDg90yKAos4tJzhh0iIvIBl6expk2bBgCQyWR46aWXEBoaKt5msViQlZWFK664wu0DpJbPvhqLlR0iIvIFl8POzp07AdgqO3v37oVKpRJvU6lU6NWrF5555hn3j5BaPKWclR0iIvIdl8POunXrANiWm7/33nvQaDQeGxQFFvbsEBGRL0lejbVgwQLx61OnTgEA2rVr574RUcBhZYeIiHxJcoOy1WrFnDlzEBkZiZSUFKSkpCAqKgqvvvqqeP0dIkd1lR2+P4iIyPskV3ZefPFFfP7553jzzTcxcOBAAMCmTZvw8ssvQ6/X4/XXX3f7IKllU9q3i+BGoERE5AOSw86iRYvw2Wef4ZZbbhGP9ezZE23btsWjjz7KsEMNsGeHiIh8SfI0VmlpKbp27drgeNeuXcUNQokc2a+zw7BDRES+IDns9OrVCx988EGD4x988AF69erllkFRYFGwQZmIiHxI8jTWW2+9hdGjR2P16tVIT08HAGRmZqKgoAB//PGH2wdILR/3xiIiIl+SXNm57rrrcOTIEdx6660oKytDWVkZxo0bh8OHD+Paa6/1xBipheOu50RE5EuSw05+fj4SExPx+uuv48cff8SPP/6I1157DW3atEF+fr6kx9q4cSNuvvlmtGnTBjKZDD///LPT7YIgYNasWUhMTERISAiGDh2Ko0ePOt2ntLQUEydOhEajQVRUFO6//35UVlZKfVnkQUpuF0FERD7ktl3PS0pKJO96XlVVhV69eiEjI6PR29966y3MmzcP8+fPR1ZWFsLCwjB8+HDo9XrxPhMnTsT+/fuxatUqLFu2DBs3bsRDDz0k7UWRR7Fnh4iIfElyz447dz0fOXIkRo4cecHn+e9//4uZM2dizJgxAIAvvvgC8fHx+PnnnzFhwgQcPHgQK1aswPbt23HllVcCAN5//32MGjUKb7/9Ntq0aSPx1ZEniD07vM4OERH5gN/uep6XlwetVouhQ4eKxyIjI9G/f39kZmZiwoQJyMzMRFRUlBh0AGDo0KGQy+XIysrCrbfe2uhjGwwGGAwG8XudTue2cVNDrOwQEZEv+e2u51qtFgAQHx/vdDw+Pl68TavVIi4uzul2pVKJ6Oho8T6NmTt3Ll555RW3jZX+Hq+zQ0REvnRJ7no+Y8YMsVIF2Co7SUlJPhxRYONqLCIi8qVm7XruSQkJCQCAoqIiJCYmiseLiorE6bKEhAQUFxc7/ZzZbEZpaan4841Rq9VQq9XuHzQ1yr4ayyoAVqsAubxhzxcREZGnSF6N5S2pqalISEjAmjVrxGM6nQ5ZWVnixQzT09NRVlaG7Oxs8T5r166F1WpF//79vT5mapzCIdxYBE5lERGRd0mu7LhTZWUlcnNzxe/z8vKwa9cuREdHIzk5GVOnTsVrr72GTp06ITU1FS+99BLatGmDsWPHAgC6deuGESNG4MEHH8T8+fNhMpnw2GOPYcKECVyJ5UeUjmHHKiBI4cPBEBHRJcenYWfHjh244YYbxO/tfTSTJk3CwoUL8eyzz6KqqgoPPfQQysrKcM0112DFihVOS9y//vprPPbYYxgyZAjkcjnGjx+PefPmef210IU5Vna4IouIiLxNJgicV9DpdIiMjER5eXmLbrz2V2aLFR1fXA4A2D1rGCJDg3w8IiIiCgSufn77bc8OBQ7nyg5XZBERkXcx7JDHyWQyMfDwWjtERORtDDvkFbyKMhER+QrDDnmFQsbKDhER+QbDDnmFkpUdIiLyEYYd8gqFuD8WG5SJiMi7GHbIK1jZISIiX2HYIa8QG5QtDDtERORdDDvkFfbNQNmgTERE3sawQ17BpedEROQrDDvkFUpeVJCIiHyEYYe8oq6yw9VYRETkXQw75BXcLoKIiHyFYYe8Qqlgzw4REfkGww55hcK+GotLz4mIyMsYdsgreFFBIiLyFYYd8gr27BARka8w7JBXKLkai4iIfIRhh7yClR0iIvIVhh3yCvbsEBGRrzDskFcouDcWERH5CMMOeQUrO0RE5CsMO+QVitqLClosbFAmIiLvYtghr2Blh4iIfIVhh7yCq7GIiMhXGHbIK1jZISIiX2HYIa/gaiwiIvIVhh3yClZ2iIjIVxh2yCvqena4GouIiLyLYYe8gpUdIiLyFYYd8oq66+ww7BARkXcx7JBXsLJDRES+wrBDXmFfjWUVGHaIiMi7GHbIK1jZISIiX2HYIa8QV2OxZ4eIiLyMYYe8gpUdIiLyFYYd8gpeZ4eIiHyFYYe8gpUdIiLyFYYd8gqFgntjERGRbzDskFewskNERL7CsENeUdezw7BDRETexbBDXsHKDhER+QrDDnkFV2MREZGvMOyQVyhrt4sw86KCRETkZQw75BXs2SEiIl9h2CGvYM8OERH5CsMOeYVCwcoOERH5BsMOeQUrO0RE5CsMO+QVXI1FRES+wrBDXiGuxgqQys7ZCgNW7CuE2cLwRkTk7xh2yCsCbTXWnGUH8PBXOVh9sNjXQyEiootg2CGvEHt2AuQ6O8eKKwEAx89V+ngkRER0MQw75BWBVtkprtDb/qsz+HgkNuU1JizacgIllf4xHiIif8KwQ16hVATOaiyj2YpzlUYAtt4df7Bw8wnM/nU/Pt543OvPbQ2A3yn5J763yF0YdsgrlAG0GuusQ/XEXuHxtSPFFQCA42e9O612pKgCvV5ZifdWH/Xq81LgW763EN1f/hMr9ml9PRQKAAw75BWKAFqNpS2vCzhFfjKNlV9SDQA4db7Gq8/719FzqDCYsWK/5z+QBEHAZ38dx+bccx5/LvK9VQeLUG20YM3BIl8PhQIAww55hTKAenaKdXVhp7hCD0Hw7WsSBAEnSqoAAKfLvBt28mufN7+kyuPnYWdBGV77/SCe+WG3R5/HU/Qmi8/fKy2JPcCfLK328UgoEDDskFcomnkF5fySauTkn3fnkJpM6xB29CYrKgxmH44GKKs2oUJvG0OF3gyd3uS157Z/EFUZLSipMv7tfYt0emQeK2nycx3R2qbqCsv1OH+R5/I3fx09i64vrcCiLSd8PZQW40Rt2LGHHqLmYNghr2huZefeBdvwz/mZyDtX5c5hXVT2yfN444+D0Jss4rH6U1e+XpFV/1++p704lXXS4YPoZMnf/26e+GYn7vh0K7afKG3Sc+UW1/UjHSmqaNJj+Mqy3YUAgD/2sv/EFVUGM87V9sZpdXqnv39ETcGwQ17huPRcailfW67H8XNVsFgFbM9r2gdlU73y2358svE4fso5LR4r0jk3Jfu6Sbl+yPBW347FKuDUecewc+F/gVcZzNhx0laZa2p1J/dsyw07u0+VAQAOFOq4wsgF+fUCfP3viaRi2CGvsG8XAUiv7tg/KOp/7WlVBjP2n9EBAHY4VCMahB1fV3ZK6ld2vPPBcKasBiaHi0Q2FnZyiyvwy67T2F1QJv7e9zTxd+hY2TncgsJOjdGCo7VjrzSYvd5E3hLVD/B/F6Tt9CYLFmflo6za/VOch7Q6rNhX6PbHJe9h2CGvUNReZweQ3rfj+OG451S5u4Z0UbscPqCzHfqF7D07cRFqAP5Q2bF9ENirZxdqUs4vqcYjX2W7rfep/gdQ/Q8ovcmCuz7bhie/3YU3lh8Uj+8+VS65uldjtDi9rsPalhN2DhSWOwX8A4Xeew+3VBd7bzXmg7W5eGHpXsxZdsCtY7FYBUxesB0Pf5WDLce4ErClCpiwk5GRgfbt2yM4OBj9+/fHtm3bfD0kcmDv2QEaVna05Xoc+5vrwzgGnENaHQxm78zf7zhRFwpOllSLFxC0V3J6tot0+t5X8kttHwS9asdzobDz0i/7sHyfFi//ul/S45+vMmL1gSKsPVSESodm7JO1z2v/3dbvHfpq60kxGO47rROPn60wODV5u+L4uUo45qPD2gqPrGw6WVLl9hVtuwucw82BM7oL3DNwlFUbMeQ/63HP/7Y1adrO3pwsvrcuUtkRBAE/77JNNa/Yp0WNsXn/jxAEAVMW5+Caf6/Fb7vPoLD2chO/7DzTrMf1BIPZ4vP31LpDxbh81goszsr36Tj+TkCEne+++w7Tpk3D7NmzkZOTg169emH48OEoLuYmjf5C4RB23ltzVGw0Lq7QY/S8vzD83Y3YWVtxKK0yImNdLo4W2T7Q7GFHJgNMFgEHC73zr/odJ537gxZuycPrvx8QP/C7t60NOz6+irL9g2Bgx1gAzg3KxTo93l11BAs352HDkbMAbOFxd0GZS4+973Q5Bv9nPR74YgfuW7gD9y/cLn542VfJ9EluBcD2If7B2qOY9cs+zPplHzLW5TZ4vDCVAkDDAHAx9imsnu0ioZDLoNObm32NoxPnqpCxLle8lMAhrQ7D3t2IEf/diAI39ojYK5OtayuBBwrrPpgc3+vesjP/PD7ecAzVRs+tIvx443EcO1uFjUfO4ve9hfhmWz7+lHAtJnuAt7+3Lrb8fGdBmTg9WG20YO2h5v2/f3NuCX7fU4hT52vw7I97xOPL9xVi45Gz+Oyv4zCafX+B1PNVRoz/aAtGzfsL76/xzIU9z5TV4J1VR5B90rkiXKzTI2NdLo6drcScZQdQZbTgzeUHUV7jvdWgUih9PQB3eOedd/Dggw9i8uTJAID58+fj999/x//+9z88//zzPh4dAYBCVhd2Ptl4HD/sKMD8u/ri443HxSXLT3+/G+/f2RtTv92Fo8WVmL/hGF66KQ3lNSaolHJc1b4VNueWYNPRs9h3uhzf7yhApd6M2Ag17h3QHj3aRmLLsXP4dfcZdGwdjjv7p8BkseKrrSdxuqwG/+jbDn1TbP/z1NWY8VXWSRSUVuPW3m3RLzXaabyCAOzKLwMA9E6Ows78MmSsOybeLpcBqbFhAIBT56tx6nw19CYrvtuej32ndRjRPQGDu8bB4WU3m8Uq4NddZ7D52Dlc0zEWN/dqg++2F6C4wgClXIaBHWPx/tpcFJyvwanz1SivMeGRr3KcmjtVCjmMFis+35SHZ0d0EY8XVxjwv015OHBGB7lchsFd49A2KgT/WXkYOr0ZbaNCUFJlQFZeKZ76fhfOVhiwpbbR+NpOsdh2ohQGsxVvrzziNOaUmFB0igvH6oPFCFUpMLJHIpZkn8LW4yXQmyz4MecU2rUKQe+kVvh+RwFKq4yICAnCxH7JSO8QI54/ezhKS9Sg2mhBbnElFm/Lxz/7tnM6xwcLK/DNtnxogpW4Z0B7caqxvjNlejz8VTZKq4z4fkcBMu7sg+lL9sBgtsJgtuLpH3bjP//sBZnMFuq+yDwJABjePR4r9xfBKgi4J709UmJCG33szzcdx9EiW0CzV4puu7IdMtYdw77TOpw6X40qgwWPLc4R3+v3X5OKrOOl6N5Wg9uvSkZwUN2/RUurjFi05STOVRpw+1VJYlURsL1XM4+V4Jfdp3FZbDgmXp2McHXj/2vfVVCGad/thtFixZqDxXjrHz3FrVwaU2O0YPG2fBzWVmBUj0Rc17n1Bd/ThworsHhbPsLVSqw6UHchwKe/tz0fANw3MBX5pdVQB8kxKb092kQFAwDyzlXhy8yTUCpkuCe9PU6cs71nB3W2vbfyzlXi1PlqWKwClu0pxG+7z8BotiI5JhT3X5MqrnJTymUwWwX8lHMKvZLqzlGRTo9FW06iymDGnf2T0SUhwun8rTtcjBX7tEhL1GBCvyS8vfKweLs91ChrQ/Y9/7PNGmw5VoJXbrkcmcdL8OuuM2gfG4q7rk654LmvNJjxZeZJbD1eAgHAlSmtcE96e0SFBon3qTba+o7+OnoWggBckRSFewe2R3SYqsHjHSyswL9XHBL/IfDfNUfRO7kV2sc6vyeNZit+yjmNlQe04kbMKqUcY3u3xajuiXBop8TJkmp8vikPJ85VQaWU48a0ePyYfQpnyvWYt+YoBnSIwSPXd0CrUBUe+TobBaU1eG/1UfH3q9Ob8cHao5g0oD0EAVh5oAirDxShV1IUHrg2FbHhjf999AaZ0MKvcmU0GhEaGoolS5Zg7Nix4vFJkyahrKwMv/zyS4OfMRgMMBjq/lWo0+mQlJSE8vJyaDQabwz7ktT++d8bPa5SyKEJCRKXmjamV1IUrusUi3lrG1YLPClMpcArY7qLF7JLjAxGYbke/VKj8dTQzrjj061eHc+FvHRTGv7Rpx16zVnZ4LbYcDV0NSaog+R4c1xPTFmcI+mxr0xphQWTr8KyPYWY8dPeBrf/794rcd/CHeL3j93QEXIZIJPJcFPPRJTXmDDhk60Y2SMRV18WjReX7pP+Amu9OKobjp+rwjfbPFMubxUaBIPZiupmToPUF65W4s+nBmHgm2vd+rj+7PI2Gpwuq0FZddP/pf/rYwNxywebXb7/M8M6NwjcTRUSpEC3xAjk5JchNlyN0T0SsKg29PqT1hFqdE2IwF9HPddPFBehRmmV8W/7La/pGItNf3N18+AgOT675ypc0ynWrWPT6XSIjIy86Od3i6/snDt3DhaLBfHx8U7H4+PjcejQoUZ/Zu7cuXjllVe8MTxycGvvtjhZUoU3x/fEv5cfwqbccwhSyDFjVFekxobhscU7UWUwo3N8BN76R0+8v/Yo1hwshkohx539ktA7uRW+33EK56uNiNcE494B7dG9bSQ2HT2LxdsKUKE3ITZcjduuTML2E6XYcbIUMsgwsGMM0hI1+G5Hgfg/XrlMhv6XRaNXuyixolCfTAbcM6A9hnaLQ5f4CFzeRoO543ugWGdAdJgKMhnQLVHjtB9Vr3ZRGNQ5FkuyT4nz/O7UoXU4RvdMxLI9hTh+thJhaiWeHtYZE/unQBAEjOye4FTC7942Eh/c2RvBSgUsgoCYMBVG90jE6nqX4FfKZRjSLR63XZmECr0JC7ecQHmNCXf2T8btVyVBrVRgwlVJ2JVfhu0nSzH2irbYerwE5yoN6JsSjUev74BVB4rw3oTeSGvT8H84fz13A1qFqqCrMeGTjcehLdcjKjQIt1+ZhAOFOhw/V4Vbr2iL/pfFYHdBGRZuOdEg/MaEqTA0LR6JkcHoEh+O/20+0WBlXJhaiX/0bQdtuR5rDhb97f+cB3aMxfMju+L5H/dg/xkdgoMU+M9tvaCrMeOlX/aJ/6JXKeW4pVcbCAA2557DgA6xUMiBX3edgaGRqQyVQo7h3RMwrndbBClt/2xOiQ5FnCYY4/u0w7I9dX0f9vf6u6uOIPdsJcb1bouNR841WHWokMswqFNrpLYOww87TqGi3oUjY8PV+OeV7ZB98jy2nyjFhf4JK5fJcGuftvhn33Z4+ofdLl2TqU9yK6R3iMEP2QV/258WplZifJ+2KK4wYGd+GV4d2x2nztfgvdVH8PSwLjh1vhr/23QCI7onoNJgxp/7tGJFQF1baTCarfh9TyGMFiuu7RSL7m0iMaRrnNOHaGpsGO6/JhVJ0aFYvrcQP+86A73Jgp7tIvHQoA7Yf0bXYBorSCHH0G5xiA1X48ecUw3CbGJkMP7Rtx02Hj2H3QVlUMpleOrGzri2U2s88lU2Jg1oj2s7xWLt4WKMuDwBN3SNw3M/7kGxzuDyuZfJgH6pMbjn6hQoFDJ8vfUkNueWwOrwAzKZ7XxPGtAewUEKfLstHxuOnG10BWuYWol/XtkOD157GRQyGe78LOuCe+N1TdTgvoHt0SYqBIBtD73PN+U16IWyv9dv6tkGZ8pqsHDLCQQHyfHhxL4wmC34ZONx/LzzNAxmK3q0jcQb43rg//48DL3Jgo/v7oup3+4Sp8sBoG2rEIzv0w4rDxQh72ylU7XN21p8ZefMmTNo27YttmzZgvT0dPH4s88+iw0bNiArK6vBz7CyQ0RE5B2CIODU+RokRTec9m2uS6ayExsbC4VCgaIi53+pFhUVISEhodGfUavVUKt9N3dIRER0qZDJZB4JOlK0+NVYKpUKffv2xZo1a8RjVqsVa9ascar0EBER0aWpxVd2AGDatGmYNGkSrrzySvTr1w///e9/UVVVJa7OIiIioktXQISd22+/HWfPnsWsWbOg1WpxxRVXYMWKFQ2alomIiOjS0+IblN3B1QYnIiIi8h+ufn63+J4dIiIior/DsENEREQBjWGHiIiIAhrDDhEREQU0hh0iIiIKaAw7REREFNAYdoiIiCigMewQERFRQGPYISIiooAWENtFNJf9ItI6nc7HIyEiIiJX2T+3L7YZBMMOgIqKCgBAUlKSj0dCREREUlVUVCAyMvKCt3NvLABWqxVnzpxBREQEZDKZ2x5Xp9MhKSkJBQUF3HPLBTxfruO5ch3PlTQ8X67juZLGE+dLEARUVFSgTZs2kMsv3JnDyg4AuVyOdu3aeezxNRoN/yJIwPPlOp4r1/FcScPz5TqeK2ncfb7+rqJjxwZlIiIiCmgMO0RERBTQGHY8SK1WY/bs2VCr1b4eSovA8+U6nivX8VxJw/PlOp4raXx5vtigTERERAGNlR0iIiIKaAw7REREFNAYdoiIiCigMewQERFRQGPY8aCMjAy0b98ewcHB6N+/P7Zt2+brIfncyy+/DJlM5vSna9eu4u16vR5TpkxBTEwMwsPDMX78eBQVFflwxN6zceNG3HzzzWjTpg1kMhl+/vlnp9sFQcCsWbOQmJiIkJAQDB06FEePHnW6T2lpKSZOnAiNRoOoqCjcf//9qKys9OKr8J6Lna977723wXttxIgRTve5VM7X3LlzcdVVVyEiIgJxcXEYO3YsDh8+7HQfV/7u5efnY/To0QgNDUVcXBymT58Os9nszZfica6cq+uvv77Be+vhhx92us+lcK4A4KOPPkLPnj3FCwWmp6dj+fLl4u3+8r5i2PGQ7777DtOmTcPs2bORk5ODXr16Yfjw4SguLvb10Hzu8ssvR2Fhofhn06ZN4m1PPfUUfvvtN/zwww/YsGEDzpw5g3HjxvlwtN5TVVWFXr16ISMjo9Hb33rrLcybNw/z589HVlYWwsLCMHz4cOj1evE+EydOxP79+7Fq1SosW7YMGzduxEMPPeStl+BVFztfADBixAin99o333zjdPulcr42bNiAKVOmYOvWrVi1ahVMJhOGDRuGqqoq8T4X+7tnsVgwevRoGI1GbNmyBYsWLcLChQsxa9YsX7wkj3HlXAHAgw8+6PTeeuutt8TbLpVzBQDt2rXDm2++iezsbOzYsQODBw/GmDFjsH//fgB+9L4SyCP69esnTJkyRfzeYrEIbdq0EebOnevDUfne7NmzhV69ejV6W1lZmRAUFCT88MMP4rGDBw8KAITMzEwvjdA/ABCWLl0qfm+1WoWEhATh//7v/8RjZWVlglqtFr755htBEAThwIEDAgBh+/bt4n2WL18uyGQy4fTp014buy/UP1+CIAiTJk0SxowZc8GfuZTPV3FxsQBA2LBhgyAIrv3d++OPPwS5XC5otVrxPh999JGg0WgEg8Hg3RfgRfXPlSAIwnXXXSc8+eSTF/yZS/Vc2bVq1Ur47LPP/Op9xcqOBxiNRmRnZ2Po0KHiMblcjqFDhyIzM9OHI/MPR48eRZs2bXDZZZdh4sSJyM/PBwBkZ2fDZDI5nbeuXbsiOTn5kj9veXl50Gq1TucmMjIS/fv3F89NZmYmoqKicOWVV4r3GTp0KORyObKysrw+Zn+wfv16xMXFoUuXLnjkkUdQUlIi3nYpn6/y8nIAQHR0NADX/u5lZmaiR48eiI+PF+8zfPhw6HQ68V/xgaj+ubL7+uuvERsbi+7du2PGjBmorq4Wb7tUz5XFYsG3336LqqoqpKen+9X7ihuBesC5c+dgsVicfnkAEB8fj0OHDvloVP6hf//+WLhwIbp06YLCwkK88soruPbaa7Fv3z5otVqoVCpERUU5/Ux8fDy0Wq1vBuwn7K+/sfeU/TatVou4uDin25VKJaKjoy/J8zdixAiMGzcOqampOHbsGF544QWMHDkSmZmZUCgUl+z5slqtmDp1KgYOHIju3bsDgEt/97RabaPvP/ttgaixcwUAd955J1JSUtCmTRvs2bMHzz33HA4fPoyffvoJwKV3rvbu3Yv09HTo9XqEh4dj6dKlSEtLw65du/zmfcWwQ141cuRI8euePXuif//+SElJwffff4+QkBAfjowCzYQJE8Sve/TogZ49e6JDhw5Yv349hgwZ4sOR+daUKVOwb98+p145atyFzpVjX1ePHj2QmJiIIUOG4NixY+jQoYO3h+lzXbp0wa5du1BeXo4lS5Zg0qRJ2LBhg6+H5YTTWB4QGxsLhULRoOO8qKgICQkJPhqVf4qKikLnzp2Rm5uLhIQEGI1GlJWVOd2H5w3i6/+791RCQkKDBniz2YzS0tJL/vwBwGWXXYbY2Fjk5uYCuDTP12OPPYZly5Zh3bp1aNeunXjclb97CQkJjb7/7LcFmgudq8b0798fAJzeW5fSuVKpVOjYsSP69u2LuXPnolevXnjvvff86n3FsOMBKpUKffv2xZo1a8RjVqsVa9asQXp6ug9H5n8qKytx7NgxJCYmom/fvggKCnI6b4cPH0Z+fv4lf95SU1ORkJDgdG50Oh2ysrLEc5Oeno6ysjJkZ2eL91m7di2sVqv4P+NL2alTp1BSUoLExEQAl9b5EgQBjz32GJYuXYq1a9ciNTXV6XZX/u6lp6dj7969TgFx1apV0Gg0SEtL884L8YKLnavG7Nq1CwCc3luXwrm6EKvVCoPB4F/vK7e1OpOTb7/9VlCr1cLChQuFAwcOCA899JAQFRXl1HF+KXr66aeF9evXC3l5ecLmzZuFoUOHCrGxsUJxcbEgCILw8MMPC8nJycLatWuFHTt2COnp6UJ6erqPR+0dFRUVws6dO4WdO3cKAIR33nlH2Llzp3Dy5ElBEAThzTffFKKiooRffvlF2LNnjzBmzBghNTVVqKmpER9jxIgRQu/evYWsrCxh06ZNQqdOnYQ77rjDVy/Jo/7ufFVUVAjPPPOMkJmZKeTl5QmrV68W+vTpI3Tq1EnQ6/XiY1wq5+uRRx4RIiMjhfXr1wuFhYXin+rqavE+F/u7Zzabhe7duwvDhg0Tdu3aJaxYsUJo3bq1MGPGDF+8JI+52LnKzc0V5syZI+zYsUPIy8sTfvnlF+Gyyy4TBg0aJD7GpXKuBEEQnn/+eWHDhg1CXl6esGfPHuH5558XZDKZsHLlSkEQ/Od9xbDjQe+//76QnJwsqFQqoV+/fsLWrVt9PSSfu/3224XExERBpVIJbdu2FW6//XYhNzdXvL2mpkZ49NFHhVatWgmhoaHCrbfeKhQWFvpwxN6zbt06AUCDP5MmTRIEwbb8/KWXXhLi4+MFtVotDBkyRDh8+LDTY5SUlAh33HGHEB4eLmg0GmHy5MlCRUWFD16N5/3d+aqurhaGDRsmtG7dWggKChJSUlKEBx98sME/Ni6V89XYeQIgLFiwQLyPK3/3Tpw4IYwcOVIICQkRYmNjhaefflowmUxefjWedbFzlZ+fLwwaNEiIjo4W1Gq10LFjR2H69OlCeXm50+NcCudKEAThvvvuE1JSUgSVSiW0bt1aGDJkiBh0BMF/3lcyQRAE99WJiIiIiPwLe3aIiIgooDHsEBERUUBj2CEiIqKAxrBDREREAY1hh4iIiAIaww4REREFNIYdIiIiCmgMO0RERBTQGHaI6JJ37733YuzYsc1+HJlMhp9//rnZj0NE7qX09QCIiHztvffeAy8mTxS4GHaIqEUwGo1QqVQeeezIyEiPPC4R+QdOYxGRJNdffz2eeOIJPPvss4iOjkZCQgJefvllp/uUlZXhgQceQOvWraHRaDB48GDs3r1bvL2xaaOpU6fi+uuvd3qexx57DFOnTkVsbCyGDx8OANiwYQP69esHtVqNxMREPP/88zCbzZLGV1/98bjyGEePHsWgQYMQHByMtLQ0rFq1qsHjFhQU4LbbbkNUVBSio6MxZswYnDhxAgBw6NAhhIaGYvHixeL9v//+e4SEhODAgQN/O14ikoZhh4gkW7RoEcLCwpCVlYW33noLc+bMcfqw/+c//4ni4mIsX74c2dnZ6NOnD4YMGYLS0lLJz6NSqbB582bMnz8fp0+fxqhRo3DVVVdh9+7d+Oijj/D555/jtddekzS+5r5Gq9WKcePGQaVSISsrC/Pnz8dzzz3n9PMmkwnDhw9HREQE/vrrL2zevBnh4eEYMWIEjEYjunbtirfffhuPPvoo8vPzcerUKTz88MP497//jbS0NEljJaKLcOse6kQU8K677jrhmmuucTp21VVXCc8995wgCILw119/CRqNRtDr9U736dChg/Dxxx8LgiAIkyZNEsaMGeN0+5NPPilcd911Ts/Tu3dvp/u88MILQpcuXQSr1Soey8jIEMLDwwWLxeLS+BpTfzwXe4w///xTUCqVwunTp8Xbly9fLgAQli5dKgiCIHz55ZcNxmowGISQkBDhzz//FI+NHj1auPbaa4UhQ4YIw4YNc7o/EbkHe3aISLKePXs6fZ+YmIji4mIAwO7du1FZWYmYmBin+9TU1ODYsWOSnqdv375O3x88eBDp6emQyWTisYEDB6KyshKnTp1CcnLyRcfnqr97jIMHDyIpKQlt2rQRb09PT3e6/+7du5Gbm4uIiAin43q93uk8/O9//0Pnzp0hl8uxf/9+p9dGRO7BsENEkgUFBTl9L5PJYLVaAQCVlZVITEzE+vXrG/xcVFQUAEAulzdY/WQymRrcPywszO3j89ZjVFZWom/fvvj6668b3Na6dWvx6927d6OqqgpyuRyFhYVITEyUNE4iujiGHSJyqz59+kCr1UKpVKJ9+/aN3qd169bYt2+f07Fdu3Y1CBj1devWDT/++CMEQRArIJs3b0ZERATatWvnlvG7olu3bigoKHAKJ1u3bnW6T58+ffDdd98hLi4OGo2m0ccpLS3FvffeixdffBGFhYWYOHEicnJyEBIS4vHXQHQpYYMyEbnV0KFDkZ6ejrFjx2LlypU4ceIEtmzZghdffBE7duwAAAwePBg7duzAF198gaNHj2L27NkNwk9jHn30URQUFODxxx/HoUOH8Msvv2D27NmYNm0a5HLv/e9s6NCh6Ny5MyZNmoTdu3fjr7/+wosvvuh0n4kTJyI2NhZjxozBX3/9hby8PKxfvx5PPPEETp06BQB4+OGHkZSUhJkzZ+Kdd96BxWLBM88847XXQXSpYNghIreSyWT4448/MGjQIEyePBmdO3fGhAkTcPLkScTHxwMAhg8fjpdeegnPPvssrrrqKlRUVOCee+656GO3bdsWf/zxB7Zt24ZevXrh4Ycfxv3334+ZM2d6+mU5kcvlWLp0KWpqatCvXz888MADeP31153uExoaio0bNyI5ORnjxo1Dt27dcP/990Ov10Oj0eCLL77AH3/8gS+//BJKpRJhYWH46quv8Omnn2L58uVefT1EgU4m1J84JyIiIgogrOwQERFRQGPYISIiooDGsENEREQBjWGHiIiIAhrDDhEREQU0hh0iIiIKaAw7REREFNAYdoiIiCigMewQERFRQGPYISIiooDGsENEREQB7f8BnAWrNAL0hQcAAAAASUVORK5CYII=\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "completed:  0.28125\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 1378/1378 [00:10<00:00, 133.03it/s]\n",
            "100%|██████████| 1378/1378 [00:09<00:00, 150.60it/s]\n",
            "100%|██████████| 1378/1378 [00:10<00:00, 136.79it/s]\n",
            "100%|██████████| 1378/1378 [00:10<00:00, 127.37it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "batch 13\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "completed:  0.40625\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 1378/1378 [00:10<00:00, 133.65it/s]\n",
            "100%|██████████| 1378/1378 [00:09<00:00, 144.71it/s]\n",
            "100%|██████████| 1378/1378 [00:09<00:00, 138.66it/s]\n",
            "100%|██████████| 1378/1378 [00:10<00:00, 135.18it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "batch 17\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "completed:  0.53125\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 1378/1378 [00:10<00:00, 135.45it/s]\n",
            "100%|██████████| 1378/1378 [00:09<00:00, 146.40it/s]\n",
            "100%|██████████| 1378/1378 [00:09<00:00, 139.83it/s]\n",
            "100%|██████████| 1378/1378 [00:10<00:00, 135.76it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "batch 21\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "completed:  0.65625\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 1378/1378 [00:10<00:00, 136.44it/s]\n",
            "100%|██████████| 1378/1378 [00:09<00:00, 144.72it/s]\n",
            "100%|██████████| 1378/1378 [00:10<00:00, 137.68it/s]\n",
            "100%|██████████| 1378/1378 [00:10<00:00, 136.19it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "batch 25\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "completed:  0.78125\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 1378/1378 [00:10<00:00, 134.27it/s]\n",
            "100%|██████████| 1378/1378 [00:09<00:00, 142.83it/s]\n",
            "100%|██████████| 1378/1378 [00:09<00:00, 139.51it/s]\n",
            "100%|██████████| 1378/1378 [00:10<00:00, 135.21it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "batch 29\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "completed:  0.90625\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 1378/1378 [00:10<00:00, 134.84it/s]\n",
            "100%|██████████| 1378/1378 [00:09<00:00, 141.28it/s]\n",
            "100%|██████████| 1378/1378 [00:09<00:00, 139.05it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "helo there\n"
          ]
        }
      ],
      "source": [
        "\n",
        "\n",
        "for ba in range(num_batches):\n",
        "  if((ba-1)%4==0):\n",
        "    indic1=0\n",
        "    indic2=0\n",
        "    for kl in range(1):\n",
        "      x= np.arange(len(count[kl]))\n",
        "      #print(count[kl], y_data[batch_size*num_batches + kl] )\n",
        "      #print(count[kl][output_dict[y_data[batch_size*num_batches + kl]]])\n",
        "      print(\"batch\", ba)\n",
        "      plt.plot(x, count[kl])\n",
        "      plt.xlabel('neuron index', fontsize=10)\n",
        "      plt.ylabel('total spikes after '+str(ba)+' batches', fontsize=10)\n",
        "      plt.show()\n",
        "    print(\"completed: \", ba/num_batches)\n",
        "  Vm_tf = tf.constant(np.zeros((batch_size, N)), dtype=tf.float32)\n",
        "  SI_tf = tf.constant(np.zeros((batch_size, N)), dtype=tf.float32)\n",
        "  SinI_tf = tf.constant(np.zeros((batch_size, in_size)), dtype=tf.float32)\n",
        "  spT_tf = tf.constant(np.zeros((batch_size, N)), dtype=tf.float32)\n",
        "  spT_in_tf = tf.constant(np.zeros((batch_size, in_size)), dtype=tf.float32)\n",
        "\n",
        "  batch_in_full = x_in_train[ba*batch_size:(ba+1)*batch_size]\n",
        "  batch_in_full_tf = tf.constant(batch_in_full, dtype=tf.float32)\n",
        "  y_in_full = y_in_train[ba*batch_size:(ba+1)*batch_size]\n",
        "\n",
        "  W_lsm_tf = tf.constant(W_lsm, dtype=tf.float32)\n",
        "\n",
        "  # Try multimodal W_lsm from MNIST\n",
        "  #W_lsm_tf = tf.constant(W_lsm_multi, dtype=tf.float32)\n",
        "\n",
        "  W_in_tf = tf.constant(W_in, dtype=tf.float32)\n",
        "\n",
        "  if flag == \"no_stdp\":\n",
        "    #Vm, SI, Sin, SinI, eta, eta1, a1, a2, in_W, W, sc_W, th, n_iter\n",
        "    S_liq, count = run_LSM(Vm_tf, SI_tf, batch_in_full_tf, SinI_tf, eta, eta1, a1, a2, W_in_tf, W_lsm_tf, w_scale, th, num_iter)\n",
        "  elif flag == \"il_stdp\":\n",
        "    #Vm, SI, Sin, SinI, spT, spT_in, eta, eta1, a1, a2, in_W, W, th, n_iter, batch_s, Nin=0, Nrev=0, Ap=0.01, An=0.02, a3=0.1, eta2=0.1\n",
        "    S_liq, in_wf, a_new = run_LSM_IL_STDP(Vm_tf, SI_tf, batch_in_full_tf, SinI_tf, spT_tf, spT_in_tf, eta, eta1, a1, a2, W_in_tf, W_lsm_tf, th, num_iter, batch_size)\n",
        "    W_in = in_wf\n",
        "    a2 = a_new\n",
        "  elif flag == \"ll_stdp\":\n",
        "    #Vm, SI, Sin, SinI, spT, eta, eta1, a1, a2, in_W, W, th, n_iter, batch_s, Nin=0, Nrev=0, Ap=0.01, An=0.02, a3=0.1, eta2=0.1\n",
        "    S_liq, lsm_wf, a_new = run_LSM_LL_STDP(Vm_tf, SI_tf, batch_in_full_tf, SinI_tf, spT_tf, eta, eta1, a1, a2, W_in_tf, W_lsm_tf, th, num_iter, batch_size)\n",
        "    W_lsm = lsm_wf\n",
        "    a2 = a_new\n",
        "  elif flag == \"full_stdp\":\n",
        "    #Vm, SI, Sin, SinI, spT, spT_in, eta, eta1, a1, a2, in_W, W, W_mask, th, n_iter, batch_s, W_sign, in_W_sign=1, Nin=0, Nrev=0, Ap=0.01, An=0.02, dw_in_scale=1, dw_lsm_scale=1, a3=0.1, eta2=0.1\n",
        "    S_liq, in_wf, lsm_wf, a_new, count = run_LSM_full_STDP(Vm_tf, SI_tf, batch_in_full_tf, SinI_tf, spT_tf, spT_in_tf, eta, eta1, a1, a2, W_in_tf, W_lsm_tf, W_lsm_mask, th, num_iter, batch_size, W_lsm_sign, An = A_new)\n",
        "    W_in = in_wf\n",
        "    W_lsm = lsm_wf\n",
        "    #A_new = a_new\n",
        "  elif flag == \"sup_stdp\":\n",
        "    #Vm, SI, Sin, SinI, spT, spT_in, eta, eta1, a1, a2, in_W, W, W_mask, th, n_iter, batch_s, W_sign, in_W_sign=1, Nin=0, Nrev=0, Ap=0.01, An=0.02, dw_in_scale=1, dw_lsm_scale=1, a3=0.1, eta2=0.1\n",
        "    S_liq, in_wf, lsm_wf, a_new, count = run_LSM_supervised_STDP(Vm_tf, SI_tf, batch_in_full_tf, SinI_tf, spT_tf, spT_in_tf, eta, eta1, a1, a2, W_in_tf, W_lsm_tf, W_lsm_mask, th, num_iter, batch_size, W_lsm_sign, An = A_new, y_labels = y_in_full)\n",
        "    W_in = in_wf\n",
        "    W_lsm = lsm_wf\n",
        "    A_new = a_new\n",
        "  elif flag == \"symsup_stdp\":\n",
        "    #Vm, SI, Sin, SinI, spT, spT_in, eta, eta1, a1, a2, in_W, W, W_mask, th, n_iter, batch_s, W_sign, in_W_sign=1, Nin=0, Nrev=0, Ap=0.01, An=0.02, dw_in_scale=1, dw_lsm_scale=1, a3=0.1, eta2=0.1\n",
        "    S_liq, in_wf, lsm_wf, a_new, count = run_LSM_symsup_STDP(Vm_tf, SI_tf, batch_in_full_tf, SinI_tf, spT_tf, spT_in_tf, eta, eta1, a1, a2, W_in_tf, W_lsm_tf, W_lsm_mask, th, num_iter, batch_size, W_lsm_sign, An = A_new, y_labels = y_in_full)\n",
        "    W_in = in_wf\n",
        "    W_lsm = lsm_wf\n",
        "    A_new = a_new\n",
        "  else:\n",
        "    S_liq = run_LSM(Vm_tf, SI_tf, batch_in_full_tf, SinI_tf, eta, eta1, a1, a2, W_in_tf, W_lsm_tf, w_scale, th, num_iter)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "  S_liq_c1 = tf.reduce_mean(S_liq[:,:partition,:], axis=1)\n",
        "  S_liq_c2 = tf.reduce_mean(S_liq[:,partition:2*partition,:], axis=1)\n",
        "  S_liq_c3 = tf.reduce_mean(S_liq[:,2*partition:3*partition,:], axis=1)\n",
        "  S_liq_c4 = tf.reduce_mean(S_liq[:,-partition:,:], axis=1)\n",
        "\n",
        "  S_liq_c = tf.concat([S_liq_c1, S_liq_c2, S_liq_c3, S_liq_c4], axis=1)\n",
        "\n",
        "  #S_liq_c = tf.reduce_mean(S_liq, axis=1)\n",
        "  #LSM_out_train2[b*batch_size:(b+1)*batch_size] = S_liq.numpy()\n",
        "  LSM_out_train[b*batch_size:(b+1)*batch_size] = S_liq_c.numpy()\n",
        "\n",
        "for ba in range(num_batches_test):\n",
        "  Vm_tf = tf.constant(np.zeros((batch_size, N)), dtype=tf.float32)\n",
        "  SI_tf = tf.constant(np.zeros((batch_size, N)), dtype=tf.float32)\n",
        "  SinI_tf = tf.constant(np.zeros((batch_size, in_size)), dtype=tf.float32)\n",
        "  spT_tf = tf.constant(np.zeros((batch_size, N)), dtype=tf.float32)\n",
        "\n",
        "  batch_in_full = x_test[ba*batch_size:(ba+1)*batch_size]\n",
        "  batch_in_full_tf = tf.constant(batch_in_full, dtype=tf.float32)\n",
        "\n",
        "  S_liq, count = run_LSM(Vm_tf, SI_tf, batch_in_full_tf, SinI_tf, eta, eta1, a1, a2, W_in_tf, W_lsm_tf, w_scale, th, num_iter)\n",
        "\n",
        "  S_liq_c1 = tf.reduce_mean(S_liq[:,:partition,:], axis=1)\n",
        "  S_liq_c2 = tf.reduce_mean(S_liq[:,partition:2*partition,:], axis=1)\n",
        "  S_liq_c3 = tf.reduce_mean(S_liq[:,2*partition:3*partition,:], axis=1)\n",
        "  S_liq_c4 = tf.reduce_mean(S_liq[:,-partition:,:], axis=1)\n",
        "\n",
        "  S_liq_c = tf.concat([S_liq_c1, S_liq_c2, S_liq_c3, S_liq_c4], axis=1)\n",
        "  #LSM_out_test2[b*batch_size:(b+1)*batch_size] = S_liq.numpy()\n",
        "\n",
        "  #S_liq_c = tf.reduce_mean(S_liq, axis=1)\n",
        "\n",
        "  LSM_out_test[ba*batch_size:(ba+1)*batch_size] = S_liq_c.numpy()\n",
        "\n",
        "with open(data_path + f\"LSM_out_train_{flag}.pkl\",\"wb\") as f:\n",
        "  pkl.dump(LSM_out_train, f)\n",
        "with open(data_path + f\"LSM_out_test_{flag}.pkl\",\"wb\") as f:\n",
        "  pkl.dump(LSM_out_test, f)\n",
        "with open(data_path + f\"Weights_LSM_{flag}.pkl\",\"wb\") as f:\n",
        "  pkl.dump(W_lsm, f)\n",
        "with open(data_path + f\"Weights_in_{flag}.pkl\",\"wb\") as f:\n",
        "  pkl.dump(W_in, f)\n",
        "with open(data_path + f\"An_{flag}.pkl\",\"wb\") as f:\n",
        "  pkl.dump(A_new, f)\n",
        "\n",
        "#with open(data_path + f\"LSM_out_train2_{flag}.pkl\",\"wb\") as f:\n",
        "#  pkl.dump(LSM_out_train2, f)\n",
        "#with open(data_path + f\"LSM_out_test2_{flag}.pkl\",\"wb\") as f:\n",
        "#  pkl.dump(LSM_out_test2, f)\n",
        "\n",
        "with open(data_path + f\"x_data.pkl\",\"wb\") as f:\n",
        "  pkl.dump(x_data, f)\n",
        "with open(data_path + f\"y_data.pkl\",\"wb\") as f:\n",
        "  pkl.dump(y_data, f)\n",
        "with open(data_path + f\"x_test.pkl\",\"wb\") as f:\n",
        "  pkl.dump(x_test, f)\n",
        "with open(data_path + f\"y_test.pkl\",\"wb\") as f:\n",
        "  pkl.dump(y_test, f)\n",
        "with open(data_path + f\"x_in_train.pkl\",\"wb\") as f:\n",
        "  pkl.dump(x_in_train, f)\n",
        "with open(data_path + f\"y_in_train.pkl\",\"wb\") as f:\n",
        "  pkl.dump(y_in_train, f)\n",
        "\n",
        "print(\"helo there\")\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "XplUZ3irVtr6",
        "outputId": "987c39f7-c959-4ce8-f41d-ba7bcf1b5934"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[-9.195841  -8.642937  -0.        -0.        -0.        -0.\n",
            " -0.        -0.        -0.        -0.        -8.123304  -9.216386\n",
            " -0.        -0.        -0.        -0.        -0.        -0.\n",
            " -0.        -0.        -0.        -0.        -0.        -0.\n",
            " -0.        -0.        -0.        -0.        -0.        -0.\n",
            " -0.        -0.        -0.        -0.        -0.        -0.\n",
            " -0.        -0.        -0.        -0.        -0.        -0.\n",
            " -0.        -0.        -0.        -0.         0.         0.\n",
            " -0.         0.        -0.        -0.         0.        -0.\n",
            "  0.        -0.         0.        -0.        -0.         0.\n",
            " -0.         0.        -0.         0.         0.        -0.\n",
            " -0.        -0.         0.        -0.        -0.         0.\n",
            " -0.         0.        -0.         0.        -0.        -0.\n",
            "  0.        -0.        -0.         0.         0.         0.\n",
            "  0.         0.        -0.         0.         0.         0.\n",
            "  0.        -0.         0.         0.         0.         0.\n",
            "  0.         0.        -0.        -0.         0.         0.\n",
            " -0.        -0.        -0.         0.        -0.         0.\n",
            " -0.        -0.         7.100157  -0.         0.        -0.\n",
            " -0.        -0.        -0.        -0.        -0.        -0.\n",
            " -0.         2.6841104 -0.        -0.        -0.         0.\n",
            " -0.        -0.        -0.         0.        -0.         0.\n",
            "  0.         0.         0.        -0.        -0.        -0.\n",
            " -0.         0.         0.        -0.        -0.         0.\n",
            " -0.        -0.         0.        -0.        -0.         0.\n",
            "  0.        -0.         0.        -0.        -0.        -0.\n",
            "  0.         0.        -0.         0.         0.         0.\n",
            "  0.        -0.         0.         0.         0.         0.\n",
            " -0.         0.        -0.         0.        -0.         0.\n",
            "  0.        -0.         0.        -0.         0.         0.\n",
            "  0.         0.        -0.         0.        -0.        -0.\n",
            "  0.         0.        -0.         0.        -0.        -0.\n",
            "  0.         0.         0.        -0.         0.         0.\n",
            "  0.         0.         0.        -0.        -0.         0.\n",
            "  0.        -0.        -0.        -0.        -0.        -0.\n",
            " -0.        -0.        -0.        -0.        -0.        -0.\n",
            " -0.         0.         0.        -0.        -0.         0.\n",
            " -0.         5.6900697 -0.        -0.         0.        -0.\n",
            " -0.        -0.        -0.         0.         0.        -0.\n",
            " -0.         0.        -0.         0.        -0.         0.\n",
            "  0.        -0.        -0.        -0.        -0.        -0.\n",
            " -0.        -0.        -0.        -0.        -0.        -0.\n",
            " -0.         0.        -0.         0.        -0.         0.\n",
            " -0.        -0.        -0.         0.         0.        -0.\n",
            "  0.        -0.         0.         0.         0.        -0.\n",
            " -0.         0.        -0.         0.         0.        -0.\n",
            "  0.         0.         0.         0.         0.         0.\n",
            "  0.         0.        -0.        -0.        -0.        -0.\n",
            "  0.         0.         0.         0.        -0.        -0.\n",
            "  0.        -0.        -0.        -0.        -0.         0.       ], shape=(300,), dtype=float32)\n",
            "tf.Tensor(\n",
            "[ 1.5000000e+01  1.4411841e+01  1.2782157e+01  1.0465145e+01\n",
            "  7.9093862e+00  5.5181918e+00  3.5539165e+00  2.1128764e+00\n",
            "  1.1595711e+00  5.8745843e-01  2.7473459e-01  1.1860581e-01\n",
            "  4.7266673e-02  1.7388437e-02  5.9050354e-03  1.8511470e-03\n",
            "  5.3569273e-04  1.4310244e-04  3.5288627e-05  8.0330219e-06\n",
            "  1.6880276e-06  3.2744367e-07  5.8634075e-08  9.6921475e-09\n",
            "  1.4789259e-09  2.0831915e-10  2.7087471e-11  3.2513534e-12\n",
            "  3.6026022e-13  3.6848932e-14  3.4792842e-15  3.0325738e-16\n",
            "  2.4399969e-17  1.8122731e-18  1.2425516e-19  7.8643284e-21\n",
            "  4.5947864e-22  2.4781377e-23  1.2337921e-24  5.6704166e-26\n",
            "  2.4057163e-27  9.4217221e-29  3.4062193e-30  1.1367667e-31\n",
            "  3.5020842e-33  0.0000000e+00 -3.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00 -3.0000000e+00 -3.0000000e+00\n",
            "  0.0000000e+00 -3.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            " -3.0000000e+00  0.0000000e+00 -3.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00 -3.0000000e+00 -3.0000000e+00 -3.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00 -3.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            " -3.0000000e+00  0.0000000e+00  0.0000000e+00 -3.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00 -3.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00 -3.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            " -3.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            " -3.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00 -3.0000000e+00 -3.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00 -3.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00 -3.0000000e+00  0.0000000e+00\n",
            " -3.0000000e+00  0.0000000e+00 -3.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00 -3.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00 -3.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            " -3.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00 -3.0000000e+00  0.0000000e+00 -3.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00 -3.0000000e+00 -3.0000000e+00  0.0000000e+00\n",
            " -3.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00 -3.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00 -3.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00  0.0000000e+00 -3.0000000e+00\n",
            "  0.0000000e+00 -3.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00 -3.0000000e+00 -3.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00 -3.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00 -3.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00 -3.0000000e+00 -3.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00 -3.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00 -3.0000000e+00 -3.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00 -3.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00 -3.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00\n",
            "  0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00], shape=(300,), dtype=float32)\n",
            "(300, 300)\n",
            "(96, 300)\n",
            "{'down': 96, 'go': 117, 'left': 135, 'no': 86, 'right': 138, 'stop': 126, 'up': 275, 'yes': 282}\n",
            "[1.740e+02 1.500e+01 1.290e+02 6.100e+01 1.450e+02 1.040e+02 2.580e+02\n",
            " 1.370e+02 1.720e+02 3.720e+02 5.940e+02 4.010e+02 3.700e+02 6.760e+02\n",
            " 5.900e+02 6.080e+02 8.230e+02 7.600e+02 6.720e+02 8.150e+02 7.600e+02\n",
            " 6.400e+02 6.550e+02 6.840e+02 5.510e+02 4.760e+02 5.900e+02 4.040e+02\n",
            " 4.770e+02 3.640e+02 5.820e+02 6.010e+02 5.230e+02 5.180e+02 6.880e+02\n",
            " 5.540e+02 9.490e+02 6.810e+02 1.125e+03 1.033e+03 1.182e+03 8.100e+02\n",
            " 8.160e+02 6.300e+02 7.840e+02 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 1.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 2.200e+01 0.000e+00 1.000e+01 5.000e+00 2.800e+01\n",
            " 1.000e+00 2.100e+01 4.100e+01 3.900e+01 0.000e+00 0.000e+00 1.800e+01\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 3.400e+01 0.000e+00\n",
            " 3.300e+01 0.000e+00 3.900e+01 1.000e+00 6.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 8.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 7.000e+00 0.000e+00 0.000e+00 2.000e+00 0.000e+00\n",
            " 0.000e+00 1.000e+01 0.000e+00 0.000e+00 0.000e+00 4.000e+00 0.000e+00\n",
            " 0.000e+00 2.000e+00 0.000e+00 1.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 3.000e+00 3.700e+01 0.000e+00 1.000e+01 0.000e+00 0.000e+00\n",
            " 0.000e+00 3.300e+01 0.000e+00 2.100e+01 0.000e+00 0.000e+00 0.000e+00\n",
            " 2.800e+01 0.000e+00 3.800e+01 3.000e+01 1.600e+01 0.000e+00 0.000e+00\n",
            " 5.100e+01 0.000e+00 5.000e+00 1.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 3.300e+01 0.000e+00 1.480e+02 0.000e+00 0.000e+00 0.000e+00\n",
            " 3.400e+01 7.000e+00 0.000e+00 0.000e+00 1.700e+01 0.000e+00 1.100e+01\n",
            " 7.200e+01 0.000e+00 0.000e+00 6.200e+01 0.000e+00 0.000e+00 0.000e+00\n",
            " 3.100e+01 0.000e+00 7.000e+00 8.000e+00 0.000e+00 9.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 3.000e+00 0.000e+00 5.300e+01\n",
            " 0.000e+00 1.900e+01 8.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 2.100e+01 0.000e+00 0.000e+00 0.000e+00 0.000e+00 1.000e+01\n",
            " 1.000e+00 0.000e+00 0.000e+00 0.000e+00 1.000e+01 0.000e+00 1.700e+01\n",
            " 1.000e+00 0.000e+00 6.000e+00 0.000e+00 0.000e+00 0.000e+00 4.000e+00\n",
            " 7.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 1.300e+01 0.000e+00 0.000e+00 1.120e+02 0.000e+00 0.000e+00 2.200e+01\n",
            " 0.000e+00 0.000e+00 0.000e+00 4.000e+00 0.000e+00 3.100e+01 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 4.400e+01\n",
            " 8.800e+01 1.000e+00 3.300e+01 0.000e+00 0.000e+00 5.200e+01 0.000e+00\n",
            " 0.000e+00 1.600e+01 0.000e+00 0.000e+00 1.500e+01 2.200e+01 0.000e+00\n",
            " 1.000e+00 6.000e+00 0.000e+00 0.000e+00 8.000e+00 7.000e+01 3.000e+00\n",
            " 0.000e+00 1.600e+01 4.000e+00 0.000e+00 3.100e+01 7.000e+00 4.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 1.700e+01 0.000e+00 0.000e+00\n",
            " 1.200e+01 0.000e+00 1.800e+01 1.600e+01 0.000e+00 4.000e+00 7.000e+00\n",
            " 2.400e+01 5.000e+01 4.300e+01 0.000e+00 0.000e+00 3.000e+00 9.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 1.700e+01 0.000e+00 0.000e+00 1.100e+01 0.000e+00\n",
            " 1.000e+01 9.800e+01 1.000e+00 5.000e+00 1.200e+01 0.000e+00] down\n",
            "2.0\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1.150e+02 4.300e+01 1.220e+02 7.000e+01 1.310e+02 1.280e+02 9.090e+02\n",
            " 2.020e+02 8.100e+02 1.021e+03 1.183e+03 9.930e+02 1.026e+03 1.097e+03\n",
            " 1.213e+03 9.640e+02 1.278e+03 1.163e+03 1.101e+03 1.192e+03 1.171e+03\n",
            " 9.700e+02 1.072e+03 8.900e+02 8.960e+02 8.190e+02 6.510e+02 4.280e+02\n",
            " 5.750e+02 2.070e+02 6.370e+02 3.710e+02 4.690e+02 3.770e+02 6.210e+02\n",
            " 4.520e+02 6.470e+02 4.790e+02 7.020e+02 8.000e+02 8.160e+02 7.820e+02\n",
            " 6.340e+02 7.430e+02 7.440e+02 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 1.000e+00 4.000e+00\n",
            " 0.000e+00 1.000e+01 1.800e+01 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 2.200e+01 0.000e+00 3.400e+01 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 3.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 7.000e+00 0.000e+00\n",
            " 0.000e+00 6.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 9.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 1.900e+01 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 1.700e+01 0.000e+00 1.300e+01 1.600e+01 0.000e+00 0.000e+00\n",
            " 0.000e+00 3.000e+00 0.000e+00 0.000e+00 9.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 2.200e+01 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 2.700e+01 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 1.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 1.000e+00 0.000e+00 0.000e+00 1.250e+02 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 3.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 4.500e+01\n",
            " 5.000e+01 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 6.000e+00 8.000e+00\n",
            " 0.000e+00 2.000e+00 0.000e+00 0.000e+00 0.000e+00 3.000e+01 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 1.900e+01 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 1.400e+01 0.000e+00 0.000e+00 0.000e+00 0.000e+00] go\n",
            "0.0\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[3.020e+02 1.590e+02 1.790e+02 1.670e+02 1.940e+02 1.650e+02 2.150e+02\n",
            " 2.920e+02 1.980e+02 4.860e+02 4.850e+02 4.910e+02 4.000e+02 7.460e+02\n",
            " 4.660e+02 6.790e+02 4.190e+02 6.340e+02 2.720e+02 4.040e+02 4.650e+02\n",
            " 4.090e+02 2.720e+02 3.690e+02 3.930e+02 5.220e+02 5.890e+02 8.730e+02\n",
            " 7.870e+02 9.340e+02 1.062e+03 9.820e+02 9.540e+02 1.012e+03 8.200e+02\n",
            " 9.960e+02 6.930e+02 7.380e+02 7.780e+02 5.870e+02 4.440e+02 3.120e+02\n",
            " 1.560e+02 2.280e+02 1.560e+02 1.000e+01 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 4.500e+01 0.000e+00 0.000e+00 3.300e+01 0.000e+00 4.400e+01\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 2.500e+01 8.000e+00\n",
            " 0.000e+00 0.000e+00 1.400e+01 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 4.000e+00 1.000e+00 9.300e+01 0.000e+00\n",
            " 1.400e+01 5.000e+00 0.000e+00 0.000e+00 9.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 3.000e+00 0.000e+00 1.000e+00 0.000e+00 6.000e+01 6.200e+01\n",
            " 2.600e+01 4.300e+01 0.000e+00 0.000e+00 0.000e+00 3.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 1.210e+02 2.400e+01 0.000e+00\n",
            " 0.000e+00 3.000e+00 1.000e+00 0.000e+00 1.200e+01 0.000e+00 1.600e+01\n",
            " 3.200e+01 3.000e+00 5.200e+01 2.000e+01 9.200e+01 0.000e+00 0.000e+00\n",
            " 2.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 2.500e+01 0.000e+00 0.000e+00 0.000e+00 0.000e+00 1.000e+00\n",
            " 2.100e+01 5.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 1.000e+00 5.000e+00 5.000e+00 2.000e+00 1.100e+01 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 3.500e+01 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 4.600e+01 0.000e+00 0.000e+00\n",
            " 9.000e+00 8.000e+00 8.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 4.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 5.000e+00\n",
            " 2.900e+01 0.000e+00 1.000e+00 7.400e+01 7.000e+00 0.000e+00 1.000e+00\n",
            " 0.000e+00 0.000e+00 2.400e+01 3.700e+01 5.000e+00 0.000e+00 4.000e+00\n",
            " 0.000e+00 0.000e+00 3.600e+01 0.000e+00 0.000e+00 2.300e+01 1.200e+01\n",
            " 4.000e+00 0.000e+00 0.000e+00 2.100e+01 0.000e+00 1.200e+01 0.000e+00\n",
            " 2.500e+01 0.000e+00 0.000e+00 4.000e+00 2.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 3.000e+00 0.000e+00 0.000e+00 1.200e+01 1.100e+01 0.000e+00\n",
            " 0.000e+00 2.160e+02 1.300e+01 0.000e+00 0.000e+00 1.100e+01 0.000e+00\n",
            " 1.700e+01 0.000e+00 0.000e+00 0.000e+00 1.000e+00 5.100e+01 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 4.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 3.000e+00 1.000e+01 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 5.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n",
            " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 1.900e+01 0.000e+00\n",
            " 4.500e+01 0.000e+00 0.000e+00 4.000e+00 0.000e+00 0.000e+00] yes\n",
            "0.0\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[480. 337. 481. 379. 437. 390. 428. 395. 293. 471. 569. 275. 339. 480.\n",
            " 352. 459. 462. 551. 483. 584. 536. 457. 452. 478. 423. 466. 463. 468.\n",
            " 444. 320. 549. 363. 367. 393. 392. 408. 447. 466. 628. 616. 625. 545.\n",
            " 586. 463. 589.   0.   0.   0.   0.   4.  24.   2.   0.  31.   0.  46.\n",
            "   2.   0.   9.   0.   1.  21.   3.   0.  26.  10.   1.   0.   0.  13.\n",
            "   1.   0.   0.   0.   0.  27.  19.  14.   0.  24.   0.   8.   0.   8.\n",
            "   1.   0.   3.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.\n",
            "   0.  10.   4.   0.   0.  16.  17.  13.  19.   0.   0.   0.   0.   0.\n",
            "   0.  11.   0.   0.   8.   2.   0.   0.   4.   0.   4.  18.   2.   9.\n",
            "  15.   0.  25.  17.  30.   0.   0.   8.   0.  11.   0.   0.   0.   0.\n",
            "   0.  28.   0.   8.   2.   0.   4.   7.  15.   0.   1.   1.   0.   2.\n",
            "   0.  35.   0.  32.   0.   0.   0.   0.   0.  57.   0.   0.   0.   0.\n",
            "   8.   0.   0.   1.   6.   0.  16.   0.  26.   0.   2.   0.   0.   0.\n",
            "   1.   1.   0.   0.   0.   0.  25.   0.   0.   0.   0.   0.   0.   0.\n",
            "  10.   0.   0.   0.   0.   0.   2.   5.   0.   0.  34.   2.   0.   1.\n",
            "   0.   0.  14.  36.   0.   0.   2.   0.   0.  34.  16.   4.  13.   0.\n",
            "   0.   3.   0.  20.   0.   0.   0.  44.   1.   6.   0.   0.   5.   0.\n",
            "   0.   2.   0.   0.  17.   0.  31.   1.  35.  10.   0.   0.  17.   0.\n",
            "   7.   1.   7.   0.   5.  26.   1.   0.   2.   0.   0.   3.   3.   0.\n",
            "   0.   0.   0.   2.   0.   0.   3.   0.   0.   0.   1.   0.   5.   6.\n",
            "   0.   0.   0.   0.   0.   3.   2.  20.   0.  11.   0.   3.   6.   0.\n",
            "  14.   6.   2.   0.  15.   0.] no\n",
            "3.0\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[435. 106. 161. 108. 115.  88. 119. 125.  90. 299. 469. 278. 306. 440.\n",
            " 450. 533. 702. 800. 581. 969. 948. 660. 921. 754. 809. 586. 593. 416.\n",
            " 454. 264. 481. 343. 341. 338. 484. 396. 639. 557. 810. 839. 971. 654.\n",
            " 725. 689. 715.   0.   0.   0.   5.   1.   0.   0.   0.   0.   0.  27.\n",
            "   0.   0.  62.   0.  22.  11.   8.   0.  57.   0.  60.   0.   0.  21.\n",
            "   0.   0.   2.   0.   0.  32.   6.  39.   3.   8.   0.   0.   0.   3.\n",
            "   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.\n",
            "   0.  11.   0.   0.   0.   0.   0.   0.  30.   7.   7.   0.   0.  11.\n",
            "   0.   0.   5.   2.  16.   0.   0.   0.   6.   0.   7.   0.  18.   0.\n",
            "  45.   0.   3.  13.  10.   0.   0.  91.   0.  35.  14.  12.   0.   0.\n",
            "   0.   0.   0.  73.   4.   2.   0.   0.  66.   0.   0.   2.  23.  20.\n",
            "  39.   1.   0.  27.   7.   0.  12.  29.   0.   0.   0.  19.   7.   0.\n",
            "   0.   0.   0.   0.   0.   0.  54.   0.  17.   0.   5.   0.   0.   0.\n",
            "   1.   0.   0.   0.   0.   1.  28.   0.   0.   0.   0.   0.   0.   0.\n",
            "  18.   0.   0.   0.   1.   0.  21.   0.   0.   0.  56.   0.   3.   0.\n",
            "  14.  19.   3. 146.   0.   0.  10.   0.   0.   0.   3.  18.   9.  19.\n",
            "   0.   0.   0.   0.  45.   0. 122.   1.   0.   9.   0.   0.   8.   0.\n",
            "   0.   0.   0.   0.   4.  60.   0.   0.   0.   2.   0.   2.  22.   3.\n",
            "   0.   0.   0.   0.   8.   6.  12.   0.   6.   0.   0.  11.   0.   0.\n",
            "   0.   0.   6.   0.   4.   0.   0.   2.  18.  15.   6.   0.   0.   3.\n",
            "   0.   0.   0.   0.   1.   0.  18.  24.   0.   4.   0.   0.  15.   0.\n",
            "  33.  48.   2.   0.  10.   0.] down\n",
            "0.0\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "flag = FLAG_global\n",
        "#print(output_dict)\n",
        "with open(data_path + f\"Weights_LSM_{flag}.pkl\",\"rb\") as f:\n",
        "  W_lsm_tf = pkl.load(f)\n",
        "with open(data_path + f\"Weights_in_{flag}.pkl\",\"rb\") as f:\n",
        "  W_in_tf = pkl.load(f)\n",
        "with open(data_path + f\"An_{flag}.pkl\",\"rb\") as f:\n",
        "  A_new = pkl.load(f)\n",
        "\n",
        "print(W_lsm_tf[0])\n",
        "print(W_in_tf[0])\n",
        "print(W_lsm_tf.shape)\n",
        "print(W_in_tf.shape)\n",
        "\n",
        "print(output_dict)\n",
        "for ba in range(num_batches_test):\n",
        "  Vm_tf = tf.constant(np.zeros((batch_size, N)), dtype=tf.float32)\n",
        "  SI_tf = tf.constant(np.zeros((batch_size, N)), dtype=tf.float32)\n",
        "  SinI_tf = tf.constant(np.zeros((batch_size, in_size)), dtype=tf.float32)\n",
        "  spT_tf = tf.constant(np.zeros((batch_size, N)), dtype=tf.float32)\n",
        "\n",
        "  batch_in_full = x_test[ba*batch_size:(ba+1)*batch_size]\n",
        "  batch_in_full_tf = tf.constant(batch_in_full, dtype=tf.float32)\n",
        "\n",
        "  if True:\n",
        "      S_liq, count = run_LSM(Vm_tf, SI_tf, batch_in_full_tf, SinI_tf, eta, eta1, a1, a2, W_in_tf, W_lsm_tf, w_scale, th, num_iter)\n",
        "      #S_liq, dummy1, dummy2, dummy3, count = run_LSM_full_STDP(Vm_tf, SI_tf, batch_in_full_tf, SinI_tf, spT_tf, spT_in_tf, eta, eta1, a1, a2, W_in_tf, W_lsm_tf, W_lsm_mask, th, num_iter, batch_size, W_lsm_sign)\n",
        "\n",
        "      indic1=0\n",
        "      indic2=0\n",
        "      if False:\n",
        "        for kl in range(count.shape[0]):\n",
        "          if y_data[batch_size*num_batches + kl] == \"no\" and indic1==0:\n",
        "            x= np.arange(len(count[kl]))\n",
        "            print(count[kl], y_data[batch_size*num_batches + kl] )\n",
        "            print(count[kl][output_dict[y_data[batch_size*num_batches + kl]]])\n",
        "            indic1 = 1\n",
        "            plt.plot(x, count[kl])\n",
        "            plt.show()\n",
        "          if y_data[batch_size*num_batches + kl] == \"go\" and indic2==0:\n",
        "            x= np.arange(len(count[kl]))\n",
        "            print(count[kl], y_data[batch_size*num_batches + kl] )\n",
        "            indic2 = 1\n",
        "            plt.plot(x, count[kl])\n",
        "            plt.show()\n",
        "          if indic1 ==1 and indic2==1:\n",
        "            break\n",
        "        break\n",
        "      else:\n",
        "        for kl in range(5):\n",
        "          x= np.arange(len(count[kl]))\n",
        "          print(count[kl], y_data[batch_size*num_batches + kl] )\n",
        "          print(count[kl][output_dict[y_data[batch_size*num_batches + kl]]])\n",
        "          indic1 = 1\n",
        "          plt.plot(x, count[kl])\n",
        "          plt.show()\n",
        "        break\n",
        "\n",
        "\n",
        "  else:\n",
        "    S_liq = run_LSM(Vm_tf, SI_tf, batch_in_full_tf, SinI_tf, eta, eta1, a1, a2, W_in_tf, W_lsm_tf, w_scale, th, num_iter)\n",
        "\n",
        "  S_liq_c1 = tf.reduce_mean(S_liq[:,:partition,:], axis=1)\n",
        "  S_liq_c2 = tf.reduce_mean(S_liq[:,partition:2*partition,:], axis=1)\n",
        "  S_liq_c3 = tf.reduce_mean(S_liq[:,2*partition:3*partition,:], axis=1)\n",
        "  S_liq_c4 = tf.reduce_mean(S_liq[:,-partition:,:], axis=1)\n",
        "\n",
        "  S_liq_c = tf.concat([S_liq_c1, S_liq_c2, S_liq_c3, S_liq_c4], axis=1)\n",
        "  #LSM_out_test2[b*batch_size:(b+1)*batch_size] = S_liq.numpy()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "x2qit_rI9PKF",
        "outputId": "68b9376d-88db-4d4b-e59f-a5a4b8811c82"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "22643\n"
          ]
        }
      ],
      "source": [
        "print(np.sum(batch_in_full[0]))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hrNy9HoN1zWF",
        "outputId": "a6f52e1f-6ee7-4644-9d63-ad613d155215"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "mean LSM spiking (train) :  0.0017796163405996292\n",
            "mean LSM spiking (test) :  0.05508129543929827\n",
            "mean input spiking (train) :  0.1725877847952951\n",
            "mean input spiking (test) :  0.17318897972605224\n",
            "10 10 3\n"
          ]
        }
      ],
      "source": [
        "print(\"mean LSM spiking (train) : \", np.mean(LSM_out_train))\n",
        "print(\"mean LSM spiking (test) : \", np.mean(LSM_out_test))\n",
        "\n",
        "print(\"mean input spiking (train) : \", np.mean(x_data))\n",
        "print(\"mean input spiking (test) : \", np.mean(x_test))\n",
        "\n",
        "print(a,b,c)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "t5meWp2OT3k0",
        "outputId": "e59016a9-5a59-4f64-86f2-36793e9cb8e3"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "300\n",
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n",
            "An is :  0.005\n",
            "tf.Tensor(\n",
            "[[1.5000000e+01 1.4411841e+01 1.2782157e+01 ... 0.0000000e+00\n",
            "  0.0000000e+00 0.0000000e+00]\n",
            " [1.4868742e+01 1.4831616e+01 1.3657122e+01 ... 0.0000000e+00\n",
            "  0.0000000e+00 0.0000000e+00]\n",
            " [1.4481818e+01 1.4997657e+01 1.4337722e+01 ... 0.0000000e+00\n",
            "  0.0000000e+00 0.0000000e+00]\n",
            " ...\n",
            " [1.4537866e-32 4.5680505e-31 1.3250052e-29 ... 0.0000000e+00\n",
            "  0.0000000e+00 0.0000000e+00]\n",
            " [2.8100494e-33 9.1670627e-32 2.7605964e-30 ... 0.0000000e+00\n",
            "  0.0000000e+00 0.0000000e+00]\n",
            " [5.3369501e-34 1.8075713e-32 5.6513758e-31 ... 0.0000000e+00\n",
            "  0.0000000e+00 0.0000000e+00]], shape=(96, 300), dtype=float32)\n",
            "hi\n",
            "completed:  0.0\n",
            "completed:  0.125\n",
            "completed:  0.25\n",
            "completed:  0.375\n",
            "completed:  0.5\n",
            "completed:  0.625\n",
            "completed:  0.75\n",
            "completed:  0.875\n"
          ]
        }
      ],
      "source": [
        "from tqdm import tqdm\n",
        "import tensorflow as tf\n",
        "\n",
        "Nx = a\n",
        "Ny = b\n",
        "Nz = c\n",
        "N = Nx*Ny*Nz\n",
        "print(N)\n",
        "\n",
        "batch_size = 200\n",
        "def run_LSM(Vm, SI, Sin, SinI, eta, eta1, a1, a2, in_W, W, sc_W, th, n_iter):\n",
        "  Sliq = []\n",
        "  global N\n",
        "  count = np.zeros((batch_size, N))\n",
        "  for i in range(n_iter):\n",
        "    Vm = (1-eta)*Vm + a1*(tf.matmul(SI, sc_W*W) + tf.matmul(SinI, in_W))\n",
        "    Sout = tf.cast(Vm>=th, dtype=tf.float32)\n",
        "    toadd = Sout.numpy()\n",
        "    count = np.add(count, toadd)\n",
        "    Vm = Vm*tf.cast(Vm<th, dtype=tf.float32)\n",
        "    SinI = (1-eta1)*SinI + a2*Sin[:,i,:]\n",
        "    SI = (1-eta1)*SI + a2*Sout\n",
        "    Sliq.append(Sout)\n",
        "  return tf.stack(Sliq, axis=1), count\n",
        "\n",
        "\n",
        "import numpy as np\n",
        "from sklearn.datasets import fetch_openml\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.metrics import confusion_matrix\n",
        "import pickle\n",
        "import tensorflow as tf\n",
        "import matplotlib.pyplot as plt\n",
        "import pathlib\n",
        "import os\n",
        "import pickle as pkl\n",
        "\n",
        "\n",
        "flag = FLAG_global\n",
        "eta = 0.1\n",
        "eta1 = 0.1\n",
        "a1 = 0.1\n",
        "a2 = 0.1\n",
        "th = 0.4\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "data_path = '/content/drive/My Drive/Colab Notebooks/tf_LSM/'\n",
        "x_data = np.load(data_path + 'mini_speech_data_decimation_16_2.npy')\n",
        "y_data = np.load(data_path + 'mini_speech_label_decimation_16_2.npy')\n",
        "data_size_test = x_data.shape[0]//5\n",
        "num_iter = x_data.shape[1]\n",
        "\n",
        "x_test=np.array(x_data[-data_size_test:])\n",
        "y_test=np.array(y_data[-data_size_test:])\n",
        "x_in_train=np.array(x_data[:-data_size_test])\n",
        "y_in_train=np.array(y_data[:-data_size_test])\n",
        "num_partitions = 4\n",
        "data_size = x_in_train.shape[0]\n",
        "in_size = x_data.shape[2]\n",
        "\n",
        "batch_size = 200\n",
        "num_batches = data_size//batch_size\n",
        "num_batches_test = data_size_test//batch_size\n",
        "\n",
        "\n",
        "with open(data_path + f\"Weights_LSM_{flag}.pkl\",\"rb\") as f:\n",
        "  W_lsm_tf = pkl.load(f)\n",
        "with open(data_path + f\"Weights_in_{flag}.pkl\",\"rb\") as f:\n",
        "  W_in_tf = pkl.load(f)\n",
        "with open(data_path + f\"An_{flag}.pkl\",\"rb\") as f:\n",
        "  A_new = pkl.load(f)\n",
        "\n",
        "#print(np.max(W_in_tf.numpy()))\n",
        "#print(W_in_tf.shape)\n",
        "\n",
        "\n",
        "print(\"An is : \", A_new)\n",
        "\n",
        "print(W_in_tf)\n",
        "LSM_out_train2 = np.zeros((x_in_train.shape[0],num_partitions*N))\n",
        "\n",
        "num_batches = data_size//batch_size\n",
        "num_batches_test = data_size_test//batch_size\n",
        "num_partitions = 4\n",
        "print(\"hi\")\n",
        "w_scale = 1\n",
        "partition = num_iter//num_partitions\n",
        "\n",
        "for ba in range(num_batches):\n",
        "  if(ba%4==0):\n",
        "    print(\"completed: \", ba/num_batches)\n",
        "  Vm_tf = tf.constant(np.zeros((batch_size, N)), dtype=tf.float32)\n",
        "  SI_tf = tf.constant(np.zeros((batch_size, N)), dtype=tf.float32)\n",
        "  SinI_tf = tf.constant(np.zeros((batch_size, in_size)), dtype=tf.float32)\n",
        "  spT_tf = tf.constant(np.zeros((batch_size, N)), dtype=tf.float32)\n",
        "  spT_in_tf = tf.constant(np.zeros((batch_size, in_size)), dtype=tf.float32)\n",
        "\n",
        "  batch_in_full = x_in_train[ba*batch_size:(ba+1)*batch_size]\n",
        "  batch_in_full_tf = tf.constant(batch_in_full, dtype=tf.float32)\n",
        "\n",
        "\n",
        "  #Vm, SI, Sin, SinI, eta, eta1, a1, a2, in_W, W, sc_W, th, n_iter\n",
        "  S_liq, count = run_LSM(Vm_tf, SI_tf, batch_in_full_tf, SinI_tf, eta, eta1, a1, a2, W_in_tf, W_lsm_tf, w_scale, th, num_iter)\n",
        "\n",
        "  if b==0:\n",
        "    with open(data_path + f\"saved_spikes.pkl\",\"wb\") as f:\n",
        "      pkl.dump(S_liq, f)\n",
        "\n",
        "  S_liq_c1 = tf.reduce_mean(S_liq[:,:partition,:], axis=1)\n",
        "  S_liq_c2 = tf.reduce_mean(S_liq[:,partition:2*partition,:], axis=1)\n",
        "  S_liq_c3 = tf.reduce_mean(S_liq[:,2*partition:3*partition,:], axis=1)\n",
        "  S_liq_c4 = tf.reduce_mean(S_liq[:,-partition:,:], axis=1)\n",
        "\n",
        "  S_liq_c = tf.concat([S_liq_c1, S_liq_c2, S_liq_c3, S_liq_c4], axis=1)\n",
        "\n",
        "  #S_liq_c = tf.reduce_mean(S_liq, axis=1)\n",
        "  #LSM_out_train2[b*batch_size:(b+1)*batch_size] = S_liq.numpy()\n",
        "  LSM_out_train2[ba*batch_size:(ba+1)*batch_size] = S_liq_c.numpy()\n",
        "\n",
        "with open(data_path + f\"LSM_out_train2_{flag}.pkl\",\"wb\") as f:\n",
        "  pkl.dump(LSM_out_train2, f)\n",
        "#  break\n",
        "\n",
        "#neuronSpikes = S_liq.numpy()\n",
        "\n",
        "#with open(data_path + \"saved_spikes.pkl\", \"wb\") as f:\n",
        "#  pkl.dump(neuronSpikes,f)\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E_1cj8EFkAhq"
      },
      "source": [
        "#Area Exploration"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 509
        },
        "id": "41fusjx-WyjQ",
        "outputId": "783416fc-bde1-4c11-f6fe-b15b2e9994d9"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnMAAAHbCAYAAACgFxwQAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA/GUlEQVR4nO3de3wU5aH/8W9CSCDAJgZIYiRcpFZIAbUgEEUPSg4BopaKWinFYK0cMaiIRaBFBKoCtqf1UoW25xQ8rUhLj2gFkVLkoscIQkW5KBXKzYYElJLlIgkhz+8Pf1mzYe/Z25N83q/Xvl7ZmdmZZ57sznznmZlnEowxRgAAALBSYqwLAAAAgNAR5gAAACxGmAMAALAYYQ4AAMBihDkAAACLEeYAAAAsRpgDAACwGGEOAADAYoQ5AAAAixHmACCMunbtqnHjxsW6GACaEcIcgJAsXrxYCQkJrldSUpIuuugijRs3Tv/85z8jttxdu3Zp1qxZ2r9/f8SWEQtlZWWaNWuWtm3bFuuiALBMUqwLAMBuc+bMUbdu3XTmzBm9++67Wrx4sd5++23t2LFDrVq1Cvvydu3apdmzZ2vw4MHq2rVr2OcfK2VlZZo9e7a6du2qyy+/PNbFAWARwhyARhk+fLj69esnSfrBD36gDh06aP78+frzn/+s2267LcalC9ypU6fUpk2bWBcDAILGaVYAYXXNNddIkvbu3esaVl1drZkzZ6pv375KS0tTmzZtdM0112jdunXnfX7p0qXq27ev2rVrJ4fDod69e+vpp5+W9OWp3VtvvVWSdN1117lO8a5fv971+VWrVumaa65RmzZt1K5dOxUVFWnnzp1uyxg3bpzatm2rvXv3asSIEWrXrp3GjBnjdZ1mzZqlhIQEffzxx7rtttvkcDjUvn17PfDAAzpz5ozfOvnHP/6hW2+9VRkZGUpNTdXAgQO1cuVK1/j169fryiuvlCTdeeedrvVavHix33kDAGEOQFjVXct2wQUXuIY5nU7913/9lwYPHqz58+dr1qxZOnr0qAoLC92uEVuzZo1Gjx6tCy64QPPnz9e8efM0ePBg/d///Z8k6dprr9X9998vSfrRj36k3/3ud/rd736nnj17SpJ+97vfqaioSG3bttX8+fP1yCOPaNeuXRo0aNB519jV1NSosLBQmZmZ+tnPfqZRo0b5XbfbbrtNZ86c0dy5czVixAg988wzGj9+vM/PVFRU6KqrrtLq1at177336vHHH9eZM2d00003afny5ZKknj17as6cOZKk8ePHu9br2muv9VsmAJABgBAsWrTISDJ//etfzdGjR82hQ4fMn/70J9OxY0eTkpJiDh065Jq2pqbGVFVVuX3+X//6l8nKyjLf//73XcMeeOAB43A4TE1NjdflLlu2zEgy69atcxt+4sQJk56ebu6++2634eXl5SYtLc1teHFxsZFkpk2bFtC6Pvroo0aSuemmm9yG33vvvUaS+eCDD1zDunTpYoqLi13vJ02aZCSZt956y62s3bp1M127djXnzp0zxhjz3nvvGUlm0aJFAZUJAOrQMgegUQoKCtSxY0fl5ubqlltuUZs2bfTnP/9ZnTp1ck3TokULJScnS5Jqa2t17Ngx1dTUqF+/fvrb3/7mmi49PV2nTp3SmjVrgi7HmjVrdPz4cY0ePVqfffaZ69WiRQsNGDDA4yndCRMmBLWMkpISt/f33XefJOn111/3+pnXX39d/fv316BBg1zD2rZtq/Hjx2v//v3atWtXUGUAgIa4AQJAozz33HP6+te/rsrKSv32t7/Vxo0blZKSct50L7zwgv7zP/9TH3/8sc6ePesa3q1bN9ff9957r/74xz9q+PDhuuiiizR06FDddtttGjZsmN9yfPLJJ5Kk66+/3uN4h8Ph9j4pKcktcAbikksucXvfvXt3JSYm+uwm5cCBAxowYMB5w+tODR84cEC9evUKqhwAUB9hDkCj9O/f33U368iRIzVo0CB997vf1e7du9W2bVtJ0u9//3uNGzdOI0eO1JQpU5SZmakWLVpo7ty5bjdKZGZmatu2bVq9erVWrVqlVatWadGiRbrjjjv0wgsv+CxHbW2tpC+vm8vOzj5vfFKS++YuJSVFiYmNOzmRkJDQqM8DQDgQ5gCETV1Au+666/TLX/5S06ZNkyT96U9/0sUXX6yXX37ZLQA9+uij580jOTlZN954o2688UbV1tbq3nvv1a9+9Ss98sgj+trXvuY1QHXv3l3Sl4GwoKAgAmv3Zetf/ZbEPXv2qLa21md/d126dNHu3bvPG/7xxx+7xksEQwCh45o5AGE1ePBg9e/fX0899ZSr244WLVpIkowxruk2bdqk0tJSt89+/vnnbu8TExPVp08fSVJVVZUkufqCO378uNu0hYWFcjgceuKJJ9xO49Y5evRoI9bqS88995zb+2effVbSl33teTNixAht3rzZbV1PnTqlX//61+ratavy8vIkeV8vAPCHljkAYTdlyhTdeuutWrx4se655x7dcMMNevnll/Xtb39bRUVF2rdvnxYuXKi8vDydPHnS9bkf/OAHOnbsmK6//np16tRJBw4c0LPPPqvLL7/cdY3Z5ZdfrhYtWmj+/PmqrKxUSkqKrr/+emVmZmrBggUaO3asvvnNb+r2229Xx44ddfDgQa1cuVJXX321fvnLXzZqvfbt26ebbrpJw4YNU2lpqX7/+9/ru9/9ri677DKvn5k2bZpeeuklDR8+XPfff78yMjL0wgsvaN++ffrf//1f16ne7t27Kz09XQsXLlS7du3Upk0bDRgwwK0lEAA8ivXttADsVNc1yXvvvXfeuHPnzpnu3bub7t27m5qaGlNbW2ueeOIJ06VLF5OSkmKuuOIKs2LFClNcXGy6dOni+tyf/vQnM3ToUJOZmWmSk5NN586dzX/8x3+Yw4cPu83/N7/5jbn44otNixYtzuumZN26daawsNCkpaWZVq1ame7du5tx48aZLVu2uKYpLi42bdq0CXhd67om2bVrl7nllltMu3btzAUXXGAmTpxovvjiC7dpG3ZNYowxe/fuNbfccotJT083rVq1Mv379zcrVqw4bzmvvvqqycvLM0lJSXRTAiBgCcbUO+8BADjPrFmzNHv2bB09elQdOnSIdXEAwA3XzAEAAFiMMAcAAGAxwhwAAIDFuGYOAADAYrTMAQAAWIwwBwAAYDHCHAAAgMUIcwAAABYjzAEAAFiMMAcAAGAxwhwAAIDFCHMAAAAWI8wBAABYjDAHAABgMcIcAACAxQhzAAAAFiPMAQAAWIwwBwAAYDHCHAAAgMUIcwAAABYjzAEAAFiMMAcAAGCxpFgXIBS1tbUqKytTu3btlJCQEOviAAAAhJUxRidOnFBOTo4SE323vVkZ5srKypSbmxvrYgAAAETUoUOH1KlTJ5/TWBnm2rVrJ+nLFXQ4HDEuDQAAQHg5nU7l5ua6Mo8vVoa5ulOrDoeDMAcAAJqsQC4n4wYIAAAAixHmAAAALEaYAwAAsBhhDgAAwGKEOQAAAIsR5gAAACxGmAMAALAYYQ4AAMBihDkAAACLEeYAAAAsRpgDAACwWFBhbsGCBerTp4/rmaj5+flatWqVa/yZM2dUUlKi9u3bq23btho1apQqKirc5nHw4EEVFRUpNTVVmZmZmjJlimpqasKzNgAAAM1MUGGuU6dOmjdvnrZu3aotW7bo+uuv17e+9S3t3LlTkvTggw/qtdde07Jly7RhwwaVlZXp5ptvdn3+3LlzKioqUnV1td555x298MILWrx4sWbOnBnetQIAAGgmEowxpjEzyMjI0E9/+lPdcsst6tixo5YsWaJbbrlFkvTxxx+rZ8+eKi0t1cCBA7Vq1SrdcMMNKisrU1ZWliRp4cKFmjp1qo4ePark5OSAlul0OpWWlqbKyko5HI7GFB8AACDuBJN1Qr5m7ty5c1q6dKlOnTql/Px8bd26VWfPnlVBQYFrmh49eqhz584qLS2VJJWWlqp3796uICdJhYWFcjqdrtY9T6qqquR0Ot1eAAAACCHMbd++XW3btlVKSoruueceLV++XHl5eSovL1dycrLS09Pdps/KylJ5ebkkqby83C3I1Y2vG+fN3LlzlZaW5nrl5uYGW2wAAIAmKegwd+mll2rbtm3atGmTJkyYoOLiYu3atSsSZXOZPn26KisrXa9Dhw5FdHkAAAC2SAr2A8nJyfra174mSerbt6/ee+89Pf300/rOd76j6upqHT9+3K11rqKiQtnZ2ZKk7Oxsbd682W1+dXe71k3jSUpKilJSUoItKgAAQJPX6H7mamtrVVVVpb59+6ply5Zau3ata9zu3bt18OBB5efnS5Ly8/O1fft2HTlyxDXNmjVr5HA4lJeX19iiAAAANDtBtcxNnz5dw4cPV+fOnXXixAktWbJE69ev1+rVq5WWlqa77rpLkydPVkZGhhwOh+677z7l5+dr4MCBkqShQ4cqLy9PY8eO1ZNPPqny8nLNmDFDJSUltLwBAACEIKgwd+TIEd1xxx06fPiw0tLS1KdPH61evVr//u//Lkn6xS9+ocTERI0aNUpVVVUqLCzU888/7/p8ixYttGLFCk2YMEH5+flq06aNiouLNWfOnPCuFQAA/9/p6hrlzVwtSdo1p1CpyUkBDwtkXoFOE8gyJfmdP9BQo/uZiwX6mQMAAE1ZVPqZAwAAQOwR5gAAACxGmAMAALAYYQ4AAMBihDkAAACLEeYAAAAsRpgDAACwGGEOAADAYoQ5AAAAixHmAAAALEaYAwCLnK6uUddpK9V12kp9dvKM6+/T1TWxLhqAGOHZrAAAAHGGZ7MCAAA0E4Q5AAAAixHmAAAALEaYAwAAsBhhDgAAwGKEOQAAAIsR5gAAACxGmAMAALAYYQ4AAMBihDkAAACLEeYAAAAsRpgDAACwGGEOAADAYoQ5AAAAixHmAAAALJYU6wIAALz77OQZ9Xts7XnDd80pVGoym3AAhDkAiGsd2rbS/nlFsS4GgDjGaVYAAACLEeYAAAAsRpgDAACwGGEOAADAYoQ5AAAAixHmAAAALEaYAwAAsBhhDgAAwGKEOQAAAIsR5gAAACzG47wAAAiT09U1ypu52vU+2Gfo1v/8lhlDXM/lDWQ+9T+7a06hJLm951m+TVeCMcbEuhDBcjqdSktLU2VlpRwOR6yLA6CJarhzTE1OOm9n3ZCnnaan+USjrADsFUzWIcwBAADEmWCyDtfMAQAAWIwwBwAAYDHCHAAAgMUIcwAAABYjzAEAAFiMMAcAAGCxoMLc3LlzdeWVV6pdu3bKzMzUyJEjtXv3brdpBg8erISEBLfXPffc4zbNwYMHVVRUpNTUVGVmZmrKlCmqqalp/NoAABCk09U16jptpbpOW6nT1eyLYJ+gepXcsGGDSkpKdOWVV6qmpkY/+tGPNHToUO3atUtt2rRxTXf33Xdrzpw5rvepqamuv8+dO6eioiJlZ2frnXfe0eHDh3XHHXeoZcuWeuKJJ8KwSgAABC41OUn75xXFuhhAyBrVafDRo0eVmZmpDRs26Nprr5X0Zcvc5ZdfrqeeesrjZ1atWqUbbrhBZWVlysrKkiQtXLhQU6dO1dGjR5WcnOx3uXQaDAAAmrKodRpcWVkpScrIyHAb/uKLL6pDhw7q1auXpk+frtOnT7vGlZaWqnfv3q4gJ0mFhYVyOp3auXOnx+VUVVXJ6XS6vQAAABDkadb6amtrNWnSJF199dXq1auXa/h3v/tddenSRTk5Ofrwww81depU7d69Wy+//LIkqby83C3ISXK9Ly8v97isuXPnavbs2aEWFQAAoMkKOcyVlJRox44devvtt92Gjx8/3vV37969deGFF2rIkCHau3evunfvHtKypk+frsmTJ7veO51O5ebmhlZwAACAJiSk06wTJ07UihUrtG7dOnXq1MnntAMGDJAk7dmzR5KUnZ2tiooKt2nq3mdnZ3ucR0pKihwOh9sLAAAAQYY5Y4wmTpyo5cuX680331S3bt38fmbbtm2SpAsvvFCSlJ+fr+3bt+vIkSOuadasWSOHw6G8vLxgigMAANDsBXWataSkREuWLNGrr76qdu3aua5xS0tLU+vWrbV3714tWbJEI0aMUPv27fXhhx/qwQcf1LXXXqs+ffpIkoYOHaq8vDyNHTtWTz75pMrLyzVjxgyVlJQoJSUl/GsIAADQhAXVNUlCQoLH4YsWLdK4ceN06NAhfe9739OOHTt06tQp5ebm6tvf/rZmzJjhdmr0wIEDmjBhgtavX682bdqouLhY8+bNU1JSYNmSrkkAAEBTFkzWaVQ/c7FCmAMAAE1Z1PqZAwAAQGwR5gAAACxGmAMAALAYYQ4AAMBihDkAAACLEeYAAAAsRpgDAATldHWNuk5bqa7TVup0dU2siwM0e0E9AQIAgNTkJO2fVxTrYgD4/2iZAwAAsBhhDgAAwGKEOQAAAIsR5gAAACxGmAMAALAYYQ4AAMBihDkAAACLEeYAAAAsRpgDAISEJ0EA8YEwBwAAYDEe5wUAceR0dY3yZq52G7ZlxhD1e2zteX/vmlMoSa7p649raNecQqUmh7bJr1+mhsvfP6/IbXzdcjytR2PLAcCzBGOMiXUhguV0OpWWlqbKyko5HI5YFwcAAMQpTwcbNggm69ixRgDQTHlrFfPHpp0WEEmpyUnaP68o1sWIKFrmAAAA4kwwWYcbIAAAACxGmAMAALAYF1QAAJodT3fbcp0hbMW3FgDimLfQIcntDr2G7wklvjWHi+LRfHADBAAAQJzhBggAAIBmgjAHAABgMS6qABB2tva43pzxP0OshfIdDPV7G+oNMPH6O6FlDgAAwGLcAAEAABBnuAECAACgmSDMAQAAWIwwBwAAYDHCHAAAgMUIcwAAABYjzAEAAFiMMAcAAGAxwhwAAIDF4uM5FAAAxJinRzw1FMlHOMXro6IQ/3gCBAAAQJzhCRAAAADNBGEOAADAYoQ5AAAAixHmAAAALEaYAwAAsBj3PQMAmqxAuhtpiG5BYBu+rQCAJis1OUn75xXFuhhARAV1mnXu3Lm68sor1a5dO2VmZmrkyJHavXu32zRnzpxRSUmJ2rdvr7Zt22rUqFGqqKhwm+bgwYMqKipSamqqMjMzNWXKFNXU1DR+bQAAAJqZoMLchg0bVFJSonfffVdr1qzR2bNnNXToUJ06dco1zYMPPqjXXntNy5Yt04YNG1RWVqabb77ZNf7cuXMqKipSdXW13nnnHb3wwgtavHixZs6cGb61AgAAaCYa9QSIo0ePKjMzUxs2bNC1116ryspKdezYUUuWLNEtt9wiSfr444/Vs2dPlZaWauDAgVq1apVuuOEGlZWVKSsrS5K0cOFCTZ06VUePHlVycrLf5fIECAAA0JRF7QkQlZWVkqSMjAxJ0tatW3X27FkVFBS4punRo4c6d+6s0tJSSVJpaal69+7tCnKSVFhYKKfTqZ07d3pcTlVVlZxOp9sL5ztdXaOu01aq67SV+uzkGdffp6s5hQ0AiB/191fsoxov5BsgamtrNWnSJF199dXq1auXJKm8vFzJyclKT093mzYrK0vl5eWuaeoHubrxdeM8mTt3rmbPnh1qUZuNhhf6ctEvACAecWNKeIXcMldSUqIdO3Zo6dKl4SyPR9OnT1dlZaXrdejQoYgvEwAAwAYhtcxNnDhRK1as0MaNG9WpUyfX8OzsbFVXV+v48eNurXMVFRXKzs52TbN582a3+dXd7Vo3TUMpKSlKSUkJpagAAABNWlAtc8YYTZw4UcuXL9ebb76pbt26uY3v27evWrZsqbVr17qG7d69WwcPHlR+fr4kKT8/X9u3b9eRI0dc06xZs0YOh0N5eXmNWRcAAIBmJ6iWuZKSEi1ZskSvvvqq2rVr57rGLS0tTa1bt1ZaWpruuusuTZ48WRkZGXI4HLrvvvuUn5+vgQMHSpKGDh2qvLw8jR07Vk8++aTKy8s1Y8YMlZSU0PoGAAAQpKC6JklISPA4fNGiRRo3bpykLzsNfuihh/TSSy+pqqpKhYWFev75591OoR44cEATJkzQ+vXr1aZNGxUXF2vevHlKSgosW9I1CQAAaMqCyTqN6mcuVghzAACgKYtaP3MAAACILcIcAACAxQhzAAAAFiPMAQAAWIwwBwAAYDHCHAAAgMUIcwAAABYjzAEAAFiMMAcAAGAxwhwAAIDFCHMAAAAWC+zJ9gAQJ05X1yhv5mpJ0q45hUpNZjOG89X/noSi7rvVcD5bZgxRv8fWuqaRFNBy6n8uEA2Xw/ccviQYY0ysCxGsYB4+CwC28hRI2LEDzUMwWYctAgDEqdTkJO2fVxTrYgCIc1wzBwAAYDHCHAAAgMUIcwAAABYjzAEAAFiMMAcAAGAxwhwAAIDFCHMAAAAWI8wBAABYjDAHAABgMcIcAACAxQhzAAAAFiPMAQAAWIwwBwAAYDHCHAAAgMUIcwAAABYjzAEAAFiMMAcAAGAxwhwAAIDFCHMAAAAWI8wBAABYjDAHAABgMcIcAACAxQhzAAAAFiPMAQAAWIwwBwAAYDHCHAAAgMUIcwAAABYjzAEAAFiMMAcAAGAxwhwAAIDFCHMAAAAWI8wBAABYjDAHAABgMcIcAACAxYIOcxs3btSNN96onJwcJSQk6JVXXnEbP27cOCUkJLi9hg0b5jbNsWPHNGbMGDkcDqWnp+uuu+7SyZMnG7UiAAAAzVHQYe7UqVO67LLL9Nxzz3mdZtiwYTp8+LDr9dJLL7mNHzNmjHbu3Kk1a9ZoxYoV2rhxo8aPHx986QEAAJq5pGA/MHz4cA0fPtznNCkpKcrOzvY47qOPPtIbb7yh9957T/369ZMkPfvssxoxYoR+9rOfKScnJ9giAQAANFsRuWZu/fr1yszM1KWXXqoJEybo888/d40rLS1Venq6K8hJUkFBgRITE7Vp0yaP86uqqpLT6XR7AQAAIAJhbtiwYfqf//kfrV27VvPnz9eGDRs0fPhwnTt3TpJUXl6uzMxMt88kJSUpIyND5eXlHuc5d+5cpaWluV65ubnhLjYAAICVgj7N6s/tt9/u+rt3797q06ePunfvrvXr12vIkCEhzXP69OmaPHmy673T6STQAQAAKAJhrqGLL75YHTp00J49ezRkyBBlZ2fryJEjbtPU1NTo2LFjXq+zS0lJUUpKSqSLinpOV9cob+Zqt2G75hQqNTnJbVzdsFiJp7IAgG08besbqr9trT/9lhlD1O+xtef97W9b3HCZnvYtoZQnHBqW3df842mfk2CMMSF/OCFBy5cv18iRI71O8+mnn6pz58565ZVXdNNNN+mjjz5SXl6etmzZor59+0qS/vKXv2jYsGH69NNPA7oBwul0Ki0tTZWVlXI4HKEWH4AlAtlg19+ZBGPXnEJJ8nhQ4G3HFShPnwl1B8CBC9C8BJN1gg5zJ0+e1J49eyRJV1xxhX7+85/ruuuuU0ZGhjIyMjR79myNGjVK2dnZ2rt3rx5++GGdOHFC27dvd7WuDR8+XBUVFVq4cKHOnj2rO++8U/369dOSJUvCvoIAYCtvYdJXAI3U8gmQQHRFNMytX79e11133XnDi4uLtWDBAo0cOVLvv/++jh8/rpycHA0dOlQ/+clPlJWV5Zr22LFjmjhxol577TUlJiZq1KhReuaZZ9S2bduwryAAxLtgWgAJVUDzEEzWCXqLMHjwYPnKf6tX+z93nZGREXArHAAAALxr1DVzsULLHAAAaMqCyToR6TQYAAAA0UGYAwAAsBhhDgAAwGLcEgUAlvDW3x53uALNGy1zAAAAFuNQDgAskZqcpP3zimJdDABxhjAHAHGgsY8Ok7yfbvX2LEwATQP9zAEAmgWuOYRNIvoECAAAbMRpajRV3AABAABgMcIcAACAxQhzAAAAFiPMAQCajdPVNeo6baW6Tlup09U1focDNuBuVgAAgDgTTNahZQ4AAMBihDkAAACLEeYAAAAsRpgDAACwGGEOAADAYoQ5AAAAi/FsVgBAxNV/yP2uOYWS5PY+Eg+6r79MfyJVBl8a1km0lx8sT/VpQ7mbA/qZAwAAiDP0MwcAAMKOJ2XEJ8IcAACAxTjRDQAAApKanKT984piXQw0QJgDACCONLzRYMuMIerQtlUMS4R4R5gDACCO0PqFYHHNHAAAgMUIcwAAABbjNCvc+Otkc8uMIer32NrzhnvqOLLhvOpPE2jnk97K07DT0frlCmcnlv7qw9uybOsMFAD8qb9d87XN9bT9C2RbKgXekXQwHUKHwtu+rr542rbTMgcAAGAxngABoNmh5RRAvAsm67AFA9DscLcgJN+n6gIJ+Z+dPOP1VFwoBwkcZESGr0t+mgpa5gAAAOIMLXMAACj0i/Eb03LT2BY/IFi0zAGICX87WXZ68YP/CxB9wWQd7mYFAACwGC1zAIAmLdJ9ktFaeb5A+6SDd8FkHcIcAABAnOEGCAAAGvDWWhQOtDghlmiZAwAAzVo83uRDyxwAAECAbO9InLtZAQAALEaYAwAAsBhhDgAAwGKEOQAAAIsR5gAAACwWdJjbuHGjbrzxRuXk5CghIUGvvPKK23hjjGbOnKkLL7xQrVu3VkFBgT755BO3aY4dO6YxY8bI4XAoPT1dd911l06ePNmoFQEAAGiOgg5zp06d0mWXXabnnnvO4/gnn3xSzzzzjBYuXKhNmzapTZs2Kiws1JkzZ1zTjBkzRjt37tSaNWu0YsUKbdy4UePHjw99LQAAAJqpRnUanJCQoOXLl2vkyJGSvmyVy8nJ0UMPPaQf/vCHkqTKykplZWVp8eLFuv322/XRRx8pLy9P7733nvr16ydJeuONNzRixAh9+umnysnJ8btcOg0GAABNWTBZJ6zXzO3bt0/l5eUqKChwDUtLS9OAAQNUWloqSSotLVV6eroryElSQUGBEhMTtWnTJo/zraqqktPpdHsBAAAgzGGuvLxckpSVleU2PCsryzWuvLxcmZmZbuOTkpKUkZHhmqahuXPnKi0tzfXKzc0NZ7EBAACsZcXdrNOnT1dlZaXrdejQoVgXCQAAIC6ENcxlZ2dLkioqKtyGV1RUuMZlZ2fryJEjbuNramp07Ngx1zQNpaSkyOFwuL0AAAAQ5jDXrVs3ZWdna+3ata5hTqdTmzZtUn5+viQpPz9fx48f19atW13TvPnmm6qtrdWAAQPCWRwAAIAmLynYD5w8eVJ79uxxvd+3b5+2bdumjIwMde7cWZMmTdJjjz2mSy65RN26ddMjjzyinJwc1x2vPXv21LBhw3T33Xdr4cKFOnv2rCZOnKjbb789oDtZAQAA8JWgw9yWLVt03XXXud5PnjxZklRcXKzFixfr4Ycf1qlTpzR+/HgdP35cgwYN0htvvKFWrVq5PvPiiy9q4sSJGjJkiBITEzVq1Cg988wzYVgdAACA5qVR/czFCv3MAQCApixm/cwBAAAgughzAAAAFiPMAQAAWIwwBwAAYDHCHAAAgMUIcwAAABYjzAEAAFiMMAcAAGAxwhwAAIDFCHMAAAAWI8wBAABYjDAHAABgMcIcAACAxQhzAAAAFiPMAQAAWIwwBwAAYDHCHAAAgMUIcwAAABYjzAEAAFiMMAcAAGAxwhwAAIDFCHMAYInT1TXqOm2luk5bqdPVNbEuDoA4QZgDAACwWFKsCwAACExqcpL2zyuKdTEAxBla5gAAACxGmAMAALAYYQ4AAMBihDkAAACLcQMEAGudrq5R3szVYZ/vrjmFSk1O8jj/LTOGqN9ja92mA4BYomUOAADAYgnGGBPrQgTL6XQqLS1NlZWVcjgcsS4OAABAWAWTdWiZAwAAsBhhDgAAwGKEOQAAAIsR5gAAzdrp6hp1nbZSXaet1OnqmlgXBwgaYQ4AAMBidJAEAGjWUpOTtH9eUayLAYSMljkAAACLEeYAAAAsRpgDAACwGGEOAADAYoQ5AAAAixHmAAAALEaYAwAAsBhhDgAAwGKEOQAAAIsR5gAAACxGmAMAALAYYQ4AAMBiYQ9zs2bNUkJCgturR48ervFnzpxRSUmJ2rdvr7Zt22rUqFGqqKgIdzEAAACahYi0zH3jG9/Q4cOHXa+3337bNe7BBx/Ua6+9pmXLlmnDhg0qKyvTzTffHIliAAAANHlJEZlpUpKys7PPG15ZWan//u//1pIlS3T99ddLkhYtWqSePXvq3Xff1cCBAyNRHAAAgCYrIi1zn3zyiXJycnTxxRdrzJgxOnjwoCRp69atOnv2rAoKClzT9ujRQ507d1ZpaanX+VVVVcnpdLq9AAAAEIEwN2DAAC1evFhvvPGGFixYoH379umaa67RiRMnVF5eruTkZKWnp7t9JisrS+Xl5V7nOXfuXKWlpbleubm54S42AACAlcJ+mnX48OGuv/v06aMBAwaoS5cu+uMf/6jWrVuHNM/p06dr8uTJrvdOp5NABwAAoCh0TZKenq6vf/3r2rNnj7Kzs1VdXa3jx4+7TVNRUeHxGrs6KSkpcjgcbi8AAABEIcydPHlSe/fu1YUXXqi+ffuqZcuWWrt2rWv87t27dfDgQeXn50e6KAAAAE1O2E+z/vCHP9SNN96oLl26qKysTI8++qhatGih0aNHKy0tTXfddZcmT56sjIwMORwO3XfffcrPz+dOVgAAgBCEPcx9+umnGj16tD7//HN17NhRgwYN0rvvvquOHTtKkn7xi18oMTFRo0aNUlVVlQoLC/X888+HuxgAAADNQoIxxsS6EMFyOp1KS0tTZWVl1K6fO11do7yZq/1Ot2tOoSR5nXbXnEKlJn+ZoQ8dO6VrnlzvdbyvZdZN99nJM+r32Fqv0wRSFn/L8TWPQMtSN93p6ppGl9ffOqcmJ3ms2/rjJf/1H+r6BFJniIyGdb9lxhC3/0/99w3HeRtWf96efpv1h9fxNz5Ynn6j3tbF2+/a3/r6W79At4H+hPP34als4ahvb6K1nMby9L966+HBru1doNt+X9tbX/uqLTOGqEPbVq73nuYRyL7O3+810HWpm04KfX8Y7e+aFFzW4dmsAAAAFqNlLgD+Wmg8qX8U1NCWGUOUmpzk98jU15GEv6Mafy1QwR45BTqNv7J4mk/D8f5azDzNI5D1aTifUI44A51H/fKE8v0BbNJwW+WrhTRSrRn+Wpk8taL7aoltahpuI+Fbw+9TLFpig8k6hLkgBdIs7WnaQE5neJqPv8ARyCnHcASbcJyK9TVNoKc/A2lK93WaNZiyhFongYRT2MnfqcpAw0EkdgyhnAZtuF2S/J/+jOfTi8Hwdyo52N+5rfyFlkAO0P2dZg10v+nrQD+QeXi7HKGuLKGWw9M6RwNhLkIC2VgGcy2Cv518INfvBLqhCWQ6Xz/aUH7QoU7jabpg6lUKrWUu0DoLtDx1031+soowh/NEOtAF830Ot3gPOoHWU7DbnVCW4W1e9bdPnlrVgmk5CnZ9fS0nkOlCqZN4mkeg00RaMFknfn9tcSaYICdJqclJ2j+vyOf0uRlttGtOoc8vTP3x3qbxVY46qclJfpflqcynq2vUddpKScGdkvB02sVTub0N91Z/DdfD23wC+eH5myaQ/2FA9Zrx5Xw43Yr6Ih2sYnkDTqA3a3hS/xIVf9OGupMN5Lftj79l+1pGoNsWT38HM49wlCWQbVwgGhuOPJ3pypu5Ouh5NdyXhzKPeETLXBBCOToD6uOUK5qDYFuJ4qEVBE1Xw++X5L+hIR5wmjXMAtkBx/MXAvEllNNdnroVaCxaCtEY8bLN83ZtsifxUmYgEHRNAgAA0EzQMheAcHVN4uu6kUjeIh/IvCO1/FDmG8rdgeEWzN3H3oS7s1XARvV/S766bGooFt2bBML2U8LxuD0KdjsfL13KxFOnwYQ5P8JxB6uNP3g0nq/rNKIlHoIxEE3R2N7aFuhsKy++RJgLo1BaYqIlXBd1errFvf68Gt5d5q3jyUBvYfc2bZ1AjsB93bbPhisw8XiEjqYp1NZtf/NC0xGu7bYt3Y4EgjAXRr5Osb718GDlZrSJ6PIjzV9nj5L//o7CXQbJ/w8s0mXyJ146lQyHcIRwTy2P3lqsA+nwGvEtHN/1cPWwb8uOGb7Fy/8xXsohEebCqjE7nMZ0OClF/2HevsTTFzxaQjnCkwJ7yoWvzwV6ajTQXuu5dg/NVaDb1zrefnv+nvwRrGA+G67LI2J1zWFT2HeE0uAQDtzNCgAA0EzQMueHr5a5v0y6RkOfesttmLejqGicCgzmBoxAnunqbZ7BHO0G2hrlTWNaLhsrmHWx6SiX05sIJ1tbW5obOmu2D6dZw6ipXzOH5s3T9zsW1yD64us5u6erawimEeZvJx/I84nDdfODP/H23QUagzAXRo15/JK3PpXCeQRUf+MY7PICeRh9w2UEc2OCv+kD3bD7e8h0JI4ofd3gEEgLaKDr1pj6qasXroVDNHg66xCumxakwLvt8fYw+kCmj6SG+4poLDfQVnZPZ5FoiYt/hLkwYScJAPbx1V1RnVj1/YjYCmd/m3Qa3EjxGuY40oENon3NXMPfRWNauxE6G7dPnr4rodyd3XDdw9m1kK9yeGoRa8yyAimDjf9neMbdrAAAAM0ELXM+NPY0q6/nEPrrULWxgrl2LR7FulPgcPP3XQrmmZVAODU83eitNamhYE9XBdI6Fgx/y29MH3OBCLSe4pFt+4PmitOsYdLYMPdqyVX61nPvBP25xv7QfJ3G8tT7fjyGpWiWL5ynHbkOB6FoijvX+tuhUO/89/bbrNsmxLKbHdvCXGMe+YjYCCbr8J+MoIsuaO1zvKfWmMY+S+50dc158/R0xNmhbSvtn1fkZw2+Eu3wV3/9gt3gNNzA+9qR+NsZ+HvyRkOEOIQiEt8bTz3+e3p8X8MW/Eh09xLuVud+j60NqDXb1535jb0Q3qYgJ0U+xMXqKQmREou7kxuDljkfYn03q68jv0geFe6aU6jPT1ZF5bTflhlDlJqcFHI90xKGeBbvO4BwC/TRhYFcXuLrDEPdASU30zROqGePGiMc3VV5m19jbwQJ9dGbkcJp1jCJVZhr2PIV7PVvwXTiGah4Py1bx9vGPdA74AKtm0C+G3XzYoeDxgi1P8FwdsEQb4I9zdqU6yJQ0eqPM1LLiqZ4WS/CXJjEc8tcOEXq1Eogp0E8BcNgr4NhQ414Y/vOTIrvx75xw5D96v9GInnA663xIRz790g3bNA1CQAAQDNBy5wPsW6Z89ZiFsjRQCBH1Y2dTzy2PgRzhBeOo6pALvqN9fcITUNTaI3ydY1rMJ0B1//thtp5cHP7XXq7zjDU7Xj9fUPD72Y8X4oTCH+X60QLp1nDJJ5PMwAIj3g8KIm2+ts6G7rcqB8W2E4jVkLtcidQdE0SJs19A4/GHck3hZaU5sBXy6q/lt76/2NPXYFEW8NgE0owi4cg5+s62LceHuzW6lPXzVLDm7Qk+TyrEInrhNG8tE5uEesiuNAy5wNHfEBs2X66pqlp2PWDJK/v63gLtoHcIR+PfZcFcilHsP1T+vtsfeyX4kc8tcwR5nzgRwPJfeMazHcimv31NVbDnam3HU807hwOtO/AYMJEw+GxDgTR0hSvCwukY/X603kLX8F8l4Nt4eQO++aBu1kBAAAQFrTM+UDLHKIhHo7im0tLVXPj787FxvaYj9ijU/LY4TRrI0UjzDXF0xPwzNdzKwNtQm8Y/ENtfg/X987bxfie5h/OUwWEg/gR6YPRcHRpEahoXDsZj99dmxoUQn1SSbDLiFR9hHJTTDydZiXMeUGYQ6Q1fC5tsM+ZDeZO20A2VPGyAwMQOvZd0RNPLXNsuS2zZcYQfVF9jmb1RvJ1RBXtI/T984o8vg9ko+xtGk/lTk1OOq8LB4k7RpuyUE/BRTvY+/qu8/30LJD/rbfukfx1/RKOToXrC+V72LCMgZYjlGUFs471v6vt26YEtZxIomXOC45uEGn++iUL9ukbgfZa3nC6SB9dIv54+m4RmuzH9XPRFU8tc9zNCgAAYDFOs8YZb83ino4AAr041tu1VaFcTOqrOTqcrZmebkoI9pqy+oJpdQjmNKunI+FAHzX0RfU5t2VKga9b3szV55UtN6PNeadsA9GUnqkIz7z97uPxOklv/cXBv1C3AbEQq/9zw21yU/l+cZrVC06zoikJ9dFiwTz8PNB5NRTN31qoHUBHk6ewFcwBRjjXK9I7uobr1fAmnYbLj7f/WWPvroyH30RT0Jj/Q2O2cdzN2kjRCHPxttEAPPHXy339aYLZWPnbSAVz40UoIvX7a8yzdqPBV6uZv0AXifUJ5P8Zyg1D3rrI8fQ/j/cAHolAF8wzgcNZFk+fD6bLkXA989bfevj6nfj6jgR6c4enVkMp8EfVhQthLgwau9FoKk23tvH2fwulNSOQ07qvllylbz33Toil/UrdBjPQC5gj1ccX39umoTmeqgznXei+HmfHZQiIFsJcGIQS5iLZZB6OI/H6RzOBXjcT6gYymCPvYOftbzn1lxdo61JjNv7RbuFpzA4llLIGe4rWW+tXIHUc6ZaXeHjahj++WuT8jQ/3+vn7n4Xa0bavz3n7zsRjS2qsRKL7EMQfwlwYxFtzvr8NfCBCvW6qYRn8LTuUHUooF2U359vwI7mTC8eOwVOZgi0zO6jQRPICb1//t1APZgMJgIE8ucTfdy4Q4dru+zrd6OugWjr/TIC3+qlfVn916GvaQA+4AgnZgexjbPtdR/qSEl/omgQAAKCZoGXOi2CP0Gw72oC7QE4XBXvqOBoCua6vsS2yTYm3VpFwzbMxwrUNCaVV1FureyiXd3ial7/vYLA3WjRXjbmEAfbhNGsYBBLmuBi2abBtJxHJa8+aw3fatv+3N8GEyEidOg/n/EMph787XYMtVywu3SCIwRsrwtxzzz2nn/70pyovL9dll12mZ599Vv379w/os4Q52CgcIcLbheJ1otWpc2PEojXTXwtTvHekG6xwXD/mSTB3W0vBdfAdzHVfcNcUvrM4X9yHuT/84Q+64447tHDhQg0YMEBPPfWUli1bpt27dyszM9Pv5wlziBRfp5m87SClr3Zaf5l0jYY+9VZEyubt+xaukBbqhdHxJJBT4TZ11BqJevfWgvX5yapGnwqNFH/htLFBLx4uRQj3Hf22/GbhXdyHuQEDBujKK6/UL3/5S0lSbW2tcnNzdd9992natGl+P0+YQ1Pgr/f7hiLRfYu/eQe6k4zVtYON6aS2vnj9LUcqYIar3iIlkI5gQ/k9eDpACWUdQ+ldIFyBsam1IsO7uL6btbq6Wlu3blVBQcFXhUhMVEFBgUpLSz1+pqqqSk6n0+0FAACAGLTMlZWV6aKLLtI777yj/Px81/CHH35YGzZs0KZNm877zKxZszR79uzzhtMyB1v5e1xMJI64A70LEWhq4vEUuif8BlFfXJ9mDSXMVVVVqaqqyvXe6XQqNzc3omEOAAAgVoIJc1E/BOjQoYNatGihiooKt+EVFRXKzs72+JmUlBSlpKREo3gAAABWifo1c8nJyerbt6/Wrv3qFGZtba3Wrl3r1lIHAAAA/2Jycn7y5MkqLi5Wv3791L9/fz311FM6deqU7rzzzlgUBwAAwFoxCXPf+c53dPToUc2cOVPl5eW6/PLL9cYbbygrKysWxQEAALAWj/MCAACIM3HdzxwAAADChzAHAABgMcIcAACAxQhzAAAAFiPMAQAAWIwwBwAAYDHCHAAAgMUIcwAAABYjzAEAAFiMMAcAAGAxwhwAAIDFkmJdgFDUPU7W6XTGuCQAAADhV5dx6jKPL1aGuRMnTkiScnNzY1wSAACAyDlx4oTS0tJ8TpNgAol8caa2tlZlZWVq166dEhISIrIMp9Op3NxcHTp0SA6HIyLLaEqor8BRV8GhvoJDfQWOugoO9RW4cNSVMUYnTpxQTk6OEhN9XxVnZctcYmKiOnXqFJVlORwOvrRBoL4CR10Fh/oKDvUVOOoqONRX4BpbV/5a5OpwAwQAAIDFCHMAAAAWI8x5kZKSokcffVQpKSmxLooVqK/AUVfBob6CQ30FjroKDvUVuGjXlZU3QAAAAOBLtMwBAABYjDAHAABgMcIcAACAxQhzAAAAFiPMefHcc8+pa9euatWqlQYMGKDNmzfHukhRN3fuXF155ZVq166dMjMzNXLkSO3evdttmjNnzqikpETt27dX27ZtNWrUKFVUVLhNc/DgQRUVFSk1NVWZmZmaMmWKampqorkqUTdv3jwlJCRo0qRJrmHUlbt//vOf+t73vqf27durdevW6t27t7Zs2eIab4zRzJkzdeGFF6p169YqKCjQJ5984jaPY8eOacyYMXI4HEpPT9ddd92lkydPRntVIurcuXN65JFH1K1bN7Vu3Vrdu3fXT37yE7fnNTbnutq4caNuvPFG5eTkKCEhQa+88orb+HDVzYcffqhrrrlGrVq1Um5urp588slIr1pE+Kqvs2fPaurUqerdu7fatGmjnJwc3XHHHSorK3ObR3OpL3/frfruueceJSQk6KmnnnIbHrW6MjjP0qVLTXJysvntb39rdu7cae6++26Tnp5uKioqYl20qCosLDSLFi0yO3bsMNu2bTMjRowwnTt3NidPnnRNc88995jc3Fyzdu1as2XLFjNw4EBz1VVXucbX1NSYXr16mYKCAvP++++b119/3XTo0MFMnz49FqsUFZs3bzZdu3Y1ffr0MQ888IBrOHX1lWPHjpkuXbqYcePGmU2bNpl//OMfZvXq1WbPnj2uaebNm2fS0tLMK6+8Yj744ANz0003mW7dupkvvvjCNc2wYcPMZZddZt59913z1ltvma997Wtm9OjRsViliHn88cdN+/btzYoVK8y+ffvMsmXLTNu2bc3TTz/tmqY519Xrr79ufvzjH5uXX37ZSDLLly93Gx+OuqmsrDRZWVlmzJgxZseOHeall14yrVu3Nr/61a+itZph46u+jh8/bgoKCswf/vAH8/HHH5vS0lLTv39/07dvX7d5NJf68vfdqvPyyy+byy67zOTk5Jhf/OIXbuOiVVeEOQ/69+9vSkpKXO/PnTtncnJyzNy5c2NYqtg7cuSIkWQ2bNhgjPnyh9+yZUuzbNky1zQfffSRkWRKS0uNMV/+GBITE015eblrmgULFhiHw2GqqqqiuwJRcOLECXPJJZeYNWvWmH/7t39zhTnqyt3UqVPNoEGDvI6vra012dnZ5qc//alr2PHjx01KSop56aWXjDHG7Nq1y0gy7733nmuaVatWmYSEBPPPf/4zcoWPsqKiIvP973/fbdjNN99sxowZY4yhrupruMMNV908//zz5oILLnD7HU6dOtVceumlEV6jyPIVUOps3rzZSDIHDhwwxjTf+vJWV59++qm56KKLzI4dO0yXLl3cwlw064rTrA1UV1dr69atKigocA1LTExUQUGBSktLY1iy2KusrJQkZWRkSJK2bt2qs2fPutVVjx491LlzZ1ddlZaWqnfv3srKynJNU1hYKKfTqZ07d0ax9NFRUlKioqIitzqRqKuG/vznP6tfv3669dZblZmZqSuuuEK/+c1vXOP37dun8vJyt/pKS0vTgAED3OorPT1d/fr1c01TUFCgxMREbdq0KXorE2FXXXWV1q5dq7///e+SpA8++EBvv/22hg8fLom68iVcdVNaWqprr71WycnJrmkKCwu1e/du/etf/4rS2sRGZWWlEhISlJ6eLon6qq+2tlZjx47VlClT9I1vfOO88dGsK8JcA5999pnOnTvntkOVpKysLJWXl8eoVLFXW1urSZMm6eqrr1avXr0kSeXl5UpOTnb9yOvUr6vy8nKPdVk3rilZunSp/va3v2nu3LnnjaOu3P3jH//QggULdMkll2j16tWaMGGC7r//fr3wwguSvlpfX7/D8vJyZWZmuo1PSkpSRkZGk6qvadOm6fbbb1ePHj3UsmVLXXHFFZo0aZLGjBkjibryJVx105x+m/WdOXNGU6dO1ejRo10Pi6e+vjJ//nwlJSXp/vvv9zg+mnWVFEzB0XyVlJRox44devvtt2NdlLh06NAhPfDAA1qzZo1atWoV6+LEvdraWvXr109PPPGEJOmKK67Qjh07tHDhQhUXF8e4dPHlj3/8o1588UUtWbJE3/jGN7Rt2zZNmjRJOTk51BUi5uzZs7rttttkjNGCBQtiXZy4s3XrVj399NP629/+poSEhFgXh5a5hjp06KAWLVqcd5dhRUWFsrOzY1Sq2Jo4caJWrFihdevWqVOnTq7h2dnZqq6u1vHjx92mr19X2dnZHuuyblxTsXXrVh05ckTf/OY3lZSUpKSkJG3YsEHPPPOMkpKSlJWVRV3Vc+GFFyovL89tWM+ePXXw4EFJX62vr99hdna2jhw54ja+pqZGx44da1L1NWXKFFfrXO/evTV27Fg9+OCDrhZg6sq7cNVNc/ptSl8FuQMHDmjNmjWuVjmJ+qrz1ltv6ciRI+rcubNrm3/gwAE99NBD6tq1q6To1hVhroHk5GT17dtXa9eudQ2rra3V2rVrlZ+fH8OSRZ8xRhMnTtTy5cv15ptvqlu3bm7j+/btq5YtW7rV1e7du3Xw4EFXXeXn52v79u1uX+i6jUPDnbnNhgwZou3bt2vbtm2uV79+/TRmzBjX39TVV66++urzurn5+9//ri5dukiSunXrpuzsbLf6cjqd2rRpk1t9HT9+XFu3bnVN8+abb6q2tlYDBgyIwlpEx+nTp5WY6L6pbtGihWprayVRV76Eq27y8/O1ceNGnT171jXNmjVrdOmll+qCCy6I0tpER12Q++STT/TXv/5V7du3dxtPfX1p7Nix+vDDD922+Tk5OZoyZYpWr14tKcp1FdTtEs3E0qVLTUpKilm8eLHZtWuXGT9+vElPT3e7y7A5mDBhgklLSzPr1683hw8fdr1Onz7tmuaee+4xnTt3Nm+++abZsmWLyc/PN/n5+a7xdd1tDB061Gzbts288cYbpmPHjk2yu42G6t/Nagx1Vd/mzZtNUlKSefzxx80nn3xiXnzxRZOammp+//vfu6aZN2+eSU9PN6+++qr58MMPzbe+9S2PXUpcccUVZtOmTebtt982l1xySZPobqO+4uJic9FFF7m6Jnn55ZdNhw4dzMMPP+yapjnX1YkTJ8z7779v3n//fSPJ/PznPzfvv/++6+7LcNTN8ePHTVZWlhk7dqzZsWOHWbp0qUlNTbWuqw1jfNdXdXW1uemmm0ynTp3Mtm3b3Lb79e+2bC715e+71VDDu1mNiV5dEea8ePbZZ03nzp1NcnKy6d+/v3n33XdjXaSok+TxtWjRItc0X3zxhbn33nvNBRdcYFJTU823v/1tc/jwYbf57N+/3wwfPty0bt3adOjQwTz00EPm7NmzUV6b6GsY5qgrd6+99prp1auXSUlJMT169DC//vWv3cbX1taaRx55xGRlZZmUlBQzZMgQs3v3brdpPv/8czN69GjTtm1b43A4zJ133mlOnDgRzdWIOKfTaR544AHTuXNn06pVK3PxxRebH//4x2471+ZcV+vWrfO4nSouLjbGhK9uPvjgAzNo0CCTkpJiLrroIjNv3rxorWJY+aqvffv2ed3ur1u3zjWP5lJf/r5bDXkKc9GqqwRj6nUjDgAAAKtwzRwAAIDFCHMAAAAWI8wBAABYjDAHAABgMcIcAACAxQhzAAAAFiPMAQAAWIwwBwAAYDHCHAAAgMUIcwAAABYjzAEAAFiMMAcAAGCx/weKqcSdITWKxAAAAABJRU5ErkJggg==\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "import pickle as pkl\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "data_path = '/content/drive/My Drive/Colab Notebooks/tf_LSM/'\n",
        "\n",
        "with open(data_path + \"saved_spikes.pkl\", \"rb\") as f:\n",
        "  neuronSpikes = pkl.load(f)\n",
        "  neuronSpikes = neuronSpikes.numpy()\n",
        "\n",
        "num_in_batch = 7\n",
        "\n",
        "raster = []\n",
        "for i in range(neuronSpikes.shape[2]):\n",
        "  this_neuron = []\n",
        "  for k in range(0,neuronSpikes.shape[1]): #1378\n",
        "    if neuronSpikes[num_in_batch][k][i] == 1:\n",
        "      this_neuron.append(k)\n",
        "  raster.append(this_neuron)\n",
        "\n",
        "\n",
        "\n",
        "from matplotlib import pyplot as plt\n",
        "fig, ax = plt.subplots(1,1)\n",
        "ax.eventplot(raster)\n",
        "fig.suptitle(\"Raster plot\")\n",
        "fig.tight_layout()\n",
        "fig.savefig(\"Question_2_raster_plot\")\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 492
        },
        "id": "doar9n8TW00R",
        "outputId": "6660eed6-7079-414d-d983-9da1aaaac705"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "num_in_batch = 1\n",
        "\n",
        "raster = []\n",
        "for i in range(neuronSpikes.shape[2]):\n",
        "  this_neuron = []\n",
        "  for k in range(0,neuronSpikes.shape[1]): #1378\n",
        "    if neuronSpikes[num_in_batch][k][i] == 1:\n",
        "      this_neuron.append(k)\n",
        "  raster.append(this_neuron)\n",
        "\n",
        "\n",
        "\n",
        "from matplotlib import pyplot as plt\n",
        "fig, ax = plt.subplots(1,1)\n",
        "ax.eventplot(raster)\n",
        "fig.suptitle(\"Raster plot\")\n",
        "fig.tight_layout()\n",
        "fig.savefig(\"Question_2_raster_plot\")\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XO_EqyEQWhdH",
        "outputId": "758d8e2a-41f8-4b5d-fd54-7629278d7cf0"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "down 0\n",
            "no 1\n",
            "down 2\n",
            "left 3\n",
            "up 4\n",
            "go 5\n",
            "down 6\n",
            "down 7\n",
            "stop 8\n",
            "left 9\n",
            "go 10\n",
            "down 11\n",
            "left 12\n",
            "up 13\n",
            "yes 14\n",
            "go 15\n",
            "left 16\n",
            "stop 17\n",
            "down 18\n",
            "go 19\n",
            "down 20\n",
            "stop 21\n",
            "left 22\n",
            "up 23\n",
            "down 24\n",
            "go 25\n",
            "down 26\n",
            "right 27\n",
            "yes 28\n",
            "stop 29\n",
            "yes 30\n",
            "no 31\n",
            "up 32\n",
            "go 33\n",
            "up 34\n",
            "go 35\n",
            "yes 36\n",
            "down 37\n",
            "up 38\n",
            "no 39\n",
            "stop 40\n",
            "left 41\n",
            "left 42\n",
            "right 43\n",
            "down 44\n",
            "up 45\n",
            "right 46\n",
            "right 47\n",
            "left 48\n",
            "down 49\n"
          ]
        }
      ],
      "source": [
        "with open(data_path + f\"y_in_train.pkl\",\"rb\") as f:\n",
        "  y_in_train = pkl.load(f)\n",
        "for i in range(50):\n",
        "  print(y_in_train[i], i)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "h_QkZj53kgrK"
      },
      "outputs": [],
      "source": [
        "new_boxes = []\n",
        "num_bins = 3\n",
        "for i in range(N):\n",
        "  Nx = i//a\n",
        "  Ny = i%a\n",
        "  new_x = Nx//(a//num_bins)\n",
        "  new_y = Ny//(b//num_bins)\n",
        "  new_box = new_x*num_bins**2 + new_y*num_bins\n",
        "  new_boxes.append(new_box)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 236
        },
        "id": "G0GALFYJlu-z",
        "outputId": "6887f16e-e92d-4774-82ce-fdd1d532bbf2"
      },
      "outputs": [
        {
          "output_type": "error",
          "ename": "IndexError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-40-91ae7570bfb1>\u001b[0m in \u001b[0;36m<cell line: 4>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      5\u001b[0m   \u001b[0;32mfor\u001b[0m \u001b[0mk\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mneuronSpikes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\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[0;31m#1378\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mneuronSpikes\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mnum_in_batch\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\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[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m       \u001b[0mbox_vec\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mnew_boxes\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbox_vec\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mnew_boxes\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\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[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbox_vec\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mIndexError\u001b[0m: list index out of range"
          ]
        }
      ],
      "source": [
        "num_in_batch = 16\n",
        "box_vec = [0 for x in range(num_bins**3)]\n",
        "raster = []\n",
        "for i in range(neuronSpikes.shape[2]): #number of neurons\n",
        "  for k in range(0,neuronSpikes.shape[1]): #1378\n",
        "    if neuronSpikes[num_in_batch][k][i] == 1:\n",
        "      box_vec[new_boxes[i]] = box_vec[new_boxes[i]]+1\n",
        "\n",
        "print(box_vec)\n",
        "print([i for i in range(len(box_vec)) if box_vec[i]>1500])\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kVW7IIpxVUzH"
      },
      "outputs": [],
      "source": [
        "num_in_batch = 38\n",
        "total_spikes = np.sum(x_in_train[num_in_batch], axis=1)\n",
        "differ = [total_spikes[i+5]- total_spikes[i] for i in range(1370)]\n",
        "a= np.arange(1370)\n",
        "plt.plot(a, differ)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fHNaECwknI-I"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "corr_change = []\n",
        "total_timediv = 15\n",
        "time_window = neuronSpikes.shape[1]//total_timediv\n",
        "\n",
        "with open(data_path + f\"filenames.pkl\",\"rb\") as f:\n",
        "    filenames = pkl.load(f)\n",
        "\n",
        "def ret_matrix_of_spacetime(num_in_batch, total_timediv):\n",
        "  global filenames\n",
        "  filename1 = filenames[num_in_batch]\n",
        "  box_vec1 = [0 for x in range(num_bins**3)]\n",
        "  for j in range(100):\n",
        "    for i in range(neuronSpikes.shape[2]): #number of neurons\n",
        "      for k in range(j*100,(j+1)*100): #1378\n",
        "        if neuronSpikes[num_in_batch][k][i] == 1:\n",
        "          box_vec1[new_boxes[i]] = box_vec1[new_boxes[i]]+1\n",
        "      print(box_)\n",
        "\n",
        "\n",
        "\n",
        "for j in range(total_timediv):\n",
        "  num_in_batch = 3\n",
        "  filename1 = filenames[num_in_batch]\n",
        "  box_vec1 = [0 for x in range(num_bins**3)]\n",
        "  for i in range(neuronSpikes.shape[2]): #number of neurons\n",
        "    for k in range(j*total_timediv,(j+1)*total_timediv): #1378\n",
        "      if neuronSpikes[num_in_batch][k][i] == 1:\n",
        "        box_vec1[new_boxes[i]] = box_vec1[new_boxes[i]]+1\n",
        "\n",
        "  num_in_batch = 36\n",
        "  filename2 = filenames[num_in_batch]\n",
        "  box_vec2 = [0 for x in range(num_bins**3)]\n",
        "  for i in range(neuronSpikes.shape[2]): #number of neurons\n",
        "    for k in range(j*total_timediv,(j+1)*total_timediv): #1378\n",
        "      if neuronSpikes[num_in_batch][k][i] == 1:\n",
        "        box_vec2[new_boxes[i]] = box_vec2[new_boxes[i]]+1\n",
        "  #print(box_vec1)\n",
        "  #print(box_vec2)\n",
        "  corr = np.corrcoef(box_vec1, box_vec2)\n",
        "  corr_change.append(corr[0][1])\n",
        "\n",
        "print(filename1, filename2)\n",
        "print(corr_change)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Jc_mtpQAYq_J"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "from sklearn.datasets import fetch_openml\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.metrics import confusion_matrix\n",
        "import pickle\n",
        "import tensorflow as tf\n",
        "import matplotlib.pyplot as plt\n",
        "import pathlib\n",
        "import os\n",
        "\n",
        "DATASET_PATH = 'data/mini_speech_commands'\n",
        "data_dir = pathlib.Path(DATASET_PATH)\n",
        "if not data_dir.exists():\n",
        "  tf.keras.utils.get_file(\n",
        "      'mini_speech_commands.zip',\n",
        "      origin=\"http://storage.googleapis.com/download.tensorflow.org/data/mini_speech_commands.zip\",\n",
        "      extract=True,\n",
        "      cache_dir='.', cache_subdir='data')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PXrU97iA13Ub"
      },
      "outputs": [],
      "source": [
        "from IPython.display import Audio\n",
        "#wn = Audio(str(filename1), autoplay=True)\n",
        "#display(wn)\n",
        "#wn = Audio(str(filename2), autoplay=True)\n",
        "#display(wn)\n",
        "from scipy.io.wavfile import read\n",
        "a = read(str(filenames[num_in_batch]))\n",
        "b = np.array(a[1],dtype=float)\n",
        "print(b.shape)\n",
        "\n",
        "wn = Audio(b[-10000:], autoplay=True, rate = 16000)\n",
        "display(wn)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BMm9kQAbqIVI"
      },
      "outputs": [],
      "source": [
        "neuronSpikes[1].sum()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tNki9pFe2A00"
      },
      "source": [
        "linear classifier weights take of all neurons.\n",
        "see assigned weight matrix 1728*10\n",
        "build a weighted spike rate.\n",
        "\n",
        "top n most imp neurons in this area\n",
        "\n",
        "build small bins, compare correlations over time, how they increase or decrease."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dd-69tFbjmri"
      },
      "source": [
        "#Linear models"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BzbEMMdUt_Zx"
      },
      "outputs": [],
      "source": [
        "with open(data_path + f\"LSM_out_train2_{flag}.pkl\",\"rb\") as f:\n",
        "  LSM_out_train2 = pkl.load(f)\n",
        "with open(data_path + f\"LSM_out_test_{flag}.pkl\",\"rb\") as f:\n",
        "  LSM_out_test = pkl.load(f)\n",
        "print(LSM_out_train2)\n",
        "print(LSM_out_test)\n",
        "print(y_in_train.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pjaxuGy5yLU1"
      },
      "outputs": [],
      "source": [
        "print(LSM_out_test.sum())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZqHRdTz8T3pY"
      },
      "outputs": [],
      "source": [
        "#print(LSM_out_train[-1000:].shape)\n",
        "print(LSM_out_test.shape)\n",
        "print(y_in_train[-1000:].shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QNyK3Y3O1-HK"
      },
      "outputs": [],
      "source": [
        "from sklearn import linear_model\n",
        "from sklearn.metrics import ConfusionMatrixDisplay\n",
        "from sklearn.neural_network import MLPClassifier\n",
        "\n",
        "\n",
        "print(LSM_out_train2.sum())\n",
        "print(\"training linear model on LSM\")\n",
        "clf = linear_model.SGDClassifier(max_iter=10000, tol=1e-6)\n",
        "#clf = MLPClassifier(solver='lbfgs', alpha=1.5, hidden_layer_sizes=(32,15), random_state=1)\n",
        "#clf.fit(LSM_out_train[-500:], y_in_train[-500:])\n",
        "clf.fit(LSM_out_train2, y_in_train)\n",
        "\n",
        "train_score = clf.score(LSM_out_train2, y_in_train)\n",
        "print(\"train score = \" + str(train_score))\n",
        "\n",
        "score = clf.score(LSM_out_test, y_test)\n",
        "print(\"test score = \" + str(score))\n",
        "\n",
        "test_predict = clf.predict(LSM_out_test)\n",
        "cm = confusion_matrix(y_test, test_predict, labels=clf.classes_)\n",
        "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=clf.classes_)\n",
        "disp.plot()\n",
        "plt.show()\n",
        "\n",
        "#print(\"training linear model on direct input\")\n",
        "#clf2 = linear_model.SGDClassifier(max_iter=10000, tol=1e-6)\n",
        "#clf2.fit(np.mean(x_in_train, axis=(1)), y_in_train)\n",
        "\n",
        "#score2 = clf2.score(np.mean(x_test, axis=(1)), y_test)\n",
        "#print(\"test score without LSM = \" + str(score2))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "f0cMhEhvJtXA"
      },
      "outputs": [],
      "source": [
        "print(LSM_out_test)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D6vFN8QKXbrS"
      },
      "source": [
        "#Intuition plotting"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hdwrRD81AGm0"
      },
      "outputs": [],
      "source": [
        "leng = 10\n",
        "with open(data_path + \"saved_spikes.pkl\", \"rb\") as f:\n",
        "  neuronSpikes = pkl.load(f)\n",
        "  neuronSpikes = neuronSpikes.numpy()\n",
        "num_in_batch = 46\n",
        "print(neuronSpikes.shape[2])\n",
        "image_vec = [[0 for x1 in range(leng)] for x2 in range(leng)]\n",
        "for i in range(neuronSpikes.shape[2]): #number of neurons\n",
        "  for k in range(0,neuronSpikes.shape[1]): #1378\n",
        "    if neuronSpikes[num_in_batch][k][i] == 1:\n",
        "      Nx1 = i//leng\n",
        "      Ny1 = i%leng\n",
        "      image_vec[Nx1][Ny1] = image_vec[Nx1][Ny1] + 1\n",
        "image_vecnp = np.array(image_vec)\n",
        "\n",
        "from matplotlib import pyplot as plt\n",
        "plt.imshow(image_vecnp, cmap='gray')\n",
        "plt.show()"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "collapsed_sections": [
        "lyrIT-SEkNm0",
        "E_1cj8EFkAhq"
      ],
      "provenance": []
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}