{ "cells": [ { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "*Copyright (C) 2021 Intel Corporation*
\n", "*SPDX-License-Identifier: BSD-3-Clause*
\n", "*See: https://spdx.org/licenses/*\n", "\n", "---\n", "\n", "# Spike-timing Dependent Plasticity (STDP)\n", "\n", "_**Motivation**: In this tutorial, we will demonstrate usage of a software model of Loihi's learning engine, exposed in Lava. This involves the LearningRule object for learning rule and other learning-related information encapsulation and the LearningDense Lava Process modelling learning-enabled connections._\n", "\n", "#### This tutorial assumes that you:\n", "- have the [Lava framework installed](../../in_depth/tutorial01_installing_lava.ipynb \"Tutorial on Installing Lava\")\n", "- are familiar with the [Process concept in Lava](../../in_depth/tutorial02_processes.ipynb \"Tutorial on Processes\")\n", "- are familiar with the [ProcessModel concept in Lava](../../in_depth/tutorial02_process_models.ipynb \"Tutorial on ProcessModels\")\n", "- are familiar with how to [connect Lava Processes](../../in_depth/tutorial05_connect_processes.ipynb \"Tutorial on connecting Processes\")\n", "\n", "This tutorial gives a bird's-eye view of how to make use of the available learning rules in Lavas Process Library. For this purpose, we will create a network of LIF and Dense processes with one plastic connection and generate frozen patterns of activity. We can easily choose between a floating point simulation of the learning engine and a fixed point simulation, which approximates the behavior on the Loihi neuromorphic hardware. We also will create monitors to observe the behavior of the weights and activity traces of the neurons and learning rules." ] }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "## STDP from Lavas Process Library\n", "\n", "Let's first generate the random, frozen input and define all parameters for the network.\n", "\n", "### Parameters" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "import numpy as np\n", "\n", "# Set this tag to \"fixed_pt\" or \"floating_pt\" to choose the corresponding models.\n", "SELECT_TAG = \"floating_pt\"\n", "\n", "# LIF parameters\n", "if SELECT_TAG == \"fixed_pt\":\n", " du = 4095\n", " dv = 4095\n", "elif SELECT_TAG == \"floating_pt\":\n", " du = 1\n", " dv = 1\n", "vth = 240\n", "\n", "# Number of neurons per layer\n", "num_neurons = 1\n", "shape_lif = (num_neurons, )\n", "shape_conn = (num_neurons, num_neurons)\n", "\n", "# Connection parameters\n", "\n", "# SpikePattern -> LIF connection weight\n", "wgt_inp = np.eye(num_neurons) * 250\n", "\n", "# LIF -> LIF connection initial weight (learning-enabled)\n", "wgt_plast_conn = np.full(shape_conn, 50)\n", " \n", "# Number of simulation time steps\n", "num_steps = 200\n", "time = list(range(1, num_steps + 1))\n", "\n", "# Spike times\n", "spike_prob = 0.03\n", "\n", "# Create spike rasters\n", "np.random.seed(123)\n", "spike_raster_pre = np.zeros((num_neurons, num_steps))\n", "np.place(spike_raster_pre, np.random.rand(num_neurons, num_steps) < spike_prob, 1)\n", "\n", "spike_raster_post = np.zeros((num_neurons, num_steps))\n", "np.place(spike_raster_post, np.random.rand(num_neurons, num_steps) < spike_prob, 1)" ] }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "### Define STDP learning rule\n", "\n", "Next, lets instatiate the STDP learning rule from the Lava Process Library. The STDPLoihi learning rule provides the parameters as described in Gerstner and al. 1996 (see also http://www.scholarpedia.org/article/Spike-timing_dependent_plasticity)." ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "from lava.proc.learning_rules.stdp_learning_rule import STDPLoihi" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "stdp = STDPLoihi(learning_rate=1,\n", " A_plus=-1,\n", " A_minus=1,\n", " tau_plus=10,\n", " tau_minus=10,\n", " t_epoch=4)" ] }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "### Create Network\n", "The following diagram depics the Lava Process architecture used in this tutorial. It consists of:\n", "- 2 Constant pattern generators for injection spike trains to LIF neurons.\n", "- 2 _LIF_ Processes representing pre- and post-synaptic Leaky Integrate-and-Fire neurons.\n", "- 1 _Dense_ Process representing learning-enable connection between LIF neurons.\n", "\n", ">**Note:** \n", "All neuronal population (spike generator, LIF) are composed of only 1 neuron in this tutorial." ] }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "\"Architecture.svg\"" ] }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "#### The plastic connection Process\n", "We now instantiate our plastic Dense process. The Dense Process provides the following Vars and Ports relevant for plasticity:\n", "\n", "| Component | Name | Description |\n", "| :- | :- | :- |\n", "| **InPort** | `s_in_bap` | Receives spikes from post-synaptic neurons.\n", "| **Var** | `tag_2` | Delay synaptic variable.\n", "| | `tag_1` | Tag synaptic variable.\n", "| | `x0` | State of $x_0$ dependency.\n", "| | `tx` | Within-epoch spike times of pre-synaptic neurons.\n", "| | `x1` | State of $x_1$ trace.\n", "| | `x2` | State of $x_2$ trace.\n", "| | `y0` | State of $y_0$ dependency.\n", "| | `ty` | Within-epoch spike times of post-synaptic neurons.\n", "| | `y1` | State of $y_1$ trace.\n", "| | `y2` | State of $y_2$ trace.\n", "| | `y3` | State of $y_3$ trace.\n", "\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "pycharm": { "name": "#%%\n" }, "tags": [] }, "outputs": [], "source": [ "from lava.proc.lif.process import LIF\n", "from lava.proc.io.source import RingBuffer\n", "from lava.proc.dense.process import LearningDense, Dense" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "# Create input devices\n", "pattern_pre = RingBuffer(data=spike_raster_pre.astype(int))\n", "pattern_post = RingBuffer(data=spike_raster_post.astype(int))\n", "\n", "# Create input connectivity\n", "conn_inp_pre = Dense(weights=wgt_inp)\n", "conn_inp_post = Dense(weights=wgt_inp)\n", "\n", "# Create pre-synaptic neurons\n", "lif_pre = LIF(u=0,\n", " v=0,\n", " du=du,\n", " dv=du,\n", " bias_mant=0,\n", " bias_exp=0,\n", " vth=vth,\n", " shape=shape_lif,\n", " name='lif_pre')\n", "\n", "# Create plastic connection\n", "plast_conn = LearningDense(weights=wgt_plast_conn,\n", " learning_rule=stdp,\n", " name='plastic_dense')\n", "\n", "# Create post-synaptic neuron\n", "lif_post = LIF(u=0,\n", " v=0,\n", " du=du,\n", " dv=du,\n", " bias_mant=0,\n", " bias_exp=0,\n", " vth=vth,\n", " shape=shape_lif,\n", " name='lif_post')\n", "\n", "# Connect network\n", "pattern_pre.s_out.connect(conn_inp_pre.s_in)\n", "conn_inp_pre.a_out.connect(lif_pre.a_in)\n", "\n", "pattern_post.s_out.connect(conn_inp_post.s_in)\n", "conn_inp_post.a_out.connect(lif_post.a_in)\n", "\n", "lif_pre.s_out.connect(plast_conn.s_in)\n", "plast_conn.a_out.connect(lif_post.a_in)\n", "\n", "# Connect back-propagating actionpotential (BAP)\n", "lif_post.s_out.connect(plast_conn.s_in_bap)" ] }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "### Create monitors to observe traces" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "pycharm": { "name": "#%%\n" }, "tags": [] }, "outputs": [], "source": [ "from lava.proc.monitor.process import Monitor" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "pycharm": { "name": "#%%\n" }, "tags": [] }, "outputs": [], "source": [ "# Create monitors\n", "mon_pre_trace = Monitor()\n", "mon_post_trace = Monitor()\n", "mon_pre_spikes = Monitor()\n", "mon_post_spikes = Monitor()\n", "mon_weight = Monitor()\n", "\n", "# Connect monitors\n", "mon_pre_trace.probe(plast_conn.x1, num_steps)\n", "mon_post_trace.probe(plast_conn.y1, num_steps)\n", "mon_pre_spikes.probe(lif_pre.s_out, num_steps)\n", "mon_post_spikes.probe(lif_post.s_out, num_steps)\n", "mon_weight.probe(plast_conn.weights, num_steps)" ] }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" }, "tags": [] }, "source": [ "### Running" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "from lava.magma.core.run_conditions import RunSteps\n", "from lava.magma.core.run_configs import Loihi2SimCfg" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "# Running\n", "pattern_pre.run(condition=RunSteps(num_steps=num_steps), run_cfg=Loihi2SimCfg(select_tag=SELECT_TAG))" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "# Get data from monitors\n", "pre_trace = mon_pre_trace.get_data()['plastic_dense']['x1']\n", "post_trace = mon_post_trace.get_data()['plastic_dense']['y1']\n", "pre_spikes = mon_pre_spikes.get_data()['lif_pre']['s_out']\n", "post_spikes = mon_post_spikes.get_data()['lif_post']['s_out']\n", "weights = mon_weight.get_data()['plastic_dense']['weights'][:, :, 0]" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "# Stopping\n", "pattern_pre.stop()" ] }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "### Results\n", "\n", "Now, we can take a look at the results of the simulation. " ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "pycharm": { "name": "#%%\n" }, "tags": [] }, "outputs": [], "source": [ "import matplotlib.pyplot as plt" ] }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "#### Plot spike trains" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Plotting pre- and post- spike arrival\n", "def plot_spikes(spikes, legend, colors):\n", " offsets = list(range(1, len(spikes) + 1))\n", " \n", " plt.figure(figsize=(10, 3))\n", " \n", " spikes_plot = plt.eventplot(positions=spikes, \n", " lineoffsets=offsets,\n", " linelength=0.9,\n", " colors=colors)\n", " \n", " plt.title(\"Spike arrival\")\n", " plt.xlabel(\"Time steps\")\n", " plt.ylabel(\"Neurons\")\n", " plt.yticks(ticks=offsets, labels=legend)\n", " \n", " plt.show()\n", "\n", "# Plot spikes\n", "plot_spikes(spikes=[np.where(post_spikes[:, 0])[0], np.where(pre_spikes[:, 0])[0]], \n", " legend=['Post', 'Pre'], \n", " colors=['#370665', '#f14a16'])" ] }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "#### Plot traces" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0kAAACiCAYAAACUEoacAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAvM0lEQVR4nO3deVhVVb8H8O8GmWeQURFRcMCBq5AKmIiSaGaRpuklp+vwSoizmd0UMUUbrMx81SzNUqvXcszUHMACEUGc7ZIoiq+CMyAzHtb9w8u+HJnOQQ6H4ft5nvPIWWvvtX97uZ7D+bH3WlsSQggQERERERERAEBH2wEQERERERE1JEySiIiIiIiIymGSREREREREVA6TJCIiIiIionKYJBEREREREZXDJImIiIiIiKgcJklERERERETlMEkiIiIiIiIqh0kSERERERFROUySiIioViZMmIC2bdvWel9TU9O6Daga3377LSRJwvXr1+vtmJokSRKWLFmi7TCIiJosJklERE3Iv/71L0iShF27dlWo8/T0hCRJiI6OrlDXpk0b+Pr61keIasnPz8eSJUsQExOj7VCIiKgZYZJERNSE9O3bFwAQGxurVJ6Tk4OLFy+iRYsWiIuLU6q7efMmbt68Ke+rqo0bNyIlJeX5Aq5Bfn4+IiMjmSQ9o6CgAO+//762wyAiarJaaDsAIiKqO05OTnB1da2QJMXHx0MIgZEjR1aoK3uvbpKkp6f3fMFSrRkaGmo7BCKiJo1XkoiImpi+ffvizJkzKCgokMvi4uLQpUsXDBkyBCdPnkRpaalSnSRJ8PPzk8u2bt0KLy8vGBkZwdraGqNHj8bNmzeVjlPZnKQHDx5g7NixMDc3h6WlJcaPH49z585BkiR8++23FWK9desWgoODYWpqCltbW8ybNw8KhQIAcP36ddja2gIAIiMjIUmSSnNxLl26hAEDBsDIyAitW7fGsmXLlM4XAMaPH4+WLVuipKSkwv6DBg1Cx44d5feSJGH69OnYvXs3unbtCgMDA3Tp0gUHDx5U2u/GjRt4++230bFjRxgZGcHGxgYjR46sMA+qbH5UbGwsZsyYAVtbW1haWuIf//gHiouLkZWVhXHjxsHKygpWVlZ45513IIRQaqOyfrh16xYmTZoEJycnGBgYwNXVFaGhoSguLgYAlJSUIDIyEu7u7jA0NISNjQ369u2Lw4cPV9ufRETNEa8kERE1MX379sX333+PhIQE9O/fH8DTRMjX1xe+vr7Izs7GxYsX0b17d7muU6dOsLGxAQAsX74cixYtwqhRozB58mTcu3cPa9asQb9+/XDmzBlYWlpWetzS0lIMGzYMp06dQmhoKDp16oQ9e/Zg/PjxlW6vUCgQFBSE3r1745NPPsGRI0ewatUqtG/fHqGhobC1tcW6desQGhqK119/HcOHDwcAOe7KZGZmIiAgAE+ePMG7774LExMTfPXVVzAyMlLabuzYsfjuu+9w6NAhvPLKK0r7Hzt2DBEREUrbx8bGYufOnXj77bdhZmaGL774AiNGjEB6errcb4mJiThx4gRGjx6N1q1b4/r161i3bh369++Py5cvw9jYWKnN8PBwODg4IDIyEidPnsRXX30FS0tLnDhxAm3atEFUVBR+++03fPzxx+jatSvGjRtX5Xnfvn0bvXr1QlZWFqZOnYpOnTrh1q1b+Pnnn5Gfnw99fX0sWbIEK1aswOTJk9GrVy/k5OQgKSkJycnJeOmll6psm4ioWRJERNSkXLp0SQAQH3zwgRBCiJKSEmFiYiK2bNkihBDC3t5erF27VgghRE5OjtDV1RVTpkwRQghx/fp1oaurK5YvX67U5oULF0SLFi2UysePHy9cXFzk97/88osAID7//HO5TKFQiAEDBggAYvPmzUr7AhBLly5VOk6PHj2El5eX/P7evXsCgIiIiFDp3GfNmiUAiISEBLns7t27wsLCQgAQaWlpclytW7cWb775ptL+n376qZAkSVy7dk0uAyD09fVFamqqXHbu3DkBQKxZs0Yuy8/PrxBPfHy8ACC+++47uWzz5s0CgAgKChKlpaVyuY+Pj5AkSUybNk0ue/LkiWjdurXw9/dXavfZPhk3bpzQ0dERiYmJFWIoO4anp6cYOnRohXoiIqqIt9sRETUxnTt3ho2NjTzX6Ny5c8jLy5NXr/P19ZUXb4iPj4dCoZDnI+3cuROlpaUYNWoU7t+/L78cHBzg7u5e6cp4ZQ4ePAg9PT1MmTJFLtPR0UFYWFiV+0ybNk3p/Ysvvohr167V7sQB/Pbbb+jTpw969eoll9na2iIkJERpOx0dHYSEhGDv3r14/PixXL5t2zb4+vrC1dVVafvAwEC0b99eft+9e3eYm5srxVr+alVJSQkePHgANzc3WFpaIjk5uUKskyZNgiRJ8vvevXtDCIFJkybJZbq6uvD29q62T0pLS7F7924MGzYM3t7eFerLjmFpaYlLly7hypUrVbZFRERPMUkiImpiJEmCr6+vPPcoLi4OdnZ2cHNzA6CcJJX9W5YkXblyBUIIuLu7w9bWVun1119/4e7du1Ue98aNG3B0dKxwW1nZcZ9laGgozzkqY2VlhUePHtXuxP8vBnd39wrl5ecYlRk3bhwKCgrk5dJTUlJw+vRpjB07tsK2bdq0qVD2bKwFBQVYvHgxnJ2dYWBggJYtW8LW1hZZWVnIzs6usU0LCwsAgLOzc4Xy6vrk3r17yMnJQdeuXavcBgCWLl2KrKwsdOjQAd26dcP8+fNx/vz5avchImquOCeJiKgJ6tu3L/bt24cLFy7I85HK+Pr6Yv78+bh16xZiY2Ph5OSEdu3aAXh6VUKSJBw4cAC6uroV2q3LB8BW1n598vDwgJeXF7Zu3Ypx48Zh69at0NfXx6hRoypsW1WsotyCCuHh4di8eTNmzZoFHx8fWFhYQJIkjB49usLCEdW1WVm5eGbhhtro168frl69ij179uD333/H119/jc8++wzr16/H5MmTn7t9IqKmhEkSEVETVP55SXFxcZg1a5Zc5+XlBQMDA8TExCAhIQEvv/yyXNe+fXsIIeDq6ooOHTqodUwXFxdER0cjPz9f6WpSampqrc+j/O1oqsZQ2e1kVT3Pady4cZgzZw4yMjKwfft2DB06FFZWVrWK9eeff8b48eOxatUquaywsBBZWVm1ak9Vtra2MDc3x8WLF2vc1traGhMnTsTEiRORm5uLfv36YcmSJUySiIiewdvtiIiaIG9vbxgaGmLbtm24deuW0pUkAwMD9OzZE2vXrkVeXp7S85GGDx8OXV1dREZGVrh6IYTAgwcPqjxmUFAQSkpKsHHjRrmstLQUa9eurfV5lCVbqiYaL7/8Mk6ePIlTp07JZffu3cO2bdsq3X7MmDGQJAkzZ87EtWvX8NZbb9U6Vl1d3Qp9tmbNGnlJc03R0dFBcHAw9u3bh6SkpAr1ZTE9+39namoKNzc3FBUVaTQ+IqLGiFeSiIiaIH19fbzwwgv4888/YWBgAC8vL6V6X19f+YpH+SSpffv2WLZsGRYuXIjr168jODgYZmZmSEtLw65duzB16lTMmzev0mMGBwejV69emDt3LlJTU9GpUyfs3bsXDx8+BKD+VSHg6WIIHh4e+Omnn9ChQwdYW1uja9euVc6/eeedd/D9999j8ODBmDlzprwEuIuLS6Xzb2xtbTF48GDs2LEDlpaWGDp0qNoxlnnllVfw/fffw8LCAh4eHoiPj8eRI0fkJcI1KSoqCr///jv8/f0xdepUdO7cGRkZGdixYwdiY2NhaWkJDw8P9O/fH15eXrC2tkZSUhJ+/vlnTJ8+XePxERE1NkySiIiaqL59++LPP/+Ub68rz8/PD6tWrYKZmRk8PT2V6t5991106NABn332GSIjIwE8XUxg0KBBePXVV6s8nq6uLvbv34+ZM2diy5Yt0NHRweuvv46IiAj4+fnB0NCwVufx9ddfIzw8HLNnz0ZxcTEiIiKqTJIcHR0RHR2N8PBwrFy5EjY2Npg2bRqcnJyUVo0rb9y4cfj1118xatSoCv2kjtWrV0NXVxfbtm1DYWEh/Pz8cOTIEQQFBdW6TVW1atUKCQkJWLRoEbZt24acnBy0atUKQ4YMka/GzZgxA3v37sXvv/+OoqIiuLi4YNmyZZg/f77G4yMiamwkURezQYmIiKqwe/duvP7664iNjYWfn5+2w6lgz549CA4Oxh9//IEXX3xR2+EQEVEDwCSJiIjqTEFBgdLzghQKBQYNGoSkpCRkZmYq1TUUr7zyCv766y+kpqbW6pZAIiJqemp9u11xcTHS0tLQvn17tGjBu/aIiOjpMtgFBQXw8fFBUVERdu7ciRMnTiAqKqrBJUg//vgjzp8/j/3792P16tVMkIiISKb2laT8/HyEh4djy5YtAIC///4b7dq1Q3h4OFq1aoV3331XI4ESEVHDt337dqxatQqpqakoLCyEm5sbQkNDG+TiAJIkwdTUFG+++SbWr1/PP/gREZFM7SRp5syZiIuLw+eff47Bgwfj/PnzaNeuHfbs2YMlS5bgzJkzmoqViIiIiIhI49T+s9nu3bvx008/oU+fPkq3JnTp0gVXr16t0+CIiIiIiIjqm9oPk7137x7s7OwqlOfl5fF+biIiIiIiavTUvpLk7e2N/fv3Izw8HMD/Pxzw66+/ho+PT91GVwdKS0tx+/ZtmJmZMYkjIiIiImrGhBB4/PgxnJycoKNT9fUitZOkqKgoDBkyBJcvX8aTJ0+wevVqXL58GSdOnMDx48efK2hNuH37NpydnbUdBhERERERNRA3b95E69atq6yv1XOSrl69ipUrV+LcuXPIzc1Fz549sWDBAnTr1u25gtWE7OxsWFpa4ubNmzA3N9d2OERERERE9UoIgYISRa32NdLTbVJ3Y+Xk5MDZ2RlZWVmwsLCocrsm/zDZnJwcWFhYIDs7m0kSERERETUrQgi8sT4ep288qtX+3i5W2DHNp8kkSqrmBmrfbpeenl5tfZs2bdRtkoiIiIiINKCgRFHrBAkAkm48QkGJAsb6zetZcmqfbdu2bavNJBWK2l3KIyIiIiIizUl6PxDG+roqbZtfrID3siMajqjhUjtJevZhsSUlJThz5gw+/fRTLF++vM4CIyIiIiKiumOsr9vsrgjVltq95OnpWaHM29sbTk5O+PjjjzF8+PA6CYyIiIiIiEgb1H6YbFU6duyIxMTEumqOiIiIiIhIK9S+kpSTk6P0XgiBjIwMLFmyBO7u7nUWGBERERERkTaonSRZWlpWWLhBCAFnZ2f8+OOPdRYYERERERGRNqidJEVHRyu919HRga2tLdzc3NCiBSeCERERERFR46Z2VuPv76+JOIiIiIiIiBoElZKkvXv3qtzgq6++WutgiIiIiIiItE2lJCk4OFilxiRJUvthsrdu3cKCBQtw4MAB5Ofnw83NDZs3b4a3tzeAp/OdIiIisHHjRmRlZcHPzw/r1q3jIhFERERERKQRKi0BXlpaqtJL3QTp0aNH8PPzg56eHg4cOIDLly9j1apVsLKykrf56KOP8MUXX2D9+vVISEiAiYkJgoKCUFhYqN6ZEhERERERqUCrKy18+OGHcHZ2xubNm+UyV1dX+WchBD7//HO8//77eO211wAA3333Hezt7bF7926MHj263mMmIiIiIqKmrVZJUl5eHo4fP4709HQUFxcr1c2YMUPldvbu3YugoCCMHDkSx48fR6tWrfD2229jypQpAIC0tDRkZmYiMDBQ3sfCwgK9e/dGfHx8pUlSUVERioqK5PfPPteJiIiIiIioOmonSWfOnMHLL7+M/Px85OXlwdraGvfv34exsTHs7OzUSpKuXbuGdevWYc6cOXjvvfeQmJiIGTNmQF9fH+PHj0dmZiYAwN7eXmk/e3t7ue5ZK1asQGRkpLqnRUREREREBEDFOUnlzZ49G8OGDcOjR49gZGSEkydP4saNG/Dy8sInn3yiVlulpaXo2bMnoqKi0KNHD0ydOhVTpkzB+vXr1Q1LtnDhQmRnZ8uvmzdv1rotIiIiIiJqftROks6ePYu5c+dCR0cHurq6KCoqgrOzMz766CO89957arXl6OgIDw8PpbLOnTsjPT0dAODg4AAAuHPnjtI2d+7ckeueZWBgAHNzc6UXERERERGRqtROkvT09KCj83Q3Ozs7OaGxsLBQ+6qNn58fUlJSlMr+/vtvuLi4AHi6iIODgwOOHj0q1+fk5CAhIQE+Pj7qhk5ERERERFQjteck9ejRA4mJiXB3d4e/vz8WL16M+/fv4/vvv0fXrl3Vamv27Nnw9fVFVFQURo0ahVOnTuGrr77CV199BeDpc5dmzZqFZcuWwd3dHa6urli0aBGcnJxUfnYTERERERHVXn6xeo/5qYqRni4kSaqTtjRN7SQpKioKjx8/BgAsX74c48aNQ2hoKNzd3bFp0ya12nrhhRewa9cuLFy4EEuXLoWrqys+//xzhISEyNu88847yMvLw9SpU5GVlYW+ffvi4MGDMDQ0VDd0IiIiIiJSk/eyI3XSzuWlQTDW1+oTiFQmCSGEtoPQpJycHFhYWCA7O5vzk4iIiIioWckvfgKPxYcAqJekCCEwcn08km48qrNYGkKSpGpuoHaUy5YtQ0hIiNJDX4mIiIiIqOmQJAk7pvmgoKRubrUDnt5u11iovXDDjh074ObmBl9fX/zzn//E/fv3NREXERERERFpkSRJMNZvUWevxjIfCajFlaRz587h0qVL2LZtGz755BPMmjULL730EkJCQhAcHAxjY2NNxElERETNhBCiTv96TdSc1dWiC83Nc89JiouLw/bt27Fjxw4UFhYiJyenrmKrE5yTRERE1HgIIfDG+nicrsN5EET0VEOYE6RtquYGat9u9ywTExMYGRlBX18fJSUlz9scERERNWMFJQomSEQa4O1i1ajmBGlbrVLJtLQ0bN++Hdu3b0dKSgr8/f0RGRmJN954o67jIyIiomYq6f1AGOvzSx1RXWhMzyhqCNROkvr06YPExER0794dEydOxJgxY9CqVStNxEZERETNmLG+brO/NYiItEPtT56BAwdi06ZN8PDw0EQ8REREREREWqV2krR8+XJNxEFERERERNQgPPfCDURERERERE0JkyQiIiIiIqJymCQRERERERGVo/acpPT0dDg7O1dYQlAIgZs3b6JNmzZ1FlxTwqeHE1FVuCwrERFRw6J2kuTq6oqMjAzY2dkplT98+BCurq5QKJgIVKagRAGPxYe0HQYRNUDeLlbYMc2HiRIREVEDoXaSJISo9Bd5bm4uDA0N6yQoIqLmJOnGIxSUKPg8GGqw6vNuiPxi/rGViLRP5d/Ic+bMAQBIkoRFixbB2NhYrlMoFEhISMB//Md/1HmATYWRni4uLw3SdhhE1IDkFyvgveyItsMgqpYQAm+sj8fpG4+0HQoRUb1ROUk6c+YMgKcflhcuXIC+vr5cp6+vD09PT8ybN6/uI2wiJEniX4mJiKjRKShRaCVB8naxgpGebr0fl4gIUCNJio6OBgBMnDgRq1evhrm5ucaCIiIiooYn6f1AGOvXT+LCBU2ISJvUvrSxefNmTcRBREREDZyxvi7viiCiZkHtT7q8vDysXLkSR48exd27d1FaWqpUf+3atToLjoiIiIiIqL6pnSRNnjwZx48fx9ixY+Ho6MhL4URERERE1KSonSQdOHAA+/fvh5+fnybiISIiIiIi0ioddXewsrKCtbW1JmIhIiIiIiLSOrWTpA8++ACLFy9Gfn6+JuIhIiIiIiLSKpVut+vRo4fS3KPU1FTY29ujbdu20NPTU9o2OTm5biMkIiIiIiKqRyolScHBwRoOg4iIiIiIqGFQKUmKiIjQdBxEREREREQNgtpzkoiIiIiIiJoytZcAt7KyqvTZSJIkwdDQEG5ubpgwYQImTpxYJwESERERERHVJ7WTpMWLF2P58uUYMmQIevXqBQA4deoUDh48iLCwMKSlpSE0NBRPnjzBlClT6jxgIiIiTRBCoKBEoe0wNM5IT5cPgiciqoHaSVJsbCyWLVuGadOmKZVv2LABv//+O3755Rd0794dX3zxBZMkIiJqFIQQeGN9PE7feKTtUDTO28UKO6b5MFEiIqqG2nOSDh06hMDAwArlAwcOxKFDhwAAL7/8Mq5du6ZWuytXroQkSZg1a5ZcVlhYiLCwMNjY2MDU1BQjRozAnTt31A2ZiIj+jxAC+cVP+Hrm9SCvuFkkSACQdONRs7hiRkT0PNS+kmRtbY19+/Zh9uzZSuX79u2DtbU1ACAvLw9mZmYqt5mYmIgNGzage/fuSuWzZ8/G/v37sWPHDlhYWGD69OkYPnw44uLi1A2biKjZa05XS55H0vuBMNbX1XYYdS6/WAHvZUe0HQYRUaOgdpK0aNEihIaGIjo6Wp6TlJiYiN9++w3r168HABw+fBj+/v4qtZebm4uQkBBs3LgRy5Ytk8uzs7PxzTffYPv27RgwYAAAYPPmzejcuTNOnjyJPn36qBs6EVGzVlCiYIJUA28XK9iY6PNWNCKiZk7tJGnKlCnw8PDAl19+iZ07dwIAOnbsiOPHj8PX1xcAMHfuXJXbCwsLw9ChQxEYGKiUJJ0+fRolJSVKt/Z16tQJbdq0QXx8fJVJUlFREYqKiuT3OTk5ap0fEVFz0FSvljwvLmpARERALZIkAPDz84Ofn99zH/zHH39EcnIyEhMTK9RlZmZCX18flpaWSuX29vbIzMysss0VK1YgMjLyuWMjImrKjPV1Yaxfq18BRERETZ5KvyFzcnJgbm4u/1ydsu1qcvPmTcycOROHDx+GoaGhSvuoYuHChZgzZ478PicnB87OznXWPhERERERNW0qJUlWVlbIyMiAnZ0dLC0tK70VQQgBSZKgUKi2Ys7p06dx9+5d9OzZUy5TKBT4448/8OWXX+LQoUMoLi5GVlaW0tWkO3fuwMHBocp2DQwMYGBgoFIMREREREREz1IpSTp27Ji8cl10dHSdHHjgwIG4cOGCUtnEiRPRqVMnLFiwAM7OztDT08PRo0cxYsQIAEBKSgrS09Ph4+NTJzEQERERERE9S6UkqfxKdaquWlcTMzMzdO3aVanMxMQENjY2cvmkSZMwZ84cWFtbw9zcHOHh4fDx8eHKdkREREREpDFqP0wWAP7880+89dZb8PX1xa1btwAA33//PWJjY+s0uM8++wyvvPIKRowYgX79+sHBwUFeUY+IiIiIiEgT1E6SfvnlFwQFBcHIyAjJycnyctvZ2dmIiop6rmBiYmLw+eefy+8NDQ2xdu1aPHz4EHl5edi5c2e185GIiIiIiIiel9pJ0rJly7B+/Xps3LgRenp6crmfnx+Sk5PrNDgiIiKqe/nFCuQXP1HxpdqCTERETYnaD8lISUlBv379KpRbWFggKyurLmIiIiIiDfJedkTbIRARNWhqX0lycHBAampqhfLY2Fi0a9euToIiIiKiumWkpwtvF6ta7+/tYgUjPd06jIiIqOFS+0rSlClTMHPmTGzatAmSJOH27duIj4/HvHnzsGjRIk3ESERERM9JkiTsmOaDgpLa3T5npKdb6XMSiYiaIrWTpHfffRelpaUYOHAg8vPz0a9fPxgYGGDevHkIDw/XRIxERERUByRJgrG+2r/6iYiaHZU/KdPS0uDq6gpJkvDf//3fmD9/PlJTU5GbmwsPDw+YmppqMk4ioiatPibHcwI+ERGRalROktq3bw8XFxcEBARgwIABCAgIgIeHhyZjIyJqNjiRnoiIqOFQOUk6duwYYmJiEBMTgx9++AHFxcVo166dnDAFBATA3t5ek7ESETUpZRPpk248qtfjcgI+ERFR9SQhhFB3p8LCQpw4cUJOmk6dOoWSkhJ06tQJly5d0kSctZaTkwMLCwtkZ2fD3Nxc2+EQESkRQtR6In1tcQI+ERE1V6rmBrVKksoUFxcjLi4OBw4cwIYNG5CbmwuFomHd884kiYiIiIiIANVzA7WWuCkuLsbJkycRHR2NmJgYJCQkwNnZGf369cOXX34Jf3//5w68rpXlgDk5OVqOhIiIiIiItKksJ6jpOpHKV5IGDBiAhIQEuLq6wt/fHy+++CL8/f3h6Oj4/NFq0L///W84OztrOwwiIiIiImogbt68idatW1dZr3KSpKenB0dHRwQHB6N///7w9/eHjY1NnQWqKaWlpbh9+zbMzMy0cg9+Tk4OnJ2dcfPmTd7upwHsX81jH2sW+1fz2Meaxf7VPPaxZrF/Na8h9bEQAo8fP4aTkxN0dHSq3E7l2+2ysrLw559/IiYmBh9++CHGjBmDDh06wN/fX06abG1t6yT4uqSjo1NtllhfzM3NtT4omjL2r+axjzWL/at57GPNYv9qHvtYs9i/mtdQ+tjCwqLGbVROkkxMTDB48GAMHjwYAPD48WPExsYiOjoaH330EUJCQuDu7o6LFy/WPmIiIiIiIiItq/oaUw1MTExgbW0Na2trWFlZoUWLFvjrr7/qMjYiIiIiIqJ6p/KVpNLSUiQlJSEmJgbR0dGIi4tDXl4eWrVqhYCAAKxduxYBAQGajLVRMjAwQEREBAwMDLQdSpPE/tU89rFmsX81j32sWexfzWMfaxb7V/MaYx+rvHCDubk58vLy4ODggICAAAQEBKB///5o3769pmMkIiIiIiKqNyonSRs2bEBAQAA6dOig6ZiIiIiIiIi0RuUkiYiIiIiIqDmo9cINRERERERETRGTJCIiIiIionKYJGnQ2rVr0bZtWxgaGqJ37944deqUtkNqlFasWIEXXngBZmZmsLOzQ3BwMFJSUpS26d+/PyRJUnpNmzZNSxE3PkuWLKnQf506dZLrCwsLERYWBhsbG5iammLEiBG4c+eOFiNuXNq2bVuhfyVJQlhYGACO39r4448/MGzYMDg5OUGSJOzevVupXgiBxYsXw9HREUZGRggMDMSVK1eUtnn48CFCQkJgbm4OS0tLTJo0Cbm5ufV4Fg1bdX1cUlKCBQsWoFu3bjAxMYGTkxPGjRuH27dvK7VR2dhfuXJlPZ9Jw1TTGJ4wYUKFvit7VmUZjuHq1dTHlX0uS5KEjz/+WN6GY7hqqnw/U+X7Q3p6OoYOHQpjY2PY2dlh/vz5ePLkSX2eSqWYJGnITz/9hDlz5iAiIgLJycnw9PREUFAQ7t69q+3QGp3jx48jLCwMJ0+exOHDh1FSUoJBgwYhLy9PabspU6YgIyNDfn300Udairhx6tKli1L/xcbGynWzZ8/Gvn37sGPHDhw/fhy3b9/G8OHDtRht45KYmKjUt4cPHwYAjBw5Ut6G41c9eXl58PT0xNq1ayut/+ijj/DFF19g/fr1SEhIgImJCYKCglBYWChvExISgkuXLuHw4cP49ddf8ccff2Dq1Kn1dQoNXnV9nJ+fj+TkZCxatAjJycnYuXMnUlJS8Oqrr1bYdunSpUpjOzw8vD7Cb/BqGsMAMHjwYKW+++GHH5TqOYarV1Mfl+/bjIwMbNq0CZIkYcSIEUrbcQxXTpXvZzV9f1AoFBg6dCiKi4tx4sQJbNmyBd9++y0WL16sjVNSJkgjevXqJcLCwuT3CoVCODk5iRUrVmgxqqbh7t27AoA4fvy4XObv7y9mzpypvaAauYiICOHp6VlpXVZWltDT0xM7duyQy/766y8BQMTHx9dThE3LzJkzRfv27UVpaakQguP3eQEQu3btkt+XlpYKBwcH8fHHH8tlWVlZwsDAQPzwww9CCCEuX74sAIjExER5mwMHDghJksStW7fqLfbG4tk+rsypU6cEAHHjxg25zMXFRXz22WeaDa4JqKx/x48fL1577bUq9+EYVo8qY/i1114TAwYMUCrjGFbds9/PVPn+8NtvvwkdHR2RmZkpb7Nu3Tphbm4uioqK6vcEnsErSRpQXFyM06dPIzAwUC7T0dFBYGAg4uPjtRhZ05CdnQ0AsLa2Virftm0bWrZsia5du2LhwoXIz8/XRniN1pUrV+Dk5IR27dohJCQE6enpAIDTp0+jpKREaTx36tQJbdq04XiuheLiYmzduhX/9V//BUmS5HKO37qTlpaGzMxMpTFrYWGB3r17y2M2Pj4elpaW8Pb2lrcJDAyEjo4OEhIS6j3mpiA7OxuSJMHS0lKpfOXKlbCxsUGPHj3w8ccfN4jbaBqLmJgY2NnZoWPHjggNDcWDBw/kOo7hunXnzh3s378fkyZNqlDHMayaZ7+fqfL9IT4+Ht26dYO9vb28TVBQEHJycnDp0qV6jL6iFlo9ehN1//59KBQKpf9wALC3t8f//M//aCmqpqG0tBSzZs2Cn58funbtKpf/53/+J1xcXODk5ITz589jwYIFSElJwc6dO7UYbePRu3dvfPvtt+jYsSMyMjIQGRmJF198ERcvXkRmZib09fUrfPGxt7dHZmamdgJuxHbv3o2srCxMmDBBLuP4rVtl47Kyz+CyuszMTNjZ2SnVt2jRAtbW1hzXtVBYWIgFCxZgzJgxMDc3l8tnzJiBnj17wtraGidOnMDChQuRkZGBTz/9VIvRNg6DBw/G8OHD4erqiqtXr+K9997DkCFDEB8fD11dXY7hOrZlyxaYmZlVuJWcY1g1lX0/U+X7Q2ZmZqWf1WV12sQkiRqVsLAwXLx4UWm+DACle7C7desGR0dHDBw4EFevXkX79u3rO8xGZ8iQIfLP3bt3R+/eveHi4oJ//etfMDIy0mJkTc8333yDIUOGwMnJSS7j+KXGrKSkBKNGjYIQAuvWrVOqmzNnjvxz9+7doa+vj3/84x9YsWIFDAwM6jvURmX06NHyz926dUP37t3Rvn17xMTEYODAgVqMrGnatGkTQkJCYGhoqFTOMayaqr6fNWa83U4DWrZsCV1d3Qqrd9y5cwcODg5aiqrxmz59On799VdER0ejdevW1W7bu3dvAEBqamp9hNbkWFpaokOHDkhNTYWDgwOKi4uRlZWltA3Hs/pu3LiBI0eOYPLkydVux/H7fMrGZXWfwQ4ODhUW0nny5AkePnzIca2GsgTpxo0bOHz4sNJVpMr07t0bT548wfXr1+snwCakXbt2aNmypfy5wDFcd/7880+kpKTU+NkMcAxXpqrvZ6p8f3BwcKj0s7qsTpuYJGmAvr4+vLy8cPToUbmstLQUR48ehY+PjxYja5yEEJg+fTp27dqFY8eOwdXVtcZ9zp49CwBwdHTUcHRNU25uLq5evQpHR0d4eXlBT09PaTynpKQgPT2d41lNmzdvhp2dHYYOHVrtdhy/z8fV1RUODg5KYzYnJwcJCQnymPXx8UFWVhZOnz4tb3Ps2DGUlpbKSSpVryxBunLlCo4cOQIbG5sa9zl79ix0dHQq3CZGNfv3v/+NBw8eyJ8LHMN155tvvoGXlxc8PT1r3JZj+P/V9P1Mle8PPj4+uHDhglLCX/YHFw8Pj/o5kapoddmIJuzHH38UBgYG4ttvvxWXL18WU6dOFZaWlkqrd5BqQkNDhYWFhYiJiREZGRnyKz8/XwghRGpqqli6dKlISkoSaWlpYs+ePaJdu3aiX79+Wo688Zg7d66IiYkRaWlpIi4uTgQGBoqWLVuKu3fvCiGEmDZtmmjTpo04duyYSEpKEj4+PsLHx0fLUTcuCoVCtGnTRixYsECpnOO3dh4/fizOnDkjzpw5IwCITz/9VJw5c0ZeWW3lypXC0tJS7NmzR5w/f1689tprwtXVVRQUFMhtDB48WPTo0UMkJCSI2NhY4e7uLsaMGaOtU2pwquvj4uJi8eqrr4rWrVuLs2fPKn02l61IdeLECfHZZ5+Js2fPiqtXr4qtW7cKW1tbMW7cOC2fWcNQXf8+fvxYzJs3T8THx4u0tDRx5MgR0bNnT+Hu7i4KCwvlNjiGq1fT54QQQmRnZwtjY2Oxbt26CvtzDFevpu9nQtT8/eHJkyeia9euYtCgQeLs2bPi4MGDwtbWVixcuFAbp6SESZIGrVmzRrRp00bo6+uLXr16iZMnT2o7pEYJQKWvzZs3CyGESE9PF/369RPW1tbCwMBAuLm5ifnz54vs7GztBt6IvPnmm8LR0VHo6+uLVq1aiTfffFOkpqbK9QUFBeLtt98WVlZWwtjYWLz++usiIyNDixE3PocOHRIAREpKilI5x2/tREdHV/q5MH78eCHE02XAFy1aJOzt7YWBgYEYOHBghb5/8OCBGDNmjDA1NRXm5uZi4sSJ4vHjx1o4m4apuj5OS0ur8rM5OjpaCCHE6dOnRe/evYWFhYUwNDQUnTt3FlFRUUpf8puz6vo3Pz9fDBo0SNja2go9PT3h4uIipkyZUuEPrRzD1avpc0IIITZs2CCMjIxEVlZWhf05hqtX0/czIVT7/nD9+nUxZMgQYWRkJFq2bCnmzp0rSkpK6vlsKpKEEEJDF6mIiIiIiIgaHc5JIiIiIiIiKodJEhERERERUTlMkoiIiIiIiMphkkRERERERFQOkyQiIiIiIqJymCQRERERERGVwySJiIiIiIioHCZJRERERERE5TBJIiIirZgwYQKCg4O1HQYREVEFLbQdABERNT2SJFVbHxERgdWrV0MIUU8RqSYmJgYBAQF49OgRLC0ttR0OERFpCZMkIiKqcxkZGfLPP/30ExYvXoyUlBS5zNTUFKamptoIjYiIqEa83Y6IiOqcg4OD/LKwsIAkSUplpqamFW6369+/P8LDwzFr1ixYWVnB3t4eGzduRF5eHiZOnAgzMzO4ubnhwIEDSse6ePEihgwZAlNTU9jb22Ps2LG4f/9+lbHduHEDw4YNg5WVFUxMTNClSxf89ttvuH79OgICAgAAVlZWkCQJEyZMAACUlpZixYoVcHV1hZGRETw9PfHzzz/LbcbExECSJOzfvx/du3eHoaEh+vTpg4sXL9Z4XCIianiYJBERUYOxZcsWtGzZEqdOnUJ4eDhCQ0MxcuRI+Pr6Ijk5GYMGDcLYsWORn58PAMjKysKAAQPQo0cPJCUl4eDBg7hz5w5GjRpV5THCwsJQVFSEP/74AxcuXMCHH34IU1NTODs745dffgEApKSkICMjA6tXrwYArFixAt999x3Wr1+PS5cuYfbs2Xjrrbdw/Phxpbbnz5+PVatWITExEba2thg2bBhKSkqqPS4RETU8vN2OiIgaDE9PT7z//vsAgIULF2LlypVo2bIlpkyZAgBYvHgx1q1bh/Pnz6NPnz748ssv0aNHD0RFRcltbNq0Cc7Ozvj777/RoUOHCsdIT0/HiBEj0K1bNwBAu3bt5Dpra2sAgJ2dnTwnqaioCFFRUThy5Ah8fHzkfWJjY7Fhwwb4+/vL+0dEROCll14C8DTha926NXbt2oVRo0ZVe1wiImpYmCQREVGD0b17d/lnXV1d2NjYyEkFANjb2wMA7t69CwA4d+4coqOjK70ic/Xq1UqTpBkzZiA0NBS///47AgMDMWLECKXjPis1NRX5+fly8lOmuLgYPXr0UCorS6KApwlXx44d8ddff9XquEREpD283Y6IiBoMPT09pfeSJCmVla2aV1paCgDIzc3FsGHDcPbsWaXXlStX0K9fv0qPMXnyZFy7dg1jx47FhQsX4O3tjTVr1lQZU25uLgBg//79Sse4fPmy0rykmqh7XCIi0h4mSURE1Gj17NkTly5dQtu2beHm5qb0MjExqXI/Z2dnTJs2DTt37sTcuXOxceNGAIC+vj4AQKFQyNt6eHjAwMAA6enpFY7h7Oys1O7Jkyflnx89eoS///4bnTt3rvG4RETUsDBJIiKiRissLAwPHz7EmDFjkJiYiKtXr+LQoUOYOHGiUqJT3qxZs3Do0CGkpaUhOTkZ0dHRciLj4uICSZLw66+/4t69e8jNzYWZmRnmzZuH2bNnY8uWLbh69SqSk5OxZs0abNmyRantpUuX4ujRo7h48SImTJiAli1byiv4VXdcIiJqWJgkERFRo+Xk5IS4uDgoFAoMGjQI3bp1w6xZs2BpaQkdncp/xSkUCoSFhaFz584YPHgwOnTogH/+858AgFatWiEyMhLvvvsu7O3tMX36dADABx98gEWLFmHFihXyfvv374erq6tS2ytXrsTMmTPh5eWFzMxM7Nu3T+nqVFXHJSKihkUSDe1x50RERI1MTEwMAgIC8OjRI3lVPCIiarx4JYmIiIiIiKgcJklERERERETl8HY7IiIiIiKicngliYiIiIiIqBwmSUREREREROUwSSIiIiIiIiqHSRIREREREVE5TJKIiIiIiIjKYZJERERERERUDpMkIiIiIiKicpgkERERERERlfO/VMmLd7VDD/IAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Plotting trace dynamics\n", " \n", "def plot_time_series(time, time_series, ylabel, title):\n", " plt.figure(figsize=(10, 1))\n", " \n", " plt.step(time, time_series)\n", " \n", " plt.title(title)\n", " plt.xlabel(\"Time steps\")\n", " plt.ylabel(ylabel)\n", " \n", " plt.show()\n", " \n", "# Plotting pre trace dynamics\n", "plot_time_series(time=time, time_series=pre_trace, ylabel=\"Trace value\", title=\"Pre trace\")\n", "# Plotting post trace dynamics\n", "plot_time_series(time=time, time_series=post_trace, ylabel=\"Trace value\", title=\"Post trace\")\n", "# Plotting weight dynamics\n", "plot_time_series(time=time, time_series=weights, ylabel=\"Weight value\", title=\"Weight dynamics\")" ] }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "#### Plot STDP learning window and weight changes" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "def extract_stdp_weight_changes(time, spikes_pre, spikes_post, wgt):\n", " # Compute the weight changes for every weight change event\n", " w_diff = np.zeros(wgt.shape)\n", " w_diff[1:] = np.diff(wgt)\n", "\n", " w_diff_non_zero = np.where(w_diff != 0)\n", " dw = w_diff[w_diff_non_zero].tolist()\n", "\n", " # Find the absolute time of every weight change event\n", " time = np.array(time)\n", " t_non_zero = time[w_diff_non_zero]\n", "\n", " # Compute the difference between post and pre synaptic spike time for every weight change event\n", " spikes_pre = np.array(spikes_pre)\n", " spikes_post = np.array(spikes_post)\n", " dt = []\n", " for i in range(0, len(dw)):\n", " time_stamp = t_non_zero[i]\n", " t_post = (spikes_post[np.where(spikes_post <= time_stamp)])[-1]\n", " t_pre = (spikes_pre[np.where(spikes_pre <= time_stamp)])[-1]\n", " dt.append(t_post-t_pre)\n", "\n", " return np.array(dt), np.array(dw)\n", " \n", "def plot_stdp(time, spikes_pre, spikes_post, wgt, \n", " on_pre_stdp, y1_impulse, y1_tau, \n", " on_post_stdp, x1_impulse, x1_tau):\n", " # Derive weight changes as a function of time differences\n", " diff_t, diff_w = extract_stdp_weight_changes(time, spikes_pre, spikes_post, wgt)\n", " \n", " # Derive learning rule coefficients\n", " on_pre_stdp = eval(str(on_pre_stdp).replace(\"^\", \"**\"))\n", " a_neg = on_pre_stdp * y1_impulse\n", " on_post_stdp = eval(str(on_post_stdp).replace(\"^\", \"**\"))\n", " a_pos = on_post_stdp * x1_impulse\n", " \n", " # Derive x-axis limit (absolute value)\n", " max_abs_dt = np.maximum(np.abs(np.max(diff_t)), np.abs(np.min(diff_t)))\n", " \n", " # Derive x-axis for learning window computation (negative part)\n", " x_neg = np.linspace(-max_abs_dt, 0, 1000)\n", " # Derive learning window (negative part)\n", " w_neg = a_neg * np.exp(x_neg / y1_tau)\n", " \n", " # Derive x-axis for learning window computation (positive part)\n", " x_pos = np.linspace(0, max_abs_dt, 1000)\n", " # Derive learning window (positive part)\n", " w_pos = a_pos * np.exp(- x_pos / x1_tau)\n", " \n", " plt.figure(figsize=(10, 5))\n", " \n", " plt.scatter(diff_t, diff_w, label=\"Weight changes\", color=\"b\")\n", " \n", " plt.plot(x_neg, w_neg, label=\"W-\", color=\"r\")\n", " plt.plot(x_pos, w_pos, label=\"W+\", color=\"g\")\n", " \n", " plt.title(\"STDP weight changes - Learning window\")\n", " plt.xlabel('t_post - t_pre')\n", " plt.ylabel('Weight change')\n", " plt.legend()\n", " plt.grid()\n", " \n", " plt.show()\n", "\n", "# Plot STDP window\n", "plot_stdp(time, np.where(pre_spikes[:, 0]), np.where(post_spikes[:, 0]), weights[:, 0], \n", " stdp.A_plus, stdp.y1_impulse, stdp.tau_plus, \n", " stdp.A_minus, stdp.x1_impulse, stdp.tau_minus)" ] }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "As can be seen, the actual weight changes follow the defined STDP with a certain amout of noise. If the tag is set to `fixed_pt`, the weight changes get more quantized, but still follow the correct trend." ] } ], "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.8.10" }, "vscode": { "interpreter": { "hash": "adaac2fd6fcd86ccecf37a646988a7a33da53e5b6c7446bb18fec9222bbb1862" } } }, "nbformat": 4, "nbformat_minor": 4 }