latest

API reference

Main

nengo_loihi.Simulator(network[, dt, seed, …])

Nengo Loihi simulator for Loihi hardware and emulator.

nengo_loihi.add_params(network)

Add nengo_loihi config option to network.

nengo_loihi.set_defaults()

Modify Nengo’s default parameters for better performance with Loihi.

class nengo_loihi.Simulator(network, dt=0.001, seed=None, model=None, precompute=False, target=None, progress_bar=None, remove_passthrough=True, hardware_options=None)[source]

Nengo Loihi simulator for Loihi hardware and emulator.

The simulator takes a nengo.Network and builds internal data structures to run the model defined by that network on Loihi emulator or hardware. Run the simulator with the Simulator.run method, and access probed data through the data attribute.

Building and running the simulation allocates resources. To properly free these resources, call the Simulator.close method. Alternatively, Simulator.close will automatically be called if you use with syntax:

with nengo_loihi.Simulator(my_network) as sim:
    sim.run(0.1)
print(sim.data[my_probe])

Note that the data attribute is still accessible even when a simulator has been closed. Running the simulator, however, will raise an error.

Parameters
networkNetwork

A network object to be built and then simulated. If None, then the model parameter must be provided instead.

dtfloat, optional (Default: 0.001)

The length of a simulator timestep, in seconds.

seedint, optional (Default: None)

A seed for all stochastic operators used in this simulator. Will be set to network.seed + 1 if not given.

modelModel, optional (Default: None)

A Model that contains build artifacts to be simulated. Usually the simulator will build this model for you; however, if you want to build the network manually, or you want to inject build artifacts in the model before building the network, then you can pass in a Model instance.

precomputebool, optional (Default: False)

Whether model inputs should be precomputed to speed up simulation. When precompute is False, the simulator will be run one step at a time in order to use model outputs as inputs in other parts of the model.

targetstr, optional (Default: None)

Whether the simulator should target the emulator ('sim') or Loihi hardware ('loihi'). If None, target will default to 'loihi' if NxSDK is installed, and the emulator if it is not.

hardware_optionsdict, optional (Default: {})

Dictionary of additional configuration for the hardware. See hardware.HardwareInterface for possible parameters.

Attributes
closedbool

Whether the simulator has been closed. Once closed, it cannot be reopened.

dataProbeDict

The dictionary mapping from Nengo objects to the data associated with those objects. In particular, each nengo.Probe maps to the data probed while running the simulation.

modelModel

The Model containing the data structures necessary for simulating the network.

precomputebool

Whether model inputs should be precomputed to speed up simulation. When precompute is False, the simulator will be run one step at a time in order to use model outputs as inputs in other parts of the model.

property dt

(float) The step time of the simulator.

property n_steps

(int) The current time step of the simulator.

property time

(float) The current time of the simulator.

close(self)[source]

Closes the simulator.

Any call to Simulator.run, Simulator.run_steps, Simulator.step, and Simulator.reset on a closed simulator raises a SimulatorClosed exception.

reset(self, seed=None)[source]

Reset the simulator state.

Parameters
seedint, optional

A seed for all stochastic operators used in the simulator. This will change the random sequences generated for noise or inputs (e.g. from processes), but not the built objects (e.g. ensembles, connections).

run(self, time_in_seconds)[source]

Simulate for the given length of time.

If the given length of time is not a multiple of dt, it will be rounded to the nearest dt. For example, if dt is 0.001 and run is called with time_in_seconds=0.0006, the simulator will advance one timestep, resulting in the actual simulator time being 0.001.

The given length of time must be positive. The simulator cannot be run backwards.

Parameters
time_in_secondsfloat

Amount of time to run the simulation for. Must be positive.

step(self)[source]

Advance the simulator by 1 step (dt seconds).

run_steps(self, steps)[source]

Simulate for the given number of dt steps.

Parameters
stepsint

Number of steps to run the simulation for.

trange(self, sample_every=None, dt=None)[source]

Create a vector of times matching probed data.

Note that the range does not start at 0 as one might expect, but at the first timestep (i.e., dt).

Parameters
sample_everyfloat, optional (Default: None)

The sampling period of the probe to create a range for. If None, a time value for every dt will be produced.

nengo_loihi.add_params(network)[source]

Add nengo_loihi config option to network.

The following options will be added:

