{ "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", "# Custom Learning Rules\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 develop custom learning rules for Loihi. 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": [ "\n", "## 2. Loihi's learning engine\n", "Loihi provides a programmable learning engine that can evolve synaptic state variables over time as a function of several locally available parameters and the equations relating input terms to output synaptic target variables are called _learning rules_. These learning rule equations are highly configurable but are constrained to a sum of products form.\n", "\n", "#### Epoch-based updates\n", "For efficiency reasons, trace and synaptic variable updates proceed in learning epochs with a length of $t_{epoch}$ time steps. Within an epoch, spike events are recorded but trace and synaptic variable updates are only computed and applied with a slight delay at the end of the epoch. This delayed application will theoretically not have any impact as long as there is only one spike per synapse and per epoch.\n", "\n", "#### Synaptic variables\n", "For each synapse, Loihi's computational model defines a set of three synaptic state variables that can be modified by the learning engine. These are :\n", "- Weight $W$, representing _synaptic efficacy_.\n", "- Delay $D$, representing _synaptic delay_.\n", "- Tag $T$, which is an additional synaptic variable that allows for constructing more complex learning dynamics.\n", "\n", "#### Learning rules\n", "The amount of change by which a target synaptic variable is updated at the end of a learning epoch is given by the learning rule associated with said variable. The rules are specified in sum-of-products form:\n", "\n", "$$Z \\in \\{W, D, T\\}$$\n", "\n", "$$dZ = \\sum_{i = 1}^{N_P} D_i \\cdot \\left[ S_i \\cdot \\prod_{j = 1}^{N_F^i} F_{i, j} \\right]$$\n", "\n", "The learning rule consists in a _sum_ of $N_P$ _products_. Each $i$'th product is composed of a dependency operator $D_i$, a scaling factor $S_i$ and a sub-product of $N_F^i$ factors with $F_{i, j}$ denoting the $j$'th factor of the current product.\n", "\n", "#### Dependencies\n", "Each product is associated with a _dependency_ operator $D_i$ that conditions the evaluation of a product on the presence of a pre- or post-synaptic spike during the past epoch or evaluates a product unconditionally every other epoch. $D_i$ also determines at what time step during an epoch, all trace variables in the associated product are evaluated. The table below lists the various dependency operators and their behavior:\n", "\n", "| Dependency | $t_{eval}$ | Description |\n", "| :- | :- | :- |\n", "| $x_0$ | $t_x$ | Conditioned on at least one pre-synaptic spike during epoch. |\n", "| $y_0$ | $t_y$ | Conditioned on at least one post-synaptic spike during epoch. |\n", "| $u_{\\kappa}$ | $t_{epoch}$ | Unconditionally executed every $\\kappa \\cdot t_{epoch}$ time steps. |\n", "\n", "#### Scaling factors\n", "Each product is also associated with a _scaling factor_ (constant literal) that is given in mantissa/exponent form :\n", "\n", "$$S_i = S_i^{mant} \\cdot 2^{S_i^{exp}}$$\n", "\n", "#### Factors\n", "Furthermore, Loihi provides a set of locally available quantities which can be used in learning rule to derive synaptic variable updates. The table below lists the various types of variables whose value $F_{i, j}$ can assume:\n", "\n", "| Factor | Description |\n", "| :- | :- |\n", "| $$x_0 + C$$ | Pre-synaptic spike. |\n", "| $$x_1(t_{eval}) + C$$ | Pre-synaptic trace $x_1$. |\n", "| $$x_2(t_{eval}) + C$$ | Pre-synaptic trace $x_2$. |\n", "| $$y_0 + C$$ | Post-synaptic spike. |\n", "| $$y_1(t_{eval}) + C$$ | Post-synaptic trace $y_1$. |\n", "| $$y_2(t_{eval}) + C$$ | Post-synaptic trace $y_2$. |\n", "| $$y_3(t_{eval}) + C$$ | Post-synaptic trace $y_3$. |\n", "| $$W + C$$ | Weight synaptic variable $W$. |\n", "| $$D + C$$ | Delay synaptic variable $D$. |\n", "| $$T + C$$ | Tag synaptic variable $T$. |\n", "| $$sgn(W + C)$$ | Sign of $W$. |\n", "| $$sgn(D + C)$$ | Sign of $D$. |\n", "| $$sgn(T + C)$$ | Sign of $T$. |\n", "| $$C$$ | Constant term _(variant 1)_. |\n", "| $$C^{mant} \\cdot 2^{C^{exp}}$$ | Constant term _(variant 2)_. |\n", "\n", "#### Traces\n", "Traces are low-pass filtered versions of spike train that are typically used in online implementations of [Spike-Timing Dependent Plasticity (STDP)](http://www.scholarpedia.org/article/Spike-timing_dependent_plasticity \"Spike-Timing Dependent Plasticity\"). For each synapse, Loihi provides a set of **2 pre-synaptic traces** $\\{x_1, x_2\\}$ and **3 post-synaptic traces** $\\{y_1, y_2, y_3\\}$. The dynamics of an ideal spike trace is given by :\n", "\n", "$$z \\in \\{x_1, x_2, y_1, y_2, y_3\\}$$\n", "\n", "$$z(t) = z(t_{k-1}) \\cdot exp(- \\frac{t-t_{k-1}}{\\tau^z}) + \\xi^z \\cdot \\delta^{z}(t - t_k)$$\n", "\n", "Here, the set $\\{t_k\\}$ are successive spike times at which the trace accumulates the spike impulse value $\\xi^{z}$ while $\\tau^z$ governs the speed of exponential decay between spike events. Finally, $\\delta^z$ denotes the raw spike train associated with the trace $z$.\n", "\n", "#### Example: Basic pair-based STDP\n", "\n", "$$dW = S_1 \\cdot x_0 \\cdot y_1 + S_2 \\cdot y_0 \\cdot x_1$$\n", "\n", "where $S_1 < 0$ and $S_2 > 0$." ] }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "### Create custom learning rule\n" ] }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" }, "tags": [] }, "source": [ "#### Instantiating LearningRule\n", "\n", "Next, we define a learning rule ($dw$) for the _weight_ synaptic variable. The learning rule is first written in string format and passed to the LearningRule object as instantiation argument. This string learning rule will get internally parsed, transformed into and stored as a _ProductSeries_, which is a custom data structure that is particularly well-suited for sum-of-products representation.\n", "\n", "Here, we use the basic pair-based STDP learning rule defined by :\n", "\n", "$$dw = -2 \\cdot x_0 \\cdot y_1 + 2 \\cdot y_0 \\cdot x_1$$\n", "\n", "### Parameters" ] }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "As a reminder, the main function of the LearningRule object is not only to encapsulate learning rules, but also other learning-related such as trace impulse values and decay constants for all of the traces as well as the length of the learning epoch. The following table lists the different fields of the LearningRule class:\n", "\n", "| Field | Python type | Description |\n", "| :- | :- | :- |\n", "| `dw` | ProductSeries | Learning rule targetting the synaptic variable $W$. |\n", "| `dd` | ProductSeries | Learning rule targetting the synaptic variable $D$. |\n", "| `dt` | ProductSeries | Learning rule targetting the synaptic variable $T$. |\n", "| `x1_impulse` | float | Trace impulse value associated with $x_1$ trace. |\n", "| `x1_tau` | int | Trace decay constant associated with $x_1$ trace. |\n", "| `x2_impulse` | float | Trace impulse value associated with $x_2$ trace. |\n", "| `x2_tau` | int | Trace decay constant associated with $x_2$ trace. |\n", "| `y1_impulse` | float | Trace impulse value associated with $y_1$ trace. |\n", "| `y1_tau` | int | Trace decay constant associated with $y_1$ trace. |\n", "| `y2_impulse` | float | Trace impulse value associated with $y_2$ trace. |\n", "| `y2_tau` | int | Trace decay constant associated with $y_2$ trace. |\n", "| `y3_impulse` | float | Trace impulse value associated with $y_3$ trace. |\n", "| `y3_tau` | int | Trace decay constant associated with $y_3$ trace. |\n", "| `t_epoch` | int | Learning epoch length. |" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "from lava.magma.core.learning.learning_rule import Loihi2FLearningRule\n", "\n", "# Learning rule coefficient\n", "on_pre_stdp = -2\n", "on_post_stdp = 2\n", "\n", "learning_rate = 1\n", "\n", "# Trace decay constants\n", "x1_tau = 10\n", "y1_tau = 10\n", "\n", "# Impulses\n", "x1_impulse = 16\n", "y1_impulse = 16\n", "\n", "# Epoch length\n", "t_epoch = 2\n", "\n", "# Define dw as string\n", "dw = f\"{learning_rate} * ({on_pre_stdp}) * x0 * y1 +\" \\\n", " f\"{learning_rate} * {on_post_stdp} * y0 * x1\"" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "# Create custom LearningRule\n", "stdp = Loihi2FLearningRule(dw=dw,\n", " x1_impulse=x1_impulse,\n", " x1_tau=x1_tau,\n", " y1_impulse=y1_impulse,\n", " y1_tau=y1_tau,\n", " t_epoch=t_epoch)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Network parameters" ] }, { "cell_type": "code", "execution_count": 3, "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 = \"fixed_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": [ "### 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": "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\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", " on_pre_stdp, stdp.y1_impulse, stdp.x1_tau, \n", " on_post_stdp, stdp.x1_impulse, stdp.y1_tau)" ] }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "### How to learn more?\n", "\n", "Find out how to use STDP from the Lava ProcessLibrary in the [STDP Tutorial](../../in_depth/tutorial09_custom_learning_rules.ipynb \"Tutorial on custom learning rules\").\n", "\n", "#### Follow the links below for deep-dive tutorials on the concepts in this tutorial:\n", "- [Processes](../../in_depth/tutorial02_processes.ipynb \"Tutorial on Processes\")\n", "- [ProcessModel](../../in_depth/tutorial03_process_models.ipynb \"Tutorial on ProcessModels\")\n", "- [Execution](../../in_depth/tutorial04_execution.ipynb \"Tutorial on Executing Processes\")\n", "- [Connecting Processes](../../in_depth/tutorial05_connect_processes.ipynb \"Tutorial on connecting Processes\")\n", "\n", "If you want to find out more about Lava, have a look at the [Lava documentation](https://lava-nc.org/ \"Lava Documentation\") or dive into the [source code](https://github.com/lava-nc/lava/ \"Lava Source Code\").\n", "\n", "To receive regular updates on the latest developments and releases of the Lava Software Framework please subscribe to the [INRC newsletter](http://eepurl.com/hJCyhb \"INRC Newsletter\")." ] } ], "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" } }, "nbformat": 4, "nbformat_minor": 4 }