From 1a8e9afec0b5e46e25e4f4cb5020002dd0be02d6 Mon Sep 17 00:00:00 2001 From: Philipp Date: Fri, 1 Jul 2022 06:04:32 -0700 Subject: [PATCH 1/5] Added walk through tutorial --- src/lava/proc/monitor/process.py | 35 +- tests/lava/tutorials/test_tutorials.py | 17 +- .../tutorial00_tour_through_lava.ipynb | 1393 +++++++++++++++++ 3 files changed, 1440 insertions(+), 5 deletions(-) create mode 100644 tutorials/end_to_end/tutorial00_tour_through_lava.ipynb diff --git a/src/lava/proc/monitor/process.py b/src/lava/proc/monitor/process.py index 727b43835..dc639a3a4 100644 --- a/src/lava/proc/monitor/process.py +++ b/src/lava/proc/monitor/process.py @@ -1,7 +1,7 @@ -# Copyright (C) 2021-22 Intel Corporation +# Copyright (C) 2021 Intel Corporation # SPDX-License-Identifier: BSD-3-Clause # See: https://spdx.org/licenses/ - +import matplotlib.pyplot as plt from lava.magma.core.process.process import AbstractProcess from lava.magma.core.process.variable import Var from lava.magma.core.process.ports.ports import InPort, OutPort, RefPort @@ -255,3 +255,34 @@ def get_data(self): self.data[target_name[0]][target_name[1]] = data_var.get() return self.data + + def plot(self, ax, target, *args, **kwargs): + """ + Plot the recorded data into subplots. + + Can handle recordings of multiple processes and multiple variables + per process. + Each process will create a separate column in the subplots, each + variable will be plotted in a separate row. + + Parameters + ---------- + ax : matplotlib.Axes + Axes to plot the data into + target: Var or OutPort + The target which should be plotted + *args + Passed to the matplotlib.plot function to customize the plot. + **kwargs + Passed to the matplotlib.plot function to customize the plot. + """ + + # fetch data + data = self.get_data() + # set plot attributes + ax.set_title(target.process.name) + ax.set_xlabel("Time step") + ax.set_ylabel(target.name) + + # plot data + ax.plot(data[target.process.name][target.name], *args, **kwargs) diff --git a/tests/lava/tutorials/test_tutorials.py b/tests/lava/tutorials/test_tutorials.py index 767189d5a..db7e78fcd 100644 --- a/tests/lava/tutorials/test_tutorials.py +++ b/tests/lava/tutorials/test_tutorials.py @@ -16,6 +16,8 @@ import lava import tutorials +from tests.lava.test_utils.utils import Utils + class TestTutorials(unittest.TestCase): """Export notebook, execute to check for errors.""" @@ -181,6 +183,17 @@ def _run_notebook(self, notebook: str, e2e_tutorial: bool = False): finally: os.chdir(cwd) + run_it_tests: bool = Utils.get_bool_env_setting("RUN_IT_TESTS") + + @unittest.skipUnless(run_it_tests, "") + @unittest.skipIf(system_name != "linux", "Tests work on linux") + def test_end_to_end_00_tour_through_lava(self): + """Test tutorial end to end 00 tour through lava.""" + self._run_notebook( + "tutorial00_tour_through_lava.ipynb", + e2e_tutorial=True + ) + @unittest.skipIf(system_name != "linux", "Tests work on linux") def test_end_to_end_01_mnist(self): """Test tutorial end to end 01 mnist.""" @@ -224,9 +237,7 @@ def test_in_depth_05__connect_processes(self): "tutorial05_connect_processes.ipynb" ) - @unittest.skip("Skip until \ - https://github.com/lava-nc/lava/issues/242 is fixed") - # @unittest.skipIf(system_name != "linux", "Tests work on linux") + @unittest.skipIf(system_name != "linux", "Tests work on linux") def test_in_depth_06_hierarchical_processes(self): """Test tutorial in depth hierarchical processes.""" self._run_notebook( diff --git a/tutorials/end_to_end/tutorial00_tour_through_lava.ipynb b/tutorials/end_to_end/tutorial00_tour_through_lava.ipynb new file mode 100644 index 000000000..cfc8e7b7a --- /dev/null +++ b/tutorials/end_to_end/tutorial00_tour_through_lava.ipynb @@ -0,0 +1,1393 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1265089b", + "metadata": {}, + "source": [ + "*Copyright (C) 2022 Intel Corporation*
\n", + "*SPDX-License-Identifier: BSD-3-Clause*
\n", + "*See: https://spdx.org/licenses/*\n", + "\n", + "---" + ] + }, + { + "cell_type": "markdown", + "id": "e0cfa11e", + "metadata": {}, + "source": [ + "# Walk through Lava\n", + "\n", + "Lava is an open-source software library dedicated to the development of algorithms for neuromorphic computation. To that end, Lava provides an easy-to-use Python interface for creating the bits and pieces required for such a neuromorphic algorithm. For easy development, Lava allows to run and test all neuromorphic algorithms on standard von-Neumann hardware like CPU, before they can be deployed on neuromorphic processors such as the Intel Loihi 1/2 processor to leverage their speed and power advantages. Furthermore, Lava is designed to be extensible to custom implementations of neuromorphic behavior and to support new hardware backends.\n", + "\n", + "Lava can fundamentally be used at two different levels: Either by using existing resources which can be used to create complex algorithms while requiring almost no deep neuromorphic knowledge. Or, for custom behavior, Lava can be easily extended with new behavior defined in Python and C.\n", + "\n", + "![lava_overview.png](https://raw.githubusercontent.com/lava-nc/lava-docs/dev/walk-through-tutorial/_static/images/tutorial00/lava_overview.png)\n", + "\n", + "This tutorial gives an high-level overview over the key components of Lava. For illustration, we will use a simple working example: a feed-forward multi-layer LIF network executed locally on CPU.\n", + "In the first section of the tutorial, we will use the internal resources of Lava to construct such a network. In the second section, we will demonstrate how to extend Lava with a custom input generator and in the last part, we will show how to run the complete network on the Loihi 2 processor.\n", + "\n", + "In addition to the core Lava library described in the present tutorial, the following tutorials guide you to use high level functionalities:\n", + "- [lava-dl](https://github.com/lava-nc/lava-dl) for deep learning applications\n", + "- [lava-optimization](https://github.com/lava-nc/lava-optimization) for constraint optimization\n", + "- [lava-dnf](https://github.com/lava-nc/lava-dnf) for Dynamic Neural Fields" + ] + }, + { + "cell_type": "markdown", + "id": "12148cf7", + "metadata": {}, + "source": [ + "# 1. Usage of the Process Library" + ] + }, + { + "cell_type": "markdown", + "id": "8abebf36", + "metadata": {}, + "source": [ + "In this section, we will use a simple 2-layered feed-forward network of LIF neurons executed on CPU as canonical example. \n", + "\n", + "The fundamental building block in the Lava architecture is the `Process`. A `Process` describes a functional group, such as a population of `LIF` neurons, which runs asynchronously and parallel and communicates via `Channels`. A `Process` can take different forms and does not necessarily be a population of neurons, for example it could be a complete network, program code or the interface to a sensor (see figure below).\n", + "\n", + "![process_overview.png](https://raw.githubusercontent.com/lava-nc/lava-docs/dev/walk-through-tutorial/_static/images/tutorial00/proc_overview.png)\n", + "\n", + "For convenience, Lava provides a growing Process Library in which many commonly used `Processes` are publicly available.\n", + "In the first section of this tutorial, we will use the `Processes` of the Process Library to create and execute a multi-layer LIF network. Take a look at the [source code](https://github.com/lava-nc/lava/tree/main/src/lava/proc) to find out what other `Processes` are implemented in the Process Library.\n", + "\n", + "Let's start by importing the classes `LIF` and `Dense` and take a brief look at the docstring." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "6ee5440d", + "metadata": {}, + "outputs": [], + "source": [ + "from lava.proc.lif.process import LIF\n", + "from lava.proc.dense.process import Dense\n", + "\n", + "LIF?" + ] + }, + { + "cell_type": "markdown", + "id": "be1692e1", + "metadata": {}, + "source": [ + "The docstring gives insights about the parameters and internal dynamics of the `LIF` neuron. `Dense` is used to connect to a neuron population in an all-to-all fashion, often implemented as a matrix-vector product.\n", + "\n", + "In the next box, we will create the `Processes` we need to implement a multi-layer LIF (LIF-Dense-LIF) network." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2e94a09b", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "# Create processes\n", + "lif1 = LIF(shape=(3, ), # Number and topological layout of units in the process\n", + " vth=10., # Membrane threshold\n", + " dv=0.1, # Inverse membrane time-constant\n", + " du=0.1, # Inverse synaptic time-constant\n", + " bias_mant=(1.1, 1.2, 1.3), # Bias added to the membrane voltage in every timestep\n", + " name=\"lif1\")\n", + "\n", + "dense = Dense(weights=np.random.rand(2, 3), # Initial value of the weights, chosen randomly\n", + " name='dense')\n", + "\n", + "lif2 = LIF(shape=(2, ), # Number and topological layout of units in the process\n", + " vth=10., # Membrane threshold\n", + " dv=0.1, # Inverse membrane time-constant\n", + " du=0.1, # Inverse synaptic time-constant\n", + " bias_mant=0., # Bias added to the membrane voltage in every timestep\n", + " name='lif2')" + ] + }, + { + "cell_type": "markdown", + "id": "45a58eab", + "metadata": {}, + "source": [ + "As you can see, we can either specify parameters with scalars, then all units share the same initial value for this parameter, or with a tuple (or list, or numpy array) to set the parameter individually per unit.\n", + "\n", + "\n", + "## Processes\n", + "\n", + "Let's investigate the objects we just created. As mentioned before, both, `LIF` and `Dense` are examples of `Processes`, the main building block in Lava.\n", + "\n", + "A `Process` holds three key components (see figure below):\n", + "\n", + "- Input ports\n", + "- Variables\n", + "- Output ports\n", + "\n", + "![process.png](https://raw.githubusercontent.com/lava-nc/lava-docs/dev/walk-through-tutorial/_static/images/tutorial00/proc.png)\n", + "\n", + "The `Vars` are used to store internal states of the `Process` while the `Ports` are used to define the connectivity between the `Processes`. Note that a `Process` only defines the `Vars` and `Ports` but not the behavior. This is done separately in a `ProcessModel`. To separate the interface from the behavioral implementation has the advantage that we can define the behavior of a `Process` for multiple hardware backends using multiple `ProcessModels` without changing the interface. We will get into more detail about `ProcessModels` in the second part of this tutorial.\n", + "\n", + "## Ports and connections\n", + "\n", + "Let's take a look at the `Ports` of the `LIF` and `Dense` processes we just created. The output `Port` of the `LIF` neuron is called `s_out`, which stands for 'spiking' output. The input `Port` is called `a_in` which stands for 'activation' input." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f476f8cc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['s_out']" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lif1.out_ports.member_names" + ] + }, + { + "cell_type": "markdown", + "id": "30a90be3", + "metadata": {}, + "source": [ + "For example, we can see the size of the `Port` which is in particular important because `Ports` can only connect if their shape matches." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "dbc3f741", + "metadata": {}, + "outputs": [], + "source": [ + "assert(lif1.s_out.size == dense.s_in.size)" + ] + }, + { + "cell_type": "markdown", + "id": "1c614760", + "metadata": {}, + "source": [ + "Similarly we can investigate the input port of the second `LIF` population." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "33bb42a7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['a_in']" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lif2.in_ports.member_names" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2ad63b37", + "metadata": {}, + "outputs": [], + "source": [ + "assert(dense.a_out.size == lif2.a_in.size)" + ] + }, + { + "cell_type": "markdown", + "id": "3018b179", + "metadata": {}, + "source": [ + "Now that we know about the input and output `Ports` of the `LIF` and `Dense` `Processes`, we can `connect` the network to complete the LIF-Dense-LIF structure.\n", + "\n", + "![process_comm.png](https://raw.githubusercontent.com/lava-nc/lava-docs/dev/walk-through-tutorial/_static/images/tutorial00/procs.png)\n", + "\n", + "As can be seen in the figure above, by `connecting` two processes, a `Channel` between them is created which means that messages between those two `Processes` can be exchanged." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "409b21ed", + "metadata": {}, + "outputs": [], + "source": [ + "# Connect the OutPort of lif1 to the InPort of dense\n", + "lif1.s_out.connect(dense.s_in)\n", + "\n", + "# Connect the OutPort of dense to the InPort of lif2\n", + "dense.a_out.connect(lif2.a_in)" + ] + }, + { + "cell_type": "markdown", + "id": "faa73547", + "metadata": {}, + "source": [ + "## Variables\n", + "\n", + "Similar to the `Ports`, we can investigate the `Vars` of a `Process`." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "ea4ee4ed", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['bias_exp', 'bias_mant', 'du', 'dv', 'u', 'v', 'vth']" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lif1.vars.member_names" + ] + }, + { + "cell_type": "markdown", + "id": "9ce2c0d6", + "metadata": {}, + "source": [ + "`Vars` are also accessible as member variables. We can print details of a specific `Var` to see the shape, initial value and current value. The `shareable` attribute controls whether a `Var` can be manipulated via remote memory access. Learn more about about this topic in the [remote memory access tutorial](https://github.com/lava-nc/lava/blob/main/tutorials/in_depth/tutorial07_remote_memory_access.ipynb)." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "e68943ad", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Variable: v\n", + " shape: (3,)\n", + " init: 0\n", + " shareable: True\n", + " value: 0" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lif1.v" + ] + }, + { + "cell_type": "markdown", + "id": "faf4ba3d", + "metadata": {}, + "source": [ + "We can take a look at the random weights of `Dense` by calling the `get` function." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "8f2f2a1a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.66292967, 0.18802606, 0.28720164],\n", + " [0.45640435, 0.69629743, 0.98676216]])" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dense.weights.get()" + ] + }, + { + "cell_type": "markdown", + "id": "92390d22", + "metadata": {}, + "source": [ + "
\n", + "Note: There is also a `set` function available to change the value of a `Var` after the network was executed.\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "5c00edda", + "metadata": {}, + "source": [ + "## Record internal Vars over time\n", + "\n", + "In order to record the evolution of the internal `Vars` over time, we need a `Monitor`.\n", + "For this example, we want to record the membrane potential of both `LIF` Processes, hence we need two `Monitors`." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b57f514c", + "metadata": {}, + "outputs": [], + "source": [ + "from lava.proc.monitor.process import Monitor\n", + "\n", + "monitor_lif1 = Monitor()\n", + "monitor_lif2 = Monitor()" + ] + }, + { + "cell_type": "markdown", + "id": "627e772a", + "metadata": {}, + "source": [ + "We can define the `Var` that a `Monitor` should record, as well as the recording duration, using the `probe` function." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "d0fc7bcd", + "metadata": {}, + "outputs": [], + "source": [ + "num_steps = 100\n", + "\n", + "monitor_lif1.probe(lif1.v, num_steps)\n", + "monitor_lif2.probe(lif2.v, num_steps)" + ] + }, + { + "cell_type": "markdown", + "id": "80969e97", + "metadata": {}, + "source": [ + "
\n", + "Note: Currently, the `Monitor` can only record a single `Var` per `Process` and supports only CPU. This functionality will be extended in future releases.\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "7ce1e7a3", + "metadata": {}, + "source": [ + "## Execution\n", + "\n", + "Now, that we finished to set up the network and recording `Processes`, we can execute the network by simply calling the `run` function of one of the `Processes`.\n", + "\n", + "The `run` function requires two parameters, a `RunCondition` and a `RunConfig`. The `RunCondition` defines *how* the network runs (i.e. for how long) while the `RunConfig` defines on which hardware backend the `Processes` should be mapped and executed." + ] + }, + { + "cell_type": "markdown", + "id": "ebfe7eb2", + "metadata": {}, + "source": [ + "### Run Conditions\n", + "\n", + "Let's investigate the different possibilities for `RunConditions`. One option is `RunContinuous` which executes the network continuously and non-blocking until `pause` or `stop` is called." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "4ddf6616", + "metadata": {}, + "outputs": [], + "source": [ + "from lava.magma.core.run_conditions import RunContinuous\n", + "run_condition = RunContinuous()" + ] + }, + { + "cell_type": "markdown", + "id": "e95ddfb4", + "metadata": {}, + "source": [ + "The second option is `RunSteps`, which allows you to define an exact amount of time steps the network should run." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "9417aed5", + "metadata": {}, + "outputs": [], + "source": [ + "from lava.magma.core.run_conditions import RunSteps, RunContinuous\n", + "\n", + "run_condition = RunSteps(num_steps=num_steps)" + ] + }, + { + "cell_type": "markdown", + "id": "6dc5e348", + "metadata": {}, + "source": [ + "For this example. we will use `RunSteps` and let the network run exactly `num_steps` time steps.\n", + "\n", + "### RunConfigs\n", + "\n", + "Next, we need to provide a `RunConfig`. As mentioned above, The `RunConfig` defines on which hardware backend the network is executed.\n", + "\n", + "For example, we could run the network on the Loihi1 processor using the `Loihi1HwCfg`, on Loihi2 using the `Loihi2HwCfg`, or on CPU using the `Loihi1SimCfg`. The compiler and runtime then automatically select the correct `ProcessModels` such that the `RunConfig` can be fulfilled.\n", + "\n", + "For this section of the tutorial, we will run our network on CPU, later we will show how to run the same network on the Loihi2 processor." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "85197548", + "metadata": {}, + "outputs": [], + "source": [ + "from lava.magma.core.run_configs import Loihi1SimCfg\n", + "\n", + "run_cfg = Loihi1SimCfg()" + ] + }, + { + "cell_type": "markdown", + "id": "df31fcdb", + "metadata": {}, + "source": [ + "### Execute\n", + "\n", + "Finally, we can simply call the `run` function of the second `LIF` process and provide the `RunConfig` and `RunCondition`." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "585bb35b", + "metadata": {}, + "outputs": [], + "source": [ + "lif2.run(condition=run_condition, run_cfg=run_cfg)" + ] + }, + { + "cell_type": "markdown", + "id": "12f01dac", + "metadata": {}, + "source": [ + "## Retrieve recorded data\n", + "\n", + "After the simulation has stopped, we can call `get_data` on the two monitors to retrieve the recorded membrane potentials." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "14b873b7", + "metadata": {}, + "outputs": [], + "source": [ + "data_lif1 = monitor_lif1.get_data()\n", + "data_lif2 = monitor_lif2.get_data()" + ] + }, + { + "cell_type": "markdown", + "id": "8740f2cd", + "metadata": {}, + "source": [ + "Alternatively, we can also use the provided `plot` functionality of the `Monitor`, to plot the recorded data. As we can see, the bias of the first `LIF` population drives the membrane potential to the threshold which generates output spikes. Those output spikes are passed through the `Dense` layer as input to the second `LIF` population." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "38ab3229", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib\n", + "%matplotlib inline\n", + "from matplotlib import pyplot as plt\n", + "\n", + "# Create a subplot for each monitor\n", + "fig = plt.figure(figsize=(16, 5))\n", + "ax0 = fig.add_subplot(121)\n", + "ax1 = fig.add_subplot(122)\n", + "\n", + "# Plot the recorded data\n", + "monitor_lif1.plot(ax0, lif1.v)\n", + "monitor_lif2.plot(ax1, lif2.v)" + ] + }, + { + "cell_type": "markdown", + "id": "05ff8e16", + "metadata": { + "scrolled": true + }, + "source": [ + "As a last step we can stop the runtime by calling the `stop` function. `Stop` will terminate the `Runtime` and all states will be lost." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "272c164e", + "metadata": {}, + "outputs": [], + "source": [ + "lif2.stop()" + ] + }, + { + "cell_type": "markdown", + "id": "22201c5a", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "- There are many tools available in the Process Library to construct basic networks\n", + "- The fundamental building block in Lava is the `Process`\n", + "- Each `Process` consists of `Vars` and `Ports`\n", + "- A `Process` defines a common interface across hardware backends, but not the behavior\n", + "- The `ProcessModel` defines the behavior of a `Process` for a specific hardware backend\n", + "- `Vars` store internal states, `Ports` are used to implement communication channels between processes\n", + "- The `RunConfig` defines on which hardware backend the network runs " + ] + }, + { + "cell_type": "markdown", + "id": "b49bdf84", + "metadata": {}, + "source": [ + "## Learn more about\n", + "- [Processes](https://github.com/lava-nc/lava/blob/main/tutorials/in_depth/tutorial02_processes.ipynb) and [hierarchical Processes](https://github.com/lava-nc/lava/blob/main/tutorials/in_depth/tutorial06_hierarchical_processes.ipynb)\n", + "- [Possible connectivity patterns](https://github.com/lava-nc/lava/blob/main/tutorials/in_depth/tutorial05_connect_processes.ipynb)\n", + "- [Remote memory access](https://github.com/lava-nc/lava/blob/main/tutorials/in_depth/tutorial07_remote_memory_access.ipynb)\n", + "- [Execution](https://github.com/lava-nc/lava/blob/main/tutorials/in_depth/tutorial04_execution.ipynb)\n", + "- Data handling and visualization (coming soon)" + ] + }, + { + "cell_type": "markdown", + "id": "2979fbf3", + "metadata": {}, + "source": [ + "# 2. Create a custom Process\n", + "\n", + "In the previous section of this tutorial, we used `Processes` which were available in the Process Library. In many cases, this might be sufficient and the Process Library is constantly growing. Nevertheless, the Process Library can not cover all use-cases. Hence, Lava makes it very easy to create new `Processes`. In the following section, we want to show how to implement a custom `Process` and the corresponding behavior using a `ProcessModel`.\n", + "\n", + "The example of the previous section implemented a bias driven LIF-Dense-LIF network. One crucial aspect which is missing this example, is the input/output interaction with sensors and actuators. Commonly used sensors would be Dynamic Vision Sensors or artificial cochleas, but for demonstration purposes we will implement a simple `SpikeGenerator`. The purpose of the `SpikeGenerator` is to output random spikes to drive the LIF-Dense-LIF network. \n", + "\n", + "Let's start by importing the necessary classes from Lava." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "136d0cc5", + "metadata": {}, + "outputs": [], + "source": [ + "from lava.magma.core.process.process import AbstractProcess\n", + "from lava.magma.core.process.variable import Var\n", + "from lava.magma.core.process.ports.ports import OutPort" + ] + }, + { + "cell_type": "markdown", + "id": "fd47594e", + "metadata": {}, + "source": [ + "All `Processes` in Lava inherit from a common base class called `AbstractProcess`. Additionally, we need `Var` for storing the spike probability and `OutPort` to define the output connections for our `SpikeGenerator`." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "509a699c", + "metadata": {}, + "outputs": [], + "source": [ + "class SpikeGenerator(AbstractProcess):\n", + " \"\"\"Spike generator process provides spikes to subsequent Processes.\n", + "\n", + " Parameters\n", + " ----------\n", + " shape: tuple\n", + " defines the dimensionality of the generated spikes per timestep\n", + " spike_prob: int\n", + " spike probability in percent\n", + " \"\"\"\n", + " def __init__(self, shape: tuple, spike_prob: int) -> None: \n", + " super().__init__()\n", + " self.spike_prob = Var(shape=(1, ), init=spike_prob)\n", + " self.s_out = OutPort(shape=shape)\n" + ] + }, + { + "cell_type": "markdown", + "id": "d254bb0f", + "metadata": {}, + "source": [ + "The constructor of `Var` requires the shape of the data to be stored and some initial value. We use this functionality to store the spike data. Similarly, we define an `OutPort` for our `SpikeGenerator`. " + ] + }, + { + "cell_type": "markdown", + "id": "619bf2d2", + "metadata": {}, + "source": [ + "## Create a new ProcessModel \n", + "As mentioned earlier, the `Process` only defines the interface but not the behavior of the `SpikeGenerator`. We will do that in a separate `ProcessModel` which has the advantage that we can define the behavior of a `Process` on different hardware backends without changing the interface (see figure below). More details about the different kinds of `ProcessModels` can be found in the dedicated in-depth tutorials ([here](https://github.com/lava-nc/lava/blob/main/tutorials/in_depth/tutorial03_process_models.ipynb) and [here](https://github.com/lava-nc/lava/blob/main/tutorials/in_depth/tutorial06_hierarchical_processes.ipynb)). Lava automatically selects the correct `ProcessModel` for each `Process` given the `RunConfig`.\n", + "\n", + "![process_models.png](https://raw.githubusercontent.com/lava-nc/lava-docs/dev/walk-through-tutorial/_static/images/tutorial00/proc_models.png)\n", + "\n", + "So, let's go ahead and define the behavior of the `SpikeGenerator` on a CPU in Python. Later in this tutorial we will show how to implement the same behavior on an embedded CPU in C and how to implement the behavior of a `LIF` process on a Loihi2 neuro-core.\n", + "\n", + "We first import all necessary classes from Lava." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "fbf1cf57", + "metadata": {}, + "outputs": [], + "source": [ + "from lava.magma.core.model.py.model import PyLoihiProcessModel\n", + "from lava.magma.core.resources import CPU\n", + "from lava.magma.core.decorator import implements, requires\n", + "from lava.magma.core.sync.protocols.loihi_protocol import LoihiProtocol\n", + "from lava.magma.core.model.py.type import LavaPyType\n", + "from lava.magma.core.model.py.ports import PyOutPort" + ] + }, + { + "cell_type": "markdown", + "id": "c1a55779", + "metadata": {}, + "source": [ + "All `ProcessModels` defined to run on CPU are written in Python and inherit from the common class called `PyLoihiProcessModel`. Further, we use the decorators `requires` and `implements` to define which computational resources (i.e. CPU, GPU, Loihi1NeuroCore, Loihi2NeuroCore) are required to execute this `ProcessModel` and which `Process` it implements. Finally, we need to specify the types of `Vars` and `Ports` in our `SpikeGenerator` using `LavaPyType` and `PyOutPort`.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "6414e76d", + "metadata": {}, + "source": [ + "
\n", + "Note: It is important to mention that the `ProcessModel` needs to implement the exact same Vars and Ports of the parent process using the same class attribute names.\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "8fdde5af", + "metadata": {}, + "source": [ + "Additionally, we define that our `PySpikeGeneratorModel` follows the `LoihiProtocol`. The `LoihiProtocol` defines that the execution of a model follows a specific sequence of phases. For example, there is the *spiking phase* (`run_spk`) in which input spikes are received, internal `Vars` are updated and output spikes are sent. There are other phases such as the *learning phase* (`run_lrn`) in which online learning takes place, or the *post management phase* (`run_post_mgmt`) in which memory content is updated. As the `SpikeGenerator` basically just sends out spikes, the correct place to implement its behavior is the `run_spk` phase. \n", + "\n", + "To implement the behavior, we need to have access to the global simulation time. We can easily access the simulation time with `self.time_step` and use that to index the `spike_data` and send out the corresponding spikes through the `OutPort`." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "55f94342", + "metadata": {}, + "outputs": [], + "source": [ + "@implements(proc=SpikeGenerator, protocol=LoihiProtocol)\n", + "@requires(CPU)\n", + "class PySpikeGeneratorModel(PyLoihiProcessModel):\n", + " \"\"\"Spike Generator process model.\"\"\"\n", + " spike_prob: int = LavaPyType(int, int)\n", + " s_out: PyOutPort = LavaPyType(PyOutPort.VEC_DENSE, float)\n", + "\n", + " def run_spk(self) -> None:\n", + " # Generate random spike data\n", + " spike_data = np.random.choice([0, 1], p=[1 - self.spike_prob/100, self.spike_prob/100], size=self.s_out.shape[0])\n", + " \n", + " # Send spikes\n", + " self.s_out.send(spike_data)" + ] + }, + { + "cell_type": "markdown", + "id": "b3953ac9", + "metadata": {}, + "source": [ + "
\n", + "Note: For the `SpikeGenerator` we only needed an `OutPort` which provides the `send` function to send data. For the `InPort` the corresponding function to receive data is called `recv`.\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "29150f57", + "metadata": {}, + "source": [ + "Next, we want to redefine our network as in the example before with the exception that we turn off all biases." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "db505395", + "metadata": {}, + "outputs": [], + "source": [ + "# Create processes\n", + "lif1 = LIF(shape=(3, ), # Number of units in this process\n", + " vth=10., # Membrane threshold\n", + " dv=0.1, # Inverse membrane time-constant\n", + " du=0.1, # Inverse synaptic time-constant\n", + " bias_mant=0., # Bias added to the membrane voltage in every timestep\n", + " name=\"lif1\")\n", + "\n", + "dense = Dense(weights=np.random.rand(2, 3), # Initial value of the weights, chosen randomly\n", + " name='dense')\n", + "\n", + "lif2 = LIF(shape=(2, ), # Number of units in this process\n", + " vth=10., # Membrane threshold\n", + " dv=0.1, # Inverse membrane time-constant\n", + " du=0.1, # Inverse synaptic time-constant\n", + " bias_mant=0., # Bias added to the membrane voltage in every timestep\n", + " name='lif2')\n", + "\n", + "# Connect the OutPort of lif1 to the InPort of dense\n", + "lif1.s_out.connect(dense.s_in)\n", + "\n", + "# Connect the OutPort of dense to the InPort of lif2\n", + "dense.a_out.connect(lif2.a_in)\n", + "\n", + "# Create Monitors to record membrane potentials\n", + "monitor_lif1 = Monitor()\n", + "monitor_lif2 = Monitor()\n", + "\n", + "# Probe membrane potentials from the two LIF populations\n", + "monitor_lif1.probe(lif1.v, num_steps)\n", + "monitor_lif2.probe(lif2.v, num_steps)" + ] + }, + { + "cell_type": "markdown", + "id": "ec9d9ebc", + "metadata": {}, + "source": [ + "## Use the custom SpikeGenerator\n", + "\n", + "We instantiate the `SpikeGenerator` as usual with the shape of the fist `LIF` population.\n", + "\n", + "To define the connectivity between the `SpikeGenerator` and the first `LIF` population, we us another `Dense` Layer.\n", + "Now, we can connect its `OutPort` to the `InPort` of the `Dense` layer and the `OutPort` of the `Dense` layer to the `InPort` of the first `LIF` population.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "6a31ced5", + "metadata": {}, + "outputs": [], + "source": [ + "# Instantiate SpikeGenerator\n", + "spike_gen = SpikeGenerator(shape=(lif1.a_in.shape[0], ), spike_prob=7)\n", + "\n", + "# Instantiate Dense\n", + "dense_input = Dense(weights=np.eye(lif1.a_in.shape[0])) # one-to-one connectivity\n", + "\n", + "# Connect spike_gen to dense_input\n", + "spike_gen.s_out.connect(dense_input.s_in)\n", + "\n", + "# Connect dense_input to LIF1 population\n", + "dense_input.a_out.connect(lif1.a_in)" + ] + }, + { + "cell_type": "markdown", + "id": "5ed3693c", + "metadata": {}, + "source": [ + "## Execute and plot\n", + "\n", + "Now that our network is complete, we can execute it the same way as before using the `RunCondition` and `RunConfig` we created in the previous example." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "6f5e0200", + "metadata": {}, + "outputs": [], + "source": [ + "lif2.run(condition=run_condition, run_cfg=run_cfg)" + ] + }, + { + "cell_type": "markdown", + "id": "dec690f3", + "metadata": {}, + "source": [ + "And now, we can retrieve the recorded data and plot the membrane potentials of the two `LIF` populations." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "864b76ee", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Create a subplot for each monitor\n", + "fig = plt.figure(figsize=(16, 5))\n", + "ax0 = fig.add_subplot(121)\n", + "ax1 = fig.add_subplot(122)\n", + "\n", + "# Plot the recorded data\n", + "monitor_lif1.plot(ax0, lif1.v)\n", + "monitor_lif2.plot(ax1, lif2.v)" + ] + }, + { + "cell_type": "markdown", + "id": "b887a813", + "metadata": {}, + "source": [ + "As we can see, the spikes provided by the `SpikeGenerator` are sucessfully sent to the first `LIF` population. which in turn sends its output spikes to the second `LIF` population." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "86f23f5b", + "metadata": {}, + "outputs": [], + "source": [ + "lif2.stop()" + ] + }, + { + "cell_type": "markdown", + "id": "db2d5158", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "- Define custom a `Process` by inheritance from `AbstractProcess`\n", + "- `Vars` are used to store internal data in the `Process`\n", + "- `Ports` are used to connect to other `Processes`\n", + "- The behavior of a `Process` is defined in a `ProcessModel`\n", + "- `ProcessModels` are aware of their hardware backend, they get selected automatically by the compiler/runtime\n", + "- `PyProcessModels` run on CPU\n", + "- Number and names of `Vars` and `Ports` of a `ProcessModel` must match those of the `Process` it implements" + ] + }, + { + "cell_type": "markdown", + "id": "f36cbfa4", + "metadata": {}, + "source": [ + "## Learn more about\n", + "- [ProcessModels](https://github.com/lava-nc/lava/blob/main/tutorials/in_depth/tutorial03_process_models.ipynb)\n", + "- SynchProtocols (coming soon)\n", + "- Available hardware backends (coming soon)" + ] + }, + { + "cell_type": "markdown", + "id": "2d5bd6f0", + "metadata": {}, + "source": [ + "# 3. Running the network on Loihi2\n", + "\n", + "This section shows how to run the LIF-Dense-LIF network with `SpikeGenerator` on a Loihi2 processor.\n", + "For that, we need to define the behavior of the `Processes` as `NcProcessModels` to run on the Loihi2 neuro cores or as `CLoihiProcessModels` to run on the embedded CPU.\n", + "\n", + "Of course, the Process Library already implemented the behavior of the `LIF` and `Dense` processes for neuro cores, but for demonstration purposes, this will be done manually in the end of the section. As the `SpikeGenerator` is a custom model and should run on the embedded CPU, its behavior needs to be defined as `CLoihiProcessModel`.\n", + "\n", + "The following sections will only execute correctly if you have access to a Loihi 2 processor.\n", + "\n", + "## SpikeGenerator as CLoihiProcessModel\n", + "\n", + "As before, we can start by importing the necessary classes. The `LavaCType` and `LavaCDataTypes` define the types of data and ports in C. The `CLoihiProcessModel` is the base class for all `ProcessModels` for embedded CPUs. And finally, the required resource is `ECPU`." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "4bfa4354", + "metadata": {}, + "outputs": [], + "source": [ + "from lava.magma.core.model.c.type import LavaCType, LavaCDataType, COutPort\n", + "from lava.magma.core.model.c.model import CLoihiProcessModel\n", + "from lava.magma.core.resources import LMT # Embedded CPU\n", + "from lava.magma.core.decorator import tag" + ] + }, + { + "cell_type": "markdown", + "id": "22a5b9ba", + "metadata": {}, + "source": [ + "For convenience, the `Vars` and `Ports` can still be defined in Python and the definitions in C are auto-generated. All we have need to provide is the name of the .c and .h file which implements the actual behavior." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "cc01826f", + "metadata": {}, + "outputs": [], + "source": [ + "@implements(proc=SpikeGenerator, protocol=LoihiProtocol)\n", + "@requires(LMT)\n", + "class CSpikeGeneratorModel(CLoihiProcessModel):\n", + " \"\"\"Spike Generator process model in C.\"\"\"\n", + " spike_prob: Var = LavaCType(cls=int, d_type=LavaCDataType.INT32)\n", + " s_out: COutPort = LavaCType(cls=COutPort, d_type=LavaCDataType.INT32)\n", + " \n", + " @property\n", + " def source_file_name(self):\n", + " return \"spike_generator.c\"" + ] + }, + { + "cell_type": "markdown", + "id": "a2de91cb", + "metadata": {}, + "source": [ + "We added the corresponding .c and .h files to this notebook, but for convenience, their content are also shown below. In the .h file, the functions are defined. For the `SpikeGenerator`, only the `run_spk` function is used." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "55ea266d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Overwriting spike_generator.h\n" + ] + } + ], + "source": [ + "%%writefile spike_generator.h\n", + "\n", + "int spk_guard(runState *rs);\n", + "void run_spk(runState *rs);" + ] + }, + { + "cell_type": "markdown", + "id": "8483cfdb", + "metadata": {}, + "source": [ + "In the .c file, the headers are imported and `run_spk` function is implemented." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "42d1e600", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Overwriting spike_generator.c\n" + ] + } + ], + "source": [ + "%%writefile spike_generator.c\n", + "\n", + "#include \"spike_generator.h\"\n", + "#include \"predefs_CSpikeGeneratorModel.h\" // Port and Var definitions, is autogenerated\n", + "\n", + "\n", + "int spk_guard(runState *rs){\n", + " return 1;\n", + "}\n", + "\n", + "void run_spk(runState *rs){\n", + " \n", + " // Generate random spike data\n", + " uint32_t spike_data[s_out.size];\n", + " \n", + " for (uint32_t i = 0; i < s_out.size; ++i)\n", + " {\n", + " uint32_t r = (uint32_t)(rand() % 100);\n", + " if (r < spike_prob[0])\n", + " {\n", + " spike_data[i] = 1;\n", + " }\n", + " else\n", + " {\n", + " spike_data[i] = 0;\n", + " }\n", + " }\n", + " \n", + " // Send spikes\n", + " send_vec_dense(rs, &s_out, spike_data);\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "0b9c3dbf", + "metadata": {}, + "source": [ + "## LIF as NcProcModel\n", + "\n", + "As mentioned before, the behavior of `LIF` and `Dense` is already implemented in the Process Library. But for demonstration purposes, the following box shows the implementation for a `LIF` neuron for Loihi2 neuro cores. \n", + "\n", + "\n", + "![net](https://raw.githubusercontent.com/lava-nc/lava-docs/dev/walk-through-tutorial/_static/images/tutorial00/net.png)\n", + "\n", + "\n", + "As usual, the `Vars` and `Ports` are defined as class members. Then, the resources for the `LIF` neuron are `allocated`, the different stages which can be allocated can be seen in the figure above.\n", + "\n", + "The `allocate` function privides the `Net` object, which has access to resources on the hardware. The `neuron_cfg` defines parameters which are shared among many neurons, `du`, `dv` and `vth` are examples of those on Loihi 2. Then we allocate the neurons and determine the number of neurons with `shape`, all per-neuron variables and set the shared parameters with `cfg`. In a last step we allocate the output axons `ax_out` with the `size` and delay `dly`.\n", + "\n", + "In a last step, we connect the input port `a_in` to the neurons, the neurons to `ax_out` and `ax_out` to the output port `s_out`." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "9305e991", + "metadata": {}, + "outputs": [], + "source": [ + "from lava.magma.core.model.nc.model import AbstractNcProcessModel\n", + "from lava.magma.core.resources import NeuroCore\n", + "from lava.magma.core.model.nc.type import LavaNcType\n", + "from lava.magma.core.nets.table_container import NcVar\n", + "from lava.magma.core.model.nc.ports import NcInPort, NcOutPort\n", + "from lava.magma.compiler.subcompilers.nc.net import NetL2\n", + "\n", + "\n", + "@implements(proc=LIF, protocol=LoihiProtocol)\n", + "@requires(NeuroCore)\n", + "@tag('hard_coded')\n", + "class MyNcModelLif(AbstractNcProcessModel):\n", + " \"\"\"Implementation of a Leaky Integrate-and-Fire (LIF) neural process\n", + " model that defines the behavior of hard-coded neurons on Loihi 2.\n", + " \"\"\"\n", + "\n", + " # Declare port implementation\n", + " a_in: NcInPort = LavaNcType(NcInPort, np.int16, precision=16)\n", + " s_out: NcOutPort = LavaNcType(NcOutPort, np.int32, precision=24)\n", + " \n", + " # Declare variable implementation\n", + " u: NcVar = LavaNcType(NcVar, np.int32, precision=24)\n", + " v: NcVar = LavaNcType(NcVar, np.int32, precision=24)\n", + " du: NcVar = LavaNcType(NcVar, np.int16, precision=12)\n", + " dv: NcVar = LavaNcType(NcVar, np.int16, precision=12)\n", + " bias_mant: NcVar = LavaNcType(NcVar, np.int16, precision=13)\n", + " bias_exp: NcVar = LavaNcType(NcVar, np.int16, precision=3)\n", + " vth: NcVar = LavaNcType(NcVar, np.int32, precision=17)\n", + "\n", + " def allocate(self, net: NetL2):\n", + " \"\"\"Allocates neural resources in 'virtual' neuro core.\"\"\"\n", + " flat_size = np.product(list(self.proc_params['shape']))\n", + "\n", + " # Allocate neurons\n", + " neurons_cfg: Node = net.neurons_cfg.allocate(\n", + " shape=1,\n", + " du=self.du,\n", + " dv=self.dv,\n", + " vth=self.vth,\n", + " homeostasis_on=False)\n", + " \n", + " neurons: Node = net.neurons.allocate_hcode(\n", + " shape=flat_size,\n", + " u=self.u,\n", + " v=self.v,\n", + " bias_mant=self.bias_mant,\n", + " bias_exp=self.bias_exp)\n", + "\n", + " # Allocate output axons\n", + " ax_out: Node = net.ax_out.allocate(shape=flat_size,\n", + " num_message_bits=0)\n", + "\n", + " # Connect InPort of Process to neurons\n", + " self.a_in.connect(neurons)\n", + " \n", + " # Connect Nodes\n", + " neurons.connect(neurons_cfg)\n", + " neurons.connect(ax_out)\n", + " \n", + " # Connect output axon to OutPort of Process\n", + " ax_out.connect(self.s_out)\n" + ] + }, + { + "cell_type": "markdown", + "id": "b165914c", + "metadata": {}, + "source": [ + "## Execution on Loihi2\n", + "\n", + "Now that we defined the behavior of all our `Processes` for Loihi2 using `CLoihiProcessModel` and `AbstractNcProcessModel`, we can create the complete network one more time." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "b720fc83", + "metadata": {}, + "outputs": [], + "source": [ + "from lava.utils.weightutils import SignMode\n", + "\n", + "num_neurons = (3, 2)\n", + "\n", + "# Create SpikeGenerator\n", + "spike_gen = SpikeGenerator(shape=(num_neurons[0], ), spike_prob=7)\n", + "\n", + "weights = np.eye(num_neurons[0], num_neurons[0]).astype(int)\n", + "\n", + "\n", + "# Instantiate Dense\n", + "dense_input = Dense(weights=weights)\n", + "\n", + "# Create processes\n", + "lif1 = LIF(shape=(num_neurons[0], ), # Number of units in this process\n", + " vth=10, # Membrane threshold\n", + " dv=0, # Inverse membrane time-constant\n", + " du=0, # Inverse synaptic time-constant\n", + " bias_mant=0, # Bias added to the membrane voltage in every timestep\n", + " name=\"lif1\")\n", + "\n", + "weights = np.random.randint(0, 10, size=(num_neurons[1], num_neurons[0])).astype(int)\n", + "\n", + "dense = Dense(weights=weights, # Initial value of the weights, chosen randomly\n", + " name='dense')\n", + "\n", + "lif2 = LIF(shape=(num_neurons[1], ), # Number of units in this process\n", + " vth=10, # Membrane threshold\n", + " dv=0, # Inverse membrane time-constant\n", + " du=0, # Inverse synaptic time-constant\n", + " bias_mant=0, # Bias added to the membrane voltage in every timestep\n", + " name='lif2')\n", + "\n", + "\n", + "# Connect spike_gen to dense_input\n", + "spike_gen.s_out.connect(dense_input.s_in)\n", + "\n", + "# Connect dense_input to LIF1 population\n", + "dense_input.a_out.connect(lif1.a_in)\n", + "\n", + "# Connect the OutPort of lif1 to the InPort of dense\n", + "lif1.s_out.connect(dense.s_in)\n", + "\n", + "# Connect the OutPort of dense to the InPort of lif2\n", + "dense.a_out.connect(lif2.a_in)" + ] + }, + { + "cell_type": "markdown", + "id": "16563e85", + "metadata": {}, + "source": [ + "In order to execute the network on Loihi2, we just need to choose the corresponding `RunConfig`, here the `Loihi2HwCfg`, and start the `Runtime` by calling `run`. The compiler automatically selects the correct `ProcessModels` to fulfill the provided `RunConfig`. As mentioned before, the following box can only be executed if you have access to Loihi2 hardware." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "dd0e331b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Membrane potentials: esteps... Done 0.76s3msDone 2.53ms\n", + "LIF1 Variable: u\n", + " shape: (3,)\n", + " init: 0\n", + " shareable: True\n", + " value: [300. 609. 295.], \n", + "LIF1 Variable: v\n", + " shape: (3,)\n", + " init: 0\n", + " shareable: True\n", + " value: [526. 240. 539.]\n", + "Membrane potentials: \n", + "LIF1 Variable: u\n", + " shape: (2,)\n", + " init: 0\n", + " shareable: True\n", + " value: [35524. 35328.], \n", + "LIF2 Variable: v\n", + " shape: (2,)\n", + " init: 0\n", + " shareable: True\n", + " value: [1078261. 1096272.]\n", + "Process model used for the SpikeGenerator: \n", + "Process model used for LIF: \n" + ] + } + ], + "source": [ + "# the next line prevents an issue with jupyter notebooks\n", + "__file__ = \"\"\n", + "\n", + "from lava.magma.core.run_configs import Loihi2HwCfg\n", + "\n", + "# Run\n", + "lif2.run(condition=RunSteps(num_steps=100), \n", + " run_cfg=Loihi2HwCfg(exception_proc_model_map={SpikeGenerator: CSpikeGeneratorModel,\n", + " LIF: MyNcModelLif}))\n", + "\n", + "# Evalute LIF1 neurons states\n", + "print(f\"Membrane potentials: \\nLIF1 {lif1.u}, \\nLIF1 {lif1.v}\")\n", + "\n", + "# Evalute LIF2 neurons states\n", + "print(f\"Membrane potentials: \\nLIF1 {lif2.u}, \\nLIF2 {lif2.v}\")\n", + "\n", + "print(f\"Process model used for the SpikeGenerator: {spike_gen.model_class}\")\n", + "\n", + "print(f\"Process model used for LIF: {lif1.model_class}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "9bcf802b", + "metadata": {}, + "outputs": [], + "source": [ + "lif2.stop()" + ] + }, + { + "cell_type": "markdown", + "id": "7f3bf656", + "metadata": {}, + "source": [ + "## Summary\n", + "- `CLoihiProcessModels` can be executed on embedded CPU on Loihi2\n", + "- The interface is implemented in Python, `Var` and `Port` definitons are auto-generated\n", + "- .c and .h files implement the behavior\n", + "- Loihi2 has hardcoded `LIF` neurons, microcoded neurons are much more flexible\n", + "- Execution on Loihi2 is as simple as changing the `RunConfig`." + ] + }, + { + "cell_type": "markdown", + "id": "a5a1af5d", + "metadata": {}, + "source": [ + "## Learn more about\n", + "- CLoihiProcessModels (coming soon)\n", + "- NcProcessModels (coming soon)\n", + "\n", + "\n", + "## How to learn more?\n", + "\n", + "If you want to find out more about Lava, have a look at the [Lava documentation](https://lava-nc.org/) or dive deeper with the [in-depth tutorials](https://github.com/lava-nc/lava/tree/main/tutorials/in_depth).\n", + "\n", + "To receive regular updates on the latest developments and releases of the Lava Software Framework please subscribe to [our newsletter](http://eepurl.com/hJCyhb)." + ] + }, + { + "cell_type": "markdown", + "id": "db8d1e02", + "metadata": {}, + "source": [ + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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": 5 +} From ecf7ceee6b01e643eaf9432c26dd8c1da336dd8c Mon Sep 17 00:00:00 2001 From: Philipp Date: Mon, 4 Jul 2022 04:00:38 -0700 Subject: [PATCH 2/5] rm c/nc parts --- .../tutorial00_tour_through_lava.ipynb | 471 ------------------ 1 file changed, 471 deletions(-) diff --git a/tutorials/end_to_end/tutorial00_tour_through_lava.ipynb b/tutorials/end_to_end/tutorial00_tour_through_lava.ipynb index cfc8e7b7a..71b4eacdd 100644 --- a/tutorials/end_to_end/tutorial00_tour_through_lava.ipynb +++ b/tutorials/end_to_end/tutorial00_tour_through_lava.ipynb @@ -2,7 +2,6 @@ "cells": [ { "cell_type": "markdown", - "id": "1265089b", "metadata": {}, "source": [ "*Copyright (C) 2022 Intel Corporation*
\n", @@ -14,7 +13,6 @@ }, { "cell_type": "markdown", - "id": "e0cfa11e", "metadata": {}, "source": [ "# Walk through Lava\n", @@ -36,7 +34,6 @@ }, { "cell_type": "markdown", - "id": "12148cf7", "metadata": {}, "source": [ "# 1. Usage of the Process Library" @@ -44,7 +41,6 @@ }, { "cell_type": "markdown", - "id": "8abebf36", "metadata": {}, "source": [ "In this section, we will use a simple 2-layered feed-forward network of LIF neurons executed on CPU as canonical example. \n", @@ -62,7 +58,6 @@ { "cell_type": "code", "execution_count": 1, - "id": "6ee5440d", "metadata": {}, "outputs": [], "source": [ @@ -74,7 +69,6 @@ }, { "cell_type": "markdown", - "id": "be1692e1", "metadata": {}, "source": [ "The docstring gives insights about the parameters and internal dynamics of the `LIF` neuron. `Dense` is used to connect to a neuron population in an all-to-all fashion, often implemented as a matrix-vector product.\n", @@ -85,7 +79,6 @@ { "cell_type": "code", "execution_count": 2, - "id": "2e94a09b", "metadata": {}, "outputs": [], "source": [ @@ -112,7 +105,6 @@ }, { "cell_type": "markdown", - "id": "45a58eab", "metadata": {}, "source": [ "As you can see, we can either specify parameters with scalars, then all units share the same initial value for this parameter, or with a tuple (or list, or numpy array) to set the parameter individually per unit.\n", @@ -140,7 +132,6 @@ { "cell_type": "code", "execution_count": 3, - "id": "f476f8cc", "metadata": {}, "outputs": [ { @@ -160,7 +151,6 @@ }, { "cell_type": "markdown", - "id": "30a90be3", "metadata": {}, "source": [ "For example, we can see the size of the `Port` which is in particular important because `Ports` can only connect if their shape matches." @@ -169,7 +159,6 @@ { "cell_type": "code", "execution_count": 4, - "id": "dbc3f741", "metadata": {}, "outputs": [], "source": [ @@ -178,7 +167,6 @@ }, { "cell_type": "markdown", - "id": "1c614760", "metadata": {}, "source": [ "Similarly we can investigate the input port of the second `LIF` population." @@ -187,7 +175,6 @@ { "cell_type": "code", "execution_count": 5, - "id": "33bb42a7", "metadata": {}, "outputs": [ { @@ -208,7 +195,6 @@ { "cell_type": "code", "execution_count": 6, - "id": "2ad63b37", "metadata": {}, "outputs": [], "source": [ @@ -217,7 +203,6 @@ }, { "cell_type": "markdown", - "id": "3018b179", "metadata": {}, "source": [ "Now that we know about the input and output `Ports` of the `LIF` and `Dense` `Processes`, we can `connect` the network to complete the LIF-Dense-LIF structure.\n", @@ -230,7 +215,6 @@ { "cell_type": "code", "execution_count": 7, - "id": "409b21ed", "metadata": {}, "outputs": [], "source": [ @@ -243,7 +227,6 @@ }, { "cell_type": "markdown", - "id": "faa73547", "metadata": {}, "source": [ "## Variables\n", @@ -254,7 +237,6 @@ { "cell_type": "code", "execution_count": 8, - "id": "ea4ee4ed", "metadata": {}, "outputs": [ { @@ -274,7 +256,6 @@ }, { "cell_type": "markdown", - "id": "9ce2c0d6", "metadata": {}, "source": [ "`Vars` are also accessible as member variables. We can print details of a specific `Var` to see the shape, initial value and current value. The `shareable` attribute controls whether a `Var` can be manipulated via remote memory access. Learn more about about this topic in the [remote memory access tutorial](https://github.com/lava-nc/lava/blob/main/tutorials/in_depth/tutorial07_remote_memory_access.ipynb)." @@ -283,7 +264,6 @@ { "cell_type": "code", "execution_count": 9, - "id": "e68943ad", "metadata": {}, "outputs": [ { @@ -307,7 +287,6 @@ }, { "cell_type": "markdown", - "id": "faf4ba3d", "metadata": {}, "source": [ "We can take a look at the random weights of `Dense` by calling the `get` function." @@ -316,7 +295,6 @@ { "cell_type": "code", "execution_count": 10, - "id": "8f2f2a1a", "metadata": {}, "outputs": [ { @@ -337,7 +315,6 @@ }, { "cell_type": "markdown", - "id": "92390d22", "metadata": {}, "source": [ "
\n", @@ -347,7 +324,6 @@ }, { "cell_type": "markdown", - "id": "5c00edda", "metadata": {}, "source": [ "## Record internal Vars over time\n", @@ -359,7 +335,6 @@ { "cell_type": "code", "execution_count": 11, - "id": "b57f514c", "metadata": {}, "outputs": [], "source": [ @@ -371,7 +346,6 @@ }, { "cell_type": "markdown", - "id": "627e772a", "metadata": {}, "source": [ "We can define the `Var` that a `Monitor` should record, as well as the recording duration, using the `probe` function." @@ -380,7 +354,6 @@ { "cell_type": "code", "execution_count": 12, - "id": "d0fc7bcd", "metadata": {}, "outputs": [], "source": [ @@ -392,7 +365,6 @@ }, { "cell_type": "markdown", - "id": "80969e97", "metadata": {}, "source": [ "
\n", @@ -402,7 +374,6 @@ }, { "cell_type": "markdown", - "id": "7ce1e7a3", "metadata": {}, "source": [ "## Execution\n", @@ -414,7 +385,6 @@ }, { "cell_type": "markdown", - "id": "ebfe7eb2", "metadata": {}, "source": [ "### Run Conditions\n", @@ -425,7 +395,6 @@ { "cell_type": "code", "execution_count": 13, - "id": "4ddf6616", "metadata": {}, "outputs": [], "source": [ @@ -435,7 +404,6 @@ }, { "cell_type": "markdown", - "id": "e95ddfb4", "metadata": {}, "source": [ "The second option is `RunSteps`, which allows you to define an exact amount of time steps the network should run." @@ -444,7 +412,6 @@ { "cell_type": "code", "execution_count": 14, - "id": "9417aed5", "metadata": {}, "outputs": [], "source": [ @@ -455,7 +422,6 @@ }, { "cell_type": "markdown", - "id": "6dc5e348", "metadata": {}, "source": [ "For this example. we will use `RunSteps` and let the network run exactly `num_steps` time steps.\n", @@ -472,7 +438,6 @@ { "cell_type": "code", "execution_count": 15, - "id": "85197548", "metadata": {}, "outputs": [], "source": [ @@ -483,7 +448,6 @@ }, { "cell_type": "markdown", - "id": "df31fcdb", "metadata": {}, "source": [ "### Execute\n", @@ -494,7 +458,6 @@ { "cell_type": "code", "execution_count": 16, - "id": "585bb35b", "metadata": {}, "outputs": [], "source": [ @@ -503,7 +466,6 @@ }, { "cell_type": "markdown", - "id": "12f01dac", "metadata": {}, "source": [ "## Retrieve recorded data\n", @@ -514,7 +476,6 @@ { "cell_type": "code", "execution_count": 17, - "id": "14b873b7", "metadata": {}, "outputs": [], "source": [ @@ -524,7 +485,6 @@ }, { "cell_type": "markdown", - "id": "8740f2cd", "metadata": {}, "source": [ "Alternatively, we can also use the provided `plot` functionality of the `Monitor`, to plot the recorded data. As we can see, the bias of the first `LIF` population drives the membrane potential to the threshold which generates output spikes. Those output spikes are passed through the `Dense` layer as input to the second `LIF` population." @@ -533,7 +493,6 @@ { "cell_type": "code", "execution_count": 18, - "id": "38ab3229", "metadata": { "scrolled": true }, @@ -568,7 +527,6 @@ }, { "cell_type": "markdown", - "id": "05ff8e16", "metadata": { "scrolled": true }, @@ -579,7 +537,6 @@ { "cell_type": "code", "execution_count": 19, - "id": "272c164e", "metadata": {}, "outputs": [], "source": [ @@ -588,7 +545,6 @@ }, { "cell_type": "markdown", - "id": "22201c5a", "metadata": {}, "source": [ "## Summary\n", @@ -604,7 +560,6 @@ }, { "cell_type": "markdown", - "id": "b49bdf84", "metadata": {}, "source": [ "## Learn more about\n", @@ -617,7 +572,6 @@ }, { "cell_type": "markdown", - "id": "2979fbf3", "metadata": {}, "source": [ "# 2. Create a custom Process\n", @@ -632,7 +586,6 @@ { "cell_type": "code", "execution_count": 20, - "id": "136d0cc5", "metadata": {}, "outputs": [], "source": [ @@ -643,7 +596,6 @@ }, { "cell_type": "markdown", - "id": "fd47594e", "metadata": {}, "source": [ "All `Processes` in Lava inherit from a common base class called `AbstractProcess`. Additionally, we need `Var` for storing the spike probability and `OutPort` to define the output connections for our `SpikeGenerator`." @@ -652,7 +604,6 @@ { "cell_type": "code", "execution_count": 21, - "id": "509a699c", "metadata": {}, "outputs": [], "source": [ @@ -674,7 +625,6 @@ }, { "cell_type": "markdown", - "id": "d254bb0f", "metadata": {}, "source": [ "The constructor of `Var` requires the shape of the data to be stored and some initial value. We use this functionality to store the spike data. Similarly, we define an `OutPort` for our `SpikeGenerator`. " @@ -682,7 +632,6 @@ }, { "cell_type": "markdown", - "id": "619bf2d2", "metadata": {}, "source": [ "## Create a new ProcessModel \n", @@ -698,7 +647,6 @@ { "cell_type": "code", "execution_count": 22, - "id": "fbf1cf57", "metadata": {}, "outputs": [], "source": [ @@ -712,7 +660,6 @@ }, { "cell_type": "markdown", - "id": "c1a55779", "metadata": {}, "source": [ "All `ProcessModels` defined to run on CPU are written in Python and inherit from the common class called `PyLoihiProcessModel`. Further, we use the decorators `requires` and `implements` to define which computational resources (i.e. CPU, GPU, Loihi1NeuroCore, Loihi2NeuroCore) are required to execute this `ProcessModel` and which `Process` it implements. Finally, we need to specify the types of `Vars` and `Ports` in our `SpikeGenerator` using `LavaPyType` and `PyOutPort`.\n", @@ -721,7 +668,6 @@ }, { "cell_type": "markdown", - "id": "6414e76d", "metadata": {}, "source": [ "
\n", @@ -731,7 +677,6 @@ }, { "cell_type": "markdown", - "id": "8fdde5af", "metadata": {}, "source": [ "Additionally, we define that our `PySpikeGeneratorModel` follows the `LoihiProtocol`. The `LoihiProtocol` defines that the execution of a model follows a specific sequence of phases. For example, there is the *spiking phase* (`run_spk`) in which input spikes are received, internal `Vars` are updated and output spikes are sent. There are other phases such as the *learning phase* (`run_lrn`) in which online learning takes place, or the *post management phase* (`run_post_mgmt`) in which memory content is updated. As the `SpikeGenerator` basically just sends out spikes, the correct place to implement its behavior is the `run_spk` phase. \n", @@ -742,7 +687,6 @@ { "cell_type": "code", "execution_count": 23, - "id": "55f94342", "metadata": {}, "outputs": [], "source": [ @@ -763,7 +707,6 @@ }, { "cell_type": "markdown", - "id": "b3953ac9", "metadata": {}, "source": [ "
\n", @@ -773,7 +716,6 @@ }, { "cell_type": "markdown", - "id": "29150f57", "metadata": {}, "source": [ "Next, we want to redefine our network as in the example before with the exception that we turn off all biases." @@ -782,7 +724,6 @@ { "cell_type": "code", "execution_count": 24, - "id": "db505395", "metadata": {}, "outputs": [], "source": [ @@ -821,7 +762,6 @@ }, { "cell_type": "markdown", - "id": "ec9d9ebc", "metadata": {}, "source": [ "## Use the custom SpikeGenerator\n", @@ -835,7 +775,6 @@ { "cell_type": "code", "execution_count": 25, - "id": "6a31ced5", "metadata": {}, "outputs": [], "source": [ @@ -854,7 +793,6 @@ }, { "cell_type": "markdown", - "id": "5ed3693c", "metadata": {}, "source": [ "## Execute and plot\n", @@ -865,7 +803,6 @@ { "cell_type": "code", "execution_count": 26, - "id": "6f5e0200", "metadata": {}, "outputs": [], "source": [ @@ -874,7 +811,6 @@ }, { "cell_type": "markdown", - "id": "dec690f3", "metadata": {}, "source": [ "And now, we can retrieve the recorded data and plot the membrane potentials of the two `LIF` populations." @@ -883,7 +819,6 @@ { "cell_type": "code", "execution_count": 27, - "id": "864b76ee", "metadata": {}, "outputs": [ { @@ -912,7 +847,6 @@ }, { "cell_type": "markdown", - "id": "b887a813", "metadata": {}, "source": [ "As we can see, the spikes provided by the `SpikeGenerator` are sucessfully sent to the first `LIF` population. which in turn sends its output spikes to the second `LIF` population." @@ -921,7 +855,6 @@ { "cell_type": "code", "execution_count": 28, - "id": "86f23f5b", "metadata": {}, "outputs": [], "source": [ @@ -930,7 +863,6 @@ }, { "cell_type": "markdown", - "id": "db2d5158", "metadata": {}, "source": [ "## Summary\n", @@ -946,7 +878,6 @@ }, { "cell_type": "markdown", - "id": "f36cbfa4", "metadata": {}, "source": [ "## Learn more about\n", @@ -957,416 +888,14 @@ }, { "cell_type": "markdown", - "id": "2d5bd6f0", "metadata": {}, "source": [ - "# 3. Running the network on Loihi2\n", - "\n", - "This section shows how to run the LIF-Dense-LIF network with `SpikeGenerator` on a Loihi2 processor.\n", - "For that, we need to define the behavior of the `Processes` as `NcProcessModels` to run on the Loihi2 neuro cores or as `CLoihiProcessModels` to run on the embedded CPU.\n", - "\n", - "Of course, the Process Library already implemented the behavior of the `LIF` and `Dense` processes for neuro cores, but for demonstration purposes, this will be done manually in the end of the section. As the `SpikeGenerator` is a custom model and should run on the embedded CPU, its behavior needs to be defined as `CLoihiProcessModel`.\n", - "\n", - "The following sections will only execute correctly if you have access to a Loihi 2 processor.\n", - "\n", - "## SpikeGenerator as CLoihiProcessModel\n", - "\n", - "As before, we can start by importing the necessary classes. The `LavaCType` and `LavaCDataTypes` define the types of data and ports in C. The `CLoihiProcessModel` is the base class for all `ProcessModels` for embedded CPUs. And finally, the required resource is `ECPU`." - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "4bfa4354", - "metadata": {}, - "outputs": [], - "source": [ - "from lava.magma.core.model.c.type import LavaCType, LavaCDataType, COutPort\n", - "from lava.magma.core.model.c.model import CLoihiProcessModel\n", - "from lava.magma.core.resources import LMT # Embedded CPU\n", - "from lava.magma.core.decorator import tag" - ] - }, - { - "cell_type": "markdown", - "id": "22a5b9ba", - "metadata": {}, - "source": [ - "For convenience, the `Vars` and `Ports` can still be defined in Python and the definitions in C are auto-generated. All we have need to provide is the name of the .c and .h file which implements the actual behavior." - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "cc01826f", - "metadata": {}, - "outputs": [], - "source": [ - "@implements(proc=SpikeGenerator, protocol=LoihiProtocol)\n", - "@requires(LMT)\n", - "class CSpikeGeneratorModel(CLoihiProcessModel):\n", - " \"\"\"Spike Generator process model in C.\"\"\"\n", - " spike_prob: Var = LavaCType(cls=int, d_type=LavaCDataType.INT32)\n", - " s_out: COutPort = LavaCType(cls=COutPort, d_type=LavaCDataType.INT32)\n", - " \n", - " @property\n", - " def source_file_name(self):\n", - " return \"spike_generator.c\"" - ] - }, - { - "cell_type": "markdown", - "id": "a2de91cb", - "metadata": {}, - "source": [ - "We added the corresponding .c and .h files to this notebook, but for convenience, their content are also shown below. In the .h file, the functions are defined. For the `SpikeGenerator`, only the `run_spk` function is used." - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "55ea266d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Overwriting spike_generator.h\n" - ] - } - ], - "source": [ - "%%writefile spike_generator.h\n", - "\n", - "int spk_guard(runState *rs);\n", - "void run_spk(runState *rs);" - ] - }, - { - "cell_type": "markdown", - "id": "8483cfdb", - "metadata": {}, - "source": [ - "In the .c file, the headers are imported and `run_spk` function is implemented." - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "42d1e600", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Overwriting spike_generator.c\n" - ] - } - ], - "source": [ - "%%writefile spike_generator.c\n", - "\n", - "#include \"spike_generator.h\"\n", - "#include \"predefs_CSpikeGeneratorModel.h\" // Port and Var definitions, is autogenerated\n", - "\n", - "\n", - "int spk_guard(runState *rs){\n", - " return 1;\n", - "}\n", - "\n", - "void run_spk(runState *rs){\n", - " \n", - " // Generate random spike data\n", - " uint32_t spike_data[s_out.size];\n", - " \n", - " for (uint32_t i = 0; i < s_out.size; ++i)\n", - " {\n", - " uint32_t r = (uint32_t)(rand() % 100);\n", - " if (r < spike_prob[0])\n", - " {\n", - " spike_data[i] = 1;\n", - " }\n", - " else\n", - " {\n", - " spike_data[i] = 0;\n", - " }\n", - " }\n", - " \n", - " // Send spikes\n", - " send_vec_dense(rs, &s_out, spike_data);\n", - "}" - ] - }, - { - "cell_type": "markdown", - "id": "0b9c3dbf", - "metadata": {}, - "source": [ - "## LIF as NcProcModel\n", - "\n", - "As mentioned before, the behavior of `LIF` and `Dense` is already implemented in the Process Library. But for demonstration purposes, the following box shows the implementation for a `LIF` neuron for Loihi2 neuro cores. \n", - "\n", - "\n", - "![net](https://raw.githubusercontent.com/lava-nc/lava-docs/dev/walk-through-tutorial/_static/images/tutorial00/net.png)\n", - "\n", - "\n", - "As usual, the `Vars` and `Ports` are defined as class members. Then, the resources for the `LIF` neuron are `allocated`, the different stages which can be allocated can be seen in the figure above.\n", - "\n", - "The `allocate` function privides the `Net` object, which has access to resources on the hardware. The `neuron_cfg` defines parameters which are shared among many neurons, `du`, `dv` and `vth` are examples of those on Loihi 2. Then we allocate the neurons and determine the number of neurons with `shape`, all per-neuron variables and set the shared parameters with `cfg`. In a last step we allocate the output axons `ax_out` with the `size` and delay `dly`.\n", - "\n", - "In a last step, we connect the input port `a_in` to the neurons, the neurons to `ax_out` and `ax_out` to the output port `s_out`." - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "9305e991", - "metadata": {}, - "outputs": [], - "source": [ - "from lava.magma.core.model.nc.model import AbstractNcProcessModel\n", - "from lava.magma.core.resources import NeuroCore\n", - "from lava.magma.core.model.nc.type import LavaNcType\n", - "from lava.magma.core.nets.table_container import NcVar\n", - "from lava.magma.core.model.nc.ports import NcInPort, NcOutPort\n", - "from lava.magma.compiler.subcompilers.nc.net import NetL2\n", - "\n", - "\n", - "@implements(proc=LIF, protocol=LoihiProtocol)\n", - "@requires(NeuroCore)\n", - "@tag('hard_coded')\n", - "class MyNcModelLif(AbstractNcProcessModel):\n", - " \"\"\"Implementation of a Leaky Integrate-and-Fire (LIF) neural process\n", - " model that defines the behavior of hard-coded neurons on Loihi 2.\n", - " \"\"\"\n", - "\n", - " # Declare port implementation\n", - " a_in: NcInPort = LavaNcType(NcInPort, np.int16, precision=16)\n", - " s_out: NcOutPort = LavaNcType(NcOutPort, np.int32, precision=24)\n", - " \n", - " # Declare variable implementation\n", - " u: NcVar = LavaNcType(NcVar, np.int32, precision=24)\n", - " v: NcVar = LavaNcType(NcVar, np.int32, precision=24)\n", - " du: NcVar = LavaNcType(NcVar, np.int16, precision=12)\n", - " dv: NcVar = LavaNcType(NcVar, np.int16, precision=12)\n", - " bias_mant: NcVar = LavaNcType(NcVar, np.int16, precision=13)\n", - " bias_exp: NcVar = LavaNcType(NcVar, np.int16, precision=3)\n", - " vth: NcVar = LavaNcType(NcVar, np.int32, precision=17)\n", - "\n", - " def allocate(self, net: NetL2):\n", - " \"\"\"Allocates neural resources in 'virtual' neuro core.\"\"\"\n", - " flat_size = np.product(list(self.proc_params['shape']))\n", - "\n", - " # Allocate neurons\n", - " neurons_cfg: Node = net.neurons_cfg.allocate(\n", - " shape=1,\n", - " du=self.du,\n", - " dv=self.dv,\n", - " vth=self.vth,\n", - " homeostasis_on=False)\n", - " \n", - " neurons: Node = net.neurons.allocate_hcode(\n", - " shape=flat_size,\n", - " u=self.u,\n", - " v=self.v,\n", - " bias_mant=self.bias_mant,\n", - " bias_exp=self.bias_exp)\n", - "\n", - " # Allocate output axons\n", - " ax_out: Node = net.ax_out.allocate(shape=flat_size,\n", - " num_message_bits=0)\n", - "\n", - " # Connect InPort of Process to neurons\n", - " self.a_in.connect(neurons)\n", - " \n", - " # Connect Nodes\n", - " neurons.connect(neurons_cfg)\n", - " neurons.connect(ax_out)\n", - " \n", - " # Connect output axon to OutPort of Process\n", - " ax_out.connect(self.s_out)\n" - ] - }, - { - "cell_type": "markdown", - "id": "b165914c", - "metadata": {}, - "source": [ - "## Execution on Loihi2\n", - "\n", - "Now that we defined the behavior of all our `Processes` for Loihi2 using `CLoihiProcessModel` and `AbstractNcProcessModel`, we can create the complete network one more time." - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "id": "b720fc83", - "metadata": {}, - "outputs": [], - "source": [ - "from lava.utils.weightutils import SignMode\n", - "\n", - "num_neurons = (3, 2)\n", - "\n", - "# Create SpikeGenerator\n", - "spike_gen = SpikeGenerator(shape=(num_neurons[0], ), spike_prob=7)\n", - "\n", - "weights = np.eye(num_neurons[0], num_neurons[0]).astype(int)\n", - "\n", - "\n", - "# Instantiate Dense\n", - "dense_input = Dense(weights=weights)\n", - "\n", - "# Create processes\n", - "lif1 = LIF(shape=(num_neurons[0], ), # Number of units in this process\n", - " vth=10, # Membrane threshold\n", - " dv=0, # Inverse membrane time-constant\n", - " du=0, # Inverse synaptic time-constant\n", - " bias_mant=0, # Bias added to the membrane voltage in every timestep\n", - " name=\"lif1\")\n", - "\n", - "weights = np.random.randint(0, 10, size=(num_neurons[1], num_neurons[0])).astype(int)\n", - "\n", - "dense = Dense(weights=weights, # Initial value of the weights, chosen randomly\n", - " name='dense')\n", - "\n", - "lif2 = LIF(shape=(num_neurons[1], ), # Number of units in this process\n", - " vth=10, # Membrane threshold\n", - " dv=0, # Inverse membrane time-constant\n", - " du=0, # Inverse synaptic time-constant\n", - " bias_mant=0, # Bias added to the membrane voltage in every timestep\n", - " name='lif2')\n", - "\n", - "\n", - "# Connect spike_gen to dense_input\n", - "spike_gen.s_out.connect(dense_input.s_in)\n", - "\n", - "# Connect dense_input to LIF1 population\n", - "dense_input.a_out.connect(lif1.a_in)\n", - "\n", - "# Connect the OutPort of lif1 to the InPort of dense\n", - "lif1.s_out.connect(dense.s_in)\n", - "\n", - "# Connect the OutPort of dense to the InPort of lif2\n", - "dense.a_out.connect(lif2.a_in)" - ] - }, - { - "cell_type": "markdown", - "id": "16563e85", - "metadata": {}, - "source": [ - "In order to execute the network on Loihi2, we just need to choose the corresponding `RunConfig`, here the `Loihi2HwCfg`, and start the `Runtime` by calling `run`. The compiler automatically selects the correct `ProcessModels` to fulfill the provided `RunConfig`. As mentioned before, the following box can only be executed if you have access to Loihi2 hardware." - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "dd0e331b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Membrane potentials: esteps... Done 0.76s3msDone 2.53ms\n", - "LIF1 Variable: u\n", - " shape: (3,)\n", - " init: 0\n", - " shareable: True\n", - " value: [300. 609. 295.], \n", - "LIF1 Variable: v\n", - " shape: (3,)\n", - " init: 0\n", - " shareable: True\n", - " value: [526. 240. 539.]\n", - "Membrane potentials: \n", - "LIF1 Variable: u\n", - " shape: (2,)\n", - " init: 0\n", - " shareable: True\n", - " value: [35524. 35328.], \n", - "LIF2 Variable: v\n", - " shape: (2,)\n", - " init: 0\n", - " shareable: True\n", - " value: [1078261. 1096272.]\n", - "Process model used for the SpikeGenerator: \n", - "Process model used for LIF: \n" - ] - } - ], - "source": [ - "# the next line prevents an issue with jupyter notebooks\n", - "__file__ = \"\"\n", - "\n", - "from lava.magma.core.run_configs import Loihi2HwCfg\n", - "\n", - "# Run\n", - "lif2.run(condition=RunSteps(num_steps=100), \n", - " run_cfg=Loihi2HwCfg(exception_proc_model_map={SpikeGenerator: CSpikeGeneratorModel,\n", - " LIF: MyNcModelLif}))\n", - "\n", - "# Evalute LIF1 neurons states\n", - "print(f\"Membrane potentials: \\nLIF1 {lif1.u}, \\nLIF1 {lif1.v}\")\n", - "\n", - "# Evalute LIF2 neurons states\n", - "print(f\"Membrane potentials: \\nLIF1 {lif2.u}, \\nLIF2 {lif2.v}\")\n", - "\n", - "print(f\"Process model used for the SpikeGenerator: {spike_gen.model_class}\")\n", - "\n", - "print(f\"Process model used for LIF: {lif1.model_class}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "id": "9bcf802b", - "metadata": {}, - "outputs": [], - "source": [ - "lif2.stop()" - ] - }, - { - "cell_type": "markdown", - "id": "7f3bf656", - "metadata": {}, - "source": [ - "## Summary\n", - "- `CLoihiProcessModels` can be executed on embedded CPU on Loihi2\n", - "- The interface is implemented in Python, `Var` and `Port` definitons are auto-generated\n", - "- .c and .h files implement the behavior\n", - "- Loihi2 has hardcoded `LIF` neurons, microcoded neurons are much more flexible\n", - "- Execution on Loihi2 is as simple as changing the `RunConfig`." - ] - }, - { - "cell_type": "markdown", - "id": "a5a1af5d", - "metadata": {}, - "source": [ - "## Learn more about\n", - "- CLoihiProcessModels (coming soon)\n", - "- NcProcessModels (coming soon)\n", - "\n", - "\n", "## How to learn more?\n", "\n", "If you want to find out more about Lava, have a look at the [Lava documentation](https://lava-nc.org/) or dive deeper with the [in-depth tutorials](https://github.com/lava-nc/lava/tree/main/tutorials/in_depth).\n", "\n", "To receive regular updates on the latest developments and releases of the Lava Software Framework please subscribe to [our newsletter](http://eepurl.com/hJCyhb)." ] - }, - { - "cell_type": "markdown", - "id": "db8d1e02", - "metadata": {}, - "source": [ - "\n" - ] } ], "metadata": { From f5a09f04f676a3fed5c39a3ad3f68142b9e8a5b5 Mon Sep 17 00:00:00 2001 From: Philipp Date: Mon, 4 Jul 2022 04:08:29 -0700 Subject: [PATCH 3/5] activate test for walk-through-tutorial without nc model --- tests/lava/tutorials/test_tutorials.py | 5 ----- 1 file changed, 5 deletions(-) diff --git a/tests/lava/tutorials/test_tutorials.py b/tests/lava/tutorials/test_tutorials.py index db7e78fcd..4921e01b7 100644 --- a/tests/lava/tutorials/test_tutorials.py +++ b/tests/lava/tutorials/test_tutorials.py @@ -16,8 +16,6 @@ import lava import tutorials -from tests.lava.test_utils.utils import Utils - class TestTutorials(unittest.TestCase): """Export notebook, execute to check for errors.""" @@ -183,9 +181,6 @@ def _run_notebook(self, notebook: str, e2e_tutorial: bool = False): finally: os.chdir(cwd) - run_it_tests: bool = Utils.get_bool_env_setting("RUN_IT_TESTS") - - @unittest.skipUnless(run_it_tests, "") @unittest.skipIf(system_name != "linux", "Tests work on linux") def test_end_to_end_00_tour_through_lava(self): """Test tutorial end to end 00 tour through lava.""" From e22cadda3e2889daab985a267896c89034eb1fd0 Mon Sep 17 00:00:00 2001 From: Philipp Date: Mon, 4 Jul 2022 07:32:13 -0700 Subject: [PATCH 4/5] changed text slightly --- .../end_to_end/tutorial00_tour_through_lava.ipynb | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/tutorials/end_to_end/tutorial00_tour_through_lava.ipynb b/tutorials/end_to_end/tutorial00_tour_through_lava.ipynb index 71b4eacdd..6f29c94da 100644 --- a/tutorials/end_to_end/tutorial00_tour_through_lava.ipynb +++ b/tutorials/end_to_end/tutorial00_tour_through_lava.ipynb @@ -24,7 +24,7 @@ "![lava_overview.png](https://raw.githubusercontent.com/lava-nc/lava-docs/dev/walk-through-tutorial/_static/images/tutorial00/lava_overview.png)\n", "\n", "This tutorial gives an high-level overview over the key components of Lava. For illustration, we will use a simple working example: a feed-forward multi-layer LIF network executed locally on CPU.\n", - "In the first section of the tutorial, we will use the internal resources of Lava to construct such a network. In the second section, we will demonstrate how to extend Lava with a custom input generator and in the last part, we will show how to run the complete network on the Loihi 2 processor.\n", + "In the first section of the tutorial, we use the internal resources of Lava to construct such a network and in the second section, we demonstrate how to extend Lava with a custom process using the example of an input generator.\n", "\n", "In addition to the core Lava library described in the present tutorial, the following tutorials guide you to use high level functionalities:\n", "- [lava-dl](https://github.com/lava-nc/lava-dl) for deep learning applications\n", @@ -900,21 +900,21 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 2", "language": "python", - "name": "python3" + "name": "python2" }, "language_info": { "codemirror_mode": { "name": "ipython", - "version": 3 + "version": 2 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.10" + "pygments_lexer": "ipython2", + "version": "2.7.18" } }, "nbformat": 4, From 01bd9e1545e0192b773e39b4da23f5d6b73a08ef Mon Sep 17 00:00:00 2001 From: weidel-p Date: Mon, 4 Jul 2022 17:08:25 +0200 Subject: [PATCH 5/5] Update process.py --- src/lava/proc/monitor/process.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/lava/proc/monitor/process.py b/src/lava/proc/monitor/process.py index dc639a3a4..2ddb4c74b 100644 --- a/src/lava/proc/monitor/process.py +++ b/src/lava/proc/monitor/process.py @@ -1,4 +1,4 @@ -# Copyright (C) 2021 Intel Corporation +# Copyright (C) 2021-22 Intel Corporation # SPDX-License-Identifier: BSD-3-Clause # See: https://spdx.org/licenses/ import matplotlib.pyplot as plt