nengo.Ensemble
  • on_chip: Whether the ensemble should be simulated on a Loihi chip. Marking specific ensembles for simulation off of a Loihi chip can help with debugging.

Examples

>>> with nengo.Network() as model:
...     ens = nengo.Ensemble(10, dimensions=1)
...     # By default, ens will be placed on a Loihi chip
...     nengo_loihi.add_params(model)
...     model.config[ens].on_chip = False
...     # Now it will be simulated with Nengo
nengo_loihi.set_defaults()[source]

Modify Nengo’s default parameters for better performance with Loihi.

The following defaults will be modified:

nengo.Ensemble
  • max_rates: Set to Uniform(low=100, high=120)

  • intercepts: Set to Uniform(low=-0.5, high=0.5)

Neurons

nengo_loihi.neurons.LoihiLIF([tau_rc, …])

Simulate LIF neurons as done by Loihi.

nengo_loihi.neurons.LoihiSpikingRectifiedLinear([…])

Simulate spiking rectified linear neurons as done by Loihi.

nengo_loihi.neurons.NeuronOutputNoise

Noise added to the output of a rate neuron.

nengo_loihi.neurons.LowpassRCNoise(tau_s)

Noise model combining Lowpass synapse and neuron membrane filters.

nengo_loihi.neurons.AlphaRCNoise(tau_s)

Noise model combining Alpha synapse and neuron membrane filters.

class nengo_loihi.neurons.LoihiLIF(tau_rc=0.02, tau_ref=0.002, min_voltage=0, amplitude=1, nengo_dl_noise=None)[source]

Simulate LIF neurons as done by Loihi.

On Loihi, the inter-spike interval has to be an integer. This causes aliasing the firing rates where a wide variety of inputs can produce the same output firing rate. This class reproduces this effect, as well as the discretization of some of the neuron parameters. It can be used in e.g. nengo or nengo_dl to reproduce these unique Loihi effects.

Parameters
nengo_dl_noiseNeuronOutputNoise

Noise added to the rate-neuron output when training with this neuron type in nengo_dl.

rates(self, x, gain, bias, dt=0.001)[source]

Always use LIFRate to determine rates.

step_math(self, dt, J, spiked, voltage, refractory_time)[source]

Implement the LIFRate nonlinearity.

class nengo_loihi.neurons.LoihiSpikingRectifiedLinear(amplitude=1)[source]

Simulate spiking rectified linear neurons as done by Loihi.

On Loihi, the inter-spike interval has to be an integer. This causes aliasing in the firing rates such that a wide variety of inputs produce the same output firing rate. This class reproduces this effect. It can be used in e.g. nengo or nengo_dl to reproduce these unique Loihi effects.

rates(self, x, gain, bias, dt=0.001)[source]

Use RectifiedLinear to determine rates.

step_math(self, dt, J, spiked, voltage)[source]

Implement the integrate and fire nonlinearity.

class nengo_loihi.neurons.NeuronOutputNoise[source]

Noise added to the output of a rate neuron.

Often used when training deep networks with rate neurons for final implementation in spiking neurons to simulate the variability caused by spiking.

class nengo_loihi.neurons.LowpassRCNoise(tau_s)[source]

Noise model combining Lowpass synapse and neuron membrane filters.

Samples “noise” (i.e. variability) from a regular spike train filtered by the following transfer function, where \(\tau_{rc}\) is the membrane time constant and \(\tau_s\) is the synapse time constant:

\[H(s) = [(\tau_s s + 1) (\tau_{rc} s + 1)]^{-1}\]

See [1] for background and derivations.

References

1

