experiments.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "df05f2d3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import nengo\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import pandas as pd\n",
    "from scipy.optimize import curve_fit\n",
    "from uniform_encoders import *\n",
    "\n",
    "palette = sns.color_palette(\"colorblind\")\n",
    "sns.set_palette(palette)\n",
    "# sns.set(context='paper', style='white', font='CMU Serif')\n",
    "sns.set(context='paper', style='white', font='CMU Serif', rc={'font.size':10, 'mathtext.fontset': 'cm'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4188e151",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Inputs():\n",
    "    def __init__(self, nCS=1, nCTX=2, dim_CS=3, dim_CTX=2, seed=0):\n",
    "        self.rng = np.random.RandomState(seed=seed)\n",
    "        self.sampler = ScatteredHypersphere(surface=True)\n",
    "        self.dim_CS = dim_CS\n",
    "        self.dim_CTX = dim_CTX\n",
    "        self.nCS = nCS\n",
    "        self.nCTX = nCTX\n",
    "        self.CS = np.zeros((self.dim_CS))\n",
    "        self.US = 0\n",
    "        self.CTX = np.zeros((self.dim_CTX))\n",
    "        self.CSs = self.sampler.sample(nCS, dim_CS, rng=self.rng)\n",
    "        self.CTXs = self.sampler.sample(nCTX, dim_CTX, rng=self.rng)\n",
    "        self.stop_learning = 0  # control signal to turn learning off\n",
    "        self.applied_current = 0  # for experiments with external perturbation\n",
    "    def get_CS(self, t):\n",
    "        applied = True if t%2>1 else False  # 1s of no input, 1s of CS input\n",
    "        return self.CS if applied else np.zeros((self.dim_CS))\n",
    "    def get_CTX(self, t):\n",
    "        return self.CTX\n",
    "    def get_US(self, t):\n",
    "        applied = True if t%2>1.5 else False # 1.5s of no input, 0.5s of US input \n",
    "        return self.US if applied else 0\n",
    "    def get_stop_learning(self, t):\n",
    "        return self.stop_learning\n",
    "    def get_applied_current(self, t):\n",
    "        return self.applied_current\n",
    "    \n",
    "def sparsity_to_x_intercept(d, p):\n",
    "    sign = 1\n",
    "    if p > 0.5:\n",
    "        p = 1.0 - p\n",
    "        sign = -1\n",
    "    return sign * np.sqrt(1-scipy.special.betaincinv((d-1)/2.0, 0.5, 2*p))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "8bd79c0d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_network(\n",
    "        dt = 0.001,\n",
    "        nCond = 5,\n",
    "        nExt = 10,\n",
    "        seed = 0,\n",
    "        nNeurons = 100,\n",
    "        nNeuronsExtCS = 300,\n",
    "        nNeuronsExtCTX = 500,\n",
    "        dim_CS = 3,\n",
    "        dim_CTX = 5,\n",
    "        nCS = 1,\n",
    "        nCTX = 3,\n",
    "        intercept_CS = 0,\n",
    "        intercept_CTX = 0,\n",
    "        intercept_LA_pyr = -0.2,\n",
    "        lr1 = 3e-5,\n",
    "        lr2 = 3e-4,\n",
    "        lr3 = 1e-5,\n",
    "        T_BLA_CS=0.25,\n",
    "        T_BLA_CTX=0.75,\n",
    "        T_BLA_US=1.0,\n",
    "    ):\n",
    "\n",
    "    rng = np.random.RandomState(seed=seed)\n",
    "    sampler = ScatteredHypersphere(surface=True)\n",
    "    inputs = Inputs(dim_CS=dim_CS, dim_CTX=dim_CTX, nCS=nCS, nCTX=nCTX, seed=seed)\n",
    "    encoders_LA_pyr = sampler.sample(2*nNeurons, 2, rng=rng)\n",
    "    intercepts_LA_pyr = nengo.dists.Uniform(intercept_LA_pyr, intercept_LA_pyr)\n",
    "    encoders_CS = sampler.sample(nNeuronsExtCS, dim_CS, rng=rng)\n",
    "    encoders_CTX = sampler.sample(nNeuronsExtCTX, dim_CTX, rng=rng)\n",
    "    intercepts_CS = nengo.dists.Uniform(intercept_CS, intercept_CS)\n",
    "    intercepts_CTX = nengo.dists.Uniform(intercept_CTX, intercept_CTX)\n",
    "    intercepts_pos = nengo.dists.Uniform(0,1)\n",
    "    encoders_pos = nengo.dists.Choice([[1]])\n",
    "    dInh = -3e0*np.ones((nNeurons, 1))\n",
    "\n",
    "    net = nengo.Network(seed=seed)\n",
    "    net.config[nengo.Connection].synapse = 0.03\n",
    "    net.config[nengo.Probe].synapse = 0.03\n",
    "\n",
    "    with net:\n",
    "        # inputs and outputs\n",
    "        CS = nengo.Node(lambda t, x: inputs.get_CS(t), size_in=2)\n",
    "        US = nengo.Node(lambda t, x: inputs.get_US(t), size_in=2)\n",
    "        CTX = nengo.Node(lambda t, x: inputs.get_CTX(t), size_in=2, size_out=dim_CTX)\n",
    "        bias = nengo.Node(lambda t: 0.5)\n",
    "        stop_learning = nengo.Node(lambda t, x: inputs.get_stop_learning(t), size_in=2)\n",
    "        applied_current = nengo.Node(lambda t, x: inputs.get_applied_current(t), size_in=2)\n",
    "        # external ensembles\n",
    "        external_CS = nengo.Ensemble(nNeuronsExtCS, dim_CS, intercepts=intercepts_CS, encoders=encoders_CS)\n",
    "        external_US = nengo.Ensemble(nNeurons, 1)\n",
    "        external_CTX = nengo.Ensemble(nNeuronsExtCTX, dim_CTX, intercepts=intercepts_CTX, encoders=encoders_CTX)\n",
    "        # amygdala ensembles\n",
    "        LA_pyr = nengo.Ensemble(2*nNeurons, 2, radius=2, encoders=encoders_LA_pyr, intercepts=intercepts_LA_pyr)  # [CS, US]\n",
    "        LA_inh = nengo.Ensemble(2*nNeurons, 2, radius=2)  # [CS, US]\n",
    "        CeL_on = nengo.Ensemble(nNeurons, 1, intercepts=intercepts_pos, encoders=encoders_pos)  # [CS]\n",
    "        CeL_off = nengo.Ensemble(nNeurons, 1, intercepts=intercepts_pos, encoders=encoders_pos)  # [bias-CS]\n",
    "        CeM = nengo.Ensemble(nNeurons, 1, intercepts=intercepts_pos, encoders=encoders_pos)\n",
    "        BLA_pyr = nengo.Ensemble(3*nNeurons, 3, radius=3)  # [CS, US, CTX]\n",
    "        BLA_inh = nengo.Ensemble(2*nNeurons, 2, radius=2)  # [CS, US]\n",
    "        # error ensembles\n",
    "        error_LA = nengo.Ensemble(nNeurons, 1)\n",
    "        error_CeL = nengo.Ensemble(nNeurons, 1)\n",
    "        error_BLA_safe = nengo.Ensemble(nNeurons, 1)\n",
    "        error_BLA_fear = nengo.Ensemble(nNeurons, 1)\n",
    "        # external connections\n",
    "        nengo.Connection(CS, external_CS, synapse=None)\n",
    "        nengo.Connection(US, external_US, synapse=None)\n",
    "        nengo.Connection(external_CS, LA_inh[0], function=lambda x: np.sum(np.square(x)))  # any CS present\n",
    "        nengo.Connection(external_US, LA_pyr[1])\n",
    "        nengo.Connection(bias, CeL_off, transform=1)\n",
    "        nengo.Connection(bias, CeM)\n",
    "        nengo.Connection(CTX, external_CTX, synapse=None)\n",
    "        # internal connections\n",
    "        nengo.Connection(LA_pyr[1], LA_inh[1])\n",
    "        nengo.Connection(CeL_on, CeL_off, transform=-1)\n",
    "        nengo.Connection(CeL_off, CeM, transform=-1)\n",
    "        nengo.Connection(LA_pyr, BLA_pyr[:2])  # communicate [CS, US]\n",
    "        nengo.Connection(BLA_pyr[:2], BLA_inh)  # communicate [CS,US]\n",
    "        nengo.Connection(BLA_pyr[0], CeM, transform=T_BLA_CS)  # CS response added to total fear response\n",
    "        nengo.Connection(BLA_pyr[1], CeM, transform=T_BLA_US)  # US response added to total fear response\n",
    "        nengo.Connection(BLA_pyr[2], CeM, transform=T_BLA_CTX)  # CTX response added to total fear response\n",
    "        # learned connections\n",
    "        conditioning = nengo.Connection(external_CS, LA_pyr[0], function=lambda x: 0, learning_rule_type=nengo.PES(lr1))\n",
    "        transmission = nengo.Connection(LA_pyr[0], CeL_on, function=lambda x: 0, learning_rule_type=nengo.PES(lr2))\n",
    "        extinction = nengo.Connection(external_CTX, BLA_pyr[2], function=lambda x: 0, learning_rule_type=nengo.PES(lr3))\n",
    "        # error connections\n",
    "        nengo.Connection(LA_pyr[0], error_LA, transform=-1)  # -CS response\n",
    "        nengo.Connection(LA_inh[1], error_LA, transform=+1)  # US\n",
    "        nengo.Connection(LA_pyr[0], error_CeL, transform=+1)  # LA_pyr CS response\n",
    "        nengo.Connection(CeL_on, error_CeL, transform=-1)  # -CeL_on CS response\n",
    "        nengo.Connection(BLA_pyr[2], error_BLA_safe)  # CTX response\n",
    "        nengo.Connection(BLA_pyr[2], error_BLA_fear, transform=-1)  # -CTX response\n",
    "        nengo.Connection(BLA_inh[0], error_BLA_safe)  # CS response\n",
    "        nengo.Connection(BLA_inh[1], error_BLA_fear)  # US\n",
    "        # error gating\n",
    "        nengo.Connection(LA_inh, error_LA.neurons, function=lambda x: x[0]-x[1], transform=dInh)  # inhibit if only CS present\n",
    "        nengo.Connection(BLA_inh, error_BLA_safe.neurons, function=lambda x: 1-x[0], transform=dInh)  # inhibit by default; release if CS\n",
    "        nengo.Connection(BLA_inh, error_BLA_safe.neurons, function=lambda x: x[1], transform=10*dInh, synapse=0.3)  # inhibit by default; release if CS\n",
    "        nengo.Connection(BLA_inh, error_BLA_fear.neurons, function=lambda x: 1-x[1], transform=0.5*dInh)  # slow learning unless US\n",
    "        # error updating\n",
    "        nengo.Connection(error_LA, conditioning.learning_rule, transform=-1)\n",
    "        nengo.Connection(error_CeL, transmission.learning_rule, transform=-1)\n",
    "        nengo.Connection(error_BLA_safe, extinction.learning_rule, transform=1)\n",
    "        nengo.Connection(error_BLA_fear, extinction.learning_rule, transform=-2)\n",
    "        # stop learning during testing\n",
    "        nengo.Connection(stop_learning, error_LA.neurons, transform=-1e3*np.ones((nNeurons, 1)))\n",
    "        nengo.Connection(stop_learning, error_BLA_safe.neurons, transform=-1e3*np.ones((nNeurons, 1)))\n",
    "        nengo.Connection(stop_learning, error_CeL.neurons, transform=-1e3*np.ones((nNeurons, 1)))\n",
    "        nengo.Connection(stop_learning, error_BLA_fear.neurons, transform=-1e3*np.ones((nNeurons, 1)))\n",
    "\n",
    "        # probes\n",
    "        net.pCS = nengo.Probe(CS, synapse=None)\n",
    "        net.pUS = nengo.Probe(US, synapse=None)\n",
    "        net.pCTX = nengo.Probe(CTX, synapse=None)\n",
    "        net.pLA_pyr_spikes = nengo.Probe(LA_pyr.neurons)\n",
    "        net.pLA_inh_spikes = nengo.Probe(LA_inh.neurons)\n",
    "        net.pCeL_on_spikes = nengo.Probe(CeL_on.neurons)\n",
    "        net.pCeL_off_spikes = nengo.Probe(CeL_off.neurons)\n",
    "        net.pCeM_spikes = nengo.Probe(CeM.neurons)\n",
    "        net.pBLA_pyr_spikes = nengo.Probe(BLA_pyr.neurons)\n",
    "        net.pBLA_inh_spikes = nengo.Probe(BLA_inh.neurons)\n",
    "        net.pBLA_pyr = nengo.Probe(BLA_pyr)\n",
    "        net.pBLA_inh = nengo.Probe(BLA_inh)\n",
    "        net.pLA_pyr = nengo.Probe(LA_pyr)\n",
    "        net.pLA_inh = nengo.Probe(LA_inh)\n",
    "        net.pCeL_on = nengo.Probe(CeL_on)\n",
    "        net.pCeL_off = nengo.Probe(CeL_off)\n",
    "        net.pCeM = nengo.Probe(CeM)\n",
    "        net.pError_LA = nengo.Probe(error_LA)\n",
    "        net.pError_CeL = nengo.Probe(error_CeL)\n",
    "        net.pBLA_pyr = nengo.Probe(BLA_pyr)\n",
    "        net.pBLA_inh = nengo.Probe(BLA_inh)\n",
    "        net.pError_BLA_safe = nengo.Probe(error_BLA_safe)\n",
    "        net.pError_BLA_fear = nengo.Probe(error_BLA_fear)\n",
    "        \n",
    "        # save pointers\n",
    "        net.inputs = inputs\n",
    "        net.applied_current = applied_current\n",
    "        net.LA_pyr = LA_pyr\n",
    "        net.LA_inh = LA_inh\n",
    "        net.CeL_on = CeL_on\n",
    "        net.CeL_off = CeL_off\n",
    "        net.CeM = CeM\n",
    "        net.BLA_pyr = BLA_pyr\n",
    "        net.BLA_inh = BLA_inh\n",
    "        net.error_LA = error_LA\n",
    "        net.error_CeL = error_CeL\n",
    "        net.error_BLA_safe = error_BLA_safe\n",
    "        net.error_BLA_fear = error_BLA_fear\n",
    "        \n",
    "    return net"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99ef9ac1-3b17-4841-9f4f-a95f6164d77c",
   "metadata": {},
   "source": [
    "## Dynamic Representations in Each Population"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "7c505d0b-a8ca-40ac-96cc-7bddd2fca04c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def basic_dynamics(\n",
    "        nNeurons=100,\n",
    "        dt=1e-3,\n",
    "        nCond=5,\n",
    "        nExt=10,\n",
    "        nTest=10,\n",
    "        dim_CS=3,\n",
    "        dim_CTX=5,\n",
    "        nCS=1,\n",
    "        nCTX=3,\n",
    "        load=False,\n",
    "    ):\n",
    "\n",
    "    net = build_network(dt=dt, nNeurons=nNeurons, nCond=nCond, nExt=nExt, dim_CS=dim_CS, dim_CTX=dim_CTX, nCTX=nCTX, nCS=nCS)\n",
    "    sim = nengo.Simulator(net, dt=dt, progress_bar=False)\n",
    "    with sim:\n",
    "        net.inputs.stop_learning = 0\n",
    "        # print(\"control\")\n",
    "        net.inputs.CS = net.inputs.CSs[0]\n",
    "        net.inputs.CTX = net.inputs.CTXs[0]\n",
    "        sim.run(2)\n",
    "        # print(\"acquisition\")\n",
    "        net.inputs.CTX = net.inputs.CTXs[0]\n",
    "        net.inputs.US = 1\n",
    "        for p in range(nCond):\n",
    "            sim.run(2)\n",
    "        # print(\"extinction\")\n",
    "        net.inputs.CTX = net.inputs.CTXs[1]\n",
    "        net.inputs.US = 0\n",
    "        for p in range(nExt):\n",
    "            sim.run(2)\n",
    "\n",
    "\n",
    "    ctxA_idx = np.where(sim.data[net.pCTX]==net.inputs.CTXs[0])[0]\n",
    "    ctxB_idx = np.where(sim.data[net.pCTX]==net.inputs.CTXs[1])[0]\n",
    "    ctx_signal = np.zeros((sim.trange().shape[0]))\n",
    "    ctx_signal[ctxB_idx] = 1\n",
    "    \n",
    "    fig, axes = plt.subplots(nrows=6, ncols=1, sharex=True, figsize=((6.38,6)), gridspec_kw={'height_ratios': [1,1,1,1,1,1]})\n",
    "    axes[0].plot(sim.trange(), np.linalg.norm(sim.data[net.pCS], ord=2, axis=1), label=\"CS\")\n",
    "    axes[0].plot(sim.trange(), 1.1*sim.data[net.pUS], label=\"US\", c='r')\n",
    "    axes[0].plot(sim.trange(), 0.9*np.dot(sim.data[net.pCTX], net.inputs.CTXs[0]), label='CTX')\n",
    "    # axes[0].legend(loc='upper right', ncol=3)\n",
    "    axes[0].legend(loc='center left', bbox_to_anchor=(1, 0.5))\n",
    "    axes[0].set(yticks=[], ylabel=\"Stimuli\")\n",
    "    axes[1].plot(sim.trange(), sim.data[net.pLA_pyr][:,0], label=\"CS\")\n",
    "    axes[1].plot(sim.trange(), sim.data[net.pLA_pyr][:,1], label=\"US\")\n",
    "    axes[1].legend(loc='center left', bbox_to_anchor=(1, 0.5))\n",
    "    axes[1].set(yticks=[], ylabel=\"LA\")\n",
    "    axes[2].plot(sim.trange(), sim.data[net.pCeL_on], label=\"On\")\n",
    "    axes[2].plot(sim.trange(), sim.data[net.pCeL_off], label=\"Off\")\n",
    "    axes[2].legend(loc='center left', bbox_to_anchor=(1, 0.5))\n",
    "    axes[2].set(yticks=[], ylabel=\"CeL\")\n",
    "    axes[3].plot(sim.trange(), sim.data[net.pBLA_pyr][:,0], label=\"CS\")\n",
    "    axes[3].plot(sim.trange(), sim.data[net.pBLA_pyr][:,1], label=\"US\")\n",
    "    axes[3].plot(sim.trange(), sim.data[net.pBLA_pyr][:,2], label=\"CTX\")\n",
    "    axes[3].legend(loc='center left', bbox_to_anchor=(1, 0.5))\n",
    "    axes[3].set(yticks=[], ylabel=\"BLA\")\n",
    "    axes[4].plot(sim.trange(), sim.data[net.pError_LA], label=\"LA\")\n",
    "    axes[4].plot(sim.trange(), sim.data[net.pError_LA], label=\"CeL\")\n",
    "    axes[4].plot(sim.trange(), sim.data[net.pError_BLA_safe], label=\"BLA safe\")\n",
    "    axes[4].plot(sim.trange(), sim.data[net.pError_BLA_fear], label=\"BLA fear\")\n",
    "    axes[4].legend(loc='center left', bbox_to_anchor=(1, 0.5))\n",
    "    axes[4].set(ylabel=\"Error\", yticks=[])\n",
    "    axes[5].plot(sim.trange(), sim.data[net.pCeM], label='CeM')\n",
    "    axes[5].set(yticks=[], ylim=((-0.1, 1.2)), ylabel=\"Output\", xlabel=\"Time (s)\", xlim=((0, 32)), xticks=np.arange(0, 34, 2))\n",
    "    axes[5].legend(loc='center left', bbox_to_anchor=(1, 0.5))\n",
    "    plt.tight_layout()\n",
    "    fig.savefig(\"plots/basic_dynamics.svg\")\n",
    "    fig.savefig(\"plots/basic_dynamics.png\", dpi=600)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "c6989cdc-a76b-4fde-a27f-231367a693ba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 638x600 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "basic_dynamics()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03dfea1a-4511-424a-906e-b9ada80150c3",
   "metadata": {},
   "source": [
    "## Acquisition, Extinction, and Testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "17a85f91-af7f-4599-96fd-9c3b74a359d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def aquisition_extinction_testing(\n",
    "        seeds=1,\n",
    "        nNeurons=100,\n",
    "        dt=1e-3,\n",
    "        nCond=5,\n",
    "        nExt=10,\n",
    "        nTest=10,\n",
    "        dim_CS=3,\n",
    "        dim_CTX=5,\n",
    "        nCS=1,\n",
    "        nCTX=3,\n",
    "        load=False,\n",
    "    ):\n",
    "\n",
    "    if load:\n",
    "        data_fear = pd.read_pickle(f\"data/dynamics_dimCS={dim_CS}_dimCTX={dim_CTX}.pkl\")\n",
    "    else:\n",
    "        columns = [\"seed\", \"Context\", \"Phase\", \"cue\", \"Defensive Response\"]\n",
    "        rng = np.random.RandomState(seeds)\n",
    "        dfs = []\n",
    "        for s in range(seeds):\n",
    "            print(f\"seed={s}\")\n",
    "            seed = s\n",
    "            lr1 = rng.uniform(2e-5, 4e-5)\n",
    "            lr2 = rng.uniform(2e-4, 6e-4)\n",
    "            lr3 = rng.uniform(8e-6, 2e-5)\n",
    "            T_BLA_CS = rng.uniform(0.2, 0.4)\n",
    "            T_BLA_CTX = rng.uniform(0.5, 1.0)\n",
    "            net = build_network(seed=s, lr1=lr1, lr2=lr2, lr3=lr3, T_BLA_CS=T_BLA_CS, T_BLA_CTX=T_BLA_CTX,\n",
    "                dt=dt, nNeurons=nNeurons, nCond=nCond, nExt=nExt, dim_CS=dim_CS, dim_CTX=dim_CTX, nCTX=nCTX, nCS=nCS)\n",
    "            for c, ctx in enumerate(net.inputs.CTXs[:2]):\n",
    "                ctx_label = [\"CTX+\", \"CTX-\"][c]\n",
    "                # print(ctx_label)\n",
    "                sim = nengo.Simulator(net, dt=dt, progress_bar=False)\n",
    "                cue = 0\n",
    "                with sim:\n",
    "                    net.inputs.stop_learning = 0\n",
    "                    # print(\"control\")\n",
    "                    net.inputs.CS = net.inputs.CSs[0]\n",
    "                    net.inputs.CTX = net.inputs.CTXs[0]\n",
    "                    sim.run(2)\n",
    "                    Tstart = int(1/dt)\n",
    "                    Tend = int(2/dt)\n",
    "                    fear = np.mean(sim.data[net.pCeM][Tstart: Tend])\n",
    "                    dfs.append(pd.DataFrame([[seed, ctx_label, 'Baseline', cue, fear]], columns=columns))\n",
    "                    cue += 1\n",
    "                    # print(\"acquisition\")\n",
    "                    net.inputs.CTX = net.inputs.CTXs[0]\n",
    "                    net.inputs.US = 1\n",
    "                    for p in range(nCond):\n",
    "                        sim.run(2)\n",
    "                        Tstart = int((2+2*cue-1)/dt)\n",
    "                        Tend = int((2+2*cue-0.5)/dt)\n",
    "                        fear = np.mean(sim.data[net.pCeM][Tstart: Tend])\n",
    "                        dfs.append(pd.DataFrame([[seed, ctx_label, 'Acquisition', cue, fear]], columns=columns))\n",
    "                        cue += 1\n",
    "                    # print(\"extinction\")\n",
    "                    net.inputs.CTX = ctx\n",
    "                    net.inputs.US = 0\n",
    "                    for p in range(nExt):\n",
    "                        sim.run(2)\n",
    "                        Tstart = int((2+2*cue-1)/dt)\n",
    "                        Tend = int((2+2*cue-0.5)/dt)\n",
    "                        fear = np.mean(sim.data[net.pCeM][Tstart: Tend])\n",
    "                        dfs.append(pd.DataFrame([[seed, ctx_label, 'Extinction', cue, fear]], columns=columns))\n",
    "                        cue += 1\n",
    "                    # for this experiment, keep learning ON for testing\n",
    "                    # net.inputs.stop_learning = 1\n",
    "                    # print(\"testing\")\n",
    "                    net.inputs.CTX = ctx\n",
    "                    net.inputs.US = 0\n",
    "                    for p in range(nTest):\n",
    "                        sim.run(2)\n",
    "                        Tstart = int((2+2*cue-1)/dt)\n",
    "                        Tend = int((2+2*cue-0.5)/dt)\n",
    "                        fear = np.mean(sim.data[net.pCeM][Tstart: Tend])\n",
    "                        dfs.append(pd.DataFrame([[seed, ctx_label, 'Testing', cue, fear]], columns=columns))\n",
    "                        cue += 1\n",
    "        data_fear = pd.concat(dfs, ignore_index=True)\n",
    "        data_fear.to_pickle(f\"data/dynamics_dimCS={dim_CS}_dimCTX={dim_CTX}.pkl\")\n",
    "\n",
    "    fig, ax = plt.subplots(nrows=1, ncols=1, figsize=((6.38, 2)))\n",
    "    sns.lineplot(data=data_fear, x='cue', y='Defensive Response', hue='Context', palette=palette[:2], marker=\"o\", ax=ax)\n",
    "    ax.axvline(1)\n",
    "    ax.axvline(nCond)\n",
    "    ax.axvline(nCond+nExt)\n",
    "    # ax.set(xlabel=None, xticks=range(1+nCond+nExt+nTest), yticks=((0, 0.25, 0.5, 0.75, 1.0)))\n",
    "    ax.set(xlabel=None, xticks=[0,nCond,nCond+nExt,nCond+nExt+nTest],\n",
    "           xticklabels=[\"Control\", \"Acquisition\", \"Extinction\", \"Testing\"], yticks=((0, 0.25, 0.5, 0.75, 1.0)))\n",
    "    plt.tight_layout()\n",
    "    fig.savefig(f\"plots/dynamics_dimCS={dim_CS}_dimCTX={dim_CTX}.svg\")\n",
    "    fig.savefig(f\"plots/dynamics_dimCS={dim_CS}_dimCTX={dim_CTX}.png\", dpi=600)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f8638fa9-9d05-4545-8520-8c352c764dad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "seed=0\n",
      "seed=1\n",
      "seed=2\n",
      "seed=3\n",
      "seed=4\n",
      "seed=5\n",
      "seed=6\n",
      "seed=7\n",
      "seed=8\n",
      "seed=9\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 638x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "aquisition_extinction_testing(seeds=10, nCond=5, nExt=10, nTest=5, load=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ccd9cd39-160b-4c78-bad8-d0bb8e1815fe",
   "metadata": {},
   "source": [
    "## Transformation of CS Representations During Acquisition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "d4cb615b-5ac3-453e-90f1-8c22c076ac61",
   "metadata": {},
   "outputs": [],
   "source": [
    "def changing_CS_representation(\n",
    "        seeds=1,\n",
    "        nNeurons=100,\n",
    "        dt=1e-3,\n",
    "        nCond=5,\n",
    "        nExt=10,\n",
    "        nTest=10,\n",
    "        dim_CS=3,\n",
    "        dim_CTX=5,\n",
    "        nCS=1,\n",
    "        nCTX=3,\n",
    "        load=False,\n",
    "    ):\n",
    "\n",
    "    if load:\n",
    "        data_activity = pd.read_pickle(f\"data/CSrepresentation_dimCS={dim_CS}_dimCTX={dim_CTX}.pkl\")\n",
    "    else:\n",
    "        rng = np.random.RandomState(seeds)\n",
    "        filter = nengo.Lowpass(0.1)\n",
    "        dfs = []\n",
    "        for s in range(seeds):\n",
    "            print(f\"seed={s}\")\n",
    "            seed = s\n",
    "            lr1 = rng.uniform(2e-5, 4e-5)\n",
    "            lr2 = rng.uniform(2e-4, 6e-4)\n",
    "            lr3 = rng.uniform(8e-6, 2e-5)\n",
    "            T_BLA_CS = rng.uniform(0.2, 0.4)\n",
    "            T_BLA_CTX = rng.uniform(0.5, 1.0)\n",
    "            net = build_network(seed=s, lr1=lr1, lr2=lr2, lr3=lr3, T_BLA_CS=T_BLA_CS, T_BLA_CTX=T_BLA_CTX,\n",
    "                dt=dt, nNeurons=nNeurons, nCond=nCond, nExt=nExt, dim_CS=dim_CS, dim_CTX=dim_CTX, nCTX=nCTX, nCS=nCS)\n",
    "            sim = nengo.Simulator(net, dt=dt, progress_bar=False)\n",
    "            with sim:\n",
    "                net.inputs.stop_learning = 0\n",
    "                net.inputs.CS = net.inputs.CSs[0]\n",
    "                net.inputs.CTX = net.inputs.CTXs[0]\n",
    "                net.inputs.US = 1\n",
    "                for p in range(nCond):\n",
    "                    sim.run(2)\n",
    "            for neuron in range(2*nNeurons):\n",
    "                US_encoder = sim.data[net.LA_pyr].encoders[neuron,1]\n",
    "                if US_encoder > 0.9: alignment = 'aligned'\n",
    "                elif US_encoder < -0.9: alignment = 'antialigned'\n",
    "                elif -0.2 < US_encoder < 0.2: alignment = 'nonaligned'\n",
    "                else: aligment = \"meh\"\n",
    "                df = pd.DataFrame()\n",
    "                df['time'] = sim.trange()\n",
    "                df['alignment'] = [alignment for _ in range(len(sim.trange()))]\n",
    "                df['neuron'] = neuron*np.ones_like(sim.trange())\n",
    "                # df['firing rate'] = sim.data[net.pLA_pyr_spikes][:,neuron].ravel()\n",
    "                df['firing rate'] = filter.filt(sim.data[net.pLA_pyr_spikes][:,neuron].ravel())\n",
    "                dfs.append(df)\n",
    "        data_activity = pd.concat(dfs, ignore_index=True)\n",
    "        data_activity.to_pickle(f\"data/CSrepresentation_dimCS={dim_CS}_dimCTX={dim_CTX}.pkl\")\n",
    "\n",
    "    aligned_neuron_idx = data_activity.query(\"alignment=='aligned'\")['neuron'].unique()\n",
    "    nonaligned_neuron_idx = data_activity.query(\"alignment=='nonaligned'\")['neuron'].unique()\n",
    "    antialigned_neuron_idx = data_activity.query(\"alignment=='antialigned'\")['neuron'].unique()\n",
    "\n",
    "\n",
    "    Tus1 = 1.5\n",
    "    Tus2 = 2\n",
    "    Tearly1 = 1\n",
    "    Tearly2 = 1.5\n",
    "    Tmiddle1 = 2*int(nCond/2)+1\n",
    "    Tmiddle2 = 2*int(nCond/2)+1.5\n",
    "    Tlate1 = 2*(nCond-1)+1\n",
    "    Tlate2 = 2*(nCond-1)+1.5\n",
    "    us = data_activity.query(\"time>@Tus1 and time<@Tus2\")\n",
    "    early = data_activity.query(\"time>@Tearly1 and time<@Tearly2\")\n",
    "    middle = data_activity.query(\"time>@Tmiddle1 and time<@Tmiddle2\")\n",
    "    late = data_activity.query(\"time>@Tlate1 and time<@Tlate2\")\n",
    "    fig, axes = plt.subplots(nrows=1, ncols=2, sharex=True, sharey=True, figsize=((6.38, 2)))\n",
    "    sns.barplot(data=early, x='neuron', y='firing rate', ax=axes[0], color=palette[0], label='CS Response', errorbar=None, alpha=0.5)\n",
    "    # sns.barplot(data=middle, x='neuron', y='firing rate', ax=axes[1], color=palette[0], label='CS Response', errorbar=None, alpha=0.5)\n",
    "    sns.barplot(data=late, x='neuron', y='firing rate', ax=axes[1], color=palette[0], label='CS Response', errorbar=None, alpha=0.5)\n",
    "    sns.barplot(data=us, x='neuron', y='firing rate', ax=axes[0], color=palette[1], label='US Response', errorbar=None, alpha=0.5)\n",
    "    # sns.barplot(data=us, x='neuron', y='firing rate', ax=axes[1], color=palette[1], label='US Response', errorbar=None, alpha=0.5)\n",
    "    sns.barplot(data=us, x='neuron', y='firing rate', ax=axes[1], color=palette[1], label='US Response', errorbar=None, alpha=0.5)\n",
    "    axes[0].legend()\n",
    "    axes[1].get_legend().remove()\n",
    "    # axes[2].get_legend().remove()\n",
    "    axes[0].set(xlabel=\"Neuron\", ylabel=\"Firing Rate (Hz)\", title=\"Before Acquisition\")\n",
    "    # axes[1].set(ylabel=\"Firing Rate (Hz)\", title=\"During Acquisition\")\n",
    "    axes[1].set(xlabel=\"Neuron\", ylabel=\"Firing Rate (Hz)\", title=\"After Acquisition\", xticks=[])\n",
    "    plt.tight_layout()\n",
    "    fig.savefig(f\"plots/CSrepresentation_dimCS={dim_CS}_dimCTX={dim_CTX}.svg\")\n",
    "    fig.savefig(f\"plots/CSrepresentation_dimCS={dim_CS}_dimCTX={dim_CTX}.png\", dpi=600)\n",
    "\n",
    "    # print(data_activity)\n",
    "    N1 = aligned_neuron_idx[0]\n",
    "    N2 = nonaligned_neuron_idx[0]\n",
    "    N3 = antialigned_neuron_idx[0]\n",
    "    aligned = data_activity.query(\"neuron==@N1\")  # in @aligned_neuron_idx\")\n",
    "    nonaligned = data_activity.query(\"neuron==@N2\")  # in @nonaligned_neuron_idx\")\n",
    "    antialigned = data_activity.query(\"neuron==@N3\")  # in @antialigned_neuron_idx\")\n",
    "    fig, axes = plt.subplots(nrows=1, ncols=3, sharex=True, sharey=True, figsize=((6.38, 2)))\n",
    "    sns.lineplot(data=aligned, x='time', y='firing rate', ax=axes[0], color=palette[0])\n",
    "    sns.lineplot(data=antialigned, x='time', y='firing rate', ax=axes[1], color=palette[0])\n",
    "    sns.lineplot(data=nonaligned, x='time', y='firing rate', ax=axes[2], color=palette[0])\n",
    "    for p in range(nCond):\n",
    "        axes[0].axvspan(2*p+1, 2*p+1.5, alpha=0.5, color=palette[2])\n",
    "        axes[0].axvspan(2*p+1.5, 2*p+2, alpha=0.5, color=palette[3])\n",
    "        axes[1].axvspan(2*p+1, 2*p+1.5, alpha=0.5, color=palette[2])\n",
    "        axes[1].axvspan(2*p+1.5, 2*p+2, alpha=0.5, color=palette[3])\n",
    "        axes[2].axvspan(2*p+1, 2*p+1.5, alpha=0.5, color=palette[2])\n",
    "        axes[2].axvspan(2*p+1.5, 2*p+2, alpha=0.5, color=palette[3])\n",
    "    axes[0].set(xlabel=\"Time (s)\", ylabel=\"Firing Rate (Hz)\", title=\"Potentiating\", yticks=[0, 100, 200], xticks=np.arange(0, 1+nCond*2, 1))\n",
    "    axes[1].set(xlabel=\"Time (s)\", ylabel=\"Firing Rate (Hz)\", title=\"Depressing\", xticks=np.arange(0, 1+nCond*2, 1))\n",
    "    axes[2].set(xlabel=\"Time (s)\", ylabel=\"Firing Rate (Hz)\", title=\"Other\", xticks=np.arange(0, 1+nCond*2, 1))\n",
    "    plt.tight_layout()\n",
    "    fig.savefig(f\"plots/aligned_dimCS={dim_CS}_dimCTX={dim_CTX}.svg\")\n",
    "    fig.savefig(f\"plots/aligned_dimCS={dim_CS}_dimCTX={dim_CTX}.png\", dpi=600)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "6a1cdde8-51fe-45aa-b779-b610800fd42e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 638x200 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 638x200 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "changing_CS_representation(seeds=1, nCond=5, nNeurons=50, load=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b6286a5",
   "metadata": {},
   "source": [
    "## Fear Expression and Neural Responses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "ca339d37",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fear_expression_neural_responses(\n",
    "        seeds=1,\n",
    "        nNeurons=100,\n",
    "        dt=1e-3,\n",
    "        nCond=5,\n",
    "        nExt=10,\n",
    "        dim_CS=3,\n",
    "        dim_CTX=5,\n",
    "        nCS=1,\n",
    "        nCTX=3,\n",
    "        load=False,\n",
    "        plot=False,\n",
    "    ):\n",
    "\n",
    "    if load:\n",
    "        data_fear = pd.read_pickle(f\"data/expression_dimCS={dim_CS}_dimCTX={dim_CTX}.pkl\")\n",
    "        data_activity = pd.read_pickle(f\"data/activity_dimCS={dim_CS}_dimCTX={dim_CTX}.pkl\")\n",
    "        data_types = pd.read_pickle(f\"data/types_dimCS={dim_CS}_dimCTX={dim_CTX}.pkl\")\n",
    "    else:\n",
    "        dfs_fear = []\n",
    "        dfs_activity = []\n",
    "        dfs_types = []\n",
    "        columns_fear = [\"seed\", \"Fear Response\", \"Experiment\"]\n",
    "        columns_activity = [\"seed\", \"Type\", \"Activity\", \"Experiment\"]\n",
    "        columns_types = [\"seed\", \"Type\", \"Percent\"]\n",
    "        rng = np.random.RandomState(seeds)\n",
    "\n",
    "        for s in range(seeds):\n",
    "            print(f\"seed={s}\")\n",
    "            seed = s\n",
    "            lr1 = rng.uniform(2e-5, 4e-5)\n",
    "            lr2 = rng.uniform(2e-4, 6e-4)\n",
    "            lr3 = rng.uniform(8e-6, 2e-5)\n",
    "            T_BLA_CS = rng.uniform(0.2, 0.4)\n",
    "            T_BLA_CTX = rng.uniform(0.5, 1.0)\n",
    "            net = build_network(seed=s, lr1=lr1, lr2=lr2, lr3=lr3, T_BLA_CS=T_BLA_CS, T_BLA_CTX=T_BLA_CTX,\n",
    "                dt=dt, nNeurons=nNeurons, nCond=nCond, nExt=nExt, dim_CS=dim_CS, dim_CTX=dim_CTX, nCTX=nCTX, nCS=nCS)\n",
    "            sim = nengo.Simulator(net, dt=dt, progress_bar=False)\n",
    "            with sim:\n",
    "                net.inputs.stop_learning = 0\n",
    "                print(\"control\")\n",
    "                net.inputs.CS = net.inputs.CSs[0]\n",
    "                net.inputs.CTX = net.inputs.CTXs[0]\n",
    "                sim.run(2)\n",
    "                T1a = int(1/dt)\n",
    "                T1b = int(2/dt)\n",
    "                print(\"conditioning\")\n",
    "                net.inputs.CTX = net.inputs.CTXs[0]\n",
    "                net.inputs.US = 1\n",
    "                for p in range(nCond):\n",
    "                    sim.run(2)\n",
    "                T2a = int((2+2*nCond-1)/dt)\n",
    "                T2b = int((2+2*nCond-0.5)/dt)\n",
    "                print(\"extinction\")\n",
    "                net.inputs.CTX = net.inputs.CTXs[1]\n",
    "                net.inputs.US = 0\n",
    "                for p in range(nExt):\n",
    "                    sim.run(2)\n",
    "                T3a = int((2+2*nCond+2*nExt-1)/dt)\n",
    "                T3b = int((2+2*nCond+2*nExt-0.5)/dt)\n",
    "        #         print(\"turn learning off for testing\")\n",
    "                net.inputs.stop_learning = 1\n",
    "                print(\"test CTX A\")\n",
    "                net.inputs.CTX = net.inputs.CTXs[0]\n",
    "                net.inputs.US = 0\n",
    "                sim.run(2)\n",
    "                T4a = int((2+2*nCond+2*nExt+1)/dt)\n",
    "                T4b = int((2+2*nCond+2*nExt+1.5)/dt)\n",
    "                print(\"test CTX B\")\n",
    "                net.inputs.CTX = net.inputs.CTXs[1]\n",
    "                net.inputs.US = 0\n",
    "                sim.run(2)\n",
    "                T5a = int((2+2*nCond+2*nExt+2+1)/dt)\n",
    "                T5b = int((2+2*nCond+2*nExt+2+1.5)/dt)  \n",
    "                print(\"test CTX C\")\n",
    "                net.inputs.CTX = net.inputs.CTXs[2]\n",
    "                net.inputs.US = 0\n",
    "                sim.run(2)\n",
    "                T6a = int((2+2*nCond+2*nExt+2+2+1)/dt)\n",
    "                T6b = int((2+2*nCond+2*nExt+2+2+1.5)/dt)  \n",
    "\n",
    "            if plot:\n",
    "                ctxA_idx = np.where(sim.data[net.pCTX]==net.inputs.CTXs[0])[0]\n",
    "                ctxB_idx = np.where(sim.data[net.pCTX]==net.inputs.CTXs[1])[0]\n",
    "                ctxC_idx = np.where(sim.data[net.pCTX]==net.inputs.CTXs[2])[0]\n",
    "                ctx_signal = np.zeros((sim.trange().shape[0]))\n",
    "                ctx_signal2 = np.zeros((sim.trange().shape[0]))\n",
    "                ctx_signal[ctxB_idx] = 1\n",
    "                ctx_signal2[ctxC_idx] = 0.5\n",
    "                fig, axes = plt.subplots(nrows=4, ncols=1, sharex=True, figsize=((8,6)), gridspec_kw={'height_ratios': [2,2,4,4]})\n",
    "                axes[0].plot(sim.trange(), sim.data[net.pCeM])\n",
    "                axes[0].set(ylabel=r\"$\\hat{x}$\", title=\"Fear Response\", yticks=((0,1)))\n",
    "                axes[1].plot(sim.trange(), 1.4*np.linalg.norm(sim.data[net.pCS], ord=2, axis=1), label=\"CS present\")\n",
    "                axes[1].plot(sim.trange(), 1.8*sim.data[net.pUS], label=\"US\", c='r')\n",
    "                axes[1].plot(sim.trange(), ctx_signal)\n",
    "                axes[1].plot(sim.trange(), ctx_signal2)\n",
    "                axes[1].set(yticks=((0,0.5,1,1.4,1.8)), yticklabels=((\"CTX+\",\"CTXn\",\"CTX-\",\"CS\",\"US\")), ylabel=r\"$\\hat{x}$\", title=\"Stimuli\")\n",
    "                axes[2].plot(sim.trange(), sim.data[net.pBLA_pyr][:,0], label=\"BLA_pyr_CS\")\n",
    "                axes[2].plot(sim.trange(), sim.data[net.pBLA_pyr][:,1], label=\"BLA_pyr_US\")\n",
    "                axes[2].plot(sim.trange(), sim.data[net.pBLA_pyr][:,2], label=\"BLA_pyr_CTX\")\n",
    "                axes[2].legend()\n",
    "                axes[2].set(yticks=((-1, 1)), yticklabels=((-1,1)), ylabel=r\"$\\hat{x}$\", title=\"Training\")\n",
    "                axes[3].plot(sim.trange(), sim.data[net.pError_LA], label=\"CS minus US\")\n",
    "                axes[3].plot(sim.trange(), sim.data[net.pError_BLA_safe], label=\"CS minus CTX\")\n",
    "                axes[3].plot(sim.trange(), sim.data[net.pError_BLA_fear], label=\"US minus CTX\")\n",
    "                axes[3].legend()\n",
    "                axes[3].set(ylabel=r\"$\\hat{x}$\", title=\"Error\", yticks=((0,1)))\n",
    "                plt.tight_layout()\n",
    "\n",
    "            dfs_fear.append(pd.DataFrame([[seed, np.mean(sim.data[net.pCeM][T1a: T1b]), \"Control\"]], columns=columns_fear))\n",
    "            dfs_fear.append(pd.DataFrame([[seed, np.mean(sim.data[net.pCeM][T4a: T4b]), \"CTX+\"]], columns=columns_fear))\n",
    "            dfs_fear.append(pd.DataFrame([[seed, np.mean(sim.data[net.pCeM][T5a: T5b]), \"CTX-\"]], columns=columns_fear))\n",
    "            dfs_fear.append(pd.DataFrame([[seed, np.mean(sim.data[net.pCeM][T6a: T6b]), \"CTX*\"]], columns=columns_fear))\n",
    "\n",
    "            aControl_LA_pyr = sim.data[net.pLA_pyr_spikes][T1a: T1b]\n",
    "            aConditioning_LA_pyr = sim.data[net.pLA_pyr_spikes][T4a: T4b]\n",
    "            aExtinction_LA_pyr = sim.data[net.pLA_pyr_spikes][T5a: T5b]\n",
    "            aControl_CeL_on = sim.data[net.pCeL_on_spikes][T1a: T1b]\n",
    "            aConditioning_CeL_on = sim.data[net.pCeL_on_spikes][T4a: T4b]\n",
    "            aExtinction_CeL_on = sim.data[net.pCeL_on_spikes][T5a: T5b]\n",
    "            aControl_CeL_off = sim.data[net.pCeL_off_spikes][T1a: T1b]\n",
    "            aConditioning_CeL_off = sim.data[net.pCeL_off_spikes][T4a: T4b]\n",
    "            aExtinction_CeL_off = sim.data[net.pCeL_off_spikes][T5a: T5b]\n",
    "            aControl_BLA = sim.data[net.pBLA_pyr_spikes][T1a: T1b]\n",
    "            aConditioning_BLA = sim.data[net.pBLA_pyr_spikes][T4a: T4b]\n",
    "            aExtinction_BLA = sim.data[net.pBLA_pyr_spikes][T5a: T5b]\n",
    "\n",
    "            LA_pyr_up = np.where(np.mean(aConditioning_LA_pyr, axis=0) > 1.5*np.mean(aControl_LA_pyr, axis=0))[0]\n",
    "            LA_pyr_down = np.where(np.mean(aConditioning_LA_pyr, axis=0) < 0.5*np.mean(aControl_LA_pyr, axis=0))[0]\n",
    "            fear_neurons_p1 = np.where(np.mean(aConditioning_BLA, axis=0) > 1.5*np.mean(aControl_BLA, axis=0))[0]\n",
    "            fear_neurons_p2 = np.where(np.mean(aExtinction_BLA, axis=0) < 0.5*np.mean(aConditioning_BLA, axis=0))[0]\n",
    "            fear_neurons = np.intersect1d(fear_neurons_p1, fear_neurons_p2)\n",
    "            extinction_neurons = np.where(np.mean(aExtinction_BLA, axis=0) > 1.5*np.mean(aConditioning_BLA, axis=0))[0]\n",
    "            persistent_neurons = np.where(np.abs(np.mean(aConditioning_BLA-aExtinction_BLA,axis=0))<0.5*np.mean(aConditioning_BLA, axis=0))[0]\n",
    "            \n",
    "            dfs_activity.append(pd.DataFrame([[seed, \"LA Up\", np.mean(aControl_LA_pyr[:,LA_pyr_up]), \"Control\"]], columns=columns_activity))\n",
    "            dfs_activity.append(pd.DataFrame([[seed, \"LA Up\", np.mean(aConditioning_LA_pyr[:,LA_pyr_up]), \"CTX+\"]], columns=columns_activity))\n",
    "            dfs_activity.append(pd.DataFrame([[seed, \"LA Up\", np.mean(aExtinction_LA_pyr[:,LA_pyr_up]), \"CTX-\"]], columns=columns_activity))\n",
    "            dfs_activity.append(pd.DataFrame([[seed, \"LA Down\", np.mean(aControl_LA_pyr[:,LA_pyr_down]), \"Control\"]], columns=columns_activity))\n",
    "            dfs_activity.append(pd.DataFrame([[seed, \"LA Down\", np.mean(aConditioning_LA_pyr[:,LA_pyr_down]), \"CTX+\"]], columns=columns_activity))\n",
    "            dfs_activity.append(pd.DataFrame([[seed, \"LA Down\", np.mean(aExtinction_LA_pyr[:,LA_pyr_down]), \"CTX-\"]], columns=columns_activity))\n",
    "            dfs_activity.append(pd.DataFrame([[seed, \"BLA Fear\", np.mean(aControl_BLA[:,fear_neurons]), \"Control\"]], columns=columns_activity))\n",
    "            dfs_activity.append(pd.DataFrame([[seed, \"BLA Fear\", np.mean(aConditioning_BLA[:,fear_neurons]), \"CTX+\"]], columns=columns_activity))\n",
    "            dfs_activity.append(pd.DataFrame([[seed, \"BLA Fear\", np.mean(aExtinction_BLA[:,fear_neurons]), \"CTX-\"]], columns=columns_activity))\n",
    "            dfs_activity.append(pd.DataFrame([[seed, \"BLA Persist\", np.mean(aControl_BLA[:,persistent_neurons]), \"Control\"]], columns=columns_activity))\n",
    "            dfs_activity.append(pd.DataFrame([[seed, \"BLA Persist\", np.mean(aConditioning_BLA[:,persistent_neurons]), \"CTX+\"]], columns=columns_activity))\n",
    "            dfs_activity.append(pd.DataFrame([[seed, \"BLA Persist\", np.mean(aExtinction_BLA[:,persistent_neurons]), \"CTX-\"]], columns=columns_activity))\n",
    "            dfs_activity.append(pd.DataFrame([[seed, \"BLA Extinct\", np.mean(aControl_BLA[:,extinction_neurons]), \"Control\"]], columns=columns_activity))\n",
    "            dfs_activity.append(pd.DataFrame([[seed, \"BLA Extinct\", np.mean(aConditioning_BLA[:,extinction_neurons]), \"CTX+\"]], columns=columns_activity))\n",
    "            dfs_activity.append(pd.DataFrame([[seed, \"BLA Extinct\", np.mean(aExtinction_BLA[:,extinction_neurons]), \"CTX-\"]], columns=columns_activity))\n",
    "            dfs_activity.append(pd.DataFrame([[seed, \"CeL On\", np.mean(aControl_CeL_on), \"Control\"]], columns=columns_activity))\n",
    "            dfs_activity.append(pd.DataFrame([[seed, \"CeL On\", np.mean(aConditioning_CeL_on), \"CTX+\"]], columns=columns_activity))\n",
    "            dfs_activity.append(pd.DataFrame([[seed, \"CeL On\", np.mean(aExtinction_CeL_on), \"CTX-\"]], columns=columns_activity))\n",
    "            dfs_activity.append(pd.DataFrame([[seed, \"CeL Off\", np.mean(aControl_CeL_off), \"Control\"]], columns=columns_activity))\n",
    "            dfs_activity.append(pd.DataFrame([[seed, \"CeL Off\", np.mean(aConditioning_CeL_off), \"CTX+\"]], columns=columns_activity))\n",
    "            dfs_activity.append(pd.DataFrame([[seed, \"CeL Off\", np.mean(aExtinction_CeL_off), \"CTX-\"]], columns=columns_activity))\n",
    "\n",
    "            percent_up = len(LA_pyr_up)/(2*nNeurons)*100\n",
    "            percent_down = len(LA_pyr_down)/(2*nNeurons)*100\n",
    "            percent_fear = len(fear_neurons)/(4*nNeurons)*100\n",
    "            percent_extinction = len(extinction_neurons)/(4*nNeurons)*100\n",
    "            percent_persistent = len(persistent_neurons)/(4*nNeurons)*100\n",
    "\n",
    "            dfs_types.append(pd.DataFrame([[seed, \"LA Up\", percent_up]], columns=columns_types))\n",
    "            dfs_types.append(pd.DataFrame([[seed, \"LA Down\", percent_down]], columns=columns_types))\n",
    "            dfs_types.append(pd.DataFrame([[seed, \"BLA Fear\", percent_fear]], columns=columns_types))\n",
    "            dfs_types.append(pd.DataFrame([[seed, \"BLA Extinct\", percent_extinction]], columns=columns_types))\n",
    "            dfs_types.append(pd.DataFrame([[seed, \"BLA Persist\", percent_persistent]], columns=columns_types))\n",
    "\n",
    "        data_fear = pd.concat(dfs_fear, ignore_index=True)\n",
    "        data_activity = pd.concat(dfs_activity, ignore_index=True)\n",
    "        data_types = pd.concat(dfs_types, ignore_index=True)\n",
    "        data_fear.to_pickle(f\"data/expression_dimCS={dim_CS}_dimCTX={dim_CTX}.pkl\")\n",
    "        data_activity.to_pickle(f\"data/activity_dimCS={dim_CS}_dimCTX={dim_CTX}.pkl\")\n",
    "        data_types.to_pickle(f\"data/types_dimCS={dim_CS}_dimCTX={dim_CTX}.pkl\")\n",
    "\n",
    "    emps = []\n",
    "    emps.append(pd.DataFrame([[(0.5-0.4)/6, \"Control\"]], columns=[\"Fear Response\", \"Experiment\"]))\n",
    "    emps.append(pd.DataFrame([[(5.6-0.5)/6, \"Acquisition\"]], columns=[\"Fear Response\", \"Experiment\"]))\n",
    "    emps.append(pd.DataFrame([[(1.5-0.2)/6, \"Extinction\"]], columns=[\"Fear Response\", \"Experiment\"]))\n",
    "    emps.append(pd.DataFrame([[(5.6-3.2)/6, \"Reinstatement\"]], columns=[\"Fear Response\", \"Experiment\"]))\n",
    "    emp_fear = pd.concat(emps, ignore_index=True) \n",
    "\n",
    "    fig, axes = plt.subplots(nrows=1, ncols=2, figsize=((6.38, 2)), sharey=True)   \n",
    "    sns.barplot(data=emp_fear, x='Experiment', y=\"Fear Response\", palette=palette[:4], hue='Experiment', ax=axes[0])\n",
    "    sns.barplot(data=data_fear, x='Experiment', y=\"Fear Response\", palette=palette[:4], hue='Experiment', ax=axes[1])\n",
    "    axes[0].set(ylabel=\"Fear Response\", xlabel=None, xticks=[0,1,2,3], xticklabels=[\"Control\", \"Acquisition\", \"Extinction\", \"Reinstate\"], yticks=((0, 0.25, 0.5, 0.75, 1.0)), title=\"Empirical Data\")\n",
    "    axes[1].set(ylabel=\"Defensive Response\", xlabel=None, xticks=[0,1,2,3], xticklabels=[\"Control\", r\"CTX$^+$\", r\"CTX$^-$\", r\"CTX$^*$\"], yticks=((0, 0.25, 0.5, 0.75, 1.0)), title=\"Model Data\")\n",
    "    # axes[0].set(ylabel=\"Fear Response\", xlabel=None, xticks=[0,1,2,3], xticklabels=[\"Control\", \"Acquisition\", \"Extinction\", \"Renewal\"], yticks=[], title=\"Empirical Data\")\n",
    "    # axes[1].set(ylabel=\"Defensive Response\", xlabel=None, xticks=[0,1,2,3], xticklabels=[\"Control\", \"Acquisition\", \"Extinction\", \"Renewal\"], yticks=[], title=\"Model Data\")\n",
    "    plt.tight_layout()\n",
    "    fig.savefig(f\"plots/Figure3.svg\")\n",
    "    fig.savefig(f\"plots/Figure3.png\", dpi=600)\n",
    "    \n",
    "    fig, ax = plt.subplots(nrows=1, ncols=1, figsize=((6.38, 2)))\n",
    "    sns.barplot(data=data_activity, x='Type', y=\"Activity\", hue=\"Experiment\", palette=palette[:3], ax=ax)\n",
    "    ax.set(xlabel=None, ylabel=\"Mean Firing Rate (Hz)\", yticks=((0,100,200,300)))\n",
    "    plt.legend(loc='upper right')\n",
    "    plt.tight_layout()\n",
    "    fig.savefig(f\"plots/Figure6.svg\")\n",
    "    fig.savefig(f\"plots/Figure6.png\", dpi=600)\n",
    "    \n",
    "    fig, axes = plt.subplots(nrows=1, ncols=5, figsize=((6.38,2)), sharey=True)\n",
    "    sns.histplot(data=data_types.query(\"Type=='LA up'\")['Percent'], stat=\"percent\", bins=10, ax=axes[0])\n",
    "    sns.histplot(data=data_types.query(\"Type=='LA down'\")['Percent'], stat=\"percent\", bins=10, ax=axes[1])\n",
    "    sns.histplot(data=data_types.query(\"Type=='BLA Fear'\")['Percent'], stat=\"percent\", bins=10, ax=axes[2])\n",
    "    sns.histplot(data=data_types.query(\"Type=='BLA Persist'\")['Percent'], stat=\"percent\", bins=10, ax=axes[3])\n",
    "    sns.histplot(data=data_types.query(\"Type=='BLA Extinct'\")['Percent'], stat=\"percent\", bins=10, ax=axes[4])\n",
    "    axes[0].set(title=\"LA Up\", ylabel=\"Frequency\\nacross networks\", xticks=((20,27,34)))\n",
    "    axes[1].set(title=\"LA Down\", xticks=((33,36,39)))\n",
    "    axes[2].set(title=\"BLA Fear\", xticks=((4,6,8)))\n",
    "    axes[3].set(title=\"BLA Persist\", xticks=((25,30,35)))\n",
    "    axes[4].set(title=\"BLA Extinct\", xticks=((5,10,15)))\n",
    "    plt.tight_layout()\n",
    "    fig.savefig(f\"plots/ResponseTypes.svg\")\n",
    "    fig.savefig(f\"plots/ResponseTypes.png\", dpi=600)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "b25b9a0c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 638x200 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 638x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 638x200 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fear_expression_neural_responses(seeds=10, plot=False, load=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e360c2e5",
   "metadata": {},
   "source": [
    "## Perturbation Experiments (external activation or inactivation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "425238b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def perturbation_experiment(\n",
    "        seeds=1,\n",
    "        nNeurons=100,\n",
    "        dt=1e-3,\n",
    "        nCond=5,\n",
    "        nExt=10,\n",
    "        dim_CS=3,\n",
    "        dim_CTX=5,\n",
    "        nCS=1,\n",
    "        nCTX=3,\n",
    "        T_current=2,\n",
    "        perturbation=\"None\",  # inject positive or negative current\n",
    "        perturb_where=\"LApyr\",  # which population to inject the current into\n",
    "        perturb_during=[\"Acquisition\", \"Extinction\", \"Test in CTX+\", \"Test in CTX-\"]):  # during which phase of the protocol will the injection happen\n",
    " \n",
    "    dfs = []\n",
    "    rng = np.random.RandomState(seeds)\n",
    "\n",
    "    for seed in range(seeds):\n",
    "        lr1 = rng.uniform(2e-5, 4e-5)\n",
    "        lr2 = rng.uniform(2e-4, 6e-4)\n",
    "        lr3 = rng.uniform(8e-6, 2e-5)\n",
    "        T_BLA_CS = rng.uniform(0.2, 0.4)\n",
    "        T_BLA_CTX = rng.uniform(0.5, 1.0)\n",
    "        for when in perturb_during:\n",
    "            net = build_network(seed=seed, lr1=lr1, lr2=lr2, lr3=lr3, T_BLA_CS=T_BLA_CS, T_BLA_CTX=T_BLA_CTX,\n",
    "                dt=dt, nNeurons=nNeurons, nCond=nCond, nExt=nExt, dim_CS=dim_CS, dim_CTX=dim_CTX, nCTX=nCTX, nCS=nCS)\n",
    "            with net:\n",
    "                if perturb_where==\"LApyr\":\n",
    "                    nengo.Connection(net.applied_current, net.LA_pyr.neurons, transform=np.ones((2*nNeurons, 1)))\n",
    "                if perturb_where==\"LAinh\":\n",
    "                    nengo.Connection(net.applied_current, net.LA_inh.neurons, transform=np.ones((2*nNeurons, 1)))\n",
    "                if perturb_where==\"BLApyr\":\n",
    "                    nengo.Connection(net.applied_current, net.BLA_pyr.neurons, transform=np.ones((3*nNeurons, 1)))\n",
    "                if perturb_where==\"BLAinh\":\n",
    "                    nengo.Connection(net.applied_current, net.BLA_inh.neurons, transform=np.ones((2*nNeurons, 1)))\n",
    "                if perturb_where==\"CeL\":\n",
    "                    nengo.Connection(net.applied_current, net.CeL_on.neurons, transform=np.ones((nNeurons, 1)))\n",
    "                    nengo.Connection(net.applied_current, net.CeL_off.neurons, transform=np.ones((nNeurons, 1)))\n",
    "                if perturb_where==\"CeM\":\n",
    "                    nengo.Connection(net.applied_current, net.CeM.neurons, transform=np.ones((nNeurons, 1)))\n",
    "                net.pApplied = nengo.Probe(net.applied_current)\n",
    "            sim = nengo.Simulator(net, dt=dt, progress_bar=False)\n",
    "            with sim:\n",
    "                net.inputs.applied_current = 0\n",
    "                net.inputs.stop_learning = 0\n",
    "                net.inputs.CS = net.inputs.CSs[0]\n",
    "                net.inputs.CTX = net.inputs.CTXs[0]\n",
    "                # if when==\"Control\" and perturbation==\"Positive\":\n",
    "                #     net.inputs.applied_current = T_current\n",
    "                # elif when==\"Control\" and perturbation==\"Negative\":\n",
    "                #     net.inputs.applied_current = -T_current\n",
    "                # else:\n",
    "                #     net.inputs.applied_current = 0\n",
    "                sim.run(2)\n",
    "                T1a = int(1/dt)\n",
    "                T1b = int(2/dt)\n",
    "                net.inputs.CTX = net.inputs.CTXs[0]\n",
    "                net.inputs.US = 1\n",
    "                if when==\"Acquisition\" and perturbation==\"Positive\":\n",
    "                    net.inputs.applied_current = T_current\n",
    "                elif when==\"Acquisition\" and perturbation==\"Negative\":\n",
    "                    net.inputs.applied_current = -T_current\n",
    "                else:\n",
    "                    net.inputs.applied_current = 0\n",
    "                for p in range(nCond):\n",
    "                    sim.run(2)\n",
    "                T2a = int((2+2*nCond-1)/dt)\n",
    "                T2b = int((2+2*nCond-0.5)/dt)\n",
    "                net.inputs.CTX = net.inputs.CTXs[1]\n",
    "                net.inputs.US = 0\n",
    "                if when==\"Extinction\" and perturbation==\"Positive\":\n",
    "                    net.inputs.applied_current = T_current\n",
    "                elif when==\"Extinction\" and perturbation==\"Negative\":\n",
    "                    net.inputs.applied_current = -T_current\n",
    "                else:\n",
    "                    net.inputs.applied_current = 0\n",
    "                for p in range(nExt):\n",
    "                    sim.run(2)\n",
    "                T3a = int((2+2*nCond+2*nExt-1)/dt)\n",
    "                T3b = int((2+2*nCond+2*nExt-0.5)/dt)\n",
    "                net.inputs.stop_learning = 1\n",
    "                if when==\"Test in CTX+\" and perturbation==\"Positive\":\n",
    "                    net.inputs.applied_current = T_current\n",
    "                elif when==\"Test in CTX+\" and perturbation==\"Negative\":\n",
    "                    net.inputs.applied_current = -T_current\n",
    "                else:\n",
    "                    net.inputs.applied_current = 0\n",
    "                net.inputs.CTX = net.inputs.CTXs[0]\n",
    "                net.inputs.US = 0\n",
    "                sim.run(2)\n",
    "                T4a = int((2+2*nCond+2*nExt+1)/dt)\n",
    "                T4b = int((2+2*nCond+2*nExt+1.5)/dt)\n",
    "                if when==\"Test in CTX-\" and perturbation==\"Positive\":\n",
    "                    net.inputs.applied_current = T_current\n",
    "                elif when==\"Test in CTX-\" and perturbation==\"Negative\":\n",
    "                    net.inputs.applied_current = -T_current\n",
    "                else:\n",
    "                    net.inputs.applied_current = 0\n",
    "                net.inputs.CTX = net.inputs.CTXs[1]\n",
    "                net.inputs.US = 0\n",
    "                sim.run(2)\n",
    "                T5a = int((2+2*nCond+2*nExt+2+1)/dt)\n",
    "                T5b = int((2+2*nCond+2*nExt+2+1.5)/dt)\n",
    "\n",
    "            columns = [\"seed\", \"Perturb Where\", \"Perturb During\", \"Test Context\", \"Perturbation\", \"Fear Response\"]\n",
    "            # dfs.append(pd.DataFrame([[seed, where, when, \"Control\", np.mean(sim.data[net.pCeM][T1a: T1b]), stim, block]], columns=columns))\n",
    "            if when!=\"Test in CTX-\": dfs.append(pd.DataFrame([[seed, perturb_where, when, \"CTX+\", perturbation, np.mean(sim.data[net.pCeM][T4a: T4b])]], columns=columns))\n",
    "            if when!=\"Test in CTX+\": dfs.append(pd.DataFrame([[seed, perturb_where, when, \"CTX-\", perturbation, np.mean(sim.data[net.pCeM][T5a: T5b])]], columns=columns))\n",
    "\n",
    "    data = pd.concat(dfs, ignore_index=True)\n",
    "    data.to_pickle(f\"data/perturbation_{perturbation}_{perturb_where}.pkl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "fb952da7",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Peter Duggins\\amygdala\\.venv\\Lib\\site-packages\\nengo\\cache.py:624: UserWarning: Decoder cache could not acquire lock and was deactivated.\n",
      "  warnings.warn(\"Decoder cache could not acquire lock and was deactivated.\")\n"
     ]
    }
   ],
   "source": [
    "perturbation_experiment(seeds=10, perturb_where=\"None\", perturbation=\"None\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "7d88283e",
   "metadata": {},
   "outputs": [],
   "source": [
    "perturbation_experiment(seeds=10, perturb_where=\"LApyr\", perturbation=\"Negative\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "9d6a9e7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "perturbation_experiment(seeds=10, perturb_where=\"LAinh\", perturbation=\"Negative\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "393961df",
   "metadata": {},
   "outputs": [],
   "source": [
    "perturbation_experiment(seeds=10, perturb_where=\"BLApyr\", perturbation=\"Negative\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "d8ba3986",
   "metadata": {},
   "outputs": [],
   "source": [
    "perturbation_experiment(seeds=10, perturb_where=\"BLAinh\", perturbation=\"Negative\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "8d36e2d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "perturbation_experiment(seeds=10, perturb_where=\"CeL\", perturbation=\"Negative\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "92fafd96",
   "metadata": {},
   "outputs": [],
   "source": [
    "perturbation_experiment(seeds=10, perturb_where=\"CeM\", perturbation=\"Negative\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "7e43ca7d",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Peter Duggins\\amygdala\\.venv\\Lib\\site-packages\\nengo\\cache.py:624: UserWarning: Decoder cache could not acquire lock and was deactivated.\n",
      "  warnings.warn(\"Decoder cache could not acquire lock and was deactivated.\")\n"
     ]
    }
   ],
   "source": [
    "perturbation_experiment(seeds=10, perturb_where=\"CeL\", perturbation=\"Positive\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "7524d0c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "perturbation_experiment(seeds=10, perturb_where=\"CeM\", perturbation=\"Positive\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bec0064",
   "metadata": {},
   "source": [
    "### Inactivation experiment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "3e8a0696",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnQAAAJOCAYAAAA+iJoEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABc8klEQVR4nO3deXxU9b3/8ffMZDKQECALBCQEMCIEEQ1B6gJYq6WUzUpdQEK12GtbtbbeNvWKP+t1oXqLv3pRK9ZarxLcQBS5VkEFt1R2lEUTpQkhCSVACIHAJDPJzPn9QTM/oiRkOTkzZ/J6Ph48Dsk5OZ/PJN+ceeesDsMwDAEAAMC2nOFuAAAAAB1DoAMAALA5Ah0AAIDNEegAAABsjkAHAABgcwQ6AAAAmyPQAQAA2ByBDgAAwOZiwt2AJFVVVSk/P19paWnyeDzhbgcAACDsfD6fysvLNW7cOCUlJbW4bEQEuvz8fOXm5oa7DQAAgIizYMECTZ8+vcVlIiLQpaWlSTrRcEZGRpi7Ob2SkhKtWbNGl19+uQYPHhzudmCSKxe+Ka+/IdxtdKq42Bi98cup4W4DJmJ7BESvoqIi5ebmhnJSSyIi0DUeZs3IyNA555wT5m5O78UXX9S2bdvUvXt3TZkyJdztwCy9tyhYV29Zue7eSiVVfamqpGGqjUuxpmg3ty1+x9B6bI+A6Nea09G4KKIdamtrm0yB9uhzcKd6H9mjPgd3hrsV2BjbIwASgQ4IG2ewockUAID2iohDrh1RWlqqyspKS2vW1NSEplu3brWsbkpKitLT0y2r15WUlpbKt79E9T7rwpVRXxea1h/YY0lNnydGpaWljKNOwvYIQLjYOtCVlpYqMzNTXq/X0rpZWVlKTEzUli1blJ2dbVnduLg4FRQUsBE1WbjGUX1WlpSYqPoDe1S1eoUlNaskZb76X4yjTsD2CEA42TrQVVZWyuv1asmSJcrMzLSs7qJFi1RcXKzs7Gw988wzltQsKChQTk6OKisr2YCarHEc9Z3yUzX06GtZXXf1Dqn+qNx9BynpOmuuPI05dkAH/vZnxlEnYHsEIJxsHegaZWZmavTo0ZbV69u3r4qLi9W3b19L66JzxSafIUevAZbVM2p3S/VHZXh6yN13kCU13Z6o+JWPaGyPAIQDW/d2mDNnjuLj4zVjxoxwtwIbO9hnpAIutw4lDw93K7AxtkcAJAJduwwfPlzz5s0Ldxuwudq4FO216v5ziFpsjwBI3LYEAADA9gh0AAAANkegA9CpCgsLNX/+fBUWFoa7FQCIWgQ6AJ0qLy9Pa9euVV5eXrhbAYCoRaAD0Kl41igAdD4CHdCFxLi6zq98MOAPdwsAYBluWwJ0IW7niUC3c+mN8n1oWFKzbl8vSR7V7duodY+ea0lNl6eHxt6yzpJaABAJCHRAFxSs9yrgD1hSa8KQesU6e+qiQUcV8PssqQkAXQ2BDkCnSuvl09WjDoa7DQCIal3nhBoAAIAoRaADAACwOQIdAACAzRHoAAAAbM60QHf33XebtSoAAAC0gWmB7qyzzpLfz408AQAArGbabUvKysp01113SZLGjBmjWbNmmbVqAAAAtMC0QDdp0iSNGDFC3bt311dffWXWagEAAHAapgW6jRs36ujRo7rggguUmZlp1moBAABwGqadQ3fNNdeopqZGDz30kGbNmqU///nPqq+vN2v1AAAAaIZpe+iOHTumyy67TFdddZU++ugjJSQk6IUXXtCNN95oVgkAAACcgmmBbs2aNdq3b5+OHj2qvn376s4779Q//vEPs1YPAACAZpgW6CZMmKDevXurX79+oc/17t3brNUDAACgGaadQ3fs2DE9//zzys/PD33uu9/9rlmrBwAAQDNMC3Tl5eWaNm2aCgoKtGzZMrNWCwAAgNMw7ZBrjx49NGzYMI0YMUIffvihWasFAADAaZgW6LZt26YPPvhAhmGorq5OvXr1Ul1dnS688EKzSgAAAOAUTAt0l112mfr376/+/furqKhIGzdu1JtvvkmgAwAA6GSmBbrRo0dr8+bN6t+/vzIyMpSRkaHvfe97Zq0eAAAAzTDtogifz6dXXnmlyeeSkpLMWj0AAACa0eFAt3HjRs2bN08XX3yx3nzzTTN6AgAAQBu065BrSUmJVqxYoZUrV0qSZs6cqWXLlmnVqlWmNgcAAIDTa1Oge/nll/X666+ruLhYU6ZM0RNPPKHt27dr5syZkqSbbrqpU5oEAABA89oU6GJjY5Wamqrbb79dl1xyiSRpx44dofkej8fc7gAAAHBabQp0M2bM0IwZM1RWVqZ33nlHHo9HXq83NH/Pnj0aNGiQ6U0CAACgee06h27gwIEaOHCgJCkxMVHvvPOO6urqtHTpUi1ZssTUBgEAANCyDl/lOmrUKE2cOFFXXHGFDMMwoycAQCsVFhZq/vz5KiwsDHcrAMLItPvQxcXF6Re/+IVZqwMAtEJeXp7Wrl2rvLy8cLcCIIw6/KSI0tJSbdq0STt27JDT6eRRXwBgodra2iZTAF1ThwNdenq60tPTNWnSJM2YMcOMngAAANAGph1yjY+P1+TJk81aHQAAAFqp1YEuGAxq9erVLS7Tr1+/DjcEAACAtmn1IVen06mtW7dq1KhRzV7NWlFRYVpjAGBHsxatUiBxp2X1Uosq1E3ShqIKnfXbxZbUdB0ut6QOgNZr0zl0zz//vBYvPvUGwzAMORwO/fKXvzSlMQCwI6+/QfV19ZbVSwme+AM7EDR0zKK6bn+DJXUAtF6bAt3cuXM1e/bsU84zDIPL5gEAAMKg1YHOMAxNnTpVAwYMaHaZadOmmdIUAAAAWq/VF0U4HA6NGDGixWVGjhzZ4YYAAK0XdMY0mQLomky7bQmiD48UghnKj3j06va+Kj/iCXcrUelgn5Gq7jVIB/qeG+5WgIgXze9rBDo0i0cKwQwfFvXWjooe+rCod7hbiUq1cSnam3aJ6ronh7sVIOJF8/sagQ7N4pFCMIM/4GwyBYBwieb3NbawAAAANkegAwAAsDkui7KZgoICy2rV1NSEplu3brWsbkpKitLT0y2r1xWV7PcpUB+wpJbXFwxNv9zrs6Smy+3SgNJSxhEQ4UpLS1VZWWlZvWh+XyPQ2cS+ffskSTk5OZbVzMrKUmJiorZs2aLs7GzL6sbFxamgoIA3405Qf6xaknTfC9Y9uikrq58SE+P15V6/Xn5zn2V1457KZBwBEay0tFSZmZnyer2W1Yzm9zUCnU1UV1dLkh544AFNnjzZkpqLFi1ScXGxsrOz9cwzz1hSs6CgQDk5OaqsrOSNuBME6o5Lkm7+fl+NPctlSc33dsfqgFcaNiBWt47rb0nNsiqX7nuhnHEERLDKykp5vV4tWbJEmZmZltSM5vc1Ap3NDBkyRKNHj7akVkJCQmhqVU1Yo39SrIYNsObX/5N/OiWvFOdxatgAa+5F53JbE1YBdFxmZibvaybgoggAAACbI9ChWd27d28yBQAAkYlDrmjWnDlzFB8frxkzZoS7FdhYrCvYZAoA4RLNOyoIdGjW8OHDNW/evHC3AZu7NKNanpigLhp0NNytAOjionlHBYEOQKdK6+XT1aMOhrsNAIjqHRWcQwcAAGBzBDoAAACbI9ABAADYHIEOAADA5gh0AAAANkega4fCwkLNnz9fhYWF4W6lU3WV1wkAgN0R6NohLy9Pa9euVV5eXrhb6VRd5XUCAGB3EXEfOp/PJ0kqKipq09ft3r1bHo9Ha9eu1e7duzujtVMqKiqS3+9XUVGRli9fbknNzZs3y+PxaPPmzerWrZslNcPxOht/po1TK2u69u+S43iVJTXDxVFVJo/Ho137HerWLXofYF9R7WAcdSLnsUOWf38RfcL1Hm61jryvNeaixpzUEodhGEa7OjTRypUrlZubG+42AAAAIs6CBQs0ffr0FpeJiEBXVVWl/Px8paWl8dceAACATuyZKy8v17hx45SUlNTishER6AAAANB+XBQBAABgcwQ6AAAAmyPQAQAA2ByBDgAAwOYIdAAAADZHoAMAALA5Ah0AAIDNEegAAABsjkAHAABgcwQ6AAAAmyPQAQAA2FxMuBuQpKqqKuXn5ystLU0ejyfc7QAAAISdz+dTeXm5xo0bp6SkpBaXjYhAl5+fr9zc3HC3AQAAEHEWLFig6dOnt7hMRAS6tLQ0SScazsjICHM3p1dSUqI1a9bo8ssv1+DBg8PdDmyKcQQzMI6A6FVUVKTc3NxQTmpJRAS6xsOsGRkZOuecc8Lczem9+OKL2rZtm7p3764pU6aEux3YFOMIZnj66ae1c+dOBQIBLVy4MNztAOgErTkdjYsi2qG2trbJFGgPxhHMsGfPniZTAF1TROyh64jS0lJVVlZaWrOmpiY03bp1q2V1U1JSlJ6eblm9roRxBDOEYxzV19eHpowjoOuydaArLS1VZmamvF6vpXWzsrKUmJioLVu2KDs727K6cXFxKigoYCNqMsYRzBCucTR+/Hi53W7V1NQwjoAuzNaBrrKyUl6vV0uWLFFmZqZldRctWqTi4mJlZ2frmWeesaRmQUGBcnJyVFlZyQbUZIwjmKFxHKX/4BYFe6ZaVte5N18yAnLGdlPaj+6zpubR/Spd8STjCIggtg50jTIzMzV69GjL6iUkJISmVtZF52IcwQzBnqmq7zXAsnrGP12SEZDhcFlW121JFQBtwUUR7dC9e/cmU6A9GEcwg8/T88S0W68wdwIgnKJiD53V5syZo/j4eM2YMSPcrcDGGEcww/5+o5VU9aUOJQ8PdysAwohA1w7Dhw/XvHnzwt0GbI5xBDPUxqVob1xKuNsAEGYccgUAALA5Ah0AAIDNEegAAABsjkAHAABgcwQ6AAAAmyPQAQAA2ByBDgAAwOYIdAAAADZHoAMAALA5Ah0AAIDNEegAAABsjkAHAABgc50W6AzD6KxVAwAA4CQxZq+woKBAR44c0YABA7R7925NmDDB7BIAAAA4iel76DZs2KC9e/fqT3/6kzZt2mT26iNCYWGh5s+fr8LCwnC3AgAAYM4euvXr1+vTTz/V2LFjNWjQIF122WX64Q9/aMaqI1JeXp7Wr18vr9er+fPnh7sdAADQxZkS6AzD0IUXXqitW7dq48aNWrp0qS644AKNHz9eQ4cONaNERKmtrW0yBQAACCdTAt1FF10kScrKytJNN92kQCCgbdu2af369VEZ6AAAACKJ6RdFvPTSSzp48KC+/e1vKzU11ezVAwAA4GtMD3RpaWm69NJLtWrVKjU0NJi9egAAAHyN6YEuGAwqJSVFc+fONXvVAAAAOAXTA92GDRv0xhtvyOl06lvf+pauueYas0t8w6xFqxRI3NnpdRqlFlWom6QNRRU667eLLanpOlxuSR0AAGA/pge673znOxowYID69OmjgoICs1d/Sl5/g+rr6i2pJUkpwRNPwQgEDR2zqK7bz+FrAABwaqYHujFjxoT+f+6555q9egAAAHyNaU+KeOGFFyRJJSUlOnLkiCoqKvTFF1+YtfqIEnTGNJkCAACEk2mJ5Hvf+54kafXq1frnP/8pwzDUr18/jRgxwqwSEeNgn5EKuNw6lDw83K0AAACYF+hSUlIkSePHj1dSUpLi4uJ0+PBhs1YfUWrjUrQ3LiXcbQAAAEgy8ZBroxEjRqi8vFw9e/bUoEGDzF49EDUKCws1f/58FRYWhrsVAIDNmR7ofD6fXnnlFbNXC0SdvLw8rV27Vnl5eeFuBQBgc6YFuo0bN2revHm6+OKL9eabb5q1WiBq1dbWNpkCANBeHTqHrqSkRCtWrNDKlSslSTNnztSyZcu0atUqU5oDAADA6bUr0L388st6/fXXVVxcrClTpuiJJ57Q9u3bNXPmTEnSTTfdZGqTAAAAaF67Al1sbKxSU1N1++2365JLLpEk7dixIzTf4/GY0x0AAABOq12BbsaMGZoxY4bKysr0zjvvyOPxyOv1hubv2bOHK1wBAAAs0qFz6AYOHKiBAwdKkhITE/XOO++orq5OS5cu1ZIlS0xpEAAAAC0z7cbCo0aN0qhRo+T1erltCWxp1qJVCiTutKxealGFuknaUFShs3672JKarsPlltQBAFjL9IeRxsXF6Re/+IXZqwU6ndffoPq6esvqpQQNSVIgaOiYRXXd/gZL6gAArGVaoCstLdWmTZu0Y8cOOZ1OXXjhhWatGgAAAC0wLdClp6crPT1dkyZN0owZM8xaLQAAAE7D9Ed/xcfHa/LkyWavFog6QWdMkykAAO3V5kAXDAa1evXqFpfp169fuxsCuoqDfUaqutcgHeh7brhbAQDYXJt3DTidTm3dulWjRo2SYRinXKaioqLDjQHRrjYuRXvjUsLdBgAgCrTrWM/zzz+vxYtPfZsFwzDkcDj0y1/+skONAQAAoHXaFejmzp2r2bNnn3KeYRjKy8vrUFMAAABovTYHOsMwNHXqVA0YMKDZZaZNm9ahpgAAANB6bb4owuFwaMSIES0uM3LkyHY3hMhRWFio+fPnq7CwMNytAADQYdH8vmb6bUsQPfLy8rR27VoOoaNDonkDCsBeovl9jUCHZtXW1jaZAu0RzRtQAPZy6NChJtNoQqAD0Kn4wwBApGi8rVo03l6NQAcAALqEYDDYZBpNeOaQzRQUFFhWq6amJjTdunWrZXVTUlKUnp5uWb2uiHEEIBKUlpaqsrLSsnqBQCA0jbbtEYHOJhqOVUuScnJyLKuZlZWlxMREbdmyRdnZ2ZbVjYuLU0FBAW/GnYBxBCBSlJaWKjMzU16v17Ka48ePl9vtVk1NTdRtjwh0NhH0nRjwDzzwgCZPnmxJzUWLFqm4uFjZ2dl65plnLKlZUFCgnJwcVVZW8kbcCRhHACJFZWWlvF6vlixZoszMTEtq3nPPPaqrq1NCQoK2bNliSU2rtkcEOpsZMmSIRo8ebUmthISE0NSqmrAG4whApMjMzLRs2+ByuULTaNseEegAAEDY7Fx6o3wfGpbUavClSHKqwVejdY+ea0nNXfsdltQh0AEAgLAJ1nsV8Acsqpb8r6mhgP+YJRWD9S5L6nDbEjSre/fuTaZAezCOAEQKp6PpNJqwhw7NGj9+vHbv3q0JEyaEuxXY2Jw5cxQfH68ZM2aEuxUAXVzvbvWqrXepd7f6cLdiOvbQoVkff/yx9u/fr48++ijcrcDGhg8frnnz5mn48OHhbgVAF5fgCTSZRhP20KFZPLIJABBNLs2olicmqIsGHQ13K6Yj0NmEy8nOVAAAOiKtl09XjzoY7jY6BYHOJmL+dQZn0bv/qXUHHrakZt2+XpI8qtu3Meou7wYAIJoQ6Gwm2FCngL/BkloThtQr1tlTFw06qoDfZ0lNqy7vBgAgmnAcD81q3DU9oJc1YQ7RqbCwUPPnz1dhYWG4WwGAqEWgA9Cp8vLytHbtWuXl5YW7FQCIWgQ6oAsJx8U1XC0NAJ0vIs6h8/lOHNIrKipq09ft3r1bHo9Hrv275Dhe1RmtRQxHVZk8Ho927XeoW7foPc+sotohj8cT+tlaoUuNo+pyeTwevb34dyr/+CFLahbv7iG/363izz/Rf/1spCU1K6oNxlEnch47ZPn3F9Gncfx8tsehiiO8r51KYy5qzEktcRiGYc0TcVuwcuVK5ebmhrsNAACAiLNgwQJNnz69xWUiItBVVVUpPz9faWlp/LUHAACgE3vmysvLNW7cOCUlJbW4bEQEOgAAALQfF0UAAADYHIEOAADA5gh0AAAANkegAwAAsDkCHQAAgM0R6AAAAGyOQAcAAGBzBDoAAACbI9ABAADYHIEOAADA5gh0AAAANhcT7gYkqaqqSvn5+UpLS5PH4wl3OwAAAGHn8/lUXl6ucePGKSkpqcVlIyLQ5efnKzc3N9xtAAAARJwFCxZo+vTpLS4TEYEuLS1N0omGMzIywtwNYI0//vGP+uqrr3T22Wfr3//938PdDmyqpKREa9as0eWXX67BgweHux0AJioqKlJubm4oJ7UkIgJd42HWjIwMnXPOOWHu5vQKCwu1fPly/fCHP9Tw4cPD3Q5M4G8IKDbGZWlNt9ut2NhYud1uS8d9OF4rOs+LL76obdu2qXv37poyZUq42wHQCVpzOlpEBDq7ycvL0/r16+X1ejV//vxwtwMTxMa4lPW7l1RTV29ZzbTiPXJJKizeo7N+u9iSmgnd3Pr0/lmW1II1amtrm0wBdE0EunZgAxqdaurqdczCQGcY/39qZV0AQPSxfaArLS1VZWWlpTVrampC061bt1pWNyUlRenp6ZbV60pKS0vl21+iel+DZTX9Drdi5Jff4Vb9gT2W1PR5YlRaWso46iRsjwCEi60DXWlpqTIzM+X1ei2tm5WVpcTERG3ZskXZ2dmW1Y2Li1NBQQEbUZOFaxz5srIUl5goX2W5qt79X0tqVknKfPW/GEedgO0RgHCydaCrrKyU1+vVkiVLlJmZaVndRYsWqbi4WNnZ2XrmmWcsqVlQUKCcnBxVVlayATVZ4zjqO+WnaujR17K67uodUv1RufsOUtJ1Uy2pGXPsgA787c+Mo07A9ghAONk60DXKzMzU6NGjLauXkJAQmlpZF50rNvkMOXoNsKye4/guqf6oHO5ucvcdZElNtycqfuUjmtXbo759+6q4uFh9+/ZlewR0YWzd26F79+5NpkB7BJ0xTaZAe8yZM0fx8fGaMWNGuFsBEEa8k7QDG1CY4WCfkQq43DqUzL0M0X7Dhw/XvHnzwt0GgDAj0LUDG1CYoTYuRXvjUsLdBgAgCjjD3QAAAAA6hkAHAABgcwQ6AAAAmyPQAQAA2ByBDgAAwOYIdAAAADZHoAMAALA5Ah0AAIDNmRbo7r77brNWBSCKFBYWav78+SosLAx3KwAQtUwLdGeddZb8fr9ZqwMQJfLy8rR27Vrl5eWFuxUAiFqmPfqrrKxMd911lyRpzJgxmjVrllmrBmBjtbW1TaYAAPOZFuh27dqlq6++WuPGjdPBgwfNWi0AE8W4us5ps8GAX05XbLjbAABLmBboHnnkEX3yySdasGCB9uzZo29/+9uaO3eu3G63WSUAdJDbeSLQ7Vx6o3wfGpbUPFLWW1KsjpRt0rpHz7WkpsvTQ2NvWWdJLQCIBKYFumPHjumyyy7TVVddpY8++kgJCQl64YUXdOONN5pVAoBJgvVeBfwBS2rFOuMlxSrWWa+A/5glNQGgqzEt0K1Zs0b79u3T0aNH1bdvX9155536xz/+YdbqAdjUpRnV8sQEddGgo+FuBQCilmmBbsKECerdu7f69esX+lzv3r3NWj0Am0rr5dPVozivFgA6k2lnSB87dkzPP/+88vPzQ5/77ne/a9bqAQAA0AzTAl15ebmmTZumgoICLVu2zKzVAgAA4DRMC3Q9evTQsGHD9G//9m/q27evWauNSNz5HgAARBLTzqHbtm2bPvjgAxmGobq6OvXq1Ut1dXW68MILzSoRMfLy8rR+/Xp5vV7Nnz8/3O0AAIAuzrRAd9lll6l///7q37+/ioqKtHHjRr355ptRGei48z0AAIgkpgW60aNHh/6fkZGhjIwMfe973zNr9QAAAGiGqc8B2rx5c5OPk5KSzFw9AAAATsG0PXQ+n0+vvPKKxowZY9YqW23WolUKJO60rF5qUYW6SdpQVKGzfrvYkpquw+WW1AEAAPbT4UC3ceNGrVixQqtXr5bX69WCBQvM6KtNvP4G1dfVW1YvSS51k1Qvl45ZVNftb7CkDgAAsJ92BbqSkhKtWLFCK1eulCTNnDlTy5Yt06pVq0xtLlId7DNSAZdbh5KHh7sVAACAtgW6l19+Wa+//rqKi4s1ZcoUPfHEE9q+fbtmzpwpSbrppps6pclIUxuXor1xKeFuAwAAQFIbA11sbKxSU1N1++2365JLLpEk7dixIzTf4/GY2x0AAABOq02BbsaMGZoxY4bKysr0zjvvyOPxyOv1hubv2bNHgwYNMr1JAAAANK9d59ANHDhQAwcOlCQlJibqnXfeUV1dnZYuXaolS5aY2iAAAABa1uH70I0aNUoTJ07UFVdcIcMwzOgJAAAAbWDajYXj4uL0i1/8wqzVAQAAoJU6fB+60tJSbdq0STt27JDT6YzKZ7cCAABEsg4HuvT0dKWnp2vSpEmaMWOGGT0BAACgDUw75BofH6/JkyebtToAAAC0UqsDXTAY1OrVq1tcpl+/fh1uCADQeoWFhZo/f74KCwvD3QoQ8aL596XVh1ydTqe2bt2qUaNGNXs1a0VFhWmNAQBOLy8vT+vXr5fX69X8+fPD3Q7QJsGAX05XrGX1wvX7YsXrbNM5dM8//7wWL158ynmGYcjhcOiXv/ylKY0BgB3NWrRKgcSdltXr849yxUlaW1Cus3576u2z2VyHyy2pg+jndMVq45MXKeA7Zkm9w8W9JHl0uPhDrXv0XEtqujw9NPaWdZ1ep02Bbu7cuZo9e/Yp5xmGoby8PFOaAgC78vobVF9Xb1m9QNIIJcmlQ8nDVWdRXbe/wZI66BoCvmMK+K0JdBOG1CvW2VMXDTqqgN9nSU2rtDrQGYahqVOnasCAAc0uM23aNFOaAgC0Tm1civbGpYS7DcAW0nr5dPWog+Fuo1O0+qIIh8OhESNGqKysTGvWrFFtba0kacuWLbr99tu1aNEijRgxotMaBQAAwKm16ZDrunXrdMsttyg2NlZ9+/bVE088odzcXI0cOVIrVqxQXV2d7rjjjs7qFQAAAKfQpkC3YsUKrVq1SqmpqVq1apUeeughLVu2TMnJyfL7/frNb37TWX0CAACgGW0KdCNGjFBqaqokadKkSTpy5IiSk5MlSbGxsRo9erT5HQIAAKBFbXpSRExM0/x3xhlnNPm4W7duHe8IAAAAbdKmQFdf3/SSeIfD0eTjhgYuZY8m0XxHbVin/IhHr27vq/IjnnC3AqCLi+btUZsOuT788MN65JFHQh8Hg0E5nScyoWEYCgaDysnJMbdDhA13oIcZPizqra8q4+VrcGj26P3hbgdAFxbN26M2BbqcnBz9+Mc/PuU8biwcfQ4dOtRkCrSHP+BsMgWAcInm7VGbAt306dO5sXAX0vhsXp7RCwBAZGtTRB01alSL80eOHNmhZhBZgsFgkykAAIhMbdpDh/ArKCiwrFYgEAhNt27dalndlJQUpaenW1avKyrZ71OgPmBJLa8vGJp+udeaZye63C4NKC1lHAERrrS0VF+W1ypQb822IZq3RwQ6m2g4Vi1Jll50Mn78eLndbtXU1Cg7O9uyunFxcSooKODNuBPU/2sc3fdCuWU1s7L6KTExXl/u9evlN/dZVjfuqUzGERDBSktLlZmZKa/Xa1nNaN4eEehsIug7MeAfeOABTZ482ZKa99xzj+rq6pSQkKAtW7ZYUrOgoEA5OTmqrKzkjbgTBOqOS5Ju/n5fjT3LZUnN93bH6oBXGjYgVreO629JzbIql+57oZxxBESwyspKeb1e3Ts7TQOTrDliEM3bIwKdTbj+dXuYIUOGWPZEDpfLFZryFJDo0j8pVsMGWPPr/8k/nZJXivM4NWyANfd+crmtCasAOm5wqkdn9bUm0EXz9ohAZxMxzhM3cS569z+17sDDltRs8KVIcqrBV6N1j55rSc1d+x2nXwgAADRBoLOZYEOdAn6rnsiR/K+poYD/mCUVg/XsWQEAoK2i7856MM2/dgqGpkB7xLqCTaYAEC7RvD1iDx2a1btbvWrrXerdrf70CwPNuDSjWp6YoC4adDTcrQDo4qJ5e0SgQ7MSPAHtqzkxBdorrZdPV486GO42ACCqt0cEOjQrmv+SAQAgmhDo0Kxo/ksGAIBowkURAAAANkegAwAAsDkCHQAAgM0R6AAAAGyOQAcAAGBzEXGVq8/nkyQVFRW16et2794tj8cj1/5dchyv6ozWIoajqkwej0e79jvUrVv0Ph6rotohj8cT+tlagXEUfRhHnct57JDl319En8bx89kehyqOsD06lcZc1JiTWuIwDMNoV4cmWrlypXJzc8PdBgAAQMRZsGCBpk+f3uIyERHoqqqqlJ+fr7S0NP7aAwAA0Ik9c+Xl5Ro3bpySkpJaXDYiAh0AAADaj4siAAAAbI5ABwAAYHMEOgAAAJsj0AEAANgcgQ4AAMDmCHQAAAA2R6ADAACwOQIdAACAzRHoAAAAbI5ABwAAYHMEOgAAAJuLCXcDklRVVaX8/HylpaXJ4/GEux0AAICw8/l8Ki8v17hx45SUlNTishER6PLz85WbmxvuNgAAACLOggULNH369BaXiYhAl5aWJulEwxkZGWHu5vRKSkq0Zs0aXX755Ro8eHC424FN/f73v1dpaanS09M1b968cLcDm2J7BESvoqIi5ebmhnJSSyIi0DUeZs3IyNA555wT5m5O78UXX9S2bdvUvXt3TZkyJdztwAT+hoBiY1yW1vR6vYqNjZXX67V03IfjtaLzPP3009q5c6cCgYAWLlwY7nYAdILWnI4WEYHObmpra5tMYX+xMS5l/e4l1dTVW1Zz4LFaOSVVH6vVWb9dbEnNhG5ufXr/LEtqwRp79uxpMgXQNdk+0JWWlqqystLSmjU1NaHp1q1bLaubkpKi9PR0y+p1JaWlparcs0teX4NlNQcYhpySgoahw6X/sKSmzxMTOswL84Vje1RfXx+asj0Cui5bB7rS0lJlZmbK6/VaWjcrK0uJiYnasmWLsrOzLasbFxengoICNqImC9c48o4Zo549e8p7pEpVax6wpGaVpMxX/4tx1AnCNY7Gjx8vt9utmpoatkdAF2brQFdZWSmv16slS5YoMzPTsrqLFi1ScXGxsrOz9cwzz1hSs6CgQDk5OaqsrGQDarLGcdR3yk/V0KOvZXWd1Tuk+qNyJqcp6brvW1Iz5tgBHfjbnxlHnaBxHKX/4BYFe6ZaVte5N18yAnLGdlPaj+6zpubR/Spd8STjCIggtg50jTIzMzV69GjL6iUkJISmVtZF54pNPkOOXgMsq+c4vkuqPyqHu5vcfQdZUtPtiYpf+YgW7JmqegvHkf7plIyA5HBaVtdtSRUAbcGTItqhe/fuTaZAewSdMU2mQHsYDmeTKYCuiXeSdpgzZ47i4+M1Y8aMcLcCGzvYZ6QCLrcOJQ8Pdyuwsf2p56vPwR060GdUuFsBEEYEunYYPnw4N4JFh9XGpWhvXEq424DNVSdmqDox8m/IDqBzsY8eAADA5gh0AAAANkegAwAAsDkCHQAAgM0R6AAAAGyOQAcAAGBzBDoAAACb67RAZxhGZ60aAAAAJzH9xsIFBQU6cuSIBgwYoN27d2vChAlmlwAAAMBJTA90GzZsUEJCglasWKE+ffoQ6AAAADqZKYFu/fr1+vTTTzV27FgNGjRIl112mX74wx+asWoAAACchimBzjAMXXjhhdq6das2btyopUuX6oILLtD48eM1dOhQM0oAAACgGaYEuosuukiSlJWVpZtuukmBQEDbt2/X+vXrCXQAAACdzPRz6CTJ5XLpjDPO0DnnnNMZqwcAAMBJTL9tyUsvvaTHHntM+/fv1wcffGD26gHYTGFhoebPn6/CwsJwtwIAUcv0QJeWlqarr75amzdvVklJidmrB2AzeXl5Wrt2rfLy8sLdCgBELdMPuQaDQaWkpGju3LlmrxqADdXW1jaZAgDM1yn3oXvjjTfkdDr1rW99S9dcc43ZJQC0U4yr6zztLxjwy+mKDXcbAGAJ0wPdd77zHQ0YMEB9+vRRQUGB2asH0AFu54lAt3PpjfJ9aM3j+Y6U9ZYUqyNlm7Tu0XMtqeny9NDYW9ZZUgsAIoFpge6FF17Q7NmzlZKSori4OFVWVsrlcpm1+ohSWFio5cuX64c//KGGDx8e7naANgvWexXwByypFeuMlxSrWGe9Av5jltQEgK7GtED3ve99T5K0evVq7du3T8FgUP369dOIESPMKhEx8vLytH79enm9Xs2fPz/c7QAR7dKManligrpo0NFwtwIAUcu0QJeSkiJJGj9+vJKSkhQXF6fDhw+btfqIwkneQOul9fLp6lEHw90GAEQ108+hO3mPXM+ePc1ePQAAAL6mU54UsXnzZo0ZM6YzVn1KsxatUiBxp2X1Uosq1E3ShqIKnfXbxZbUdB0ut6QOAACwH9MDnc/n0yuvvGJpoPP6G1RfV29ZvZTgiasDA0FDxyyq6/Y3WFIHAADYj2k3pdq4caPmzZuniy++WG+++aZZq41IQWdMkykAAEA4dSiRlJSUaMWKFVq5cqUkaebMmVq2bJlWrVplSnOR6mCfkQq43DqUzC1LAABA+LUr0L388st6/fXXVVxcrClTpuiJJ57Q9u3bNXPmTEnSTTfdZGqTkaY2LkV741LC3QYAAICkdga62NhYpaam6vbbb9cll1wiSdqxY0dovsfjMac7AAAAnFa7At2MGTM0Y8YMlZWV6Z133pHH45HX6w3N37NnjwYNGmRakwAAAGheh86hGzhwoAYOHChJSkxM1DvvvKO6ujotXbpUS5YsMaVBAAAAtMy0q1xHjRqliRMn6oorrpBhWPPQbwAAAJgY6BrFxcXpF7/4hdmrBQAAQDNMu5FaaWmpNm3apB07dsjpdOrCCy80a9UAAABogWmBLj09Xenp6Zo0aZJmzJhh1moBAABwGqYfco2Pj9fkyZPNXi0AAACa0eZAFwwGtXr16haX6devX7sbAgAAQNu0+ZCr0+nU1q1bNWrUqGavZq2oqOhwYwAAAGiddp1D9/zzz2vx4sWnnGcYhhwOh375y192qDEAAAC0TrsC3dy5czV79uxTzjMMQ3l5eR1qCgAAAK3X5kBnGIamTp2qAQMGNLvMtGnTOtQUAAAAWq/NF0U4HA6NGDFCZWVlWrNmjWprayVJW7Zs0e23365FixZpxIgRpjcKAACAU2vXIdd169bplltuUWxsrPr27asnnnhCubm5GjlypFasWKG6ujrdcccdZvcKAACAU2hXoFuxYoVWrVql1NRUrVq1Sg899JCWLVum5ORk+f1+/eY3vzG7TwAAADSjXYFuxIgRSk1NlSRNmjRJR44cUXJysiQpNjZWo0ePNq9DAAAAtKhdT4qIiWmaA88444wmH3fr1q39HSFiFBYWav78+SosLAx3K7Cx8iMevbq9r8qPeMLdCgBErXYFuvr6+iYfOxyOJh83NDS0vyNEjLy8PK1du5bb0KBDPizqrR0VPfRhUe9wtwKgi4vmHRXtOuT68MMP65FHHgl9HAwG5XSeyIaGYSgYDConJ8ecDhE2hw4dajIF2sMfcDaZAkC4LFq0SDt37tSBAwe0cOHCcLdjqnYFupycHP34xz8+5TxuLBw9Gh/hxqPcAADRYM+ePU2m0aRdgW769OncWLgLCAaDTaYAANhZNL+vtSvQjRo1qsX5I0eObFczOL2CggLLagUCgdB069atltVNSUlRenq6ZfW6opL9PgXqA5bU8vqCoemXe32W1HS5XRpQWso4AiJcaWmpKisrLasXze9r7Qp0sF7DsWpJsvTcxPHjx8vtdqumpkbZ2dmW1Y2Li1NBQQFvxp2g/l/j6L4Xyi2rmZXVT4mJ8fpyr18vv7nPsrpxT2UyjoAIVlpaqszMTHm9XstqRvP7GoHOJoK+EwP+gQce0OTJky2pec8996iurk4JCQnasmWLJTULCgqUk5OjyspK3og7QaDuuCTp5u/31dizXJbUfG93rA54pWEDYnXruP6W1Cyrcum+F8oZR0AEq6yslNfr1ZIlS5SZmWlJzWh+XyPQ2cyQIUMsu3Gzy+UKTblZdHTpnxSrYQOs+fX/5J9OySvFeZwaNsCae9G53NaEVQAdl5mZyfuaCQh0NuFycssHAED02bn0Rvk+NCyp1eBLkeRUg69G6x4915Kau/Y7Tr+QCQh0NhHjPDEgit79T6078LAlNaN54AMAIkOw3quA35qLtKTkf00NBfzHLKkYrLfmiAGBzmaCDXUK+K15EofTkfyvafQNfABA1/OvfSOhaTThOB6a1btbfZMp0B6xrmCTKQCESzS/r7GHDs1K8AS0r+bEFGivSzOq5YkJ6qJBR8PdCoAuzhNjNJlGEwIdmsUbMcyQ1sunq0cdDHcbABDVRwwIdGgWb8QAgGgSzTsqCHQAAKBLiOYdFVwUAQAAYHMEOgAAAJsj0AEAANgcgQ4AAMDmIuKiCJ/PJ0kqKipq09ft3r1bHo9Hrv275Dhe1RmtRQxHVZk8Ho927XeoW7fofZpCRbVDHo8n9LO1AuMo+jCOOpfz2CHLv7+IPo3j57M9DlUcYXt0Ko25qDEntcRhGEbY7663cuVK5ebmhrsNAACAiLNgwQJNnz69xWUiItBVVVUpPz9faWlp/LUHAACgE3vmysvLNW7cOCUlJbW4bEQEOgAAALQfF0UAAADYHIEOAADA5gh0AAAANkegAwAAsDkCHQAAgM0R6AAAAGyOQAcAAGBzBDoAAACbI9ABAADYHIEOAADA5gh0AAAANhcT7gYkqaqqSvn5+UpLS5PH4wl3OwAAAGHn8/lUXl6ucePGKSkpqcVlIyLQ5efnKzc3N9xtAAAARJwFCxZo+vTpLS4TEYEuLS1N0omGMzIywtzN6ZWUlGjNmjW6/PLLNXjw4HC3A5NcufBNef0NltXrVletnkf26EivwfJ162VJzbjYGL3xy6mW1OqqGEcAzFJUVKTc3NxQTmpJRAS6xsOsGRkZOuecc8Lczek9/fTT2rlzpwKBgBYuXBjudmCW3lsUrKu3rJwREyOX/5DUI1nBuBRrinZz2+J3zNYYRwBM1prT0bgooh1KS0ubTIH26HNwp3of2aM+B3eGuxXYGOMIgESga5dAINBkCrSHM9jQZAq0B+MIgBQhh1w7orS0VJWVlZbWPDnQbd261bK6KSkpSk9Pt6xeV1JaWirf/hLV+6x7UzTq60LT+gN7LKnp88SotLSUcdRJGEcAwsXWga60tFSZmZnyer2W1h0/frzcbrdqamqUnZ1tWd24uDgVFBSwETVZuMZRfVaWlJio+gN7VLV6hSU1qyRlvvpfjKNOwDgCEE62DnSVlZXyer1K/8EtCvZMtayuc2++ZATkjO2mtB/dZ03No/tVuuJJVVZWsgE1WeM46jvlp2ro0deyuu7qHVL9Ubn7DlLSddZcMRhz7IAO/O3PjKNOwDgCEE62DnSNgj1TVd9rgGX1jH+6JCMgw+GyrK7bkipdW2zyGXJYOI4cx3dJ9UflcHeTu+8gS2q6PVHxKx/RGEcAwoGLItrB5+l5YmrRPZ8QnYLOmCZToD0YRwCkKNlDZ7X9/UYrqepLHUoeHu5WYGMH+4xUwOVmHKFDGEcAJAJdu9TGpWivVTfwRNRiHMEMjCMAEodcAQAAbI9ABwAAYHMEOgAAAJsj0AEAANgcgQ4AAMDmCHQAAAA2R6ADAACwOQIdAACAzRHoAAAAbI5ABwAAYHMEOgAAAJsj0AEAANgcgQ4AAMDmCHQAAAA2R6ADAACwOQIdAACAzRHoAAAAbI5ABwAAYHMxnbHS0tJSbd26VT169FBqaqrOPffczigDAAAAddIeuvT0dF155ZUKBoPKycnpjBIAAAD4l07ZQydJDodDEydOVH5+fmeVAAAAgDq4h84wDH311VctLnP22Wd3pAQAAABOo0OBzuFwaNOmTS0uExPTaTsBAQAAIBMOuT755JNavXp1s/PLy8s1c+bMjpYBAABAMzoc6AYNGqSxY8c2O9/v93e0BAAAAFrQoUAXDAY1e/ZsTZkypdll0tPTO1ICAAAAp9Ghc+icTuc3wpzP59OhQ4ckSTU1NZo+fXpHSgAAAOA0TL0P3XvvvadZs2bpueeekyTt3LlTGzZsMLMEAAAAvsbUQLd371699tproXPqLrroItXU1JhZAgAAAF9jaqAbMGCApBO3M2nUePgVAAAAncPUm8QVFRVJko4ePaqvvvpKn3zyCXvoAAAAOpmpge6GG27QggUL9Pbbb8vlcumqq67S7bffbmYJAAAAfE2HA93999+vjz76SCNHjtTcuXN1zz336Oabb9b69es1ZMgQnhQBAADQyTqctn7wgx8oKytL06ZNC30uNTVVV155pXbt2qXNmzdrzJgxHS0DAACAZnT4oogvvviiSZg72dChQ1VSUtLREgAAAGhBhwOdYRgtzm9oaOhoCQAAALSgw4Hu4MGDLc7ft29fR0sAAAB0WGFhoebPn6/CwsJwt2K6Dge648ePN/uN+eKLL+T1ejtaAoCNRfMGFIC95OXlae3atcrLywt3K6br8EURN998s2644QZNnjxZ48aNU2Jiog4fPqyPP/5Yb731lhYvXmxGnwBsKi8vT+vXr5fX69X8+fPD3Q6ALqy2trbJNJp0ONAlJydr0aJFuvvuu/XYY4/J4XDIMAxdcMEFeuqpp5ScnGxGnwBsKpo3oAAQKUy5SdzAgQO1ePFi7du3TxUVFerXr5/69+9vxqoBAABwGqbe9bd///4EOQAAAIt1+KIIRC9OZgcAwB4IdGhWNF8NBABANCHQoVmczA4AgD0Q6NCsxnsIci9BdATjCECkiObtEYEOzdq/f3+TKdAejCMAkSKat0cEOjQrEAg0mQLtwTgCECmieXtEoAMAALA5Ah3QhcS4us6vfDDgD3cLAE6jq/yeWvE6Tb2xMDpfQUGBZbVO3jW9detWy+qmpKQoPT3dsnpdidt5ItC9+dh12p5sWFLTXztQklP+2ho99+uzLKnpdMfp27e8yTgCIlz53gp98ORUBeutuUghmrdHBDq7qD0qScrJybGs5Pjx4+V2u1VTU6Ps7GzL6sbFxamgoIA3405Qf6xaknTv8/+wrOb48WfI7XbK6wvox38ssqxu3OOZjCMggpWWliozM9PSK06jeXtEoLMJh//EveB+OjVNF57tsaTmy9tdqg9KcR6X/uffMyypWXrIoXuf/4cqKyt5I+4EgbrjkqSbv99XY89yWVJzWYHzX+PIqWd+Yc2jAcuqXLrvhXLGERDBKisr5fV6de/sNA1MsuYihWjeHhHobKZfL+msvtYMfKfTkIInplbVlKwJGV1d/6RYDRtgza+/80v9axxJwwZY88eIy804AuxicKrHuve1KN4edZ0zpAEAAKIUgQ4AAMDmCHRoltPRdAq0B+MIQKSI5u0RgQ7N6t2tvskUaA/GEYBIkRJ34n5wfeKi7/53BDo0K8ETaDIF2oNxBCBSTBpepXP71WjS8Kpwt2I6rnJFsy7NqJYnJqiLBh0NdyuwMcYRgEiR1sunq0cdDHcbnYJAh2ZF88CHdRhHAND5OOQKAABgcwQ6AAAAmyPQAQAA2ByBDgAAwOYIdAAAADYXEVe5+nw+SVJRUVGbvm737t3yeDxy7d8lx/Hou6fMyRxVZfJ4PNq136Fu3aL3weMV1Q55PJ7Qz9YKjKPowzjqXM5jhyz//iL6NI6fz/Y4VHGE7dGpNOaixpzUEodhGEa7OjTRypUrlZubG+42AAAAIs6CBQs0ffr0FpeJiEBXVVWl/Px8paWl8dceAACATuyZKy8v17hx45SUlNTishER6AAAANB+XBQBAABgcwQ6AAAAmyPQAQAA2ByBDgAAwOYIdAAAADZHoAMAALA5Ah0AAIDNEegAAABsjkAHAABgcwQ6AAAAmyPQAQAA2FxMuBuQpKqqKuXn5ystLU0ejyfc7QAAAISdz+dTeXm5xo0bp6SkpBaXjYhAl5+fr9zc3HC3AQAAEHEWLFig6dOnt7hMRAS6tLQ0SScazsjICHM3p1dSUqI1a9bo8ssv1+DBg8PdDmyKcQQzMI6A6FVUVKTc3NxQTmpJRAS6xsOsGRkZOuecc8Lczek9/fTT2rlzpwKBgBYuXBjudmBTjCOY4cUXX9S2bdvUvXt3TZkyJdztAOgErTkdjYsi2mHPnj1NpkB7MI5ghtra2iZTAF1TROyh64jS0lJVVlZaWrO+vj403bp1q2V1U1JSlJ6eblm9roRxBDOEYxzV1NSEpowjoOuydaArLS1VZmamvF6vpXXHjx8vt9utmpoaZWdnW1Y3Li5OBQUFbERNxjiCGcI1jrKyspSYmKgtW7YwjmAJwzBC/9AxDocj9K+jbB3oKisr5fV6lf6DWxTsmWpZXefefMkIyBnbTWk/us+amkf3q3TFk6qsrGQDajLGEczQOI6WLFmizMxMy+ouWrRIxcXFys7O1jPPPGNJzYKCAuXk5DCOuphgMKgDBw6ourqaMGcih8Oh3r17q2/fvnI6238mnK0DXaNgz1TV9xpgXcF/OiUjIDmcltV1W1Kla2McwQyZmZkaPXq0ZfUSEhJCUyvrouvZs2ePnE6nBg8eLLebrYlZ6uvrtX//fu3Zs0dDhgxp93qiItBZzXA4m0yB9mAcwQzdu3dvMgU6QzAYVF1dnYYOHaqYGKKDmVwulwYMGKBdu3YpGAy2ey8dP5V22J96vvoc3KEDfUaFuxXYGOMIZpgzZ47i4+M1Y8aMcLeCKNZ4iNWMc73wTY3f144cyibQtUN1YoaqEyP/BsiIbIwjmGH48OGaN29euNsAEGYEOgAA0C4ff/yxHn30UU2aNEndunXTX//6V6Wnp2vixImqrq7WK6+8onfffbddpwR8/vnnrXrYQGlpqf7nf/5HycnJSk5OViAQ0JgxY/T666/rrrvuas/LanMPp7Nnzx4lJyerR48eHV5Xcwh0AACgXQ4fPqw///nP6tOnjyTp3Xff1dixYzVnzhxJ0uDBg1VVVaUBA9p24VddXZ3+/ve/nzZM7dixQ/PmzdOTTz6pgQMHhj6/aNEiffHFF218Nd+0Zs0aUwLdhg0bNGHChE4NdJyNDQAA2sXtdofC3Kmcf/75qqqqatM66+rq9Mgjj6ihoaHF5RoaGvTrX/9ac+fObRLmJOmnP/2pUlJS2lT3ZIZhaN26dXr33XdbvfypPjYMQ2VlZXr22Wfb3UtrsYcOAAC0y6RJk1qcP3DgQA0cOFCBQEDPP/+8+vfvr2PHjikQCGjmzJnavHmzqqurlZCQoE2bNunCCy9UfX29ysrKtHfvXr300kv61re+pTPPPPMb6/7ss8+0Z88ejRs37hvznE6nbrjhBknSsWPHtGTJEmVkZOj48eOKiYnR1KlT9eWXX+oPf/iDsrKyNGTIEHk8Hn3wwQd64IEHdODAAX322WeqrKzUSy+9pL59++ryyy8/5eu47rrr9Nxzz2nRokX6yU9+optvvlnXXXed0tPT9W//9m/aunWrDh8+rJUrVyohIUGzZs0y55v/NQQ6AADQLq296vW5556Ty+XS97//fUnST37yE11yySV6+eWXde+99yohIUFJSUk6cuSILrroIm3evFkul6vF8LNv3z5JUmJi4innn3/++ZKke++9Vz/+8Y81cuRISdL999+vxMREXXLJJZo8ebLef/993XbbbZKkv/3tb/r88881cuRITZs2Ta+99lqTHpp7HT/+8Y915pln6qWXXlJNTY2uvfZaXX311ZKkYcOG6S9/+YumT5+ufv36ter71R4ccgUAAJ3q7bffls/n00cffaSPPvpIWVlZqq2t1RVXXKHJkyfrtttu0+eff96mx9c1hqPDhw+fcn5FRYXq6ur09ttva9iwYaHPDx8+XK+99pqkE4E0I+P/323A4/G0+Pi+5l6HJF166aUaPHiw7r777rDcRog9dAAAoFO5XC6dddZZmjBhgiSFprGxsfrf//1fffrpp1q2bJm8Xq+uv/76Jl/72Wefhfa2nSwrK0sDBw5Ufn6+rrrqqm/MX79+vb773e+e8rmzgUAg9P+v3yj5VPeCa+yhudfR6JxzztFnn32mL7/88pSPADx8+LCOHj2qQYMGfWNeR7GHDgAAdKof/OAH+uSTT0IfFxYWavfu3Xr22WfVs2dPXXbZZfrDH/6g0tJSSVLPnj3l8/kkKfS5r4uJidH//b//V88++6zKysqazNu8ebNGjRql+Ph4ffvb39b27dtD87Zt26apU6eetudevXrJ7/c36aG51yGdCH39+/fXH/7wB919991N9vQ1vp7KysrQHj2zsYcOAAB0yMaNG1VcXKzi4mLV19drwIABOu+880KHM2fNmqVnn31Wzz33nNLS0iRJV1xxhdxut9544w0lJCTowIED+tGPfiTpxMUW8+fP14oVKzR8+PBm65533nl6/PHH9Ze//EXJyclKTU2V0+nUyJEjQxdSPPzww3r22We1d+9e1dbW6rzzztMVV1yhoqIirV27VtXV1Ro3bpyOHj2qnTt3yuVyKT09Xf3799fEiROVl5en5OTkZl/HhAkT9Mc//lGvvPKKli1bptTUVDU0NOjnP/+5fvrTn+riiy/W3Llz9eKLL2rw4MG67rrrOuVnQKADAAAdkpWVpTFjxmjmzJkyDEPBYPAby8ydO/cbn7vnnntOub7U1FQ99thjrao9ePBg3X///c3O79Wrl+64445vfD4jI0NPPPFEk89deumlTT6+++67v/F1p3odv/rVr/Tv//7voY9XrlzZZP706dM1ffr0Zns0A4EOAAB0iNvtDv3f4XDI5XKFsRvrOZ3hP4Mt/B0AAACgQwh0AAAANkegAwAAsDkCHQAAgM0R6AAAAGyuw4Gu8YZ6zSkvLz/lXZcBAABgjg4HurfeeqvF+e+//35HSwAAAITNyffWO/mxYZGkw/ehe/zxx79xY75GhmHI4XBozpw5HS0DAADQZtu3b9fy5cuVnp6u3r17y+Vy6dChQyopKZHL5dLQoUNDT7qYNWuWqqqq9O6772r58uV6+eWX9dRTTyklJUWPPfaYzjjjDN16660qKyvT7NmzNXv27HC/vJAOB7o//vGPqqurU2ZmppKSkprMMwxDS5cuDQU7AAAQvfwNAcXGdN5Nhdu6/r///e965pln9MQTTyg+Pl6SVFFRoSuvvFI33HCDbrnlFklS9+7d5Xa7df3110uSevfurZiYGOXk5Cg9PV333HOPkpKSFBMTo0suuUTTp09X7969T1lz+/btGjVqVMdeaDt0ONBNnjxZklRQUKB//OMfio+P1/nnnx+a//3vf59ABwBAFxAb41LW715STV296etO6ObWp/fPavXyfr9f8+bN08KFC0NhTpL69eunmTNn6owzzmj2a9PT01VbW6vu3btrwoQJOu+887Rw4UJdc801oT19zTl27FirezSTaY/+yszMlCQdP35cf//73xUMBnX22Wdr6NChZpUAAAARrqauXsc6IdC11aeffqqjR4+ecm/Z9OnT1a9fv2a/dsKECU0+vvvuuzV16lTFxcWd8rmwkcD025bEx8frkksuUUxMjG699VbdddddZpcAAABo0YEDB5SQkHDK56xmZGQ02Wt3Oqmpqbryyiu1YcOGiL1zh2l76KQT37zXXntNr732mpKTk3X99dfr+9//vpklAAAATqtPnz6qqalRMBj8Rqg7dOiQevbsKbfb3ap1VVZWatiwYdq8ebOWLVuma6+9NjSvuLhYX331Vejjr776SkePHg19PHToUGVkZHTw1ZxehwNdMBjU+++/r2XLlmn79u2aNm2annzySZ111lmSpKqqKnXv3r3DjQIAALTW6NGj1aNHD23fvr3Juf2StHHjRk2cOLHV63rjjTd044036uyzz9bPfvYzXXHFFaELQc8880ydeeaZoWV79uypiy++2JTX0BYdPuR6xRVXKC8vT9OmTdMHH3ygu+66KxTmJOnFF1/saAkAAIA2iY2N1e9//3v993//t44fPx76vM/nk2EYcrlad7Xsxx9/rLFjx8rlcum8887TxIkTtWDBgs5qu906vIdu4MCBuvLKK+X3+0M3GW68qjUQCOjtt9/Wbbfd1uFGAQBA5Evo1rrDmFasd/z48erRo4cefvjh0NWpbrdbU6dOlXTiitT33ntP7777roqLi/Xqq68qOztbQ4YMUVVVlf76179q2bJluvPOO3XuuedKOnFj4ddff13JycmaMWNGk71z4dThQPeDH/xAV111VbPzW3t8GgAA2Ju/IdCmW4u0Z/1tvc9dVlaWsrKyTjkvPj5eU6dO1ZVXXhnaEdUoKSlJubm5ys3NbXIhxAMPPKAHH3ywfS+gE3X4kOvXw5zP59OhQ4ckSTU1NZo+fXpHSwAAABvozJsKd8b6HQ6HYmJiQvfKdblcpzwUe/K9dE93X90xY8aY2mNrmXrbkvfee0+zZs3Sc889J0nauXOnNmzYYGYJAACAiBUbGxuWuqYGur179+q1117T2LFjJUkXXXSRampqzCwBAACArzE10A0YMEBS092RjYdfAQAA0DlMvbFwUVGRJOno0aP66quv9Mknn7CHDgAAoJOZGuhuuOEGLViwQG+//bZcLpeuuuoq3X777WaWAAAAwNd0ONDdf//9+uijjzRy5EjNnTtX99xzj26++WatX79eQ4YMUUyMqZkRAAAAX2PKfeiysrI0bdq00OcaH2K7a9cubd68OWyX8AIAAHSUYRgyDENOp1OBQKDVT5mwUocD3RdffKGZM2eect7QoUP16quvEugAAEBYbN++XcuXLw89KcLlcunQoUMqKSmRy+XS0KFDtXHjRhUXF2vWrFmqqqrSu+++q+XLl+vll1/WU089pZSUFD322GM644wzdOutt6qsrEyzZ8/W7Nmzw/3yQjoc6E6+e/KpNDQ0dLQEAACwgWDAL6er8+7D1tb1//3vf9czzzyjJ554QvHx8ZKkiooKXXnllbrhhht0yy23SJK6d+8ut9ut66+/XpLUu3dvxcTEKCcnR+np6brnnnuUlJSkmJgYXXLJJZo+fbp69+5t+uvriA4HuoMHD7Y4f9++fR0tAQAAbMDpitXGJy9SwHfM9HW7PD009pZ1rV7e7/dr3rx5WrhwYSjMSVK/fv00c+ZMnXHGGc1+bXp6umpra9W9e3dNmDBB5513nhYuXKhrrrkmtKcv0nQ40B0/flyFhYUaPnz4N+Z98cUX8nq9HS0BAABsIuA7poDf/EDXVp9++qmOHj2qUaNGfWPe9OnT1a9fv2a/dsKECU0+vvvuuzV16lTFxcXpjjvuML1XM3Q40N1888264YYbNHnyZI0bN06JiYk6fPiwPv74Y7311ltavHixGX0CAAC02oEDB5SQkCCn85vPUMjIyGjTuhov9tywYYMMwzjt81zDocNPikhOTtaiRYu0fv16XXvttZo4caKuvfZarV+/Xk899ZSSk5PN6BMAAKDV+vTpo5qaGgWDwW/MO3TokOrr61u9rsrKSg0bNkx1dXVatmyZmW2axpSbxA0cOFCLFy/Wvn37VFFRoX79+ql///5mrBoAAKDNRo8erR49emj79u06//zzm8zbuHGjJk6c2Op1vfHGG7rxxht19tln62c/+5muuOIKJSUl6cCBA/rZz34WWu6pp55S3759zXoJbWLqXX/79+9PkAMAAGEXGxur3//+9/rv//5v/elPfwpdGOHz+WQYRqvvJffxxx9r7NixcrlcOu+88zRx4kQtWLBADz30kPr27avXXnutM19Gq/EYBwAAYBqXp0fErHf8+PHq0aOHHn744dDVqW63W1OnTpUkHTt2TO+9957effddFRcX69VXX1V2draGDBmiqqoq/fWvf9WyZct055136txzz5UkBQIBvf7660pOTtaMGTN05plnmvo624tAh2YVFhZq+fLl+uEPf3jKq5gBADhZMOBv061F2rP+tt7nLisrS1lZWaecFx8fr6lTp+rKK6+Uw+FQIBAIzUtKSlJubq5yc3Ob3HP3gQce0IMPPti+F9CJOnxRBKJXXl6e1q5dq7y8vHC3AhsrLCzU/PnzVVhYGO5WAHSyzrypsBnrr62t1b59+1RbWytJcjgciomJCV216nK5Tnko9uSrWiPxCleJQIcWHDp0qMkUaA/+MAAQKaqqqnT06FFVVVWFuxXTEejQrIqKiiZToD34wwBApGi8hcmpbmVidwQ6NCuaBz6swx8GAND5uCjCZgoKCiyr1XhyaCAQ0NatWy2rm5KSovT0dMvqdUVWjqPGm3fW19czjgA04fP51NDQYFm9k9/Xjh8/blndmJgYeTyezq3RqWuHaRqOVUuScnJyLKs5fvx4ud1u1dTUKDs727K6cXFxKigo4M24EzCOALRH44UAJ1/t2VE+n0+ff/65pUeB4uLi5HK55PV6Lf3D1ul06pxzzmk21DV+XztywQWBziaCPq+kE5dLT5482ZKa99xzj+rq6pSQkKAtW7ZYUrOgoEA5OTmqrKzkjbgTMI4AtIfT6VS3bt20d+9epaamyu12d3idfr9fwWBQgwYNUrdu3Uzo8vQqKyvl8/nUvXt3DRw40JKadXV12rNnj/x+v2Jivhm76uvrtX//fnXr1u2Uz51tLQKdzQwZMkSjR4+2pFbjpdsul8uymrAG4whAWw0aNEgHDhxQSUmJKXvq/H6/Kisr5Xa7FRvbubc7aVRVVaX6+nq53W7V1dVZUvN0r9PhcKh3794dfmQYgc4mXB1I7UAjxhGA9nI6nerXr59SU1NlGEaHQ91nn32mq666Svn5+Ro5cqRJXbbsP/7jP7Rjxw6de+65evjhhy2p2dLrdDgcoX8dRaCziRjniR920bv/qXUHrBmEDb4USU41+Gq07tFzLam5a39k3rAxWjCOAHSUWQHE4XCorq5ODoej1c9V7ahAIKD6+noFAgHLalr1Ogl0NhNsqFPAb9UVQcn/mhoK+I9ZUjFYb80vWFdn5ThyOpL/NWUcAQiv7t27N5lGEwIdmvWvnTmhKdAevbvVq7bepd7d6sPdCoAubs6cOYqPj9eMGTPC3YrpCHRoFm/EMIMnxmgyBYBwGT58uObNmxfuNjoFZ0ijWQmeQJMp0B6xrmCTKQDAfOyhQ7MuzaiWJyaoiwYdDXcrsDHGEQB0PgIdmpXWy6erRx0MdxuwOcYRAHQ+DrkCAADYHIEOAADA5gh0AAAANkegAwAAsLmIuCjC5/NJkoqKitr0dbt375bH45Fr/y45jld1RmsRw1FVJo/Ho137HerWLXrvgl9R7ZDH4wn9bK3AOIo+4RxHa9eu1e7duy2pGS6Nr9XK7y+iT1f5nenI70tjLmrMSS1xGB19uq4JVq5cqdzc3HC3AQAAEHEWLFig6dOnt7hMRAS6qqoq5efnKy0tjb/2AAAAdGLPXHl5ucaNG6ekpKQWl42IQAcAAID246IIAAAAmyPQAQAA2ByBDgAAwOYIdAAAADZHoAMAALA5Ah0AAIDNEegAAABsjkAHAABgcwQ6AEBEMQxDwWBQkhQIBMLcDeyuq4ynmHA3EA1++tOf6vHHH1dsbKzp6zYMQ5MmTdJf/vIXpaenn3KZOXPm6Pbbb9cFF1wg6cSDgIcMGRKan5ubq/Hjx5/2OXAIj/z8fC1evFj79u3TddddJ0mqqanRsmXLNH/+fF100UXNfu3Xf9ZLly7Vzp07df/997erF7/frwMHDigtLU2SVF1drauuukpvvfWWunfv3q51ov3+93//VytWrNC3v/1tVVZW6vnnn9dvfvMb+Xw+vf7661q0aJEGDhzY6vUdOnRIbrdbPXv2POX8jv689+/fr7/85S9KSkpSnz595Pf7NWTIEB05ckQNDQ2nfS0FBQX6n//5H+3atUuPP/64LrroIv31r3/V008/rdmzZ+vmm29WfHx8m/vCCYynKB9PBjqkrKzMuPDCC43333+/02p8+OGHht/vb3b+hg0bjJqamtDHL7zwQpP527ZtMw4cONBp/aHjli9fbvz6179u8rnS0lLjjTfeaPHrvv6z/uc//2l88cUX7e7jH//4h7F+/frQx8Fg0Fi7dm2714eOefXVVw2fz2cYxoltzfjx40Pztm3bZmzbtq1N6/vggw+MsrKyZud35OddUVFhXHXVVUZJSUnoc36/35g1a5axYsWKVr+WgwcPGmPHjjW2b99uGIZhfPTRR8bWrVubrdvW70FXxng6/XiyMw65dtD27dt122236a233urQegzDUENDQ+hjv98f+v+ECRPkdrub/dqxY8eqR48eCgaDevvtt7Vjx44m80eNGqU+ffp0qD9Yq7KyUgMHDpTH45Fx0uOWGxoaQocPvvrqK7322mtNvq5///7KzMxsV83jx4/rsccea/I5h8Ohyy67rF3rQ8f17t272T3/w4YN0+HDh1u9rqqqKj399NMtLtORn/fvf/97TZo0SYMGDQp9zu1269Zbb5XU+teSkpKi22+/Xffee6+OHz+u3bt3Kysrq9m6x44da1e/XRHj6fTjyc445NpBsbGxmjJlip544gn5/f7QAPv000/18ccfa+jQoaqurtasWbNUW1urhQsXaujQoZJOvDlfcsklqqqq0v/5P/9HN954o6ZOnaoHHnhAJSUlysvL06ZNm/Tggw9q0aJFSk1N1UsvvaShQ4eqqqpKBw4c0Le+9S09+OCD+tWvfqV+/fppy5YtKioq0pIlSzRu3Di53W498MADmjp1qqZOnara2lrl5eXpzDPP1L59+zR69Gidc845evHFF/XMM8/o/vvvV11dnd555x3de++90bU72ib8fr82bNigKVOmKDU1VT/+8Y9lGIaef/555ebmyjAM3X777dq4caPKysq0ZMkSDR06VGPGjNGDDz4oh8Oh3/3ud3r77bc1f/58/f73v5ff79f777+v2267Tf3791d9fb2efPJJDRkyRIFAIDSm9u3bp3fffVfFxcWaNWuW3nvvPT388MN67733JElffPGFNm3apAEDBmj37t3KycmR1+vVgw8+qMTERGVnZ6uurk779u3TbbfdFubvpP1dfvnlzc7zeDy69NJL5ff79dxzzykjI0MFBQWaPHmyUlNT9frrr+vss8/W7t271bNnTxmGoYMHD2rFihVKT08/5SkYJ/+8S0pK9MADD2jUqFEaOnSo9u3bp549e+qaa675xtf5/X6tWbNGN9100zfmjRkzRiUlJRo2bNhpX0ujWbNmafny5brjjjv06KOPnu7bhFZiPEX5eArj3kHbKy0tNYqLiw3DMIxbbrnFeO+99wzDMIyamhrjyiuvDB0mnThxolFTU2Pcd999xuuvv24YhmE0NDQYEydODO2ufvTRR43ly5cbhnFi93FOTk6ozm9/+1ujrKzM2Llzp/H444+HPr906VLDMAxj4cKFocNk69evN+68884mfb766quhdT/wwAPGZ599Fpo3d+7c0OHaiRMnGgUFBYZhGMYjjzxirF69uqPfIrTS8uXLjauvvtp44YUXjJ///Oehn61hnBhP1113nVFVVdXk84ZhGJdddlmTj0tLS5v8/GfPnm18+OGHhmEYxksvvWQ8++yzhmEYxlNPPRU6XLt06VLjj3/8o2EYhnHnnXc2OeTauA7DMIzjx48bN9xwgxEMBg3DMIzt27cb999/v2EYhrFu3Trj2muvDX3NxIkT2/mdQHO+flip0eOPP2689dZbhmEYxqFDh4yf//znxurVq0PbmpqaGuNvf/ubYRiGkZOT0+IhMsP4/z9vwzix7fjVr35lGIZh+Hw+Y+rUqaf8moqKCuPss89ucnisPa/lZKtWrTIuuOAC4+DBgy0u9/e//71VNdEU4yn6cMi1A7Zt26b169frpZdeUnJycuiw65YtW9S/f//QYdLVq1erR48eevvttzVhwgRJksvlCp143vhxcxwOhyQpIyNDa9eu1cyZM/X0009r2rRpTeaf7usl6e2339ZZZ50V+rhnz57avHmzJKm+vj609zA2NlbHjx9v3TcCphg0aJCuv/56LVy4MLRn9NChQ+rRo4duu+02/eQnP9HkyZNbXMfXx4LD4dDgwYMlNf2Zvvvuuzr//PMlSddcc43uuOOO065z8+bN6tmzZ+jjs88+OzTmHQ5Hk4t26uvrW/mq0VFr167VkSNH9NFHH2nnzp0aOnSosrKy9OSTT+qGG27QG2+8oe9973utXt/JY8jhcIQOebW0TUhMTJTb7VZ1dfUp5+/fv7/1L0gnTkEpLS3VtGnT9NBDDzWZV11drVWrVoX+bd68+Rsfo/262niKJhxy7YAePXpo6tSpkk6cf/Sd73xHPp9PwWAwdIn01zmdp8/QxknnTJ3s6NGjWrJkib766iutXLlSf/zjHzVv3rxm11NUVKSMjIwmn2s8B+vkWiefu3dysGyuD3Qut9sdOlywadMmTZo0SSkpKerdu7c2b97c5FBCo1P9rBudPOYaf6bBYLDFy/cPHz4swzCUlJQU+lwgEGj12IF1XC6XRowYoVGjRkk6cc5tWVmZ3nzzTW3dulWvvPKKGhoadMMNN4S+pri4WIMHD27V9qg1P9fY2Fh95zvf0YYNG3Teeec1mffPf/5T+/fvV2pqaqtf05tvvqmpU6cqISFB3//+97V+/XpdeOGFkk6cOzVp0qTQsj179tTFF1/c6nWjZV1tPP3sZz/TgQMHJEm/+MUvbH3OMHvo2qmoqKjJm118fLyGDx+ujz76SNnZ2dq3b1/ozW7Pnj0qLy/XxIkTtX79ekkn3lDLy8tDX+/xeEIhcPfu3aesuXv3bq1bt07nn3++fve738nr9X5jmZ49e4YuqDjVXzHf/e539cUXX4R62L9/f+h2J4gc8fHx8vv9KikpUW1trQoKCrRw4UItWrRIR48eDS3XeM5mW/9iveKKK5pcPPPJJ59IkhISEuT3+3Xo0KEmYU2SsrOzdeDAgdA43blzpyZOnNiu1wfzTJ48WRs3bgx9/P7772vTpk0qLi7WhRdeqAcffFB79+6V9P9/vvv372/Vm29bzJs3T2+99ZZKSkqafH7Tpk3feFNuycGDB1VXV6f+/furR48euuuuu3Tfffc1uVAMnaerjaennnpKr732ml577TVbhzmJPXTt8uGHH+qRRx5RRkaGHnnkEcXExGjjxo2qrq7WE088oWAwqHvvvVePPfaYzjnnHLlcLl1xxRXKzc3Vn/70J0kn9pqcfO+eSZMmafHixXrnnXfk9XpVXl6ujz76SPHx8fr888+1bNkyXXLJJdq5c6ekE3tQrr76ahUWFmrjxo06ePCghg0bpqFDhyomJkYrVqzQ+eefr7KyMr3//vtyOBz61re+pf/4j//Qs88+q4qKCu3fv1933nmnevXqpTfffFNVVVVasmSJxo4dq40bN6p379664IIL2nRfIrTdunXr9M4772jv3r166aWXJEm1tbV6++23NXHiRM2ePVvXXHONevTooR49eujWW2/Vr371K2VnZ2vKlCl64YUXNHToUPn9fi1dulSff/65tm7dqpqaGpWUlGjZsmW66qqr9P7776u6ulpffvmlfvKTn+hPf/qTXn31VSUkJISujL3yyiu1dOlSjR49Wj/4wQ/04Ycfas+ePVqyZIlycnJ011136c9//rMGDRqkoqIi3XXXXaqqqtKbb74ZqltRUaGqqiotXrxYP/rRj8L5rY0aq1ev1rZt21RdXa28vDxlZmZqzJgxkqQf/ehHWrRokZYuXapu3bpp1KhROn78uNavX6+9e/dq3759uv766yVJ1157rZYtWxY63P51J/+8L7300tCY+eqrr7RhwwZVVVXpb3/7m6ZMmfKNr+3Xr5+eeuop/eUvf1FiYqL69u0rwzD03e9+t8mbfUuv5ZlnntGrr76q8847L3SyvN/v1+7du/XrX/9as2fPDu1ZQfsxnqJzPDkMjquZovHbeLrz2U42Z84cPfTQQ03OpQNOZhhGm8YUolN9fb1iYmLkcDhCh8tbupVRJGvNazl53J9u2/rJJ59wyLWNGE9te6+2C/bQmSQaBwfCj3EFSU3eoJxOp+mHt6zUmtfy9RPpW9K4Nwatx3iKTvb9KdrcBx98oN27d2vp0qWcGwIA7dQZj1wE7IhDrgAAADbHHjoAAACbI9ABAADYHIEOAADA5gh0AAAANkegAwAAsDkCHQAAgM0R6AAAAGyOQAcAAGBzBDoAAACb+3+eGof+K1FhQgAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 638x600 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "perturbation = \"Negative\"\n",
    "perturb_wheres = [\"LApyr\", \"LAinh\", \"BLApyr\", \"BLAinh\", \"CeL\", \"CeM\"]\n",
    "labels = [r\"LA$_{pyr}$\", r\"LA$_{inh}$\", r\"BLA$_{pyr}$\", r\"BLA$_{inh}$\", \"CeL\", \"CeM\"]\n",
    "fig, axes = plt.subplots(nrows=len(perturb_wheres), ncols=1, sharex=True, figsize=((6.38, 6)))\n",
    "\n",
    "control = pd.read_pickle(f\"data/perturbation_None_None.pkl\")\n",
    "for i, where in enumerate(perturb_wheres):\n",
    "    data = pd.read_pickle(f\"data/perturbation_{perturbation}_{where}.pkl\")\n",
    "    sns.barplot(data=data, x='Perturb During', y='Fear Response', hue=\"Test Context\", ax=axes[i], palette=palette[:2])\n",
    "    sns.barplot(data=control, x='Perturb During', y='Fear Response', hue=\"Test Context\", ax=axes[i], linewidth=1, facecolor=(0,0,0,0), edgecolor=(0,0,0,1), legend=False)\n",
    "    axes[i].set(ylabel=labels[i], yticks=(()), ylim=((0, 1.0)), xlabel=None)\n",
    "\n",
    "for i in range(len(perturb_wheres)-1):\n",
    "    axes[i].get_legend().remove()\n",
    "plt.tight_layout()\n",
    "fig.savefig(f\"plots/inactivation.png\", dpi=600)\n",
    "fig.savefig(f\"plots/inactivation.svg\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "75bc6103",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 638x300 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "perturbation = \"Positive\"\n",
    "perturb_wheres = [\"CeL\", \"CeM\"]\n",
    "labels = [\"CeL\", \"CeM\"]\n",
    "fig, axes = plt.subplots(nrows=len(perturb_wheres), ncols=1, sharex=True, figsize=((6.38, 3)))\n",
    "\n",
    "control = pd.read_pickle(f\"data/perturbation_None_None.pkl\")\n",
    "for i, where in enumerate(perturb_wheres):\n",
    "    data = pd.read_pickle(f\"data/perturbation_{perturbation}_{where}.pkl\")\n",
    "    sns.barplot(data=data, x='Perturb During', y='Fear Response', hue=\"Test Context\", ax=axes[i], palette=palette[:2])\n",
    "    sns.barplot(data=control, x='Perturb During', y='Fear Response', hue=\"Test Context\", ax=axes[i], linewidth=1, facecolor=(0,0,0,0), edgecolor=(0,0,0,1), legend=False)\n",
    "    axes[i].set(ylabel=labels[i], yticks=(()), ylim=((0, 1.0)), xlabel=None)\n",
    "for i in range(len(perturb_wheres)-1):\n",
    "    axes[i].get_legend().remove()\n",
    "plt.tight_layout()\n",
    "fig.savefig(f\"plots/activation.png\", dpi=600)\n",
    "fig.savefig(f\"plots/activation.svg\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7617df4a",
   "metadata": {},
   "source": [
    "## Fear Generalization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "143d08de",
   "metadata": {},
   "outputs": [],
   "source": [
    "def genCS(\n",
    "        seeds=1,\n",
    "        nNeurons=100,\n",
    "        nNeuronsExtCS=300,\n",
    "        nNeuronsExtCTX=500,\n",
    "        dt=1e-3,\n",
    "        nCond=10,\n",
    "        nCS=2,\n",
    "        nCTX=1,\n",
    "        dim_CS=3,\n",
    "        dim_CTX=5,\n",
    "        intercept_CS=0,\n",
    "        intercept_CTX=0,\n",
    "        load=False,\n",
    "        choose_intercepts_method='fixed',\n",
    "        sparsity=0.5,\n",
    "        CSminusSim=0.0,\n",
    "        minSim=-1.0,\n",
    "        compare_empirical=False,\n",
    "    ):\n",
    "\n",
    "    if load:\n",
    "        data = pd.read_pickle(f\"data/genCS_intercept{intercept_CS}_dimCS={dim_CS}_dimCTX={dim_CTX}.pkl\")\n",
    "    else:\n",
    "        rng = np.random.RandomState(seeds)\n",
    "        dfs1 = []\n",
    "        dfs2 = []\n",
    "        columns = [\"seed\", \"Fear Response\", \"Similarity to CS+\"]\n",
    "        for seed in range(seeds):\n",
    "            print(f\"seed={seed}\")\n",
    "            lr1 = rng.uniform(1e-4, 3e-4)\n",
    "            lr2 = rng.uniform(2e-4, 6e-4)\n",
    "            lr3 = rng.uniform(2e-5, 5e-5)\n",
    "#             lr1 = rng.uniform(2e-5, 4e-5)\n",
    "#             lr2 = rng.uniform(2e-4, 6e-4)\n",
    "#             lr3 = rng.uniform(8e-6, 2e-5)\n",
    "            T_BLA_CS = rng.uniform(0.2, 0.4)\n",
    "            T_BLA_CTX = rng.uniform(0.5, 1.0)\n",
    "            if choose_intercepts_method=='fixed':\n",
    "                intCS = intercept_CS\n",
    "                intCTX = intercept_CTX\n",
    "            elif choose_intercepts_method=='sparsity':\n",
    "                intCS = sparsity_to_x_intercept(dim_CS, sparsity)\n",
    "#                 print(f\"sparsity {sparsity}, dimension {dim_CS} => intercept {intCS}\")\n",
    "                intCTX = intercept_CTX\n",
    "#                 intCTX = sparsity_to_x_intercept(dim_CTX, sparsity)                \n",
    "            net = build_network(\n",
    "                seed=seed, lr1=lr1, lr2=lr2, lr3=lr3, T_BLA_CS=T_BLA_CS, T_BLA_CTX=T_BLA_CTX,\n",
    "                intercept_CS=intCS, intercept_CTX=intCTX,\n",
    "                dt=dt, nNeurons=nNeurons, nNeuronsExtCS=nNeuronsExtCS, nNeuronsExtCTX=nNeuronsExtCTX,\n",
    "                nCond=nCond, dim_CS=dim_CS, dim_CTX=dim_CTX, nCTX=nCTX, nCS=10000)\n",
    "            sim = nengo.Simulator(net, dt=dt, progress_bar=False)\n",
    "            CTX = net.inputs.CTXs[0]\n",
    "            CSplus = net.inputs.CSs[0]\n",
    "            similarities = np.dot(CSplus, net.inputs.CSs.T)\n",
    "            CSminus = net.inputs.CSs[np.argmin(np.abs(similarities-CSminusSim))]   \n",
    "#             CSminus = net.inputs.CSs[np.argmin(similarities)]\n",
    "            target_similarities = np.linspace(minSim, 1, nCS)\n",
    "            stims = np.array([CSplus for n in range(nCond)] + [CSminus for n in range(nCond)])\n",
    "            rng.shuffle(stims)\n",
    "            target_similarities2 = np.linspace(CSminusSim, 1, 6)\n",
    "            with sim:\n",
    "                print(\"acquisition\")\n",
    "                net.inputs.stop_learning = 0\n",
    "                net.inputs.CTX = CTX\n",
    "                for p in range(len(stims)):\n",
    "#                     print(f\"pair {p}\")\n",
    "                    net.inputs.CS = stims[p]\n",
    "                    net.inputs.US = 1 if np.all(stims[p]==CSplus) else 0\n",
    "                    sim.run(2)\n",
    "                print(\"testing full range\")\n",
    "                net.inputs.stop_learning = 1\n",
    "                net.inputs.US = 0\n",
    "                for cs in range(nCS):\n",
    "                    target_sim = target_similarities[cs]\n",
    "                    CS = net.inputs.CSs[np.argmin(np.abs(similarities-target_sim))]\n",
    "                    net.inputs.CS = CS\n",
    "                    print(f\"CS* #{cs}, similarity={np.dot(CSplus, CS):.2}\")\n",
    "                    sim.run(2)\n",
    "                    freezing = np.mean(sim.data[net.pCeM][-int(1/dt):])\n",
    "                    similarity = np.dot(CSplus, CS)\n",
    "                    dfs1.append(pd.DataFrame([[int(seed), freezing, np.around(similarity, 3)]], columns=columns))\n",
    "                if compare_empirical:\n",
    "                    target_similarities2 = np.linspace(CSminusSim, 1, 6)\n",
    "                    for cs in range(6):\n",
    "                        target_sim = target_similarities2[cs]\n",
    "                        CS = net.inputs.CSs[np.argmin(np.abs(similarities-target_sim))]\n",
    "                        net.inputs.CS = CS\n",
    "                        print(f\"CS* #{cs} (empirical comparison), similarity={np.dot(CSplus, CS):.2}\")\n",
    "                        sim.run(2)\n",
    "                        freezing = np.mean(sim.data[net.pCeM][-int(1/dt):])\n",
    "                        similarity = np.dot(CSplus, CS)\n",
    "                        dfs2.append(pd.DataFrame([[int(seed), freezing, np.around(similarity, 3)]], columns=columns))\n",
    "\n",
    "    data = pd.concat(dfs1, ignore_index=True)\n",
    "    if choose_intercepts_method=='fixed':\n",
    "        data.to_pickle(f\"data/genCS_intercept{intCS}_dimCS={dim_CS}.pkl\")\n",
    "    elif choose_intercepts_method=='sparsity':\n",
    "        data.to_pickle(f\"data/genCS_sparsity{sparsity}_dimCS={dim_CS}.pkl\")\n",
    "    if compare_empirical:\n",
    "        data_compare_empirical = pd.concat(dfs2, ignore_index=True)\n",
    "        data_compare_empirical.to_pickle(f\"data/genCS_sparsity{sparsity}_dimCS={dim_CS}_compare_empirical.pkl\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f040beeb",
   "metadata": {},
   "source": [
    "### CS Generalization Plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "c4c1e07e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_genCS(sparsities, dim_CS, dim_CTX, xmin=-1, xmax=1.05, ymin=0.3, ymax=1.0):\n",
    "\n",
    "    xs = [2.0, 2.45, 3.05, 3.65, 4.25, 4.7]\n",
    "    xITI = [1.5]\n",
    "    ys_control = [0.06, 0.12, 0.21, 0.58, 1.07, 1.61]\n",
    "    yITI_control = [0.04]\n",
    "    ys_GAD = [0.44, 0.56, 0.72, 1.07, 1.51, 1.68]\n",
    "    yITI_GAD = [0.70]\n",
    "    \n",
    "    def sigmoid(x, L ,x0, k, b):\n",
    "        y = L / (1 + np.exp(-k*(x-x0))) + b\n",
    "        return (y)\n",
    "\n",
    "    p0_control = [max(ys_control), np.median(xs),1,min(ys_control)] # this is an mandatory initial guess\n",
    "    p0_GAD = [max(ys_GAD), np.median(xs),1,min(ys_GAD)] # this is an mandatory initial guess\n",
    "    popt_control, pcov_control = curve_fit(sigmoid, xs, ys_control, p0_control, method='dogbox')\n",
    "    popt_GAD, pcov_GAD = curve_fit(sigmoid, xs, ys_GAD, p0_GAD, method='dogbox')\n",
    "    xs2 = np.linspace(min(xs), max(xs), 1000)\n",
    "    yfit_control = sigmoid(xs2, *popt_control)\n",
    "    yfit_GAD = sigmoid(xs2, *popt_GAD)\n",
    "\n",
    "    fig, axes = plt.subplots(nrows=1, ncols=2, figsize=((6.38, 2)))\n",
    "    sns.scatterplot(x=xs, y=ys_control, ax=axes[0], s=50, label=\"Control\")\n",
    "#     sns.scatterplot(x=xITI, y=yITI_control, ax=axes[0], s=50, color=palette[0], label=None, marker='s')\n",
    "    sns.lineplot(x=xs2, y=yfit_control, ax=axes[0], label=None, color=palette[0])\n",
    "    axes[0].set(xlabel=\"Test Stimulus\", ylabel=\"Risk Ratings\",\n",
    "          ylim=((-0.1, 1.8)), yticks=((0, 0.4, 0.8, 1.2, 1.6)), xticks=(()))\n",
    "    sns.scatterplot(x=xs, y=ys_GAD, ax=axes[0], s=50, label=\"Anxiety Disorder\")\n",
    "#     sns.scatterplot(x=xITI, y=yITI_GAD, ax=axes[0], s=50, color=palette[1], label=None, marker='s')\n",
    "    sns.lineplot(x=xs2, y=yfit_GAD, ax=axes[0], label=None, color=palette[1])\n",
    "    xtickExtra = [r\"CS$^-$\", r\"CS$^1$\", r\"CS$^2$\", r\"CS$^3$\", r\"CS$^4$\", r\"CS$^+$\"]\n",
    "#     xticklabels = ['ITI'] + [xtickExtra[i] for i in range(len(xs))]\n",
    "    xticklabels = [xtickExtra[i] for i in range(len(xs))]\n",
    "    axes[0].set(ylabel=\"Fear Response\", xlabel=\"Test Stimulus\", title=\"Empirical Data\",\n",
    "          ylim=((-0.1, 1.8)), yticks=((0, 0.4, 0.8, 1.2, 1.6)), xticks=xs, xticklabels=xticklabels) #xITI+\n",
    "    axes[0].legend(title=\"Experimental Group\")\n",
    "\n",
    "    for i, sparsity in enumerate(sparsities):\n",
    "        data = pd.read_pickle(f\"data/genCS_sparsity{sparsity}_dimCS={dim_CS}.pkl\")\n",
    "        sns.lineplot(data=data, x='Similarity to CS+', y=\"Fear Response\",\n",
    "            ax=axes[1], color=palette[i])\n",
    "        data_compare_empirical = pd.read_pickle(f\"data/genCS_sparsity{sparsity}_dimCS={dim_CS}_compare_empirical.pkl\")\n",
    "        if sparsity==min(sparsities): label=\"Strong\"\n",
    "        if sparsity==max(sparsities): label=\"Weak\"\n",
    "        X = data_compare_empirical.query(\"seed==0\")['Similarity to CS+'].to_numpy()\n",
    "        Y = data_compare_empirical['Fear Response'].to_numpy().reshape(-1, len(X)).T\n",
    "        sns.scatterplot(x=X, y=np.mean(Y, axis=1), palette=palette[i], s=50, label=label, zorder=2)\n",
    "        xticks = data_compare_empirical.query(\"seed==0\")['Similarity to CS+'].to_numpy()\n",
    "\n",
    "    axes[0].set(xlabel=None, yticks=[])\n",
    "    axes[1].set(xticks=xticks, xlim=((xmin, xmax)),\n",
    "#         xlabel=r'Similarity of CS$^*$ to CS$^+$',\n",
    "        xticklabels=xticklabels,\n",
    "        xlabel=None,\n",
    "        title=\"Model Data\", ylabel=None, yticks=[], ylim=((ymin, ymax)))  # yticks=((0.0, 0.2, 0.4, 0.6, 0.8, 1.0, 1.2)),\n",
    "    axes[1].legend(title=\"Pattern Separation\", loc=\"upper left\")\n",
    "\n",
    "    plt.tight_layout()\n",
    "    fig.savefig(f\"plots/FugreN8.svg\")\n",
    "    fig.savefig(f\"plots/FugreN8.png\", dpi=600)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "2af8145a-06bf-4ae1-8d96-99a76d4ad094",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Peter Duggins\\AppData\\Local\\Temp\\ipykernel_16824\\3129531256.py:47: UserWarning: Ignoring `palette` because no `hue` variable has been assigned.\n",
      "  sns.scatterplot(x=X, y=np.mean(Y, axis=1), palette=palette[i], s=50, label=label, zorder=2)\n",
      "C:\\Users\\Peter Duggins\\AppData\\Local\\Temp\\ipykernel_16824\\3129531256.py:47: UserWarning: Ignoring `palette` because no `hue` variable has been assigned.\n",
      "  sns.scatterplot(x=X, y=np.mean(Y, axis=1), palette=palette[i], s=50, label=label, zorder=2)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 638x200 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sparsities = [0.1, 0.2]\n",
    "seeds = 10\n",
    "nCS = 20\n",
    "dim_CS = 3\n",
    "dim_CTX = 5\n",
    "nNeuronsExtCS = 3000\n",
    "CSminusSim = 0.3\n",
    "minSim = 0.0\n",
    "# for i in sparsities:\n",
    "#     print(f\"sparsity {i}\")\n",
    "#     genCS(seeds=seeds, nCS=nCS, dim_CS=dim_CS, dim_CTX=dim_CTX, nNeuronsExtCS=nNeuronsExtCS,\n",
    "#           sparsity=i, choose_intercepts_method='sparsity', nCond=15,\n",
    "#           minSim=minSim, CSminusSim=CSminusSim, compare_empirical=True)\n",
    "plot_genCS(sparsities, dim_CS, dim_CTX, xmin=minSim, ymin=0.35, ymax=1.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd866878",
   "metadata": {},
   "source": [
    "### Higher Dimensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "3aa40e5f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 638x250 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dimensions = [3, 7, 11]\n",
    "sparsities = [0.15, 0.25, 0.35]\n",
    "seeds = 20\n",
    "nCS = 50\n",
    "dim_CTX = 5\n",
    "nNeuronsExtCS = 3000\n",
    "CSminusSim = -1\n",
    "minSim = -1\n",
    "ymin, ymax = 0.35, 1.1\n",
    "# for d in dimensions:\n",
    "#     for i in sparsities:\n",
    "#         print(f\"dimension {d}, sparsity {i}\")\n",
    "#         genCS(seeds=seeds, nCS=nCS, dim_CS=d, dim_CTX=dim_CTX, nNeuronsExtCS=nNeuronsExtCS,\n",
    "#               sparsity=i, choose_intercepts_method='sparsity',\n",
    "#               minSim=minSim, CSminusSim=CSminusSim)\n",
    "\n",
    "fig, axes = plt.subplots(nrows=1, ncols=len(dimensions), figsize=((6.38, 2.5)), sharey=True)\n",
    "for j, dim_CS in enumerate(dimensions):\n",
    "    for i, sparsity in enumerate(sparsities):\n",
    "        data = pd.read_pickle(f\"data/genCS_sparsity{sparsity}_dimCS={dim_CS}.pkl\")\n",
    "#         label = sparsity\n",
    "        if sparsity==0.15: label=\"Strong\"\n",
    "        if sparsity==0.25: label=\"Moderate\"\n",
    "        if sparsity==0.35: label=\"Weak\"\n",
    "        sns.lineplot(data=data, x='Similarity to CS+', y=\"Fear Response\",\n",
    "            ax=axes[j], color=palette[i], label=label)\n",
    "        axes[j].set(xticks=((-1.0, 0, 1.0)), xlim=((minSim, 1.0)),\n",
    "            xlabel=r\"Similarity of CS$^*$ to CS$^+$\",\n",
    "            title=r\"$D=$\"+str(dim_CS), ylabel=\"Defensive Response\",\n",
    "            yticks=((0.5, 0.75, 1.0)), ylim=((ymin, ymax)))\n",
    "        axes[j].get_legend().remove()\n",
    "\n",
    "# axes[0].legend(title=\"Sparsity\")\n",
    "axes[1].legend(title=\"Pattern Separation\", loc='upper left')\n",
    "# axes[2].legend(title=\"Pattern Separation\", loc=\"center left\", bbox_to_anchor=(1, 0.5))\n",
    "plt.rc('axes', unicode_minus=False)\n",
    "plt.tight_layout()\n",
    "fig.savefig(f\"plots/FigureN7.svg\")\n",
    "fig.savefig(f\"plots/FigureN7.png\", dpi=600)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b0cc5cd",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}