E. Hunsberger (2018) “Spiking Deep Neural Networks: Engineered and Biological Approaches to Object Recognition.” PhD thesis. pp. 106–113. (http://compneuro.uwaterloo.ca/publications/hunsberger2018.html)

Attributes
tau_sfloat

Time constant for Lowpass synaptic filter.

class nengo_loihi.neurons.AlphaRCNoise(tau_s)[source]

Noise model combining Alpha synapse and neuron membrane filters.

Samples “noise” (i.e. variability) from a regular spike train filtered by the following transfer function, where \(\tau_{rc}\) is the membrane time constant and \(\tau_s\) is the synapse time constant:

\[H(s) = [(\tau_s s + 1)^2 (\tau_{rc} s + 1)]^{-1}\]

See [1] for background and derivations.

References

1

E. Hunsberger (2018) “Spiking Deep Neural Networks: Engineered and Biological Approaches to Object Recognition.” PhD thesis. pp. 106–113. (http://compneuro.uwaterloo.ca/publications/hunsberger2018.html)

Attributes
tau_sfloat

Time constant for Alpha synaptic filter.

Builder

The builder turns a Nengo network into a builder.Model appropriate for running on Loihi. This model is mainly composed of LoihiBlock objects, which map parts of the network to Loihi compartments, axons, and synapses.

nengo_loihi.builder.Model([dt, label, builder])

The data structure for the emulator/hardware simulator.

nengo_loihi.builder.Builder

Fills in the Loihi Model object based on the Nengo Network.

nengo_loihi.block.LoihiBlock(n_neurons[, label])

Class holding Loihi objects that can be placed on the chip.

nengo_loihi.block.Compartment(n_compartments)

Stores information for configuring Loihi compartments.

nengo_loihi.block.Axon(n_axons[, label])

A group of axons targeting a specific Synapse object.

nengo_loihi.block.Synapse(n_axons[, label])

A group of Loihi synapses that share some properties.

nengo_loihi.block.Probe([target, key, …])

Record data from compartment states of a LoihiBlock.

class nengo_loihi.builder.Model(dt=0.001, label=None, builder=None)[source]

The data structure for the emulator/hardware simulator.

Defines methods for adding inputs and blocks. Also handles build functions, and information associated with building the Nengo model.

Some of the Model attributes can be modified before the build process to change how certain build functions work. Those attributes are listed first in the attributes section below. To change them, create an instance of Model and pass it in to Simulator along with your network:

model = nengo_loihi.builder.Model(dt=0.001)
model.pes_error_scale = 50.

with nengo_loihi.Simulator(network, model=model) as sim:
    sim.run(1.0)
Parameters
dtfloat, optional (Default: 0.001)

The length of a simulator timestep, in seconds.

labelstr, optional (Default: None)

A name or description to differentiate models.

builderBuilder, optional (Default: None)

A Builder instance to keep track of build functions. If None, the default builder will be used.

Attributes
Build parameters
decode_neuronsDecodeNeurons

Type of neurons used to facilitate decoded (NEF-style) connections.

decode_taufloat

Time constant of lowpass synaptic filter used with decode neurons.

intercept_limitfloat

Limit for clipping intercepts, to avoid neurons with high gains.

node_neuronsDecodeNeurons

Type of neurons used to convert real-valued node outputs to spikes for the chip.

pes_error_scalefloat

Scaling for PES errors, before rounding and clipping to -127..127.

pes_wgt_expint

Learning weight exponent (base 2) for PES learning connections. This controls the maximum weight magnitude (where a larger exponent means larger potential weights, but lower weight resolution).

vth_nonspikingfloat

Voltage threshold for non-spiking neurons (i.e. voltage decoders).

Internal attributes
blockslist of LoihiBlock

List of Loihi blocks simulated by this model.

builderBuilder

The build functions used by this model.

dtfloat

The length of a simulator timestep, in seconds.

chip2host_paramsdict

Mapping from Nengo objects to any additional parameters associated with those objects for use during the build process.

inputslist of LoihiInput

List of inputs to this model.

labelstr or None

A name or description to differentiate models.

objsdict

Dictionary mapping from Nengo objects to Nengo Loihi objects.

paramsdict

Mapping from objects to namedtuples containing parameters generated in the build process.

probeslist

List of all probes. Probes must be added to this list in the build process, as this list is used by Simulator.

seededdict

All objects are assigned a seed, whether the user defined the seed or it was automatically generated. ‘seeded’ keeps track of whether the seed is user-defined. We consider the seed to be user-defined if it was set directly on the object, or if a seed was set on the network in which the object resides, or if a seed was set on any ancestor network of the network in which the object resides.

seedsdict

Mapping from objects to the integer seed assigned to that object.

host_model(self, obj)[source]

Returns the Model corresponding to where obj should be built.

class nengo_loihi.builder.Builder[source]

Fills in the Loihi Model object based on the Nengo Network.

We cannot use the Nengo builder as is because we make normal Nengo networks for host-to-chip and chip-to-host communication. To keep Nengo and Nengo Loihi builders separate, we make a blank subclass, which effectively copies the class.

class nengo_loihi.block.LoihiBlock(n_neurons, label=None)[source]

Class holding Loihi objects that can be placed on the chip.

This class can be thought of as a block of the Loihi board, and is how Nengo Loihi keeps track of how Loihi Neuron cores will be configured. Generally, the job of the build process is to convert Nengo objects (ensembles, connections, nodes, and probes) to LoihiBlocks, which will then be used by the EmulatorInterface or HardwareInterface.

Initially, parameters in a LoihiBlock are floating point values. The discretize_block function converts them to integer values inplace for use on Loihi.

Attributes
axonslist of Axon

Axon objects outputting from the compartments in the block.

compartmentCompartment

Compartment object representing all compartments in the block.

n_neuronsint

The number of neurons in the block.

named_synapsesdict {str: Synape}

Mapping from a name to a Synapse object.

labelstring

A label for the block (for debugging purposes).

probeslist of Probe

Probes recording information from objects in the block.

synapseslist of Synapse

Synapse objects projecting to compartments in the block.

class nengo_loihi.block.Compartment(n_compartments, label=None)[source]

Stores information for configuring Loihi compartments.

The information stored here will be associated with some block, and all compartments will share certain information. While compartments are usually thought of neurons, we use compartments to implement Nengo ensembles, nodes, and connection through special decode neurons.

Before discretize_compartment has been called, most attributes in this class are floating-point values. Calling discretize_compartment converts them to integer values inplace for use on Loihi.

Attributes
bias(n,) ndarray

Compartment biases.

enableNoise(n,) ndarray

Whether to enable noise for each compartment.

decayU(n,) ndarray

Input (synapse) decay constant for each compartment.

decayV(n,) ndarray

Voltage decay constant for each compartment.

labelstring

A label for the block (for debugging purposes).

n_compartmentsint

The number of compartments in the block.

noiseAtDenOrVm{0, 1}

Inject noise into current (0) or voltage (1).

noiseExp0float or int

Exponent for noise generation. Floating point values are base 10 in units of current or voltage. Integer values are in base 2.

noiseMantOffset0float or int

Offset for noise generation.

refractDelay(n,) ndarray

Compartment refractory delays, in time steps.

scaleUbool

Scale input (U) by decayU so that the integral of U is the same before and after filtering.

scaleVbool

Scale voltage (V) by decayV so that the integral of V is the same before and after filtering.

tau_sfloat or None

Time constant used to set decayU. None if decayU has not been set.

vmaxfloat or int (range [2**9 - 1, 2**23 - 1])

Maximum voltage for all compartments, in the same units as vth.

vminfloat or int (range [-2**23 + 1, 0])

Minimum voltage for all compartments, in the same units as vth.

vth(n,) ndarray

Compartment voltage thresholds.

configure_default_filter(self, tau_s, dt=0.001)[source]

Set the default Lowpass synaptic input filter for compartments.

Parameters
tau_sfloat

nengo.Lowpass synapse time constant for filtering.

dtfloat

Simulator time step.

configure_filter(self, tau_s, dt=0.001)[source]

Set Lowpass synaptic input filter for compartments.

Parameters
tau_sfloat

nengo.Lowpass synapse time constant for filtering.

dtfloat

Simulator time step.

configure_lif(self, tau_rc=0.02, tau_ref=0.001, vth=1, dt=0.001, min_voltage=0)[source]

Configure these compartments as individual LIF neurons.

Parameters
tau_rcfloat

Membrane time constant (in seconds) of the neurons.

tau_reffloat

Refractory period (in seconds) of the neurons.

vthfloat

Voltage firing threshold of the neurons.

dtfloat

Simulator time step length (in seconds).

min_voltagefloat

The minimum voltage for the neurons.

configure_nonspiking(self, tau_ref=0.0, vth=1, dt=0.001)[source]

Configure these compartments as individual non-spiking neurons.

Parameters
tau_reffloat

Refractory period (in seconds) of the neurons.

vthfloat

Voltage firing threshold of the neurons.

dtfloat

Simulator time step length (in seconds).

configure_relu(self, tau_ref=0.0, vth=1, dt=0.001)[source]

Configure these compartments as individual Rectified Linear neurons.

These are also known as non-leaky integrate-and-fire neurons. The voltage is the integral of the input current.

Parameters
tau_reffloat

Refractory period (in seconds) of the neurons.

vthfloat

Voltage firing threshold of the neurons.

dtfloat

Simulator time step length (in seconds).

class nengo_loihi.block.Axon(n_axons, label=None)[source]

A group of axons targeting a specific Synapse object.

Attributes
cx_atomslist of length block.n_neurons

Atom (weight index) associated with each block compartment.

cx_to_axon_maplist of length block.n_neurons

Index of the axon in target targeted by each block compartment.

n_axonsint

The number of outgoing axons.

targetSynapse

Target synapses for these axons.

class Spike(axon_id, atom=0)[source]

A spike targeting a particular axon within a Synapse object.

The Synapse target is implicit, given by the Axon object that creates this Spike.

Parameters
axon_idint

The index of the axon within the targeted Synapse object.

atomint, optional (Default: 0)

An index into the target Synapse weights. This allows spikes targeting a particular axon to use different weights.

property slots_per_axon

The number of axonCfg slots occupied by each axon.

axon_slots(self)[source]

The total number of axonCfg slots used by all axons.

class nengo_loihi.block.Synapse(n_axons, label=None)[source]

A group of Loihi synapses that share some properties.

Attributes
axon_cx_baseslist or None

List providing ax cx_base (compartment offset) for each input axon.

axon_to_weight_mapdict or None

Map from input axon index to weight index, to allow weights to be re-used by axons. If None, the weight index for an input axon is the axon index.

indices(population, axon, compartment) ndarray

The synapse indices.

learningbool

Whether synaptic tracing and learning is enabled for these synapses.

learning_ratefloat

The learning rate.

learning_wgt_expint

The weight exponent used on this connection if learning is enabled.

n_axonsint

Number of input axons to this group of synapses.

pop_typeint (0, 16, 32)

Whether these synapses are discrete (0), pop16, or pop32. This determines the type of axons these synapses can connect to.

synapse_fmtSynapseFmt

The synapse format object for these synapses.

tracing_magfloat

Magnitude by which the learning trace is increased for each spike.

tracing_tauint

Decay time constant for the learning trace, in timesteps (not seconds).

weights(n_axons,) list of (n_populations, n_compartments) ndarray

The synapse weights. Organized as a list of arrays so each axon can have a different number of target compartments.

class nengo_loihi.block.Probe(target=None, key=None, slice=None, weights=None, synapse=None)[source]

Record data from compartment states of a LoihiBlock.

Parameters
targetLoihiBlock

The block to record values from. Use slice to record from a subset of compartments.

keystring (‘current’, ‘voltage’, ‘spiked’)

The compartment attribute to probe.

sliceslice or list

Select a subset of the compartments in the block to record from.

synapsenengo.synapses.Synapse

A synapse to use for filtering the probe.

weightsnp.ndarray

A linear transformation to apply to the outputs.

Decode neurons

Decode neurons facilitate NEF-style connections on the chip. The type of decode neurons used by a model can be set on builder.Model.

nengo_loihi.decode_neurons.DecodeNeurons([dt])

Defines parameters for a group of decode neurons.

nengo_loihi.decode_neurons.OnOffDecodeNeurons([…])

One or more pairs of on/off neurons per dimension.

nengo_loihi.decode_neurons.NoisyDecodeNeurons(…)

Uses multiple on/off neuron pairs per dimension, plus noise.

nengo_loihi.decode_neurons.Preset5DecodeNeurons([…])

Uses five heterogeneous on/off pairs with pre-set values per dimension.

nengo_loihi.decode_neurons.Preset10DecodeNeurons([…])

Uses ten heterogeneous on/off pairs with pre-set values per dimension.

class nengo_loihi.decode_neurons.DecodeNeurons(dt=0.001)[source]

Defines parameters for a group of decode neurons.

DecodeNeurons are used on the chip to facilitate NEF-style connections, where activities from a neural ensemble are first transformed into a decoded value (which is stored in the activities and synapses of the spiking decode neurons), before being passed on to another ensemble (via that ensemble’s encoders).

Parameters
dtfloat

Time step used by the simulator.

get_block(self, weights, block_label=None, syn_label=None)[source]

Get a LoihiBlock for implementing neurons on the chip.

Parameters
weights(d, n) ndarray

Weights that project the n inputs to the d dimensions represented by these neurons. Typically, the inputs will be neurons belonging to an Ensemble, and these weights will be decoders.

block_labelstring (Default: None)

Optional label for the LoihiBlock.

syn_labelstring (Default: None)

Optional label for the Synapse.

Returns
blockLoihiBlock

The neurons on the chip.

synSynapse

The synapses connecting into the chip neurons.

get_ensemble(self, dim)[source]

Get a Nengo Ensemble for implementing neurons on the host.

Parameters
dimint

Number of dimensions to be represented by these neurons.

Returns
ensEnsemble

An Ensemble for implementing these neurons in a Nengo network.

get_post_encoders(self, encoders)[source]

Encoders for post population that these neurons connect in to.

Parameters
encoders(n, d) ndarray

Regular scaled encoders for the ensemble, which map the ensemble’s d input dimensions to its n neurons.

Returns
decode_neuron_encoders(?, n) ndarray

Encoders for mapping these neurons to the post-ensemble’s neurons. The number of rows depends on how get_post_inds is being used (i.e. there could be one row per neuron in this block, or there could be fewer rows with get_post_inds mapping multiple neurons to each row).

get_post_inds(self, inds, d)[source]

Indices for mapping neurons to post-encoder dimensions.

Parameters
indslist of ints

Indices for mapping decode neuron dimensions to post-ensemble dimensions. Usually, this will be determined by a slice on the post ensemble in a connection (which maps the output of the transform/function to select dimensions on the post ensemble).

dint

Number of dimensions in the post-ensemble.

class nengo_loihi.decode_neurons.OnOffDecodeNeurons(pairs_per_dim=1, dt=0.001, rate=None)[source]

One or more pairs of on/off neurons per dimension.

In this class itself, all the pairs in a dimension are identical. It can still be advantageous to have more than one pair per dimension, though, since this can allow all neurons to have lower firing rates and thus act more linearly (due to period aliasing at high firing rates). Subclasses may use pairs that are not identical (by adding noise or heterogeneity).

Parameters
pairs_per_dimint

Number of repeated neurons per dimension. Currently, all DecodeNeuron classes use separate on/off neuron pairs for each dimension. This is the number of such pairs per dimension.

dtfloat

Time step used by the simulator.

ratefloat (Default: None)

Max firing rate of each neuron. By default, this is chosen so that the sum of all repeated neuron rates is 1. / dt, and thus as a group the neurons average one spike per timestep.

get_block(self, weights, block_label=None, syn_label=None)[source]

Get a LoihiBlock for implementing neurons on the chip.

Parameters
weights(d, n) ndarray

Weights that project the n inputs to the d dimensions represented by these neurons. Typically, the inputs will be neurons belonging to an Ensemble, and these weights will be decoders.

block_labelstring (Default: None)

Optional label for the LoihiBlock.

syn_labelstring (Default: None)

Optional label for the Synapse.

Returns
blockLoihiBlock

The neurons on the chip.

synSynapse

The synapses connecting into the chip neurons.

get_ensemble(self, dim)[source]

Get a Nengo Ensemble for implementing neurons on the host.

Parameters
dimint

Number of dimensions to be represented by these neurons.

Returns
ensEnsemble

An Ensemble for implementing these neurons in a Nengo network.

get_post_encoders(self, encoders)[source]

Encoders for post population that these neurons connect in to.

Parameters
encoders(n, d) ndarray

Regular scaled encoders for the ensemble, which map the ensemble’s d input dimensions to its n neurons.

Returns
decode_neuron_encoders(?, n) ndarray

Encoders for mapping these neurons to the post-ensemble’s neurons. The number of rows depends on how get_post_inds is being used (i.e. there could be one row per neuron in this block, or there could be fewer rows with get_post_inds mapping multiple neurons to each row).

get_post_inds(self, inds, d)[source]

Indices for mapping neurons to post-encoder dimensions.

Parameters
indslist of ints

Indices for mapping decode neuron dimensions to post-ensemble dimensions. Usually, this will be determined by a slice on the post ensemble in a connection (which maps the output of the transform/function to select dimensions on the post ensemble).

dint

Number of dimensions in the post-ensemble.

class nengo_loihi.decode_neurons.NoisyDecodeNeurons(pairs_per_dim, dt=0.001, rate=None, noise_exp=-2.0)[source]

Uses multiple on/off neuron pairs per dimension, plus noise.

The noise allows each on-off neuron pair to do something different. The population average is a better representation of the encoded value than can be achieved with a single on/off neuron pair (if the magnitude of the noise is correctly calibrated).

Parameters
pairs_per_dimint

Number of repeated neurons per dimension. Currently, all DecodeNeuron classes use separate on/off neuron pairs for each dimension. This is the number of such pairs per dimension.

dtfloat

Time step used by the simulator.

ratefloat (Default: None)

Max firing rate of each neuron. By default, this is chosen so that the sum of all repeated neuron rates is 1. / dt, and thus as a group the neurons average one spike per timestep.

noise_expfloat, optional (Default: -2.)

Base-10 exponent for noise added to neuron voltages.

get_block(self, weights, block_label=None, syn_label=None)[source]

Get a LoihiBlock for implementing neurons on the chip.

Parameters
weights(d, n) ndarray

Weights that project the n inputs to the d dimensions represented by these neurons. Typically, the inputs will be neurons belonging to an Ensemble, and these weights will be decoders.

block_labelstring (Default: None)

Optional label for the LoihiBlock.

syn_labelstring (Default: None)

Optional label for the Synapse.

Returns
blockLoihiBlock

The neurons on the chip.

synSynapse

The synapses connecting into the chip neurons.

class nengo_loihi.decode_neurons.Preset5DecodeNeurons(dt=0.001, rate=None)[source]

Uses five heterogeneous on/off pairs with pre-set values per dimension.

The script for configuring these values can be found at:

nengo-loihi-sandbox/utils/interneuron_unidecoder_design.py

class nengo_loihi.decode_neurons.Preset10DecodeNeurons(dt=0.001, rate=None)[source]

Uses ten heterogeneous on/off pairs with pre-set values per dimension.

The script for configuring these values can be found at:

nengo-loihi-sandbox/utils/interneuron_unidecoder_design.py

Discretization

nengo_loihi.discretize.discretize_model(model)[source]

Discretize a Model in-place.

Turns a floating-point Model into a discrete (integer) model appropriate for Loihi.

Parameters
modelModel

The model to discretize.

nengo_loihi.discretize.discretize_block(block)[source]

Discretize a LoihiBlock in-place.

Turns a floating-point LoihiBlock into a discrete (integer) block appropriate for Loihi.

Parameters
blockLoihiBlock

The block to discretize.

nengo_loihi.discretize.discretize_compartment(comp, w_max)[source]

Discretize a Compartment in-place.

Turns a floating-point Compartment into a discrete (integer) block appropriate for Loihi.

Parameters
compCompartment

The compartment to discretize.

w_maxfloat

The largest connection weight in the LoihiBlock containing comp. Used to set several scaling factors.

nengo_loihi.discretize.discretize_synapse(synapse, w_max, w_scale, w_exp)[source]

Discretize a Synapse in-place.

Turns a floating-point Synapse into a discrete (integer) block appropriate for Loihi.

Parameters
synapseSynapse

The synapse to discretize.

w_maxfloat

The largest connection weight in the LoihiBlock containing synapse. Used to scale weights appropriately.

w_scalefloat

Connection weight scaling factor. Usually computed by discretize_compartment.

w_expfloat

Exponent on the connection weight scaling factor. Usually computed by discretize_compartment.

Emulator

nengo_loihi.emulator.EmulatorInterface(model)

Software emulator for Loihi chip behaviour.

nengo_loihi.emulator.interface.BlockInfo(blocks)

Provide information about all the LoihiBlocks in the model.

nengo_loihi.emulator.interface.IterableState(…)

Base class for aspects of the emulator state.

nengo_loihi.emulator.interface.CompartmentState(…)

State representing the Compartments of all blocks.

nengo_loihi.emulator.interface.NoiseState(…)

State representing the noise parameters for all compartments.

nengo_loihi.emulator.interface.SynapseState(…)

State representing all synapses.

nengo_loihi.emulator.interface.AxonState(…)

State representing all (output) Axons.

nengo_loihi.emulator.interface.ProbeState(…)

State representing all probes.

class nengo_loihi.emulator.EmulatorInterface(model, seed=None)[source]

Software emulator for Loihi chip behaviour.

Parameters
modelModel

Model specification that will be simulated.

seedint, optional (Default: None)

A seed for all stochastic operations done in this simulator.

run_steps(self, steps)[source]

Simulate for the given number of dt steps.

Parameters
stepsint

Number of steps to run the simulation for.

step(self)[source]

Advance the simulation by 1 step (dt seconds).

class nengo_loihi.emulator.interface.BlockInfo(blocks)[source]

Provide information about all the LoihiBlocks in the model.

Attributes
dtypedtype

Datatype of the blocks. Either np.float32 if the blocks are not discretized or np.int32 if they are. All blocks are the same.

blockslist of LoihiBlock

List of all the blocks in the model.

n_compartmentsint

Total number of compartments across all blocks.

slicesdict of {LoihiBlock: slice}

Maps each block to a slice for that block’s compartments with respect to all compartments. Used to slice into any array storing data across all compartments.

class nengo_loihi.emulator.interface.IterableState(block_info, block_key, strict=True)[source]

Base class for aspects of the emulator state.

This class takes the name of a LoihiBlock attribute as the block_key and maps these objects to their parent blocks and slices.

Attributes
dtypedtype

Datatype of the state elements (given by the BlockInfo datatype).

block_mapdict of {item: block}

Maps an item (determined by block_key) to the block it belongs to.

n_compartmentsint

The total number of neuron compartments (given by BlockInfo).

slicesdict of {item: slice}

Maps an item to the block_info.slice for the block it belongs to.

strictbool (Default: True)

Whether “undesired” chip effects (ex. overflow) raise errors (True) or whether they only raise warnings (False).

class nengo_loihi.emulator.interface.CompartmentState(block_info, strict=True)[source]

State representing the Compartments of all blocks.

class nengo_loihi.emulator.interface.NoiseState(block_info)[source]

State representing the noise parameters for all compartments.

class nengo_loihi.emulator.interface.SynapseState(block_info, pes_error_scale=1.0, strict=True)[source]

State representing all synapses.

Attributes
pes_error_scalefloat

Scaling for the errors of PES learning rules.

pes_errors{Synapse: ndarray(n_neurons / 2)}

Maps synapse to PES learning rule errors for those synapses.

spikes_in{Synapse: list}

Maps synapse to a queue of input spikes targeting those synapses.

traces{Synapse: ndarray(Synapse.n_axons)}

Maps synapse to trace values for each of their axons.

trace_spikes{Synapse: set}

Maps synapse to a queue of input spikes waiting to be added to those synapse traces.

class nengo_loihi.emulator.interface.AxonState(block_info)[source]

State representing all (output) Axons.

class nengo_loihi.emulator.interface.ProbeState(block_info, inputs, dt)[source]

State representing all probes.

Attributes
dtfloat

Time constant of the Emulator.

filters{nengo_loihi.Probe: function}

Maps Probes to the filtering function for that probe.

filter_pos{nengo_loihi.Probe: int}

Maps Probes to the position of their filter in the data.

block_probes{nengo_loihi.Probe: slice}

Maps Probes to the BlockInfo slice for the block they are probing.

input_probes{nengo_loihi.Probe: SpikeInput}

Maps Probes to the SpikeInput that they are probing.

send(self, probe, already_sent, receiver)[source]

Send probed data to the receiver node.

Returns
stepsint

The number of steps sent to the receiver.

Hardware

nengo_loihi.hardware.HardwareInterface(model)

Place a Model onto a Loihi board and run it.

class nengo_loihi.hardware.HardwareInterface(model, use_snips=True, seed=None, snip_max_spikes_per_step=50, allocator=<nengo_loihi.hardware.allocators.OneToOne object>)[source]

Place a Model onto a Loihi board and run it.

Parameters
modelModel

Model specification that will be placed on the Loihi board.

use_snipsboolean, optional (Default: True)

Whether to use snips (e.g., for precompute=False).

seedint, optional (Default: None)

A seed for stochastic operations.

snip_max_spikes_per_stepint

The maximum number of spikes that can be sent to the chip in one timestep if .use_snips is True.

allocatorAllocator, optional (Default: OneToOne())

Callable object that allocates the board’s devices to given models. Defaults to one block and one input per core on a single chip.