API Reference: hxtorch¶

hxtorch from Python¶

hxtorch.spiking.experiment.BaseExperiment : public ABC

Subclassed by hxtorch.spiking.experiment.Experiment

Public Functions

__init__(self, BaseModuleManager modules, bool mock, float dt)¶

connect(self, torch.nn.Module module, handle.TensorHandle input_handles, handle.TensorHandle output_handle)¶

get_hw_results(self, Optional[int] runtime)¶

Public Members

dt¶

mock¶

modules¶

hxtorch.spiking.backend.module_manager.BaseModuleManager : public ABC

Abstract base class for module manager.

Subclassed by hxtorch.spiking.backend.module_manager.ModuleManager

Public Functions

__init__(self)¶

__str__(self)¶: Add proper object string.

add_node(self, Module module, Source sources, Target target)¶

Adds a new module to the manager.

This method adds a node to the internal graph to reporesent the module. It assigned edges to this node holding the data in sources, resp. target. :param module: Module to represented in to the graph. :param sources: The sources to the node representing module. :param targets: The targets of the node representing module.

add_wrapper(self, Wrapper wrapper)¶

Adds a new wrapper to the manager.

This must be called after all modules wrapped by this wrapper are represented in the graph. internal graph to reporesent the module. It assigned edges to this node holding the data in sources, resp. target. :param module: Module to represented in to the graph.

clear(self)¶: Clear the internal graph and remove the module -> node and wrapper -> node mapping.

done(self)¶

Create a list of elements of form (module, sources, targets), which can be looped in the correct order.

:return: Returns the a list of nodes to be executed.

Public Members

graph¶

hxtorch.spiking.modules.batch_dropout.BatchDropout : public hxtorch.spiking.modules.types.Population

Batch dropout layer.

Caveat: In-place operations on TensorHandles are not supported. Must be placed after a neuron layer, i.e. Neuron.

Public Functions

__init__(self, int size, float dropout, Experiment experiment, Union[Callable, torch.autograd.Function] func=F.batch_dropout)¶

Initialize BatchDropout layer.

This layer disables spiking neurons in the previous spiking Neuron layer with a probability of dropout. Note, size has to be equal to the size in the corresponding spiking layer. The spiking mask is maintained for the whole batch.

:param size: Size of the population this dropout layer is applied to. :param dropout: Probability that a neuron in the precessing layer gets disabled during training. :param experiment: Experiment to append layer to. :param func: Callable function implementing the module’s forward functionallity or a torch.autograd.Function implementing the module’s forward and backward operation. Defaults to batch_dropout.

mask(self)¶

Getter for spike mask.

:returns: Returns the current spike mask.

mask(self, torch.Tensor mask)¶

Setter for the spike mask.

:param mask: Spike mask. Must be of shape (self.size,).

set_mask(self)¶

Creates a new random dropout mask, applied to the spiking neurons in the previous module.

If module.eval() dropout will be disabled.

:returns: Returns a random boolen spike mask of size self.size.

Public Members

extra_args¶

mask¶

size¶

Public Static Attributes

Type¶

Private Members

_changed_since_last_run¶

_dropout¶

_mask¶

hxtorch.perceptron.nn.Conv1d : public hxtorch.perceptron.nn.ConvNd , public torch.nn.Conv1d

Applies a 1D convolution over an input signal composed of several input planes.

Subclassed by hxtorch.perceptron.nn.ExpandedConv1d

Public Functions

__init__(self, Integral in_channels, Integral out_channels, Union[Integral, Tuple[Integral]] kernel_size, Integral stride=1, Union[Integral, Tuple[Integral, Integral]] padding=0, Union[Integral, Tuple] dilation=1, Integral groups=1, bool bias=True, str padding_mode='zeros', Optional[Integral] num_sends=None, Integral wait_between_events=defaults.wait_between_events, bool mock=False, *Optional[Callable[[torch.Tensor], torch.Tensor]] input_transform=None, Optional[Callable[[torch.Tensor], torch.Tensor]] weight_transform=clamp_weight_)¶

:param in_channels: Number of channels in the input :param out_channels: Number of channels produced by the convolution :param kernel_size: Size of the convolving kernel :param stride: Stride of the convolution :param padding: Zero-padding added to both sides of the input :param padding_mode: ‘zeros’, ‘reflect’, ‘replicate’ or ‘circular’ :param dilation: Spacing between kernel elements :param groups: Number of blocked connections from input channels to output channels :param bias: If True, adds a learnable bias to the output :param num_sends: Number of sends of the input.

Values greater than 1 result in higher output to the neurons and increases the s/n ratio. For None this is automatically adjusted during initialization. :param wait_between_events: Wait time between two successive vector inputs, in FPGA clock cycles. Shorter wait time can lead to saturation of the synaptic input. :param mock: Enable mock mode. :param input_transform: Function that receives the input and returns a tensor to be used as input to the chip. :param weight_transform: Function that receives the weight and returns a tensor to be used as weight matrix on the chip.

Private Members

_conv¶

hxtorch.perceptron.nn.Conv2d : public hxtorch.perceptron.nn.ConvNd , public torch.nn.Conv2d

Applies a 2D convolution over an input image composed of several input planes.

Public Functions

__init__(self, Integral in_channels, Integral out_channels, Union[Integral, Tuple[Integral, Integral]] kernel_size, Integral stride=1, Union[Integral, Tuple[Integral, Integral]] padding=0, Integral dilation=1, Integral groups=1, bool bias=True, str padding_mode='zeros', Optional[Integral] num_sends=None, Integral wait_between_events=defaults.wait_between_events, bool mock=False, *Optional[Callable[[torch.Tensor], torch.Tensor]] input_transform=None, Optional[Callable[[torch.Tensor], torch.Tensor]] weight_transform=clamp_weight_)¶

:param in_channels: Number of channels in the input :param out_channels: Number of channels produced by the convolution :param kernel_size: Size of the convolving kernel :param stride: Stride of the convolution :param padding: Zero-padding added to both sides of the input :param padding_mode: ‘zeros’, ‘reflect’, ‘replicate’ or ‘circular’ :param dilation: Spacing between kernel elements :param groups: Number of blocked connections from input channels to output channels :param bias: If True, adds a learnable bias to the output :param num_sends: Number of sends of the input.

Values greater than 1 result in higher output to the neurons and increases the s/n ratio. For None this is automatically adjusted during initialization. :param mock: Enable mock mode. :param wait_between_events: Wait time between two successive vector inputs, in FPGA clock cycles. Shorter wait time can lead to saturation of the synaptic input. :param input_transform: Function that receives the input and returns a tensor to be used as input to the chip. :param weight_transform: Function that receives the weight and returns a tensor to be used as weight matrix on the chip.

Private Members

_conv¶

hxtorch.perceptron.nn.ConvertingReLU : public hxtorch.perceptron.nn.ReLU

Applies a rectified linear unit to the input, shifts and clips to the input range of the chip.

Public Functions

__init__(self, Integral shift=2, bool mock=False)¶: :param shift: Number of bits the result is shifted by :param mock: Enable mock mode

forward(self, torch.Tensor input)¶

Public Members

shift¶

hxtorch.perceptron.nn.ConvNd : public hxtorch.perceptron.nn.MACLayer , public torch.nn.modules.conv._ConvNd

Base class for n-dimensional convolution.

Subclassed by hxtorch.perceptron.nn.Conv1d, hxtorch.perceptron.nn.Conv2d

Public Functions

forward(self, input)¶

Public Members

padding_mode¶

Private Functions

_conv(self, torch.Tensor input, torch.Tensor weight, torch.Tensor bias, Tuple[Integral, ...] stride, **kwargs)¶: Implementation of convolution function.

hxtorch.spiking.transforms.encode.CoordinatesToSpikes : public torch.nn.Module

Convert values between 0 and 1 to spikes in a given timeframe.

Public Functions

__init__(self, int seq_length, float t_early, float t_late, float dt=1.e-6, Optional[float] t_bias=None, torch.device device=torch.device("cpu"))¶

Construct a coordinates-to-spikes converter.

This converter takes coordinate values in [0, 1] and maps them to spike times in interval [t_early, t_late]. A spike is indicated by a 1 on a dense time axis of length seq_length with temporal resolution dt. Further, it adds a bias spike at time t_bias, if t_bias is not None.

:param seq_length: Number of time steps in the resulting time sequence. The effective time length is given by seq_length * dt. :param t_early: The earliest time a spike will occur. :param t_late: The latest time a spike will occur. :param dt: The temporal resolution. :param t_bias: The time a bias spike occurs.

forward(self, torch.Tensor coordinate_values)¶

Convert coordinate values of to dense spike tensor of zeros and ones.

:param coordinate_values: Tensor with values in [0, 1], shaped (batch_size, num_channels)

:returns: Returns a dense tensor of shape (batch_size, seq_length, num_channels)

Private Members

_dev¶

_dt¶

_seq_length¶

_t_bias¶

_t_early¶

_t_late¶

hxtorch.spiking.functional.iaf.CUBAIAFParams : public NamedTuple

Parameters for IAF integration and backward path.

Public Static Attributes

float¶

str¶

Tensor¶

hxtorch.spiking.functional.lif.CUBALIFParams : public NamedTuple

Parameters for CUBA LIF integration and backward path.

Public Static Attributes

float¶

str¶

Tensor¶

hxtorch.spiking.functional.li.CUBALIParams : public NamedTuple

Parameters for CUBA LI integration and backward path.

Public Static Attributes

Tensor¶

hxtorch.perceptron.nn.ExpandedConv1d : public hxtorch.perceptron.nn.Conv1d

Unrolls the weight matrix for execution on hardware.

This maximizes the use of the synapses array.

Caveat: Fixed-pattern noise cannot be individually compensated for during training, because the same weights are used at different locations!

Public Functions

__init__(self, int in_channels, int out_channels, Union[int, Tuple[int]] kernel_size, int stride=1, Union[int, Tuple[int, int]] padding=0, Union[int, Tuple] dilation=1, int groups=1, bool bias=True, str padding_mode='zeros', Optional[int] num_sends=None, int wait_between_events=defaults.wait_between_events, bool mock=False, *Optional[Callable[[torch.Tensor], torch.Tensor]] input_transform=None, Optional[Callable[[torch.Tensor], torch.Tensor]] weight_transform=clamp_weight_, Optional[int] num_expansions=None)¶

:param in_channels: Number of channels in the input :param out_channels: Number of channels produced by the convolution :param kernel_size: Size of the convolving kernel :param stride: Stride of the convolution :param padding: Zero-padding added to both sides of the input :param padding_mode: ‘zeros’, ‘reflect’, ‘replicate’ or ‘circular’ :param dilation: Spacing between kernel elements :param groups: Number of blocked connections from input channels to output channels :param bias: If True, adds a learnable bias to the output :param num_sends: Number of sends of the input.

Values greater than 1 result in higher output to the neurons and increases the s/n ratio. For None this is automatically adjusted during initialization. :param wait_between_events: Wait time between two successive vector inputs, in FPGA clock cycles. Shorter wait time can lead to saturation of the synaptic input. :param mock: Enable mock mode. :param input_transform: Function that receives the input and returns a tensor to be used as input to the chip. :param weight_transform: Function that receives the weight and returns a tensor to be used as weight matrix on the chip. :param num_expansions: Number of enrolled kernels in a single operation

extra_repr(self)¶

Public Members

num_expansions¶

Private Functions

_conv(self, *args, **kwargs)¶

hxtorch.spiking.experiment.Experiment : public hxtorch.spiking.experiment.BaseExperiment

Experiment class for describing experiments on hardware.

Public Functions

__init__(self, bool mock=False, float dt=1e-6, Optional[Union[Path, str]] calib_path=None, hw_routing_func=grenade.network.build_routing, grenade.signal_flow.ExecutionInstance execution_instance=grenade.signal_flow.ExecutionInstance())¶

Instanziate a new experiment, represting an experiment on hardware and/or in software.

:param mock: Indicating whether module is executed on hardware (False) or simulated in software (True).

clear(self)¶

Reset the experiments’s state.

Corresponds to creating a new Experiment instance.

connect(self, torch.nn.Module module, Tuple[handle.TensorHandle] input_handles, handle.TensorHandle output_handle)¶

Add an module to the experiment and connect it to other experiment modules via input and output handles.

:param module: The HXModule to add to the experiment. :param input_handles: The TensorHandle serving as input to the module (its obsv_state). :param output_handle: The TensorHandle outputted by the module, serving as input to subsequent HXModules.

get_hw_results(self, Optional[int] runtime)¶

Executes the experiment in mock or on hardware using the information added to the experiment for a time given by runtime and returns a dict of hardware data represented as PyTorch data types.

:param runtime: The runtime of the experiment on hardware in ms.

:returns: Returns the data map as dict, where the keys are the population descriptors and values are tuples of values returned by the correpsonding module’s post_process method.

load_calib(self, Optional[Union[Path, str]] calib_path=None)¶

Load a calibration from path calib_path and apply to the experiment`s chip object.

If no path is specified a nightly calib is applied. :param calib_path: The path to the calibration. It None, the nightly calib is loaded. :return: Returns the chip object for the given calibration.

register_population(self, spiking_modules.HXModule module)¶

Register a module as population.

:param module: The module to register as population.

register_projection(self, spiking_modules.HXModule module)¶

Register a module as projection.

:param module: The module to register as projection.

wrap_modules(self, List[spiking_modules.HXModule] modules, Optional[Callable] func=None)¶

Wrap a number of given modules into a wrapper to which a single function func can be assigned.

In the PyTorch graph the individual module functions are then bypassed and only the wrapper’s function is considered when building the PyTorch graph. This functionality is of interest if several modules have cyclic dependencies and need to be represented by one PyTorch function. :param modules: A list of module to be wrapped. These modules need to constitute a closed sub-graph with no modules in between that are not element of the wrapper. :func: The function to assign to the wrapper. TODO: Add info about this functions signature.

Public Members

cadc_recording¶

execution_instance¶

grenade_network¶

grenade_network_graph¶

has_madc_recording¶

hw_routing_func¶

id_counter¶

injection_inside_realtime_begin¶

injection_inside_realtime_end¶

injection_post_realtime¶

injection_pre_realtime¶

injection_pre_static_config¶

neuron_placement¶

Private Functions

_configure_populations(self)¶: Configure the population on hardware.

_generate_inputs(self, grenade.network.NetworkGraph network_graph)¶: Generate external input events from the routed network graph representation.

_generate_network_graphs(self)¶

Generate grenade network graph from the populations and projections in modules.

:return: Returns the grenade network graph.

_generate_playback_hooks(self)¶: Handle injected config (not suppored yet)

_get_population_observables(self, grenade.network.NetworkGraph network_graph, grenade.signal_flow.IODataMap result_map, runtime)¶

Takes the greade network graph and the result map returned by grenade after experiment execution and returns a data map where for each population descriptor of registered populations the population-specific hardware observables are represented as Optional[torch.Tensor]s.

Note: This function calles the modules post_process method. :param network_graph: The logical grenade network graph describing the logic of th experiment. :param result_map: The result map returned by grenade holding all recorded hardware observables. :param runtime: The runtime of the experiment executed on hardware in ms. :returns: Returns the data map as dict, where the keys are the population descriptors and values are tuples of values returned by the correpsonding module’s post_process method.

_prepare_static_config(self)¶

Prepares all the static chip config.

Accesses the chip object initialized by hxtorch.hardware_init and appends corresponding configurations to. Additionally this method defines the pre_static_config builder injected to grenade at run.

Private Members

_batch_size¶

_chip¶

_populations¶

_projections¶

_static_config_prepared¶

hxtorch.spiking.handle.HandleMeta : public type

Meta class to create Handle types with properties.

Subclassed by hxtorch.spiking.handle.TensorHandle

Public Functions

__new__(mcs, clsname, bases, dict_)¶: Create a new instance of the given class.

hxtorch.spiking.modules.hx_module.HXModule : public torch.nn.Module

PyTorch module supplying basic functionality for building SNNs on HX.

Subclassed by hxtorch.spiking.modules.hx_module_wrapper.HXModuleWrapper, hxtorch.spiking.modules.input_neuron.InputNeuron, hxtorch.spiking.modules.types.Population, hxtorch.spiking.modules.types.Projection

Public Functions

__init__(self, Experiment experiment, Union[Callable, torch.autograd.Function] func)¶

:param experiment: Experiment to append layer to.

:param func: Callable function implementing the module’s forward functionallity or a torch.autograd.Function implementing the module’s forward and backward operation. TODO: Inform about func args

changed_since_last_run(self)¶

Getter for changed_since_last_run.

:returns: Boolean indicating wether module changed since last run.

exec_forward(self, Union[Tuple[TensorHandle], TensorHandle] input, TensorHandle output, Dict[grenade.PopulationDescriptor, Tuple[torch.Tensor]] hw_map)¶: Inject hardware observables into TensorHandles or execute forward in mock-mode.

forward(self, *Union[Tuple[TensorHandle], TensorHandle] input)¶

Forward method registering layer operation in given experiment.

Input and output references will hold corresponding data as soon as ‘hxtorch.run’ in executed.

:param input: Reference to TensorHandle holding data tensors as soon as required.

:returns: Returns a Reference to TensorHandle holding result data asociated with this layer after ‘hxtorch.run’ is executed.

func(self)¶

func(self, Callable function)¶

Assign a PyTorch-differentiable function to the module.

   :param function: The function describing the modules f

post_process(self, Optional[DataHandle] hw_spikes, Optional[DataHandle] hw_cadc, Optional[DataHandle] hw_madc)¶

This methods needs to be overridden for every derived module that demands hardware observables.

:returns: Hardware data represented as torch.Tensors. Note that torch.Tensors are required here to enable gradient flow.

reset_changed_since_last_run(self)¶

Reset changed_since_last_run.

Sets the corresponding flag to false.

Public Members

experiment¶

func¶

Public Static Attributes

Type¶

Private Functions

_prepare_func(self, function)¶

Strips all args and kwargs excluding input and hw_data from self._func.

If self._func does not have an hw_data keyword argument the prepared function will have it. This unifies the signature of all functions used in exec_forward to func(input, hw_data=...). :param function: The function to be used for building the PyTorch graph. :returns: Returns the member ‘func(input, *args, **kwrags, hw_data=…)’ stripped down to ‘func(input, hw_data=…).

_wrap_func(self, function)¶

Private Members

_changed_since_last_run¶

_func¶

_func_is_wrapped¶

_output_handle¶

hxtorch.spiking.modules.hx_module_wrapper.HXModuleWrapper : public hxtorch.spiking.modules.hx_module.HXModule

Class to wrap HXModules.

Public Functions

__init__(self, Experiment experiment, List[HXModule] modules, Optional[Callable] func)¶

A module which wrappes a number of HXModules defined in modules to which a single PyTorch-differential function func is defined.

For instance, this allows to wrap a Synapse and a Neuron to descripe recurrence. :param experiment: The experiment to register this wrapper in. :param modules: A list of modules to be represented by this wrapper. :param func: The function describing the unified functionallity of all modules assigned to this wrapper. As for HXModules, this needs to be a PyTorch-differentiable function and can be either an autograd.Function or a function defined by PyTorch operation. The signature of this function is expected as:

All positional arguments of each function in modules appended in the order given in modules.
All keywords arguments of each function in modules. If a keyword is occurred multiple times it is post-fixed _i, where i is an integered incremented with each occurrence.
A keyword argument hw_data if hardware data is expected, which is a tuple holding the data for each module for which data is expected. The order is defined by modules. The function is expected to output a tensor or a tuple of tensors for each module in modules, that can be assigned to the output handle of the corresponding HXModule.

contains(self, List[HXModule] modules)¶

Checks whether a list of modules modules is registered in the wrapper.

:param modules: The modules for which to check if they are registered. :return: Returns a bool indicating whether modules are a subset.

exec_forward(self, Tuple[TensorHandle] input, Tuple[TensorHandle] output, Dict[grenade.PopulationDescriptor, Tuple[torch.Tensor]] hw_map)¶

Execute the the forward function of the wrapper.

This method assigns each output handle in output their corresponding PyTorch tensors and adds the wrapper’s func to the PyTorch graph. :param input: A tuple of the input handles where each handle corresponds to a certain module. The order is defined by modules. Note, a module can have multiple input handles. :param output: A tuole of output handles, each correspnding to one module. The order is defined by modules. :param hw_map: The hardware data map.

update(self, List[HXModule] modules, Optional[Callable] func=None)¶

Update the modules and the function in the wrapper.

:param modules: The new modules to assign to the wrapper. :param func: The new function to represent the modules in the wrapper.

update_args(self, List[HXModule] modules)¶

Gathers the args and kwargs of all modules in modules and renames keyword arguments that occur multiple times.

:param modules: The modules represented by the wrapper.

Public Members

extra_args¶

extra_kwargs¶

func¶

modules¶

hxtorch.spiking.functional.iaf.IAF : public torch.autograd.Function

IAF forward mock and backward.

Public Static Functions

backward(ctx, torch.Tensor grad_output)¶: Implements LIF backward.

forward(ctx, torch.Tensor input)¶: Gets overridden.

hxtorch.spiking.modules.iaf_neuron.IAFNeuron : public hxtorch.spiking.modules.neuron.Neuron

Integrate-and-fire neuron Caveat: For execution on hardware, this module can only be used in conjuction with a preceding Synapse module.

Public Functions

__init__(self, int size, Experiment experiment, Union[Callable, torch.autograd.Function] func=F.IAF, Optional[NamedTuple] params=None, bool enable_spike_recording=True, bool enable_cadc_recording=True, bool enable_madc_recording=False, Optional[int] record_neuron_id=None, Optional[List[halco.LogicalNeuronOnDLS]] placement_constraint=None, Union[Dict[halco.AtomicNeuronOnDLS, float], torch.Tensor, float] trace_offset=0., Union[Dict[halco.AtomicNeuronOnDLS, float], torch.Tensor, float] trace_scale=1., int cadc_time_shift=1, bool shift_cadc_to_first=False, str interpolation_mode="linear", Optional[Morphology] neuron_structure=None)¶

Initialize an IAFNeuron.

This module creates a population of a non- leaking spiking neurons of size size. This module has a internal spiking mask, which allows to disable the event ouput and spike recordings of specific neurons within the layer. This is particularly useful for dropout.

:param size: Size of the population. :param experiment: Experiment to append layer to. :param func: Callable function implementing the module’s forward functionallity or a torch.autograd.Function implementing the module’s forward and backward operation. Defaults to LIF. :param params: Neuron Parameters in case of mock neuron integration of for backward path. If func does have a param argument the params object will get injected automatically. :param enable_spike_recording: Boolean flag to enable or disable spike recording. Note, this does not disable the event out put of neurons. The event output has to be disabled via mask. :param enable_cadc_recording: Enables or disables parallel sampling of the populations membrane trace via the CADC. A maximum sample rate of 1.7us is possible. :param enable_madc_recording: Enables or disables the recording of the neurons record_neuron_id membrane trace via the MADC. Only a single neuron can be recorded. This membrane traces is samples with a significant higher resolution as with the CADC. :param record_neuron_id: The in-population neuron index of the neuron to be recorded with the MADC. This has only an effect when enable_madc_recording is enabled. :param placement_constraint: An optional list of logical neurons defining where to place the module`s neurons on hardware. :param trace_offset: The value by which the measured CADC traces are shifted before the scaling is applied. If this offset is given as float the same value is applied to all neuron traces in this population. One can also provide a torch tensor holding one offset for each individual neuron in this population. The corresponding tensor has to be of size size. Further, the offsets can be supplied in a dictionary where the keys are the hardware neuron coordinates and the values are the offsets, i.e. Dict[AtomicNeuronOnDLS, float]. The dictionary has to provide one coordinate for each hardware neuron represented by this population, but might also hold neuron coordinates that do not correspond to this layer. The layer-specific offsets are then picked and applied implicitly. :param trace_scale: The value by which the measured CADC traces are scaled after the offset is applied. If this scale is given as float all neuron traces are scaled with the same value population. One can also provide a torch tensor holding one scale for each individual neuron in this population. The corresponding tensor has to be of size size. Further, the scales can be supplied in a dictionary where the keys are the hardware neuron coordinates and the values are the scales, i.e. Dict[AtomicNeuronOnDLS, float]. The dictionary has to provide one coordinate for each hardware neuron represented by this population, but might also hold neuron coordinates that do not correspond to this layer. The layer- specific scales are then picked and applied implicitly. :param cadc_time_shift: An integer indicating by how many time steps the CADC values are shifted in time. A positive value shifts later CADC samples to earlier times and vice versa for a negative value. :param shift_cadc_to_first: A boolean indicating that the first measured CADC value is used as an offset. Note, this disables the param trace_offset. :param interpolation_mode: The method used to interpolate the measured CADC traces onto the given time grid. :param neuron_structure: Structure of the neuron. If not supplied a single neuron circuit is used.

configure_hw_entity(self, int neuron_id, lola.NeuronBlock neuron_block, halco.LogicalNeuronOnDLS coord)¶

Disables the neurons leak to behave like a integrate-and-fire neuron.

:param neuron_id: In-population neuron index. :param neuron_block: The neuron block hardware entity. :param coord: Coordinate of neuron on hardware. :returns: Configured neuron block.

Public Static Attributes

ReadoutSource¶

Type¶

hxtorch.spiking.modules.input_neuron.InputNeuron : public hxtorch.spiking.modules.hx_module.HXModule

Spike source generating spikes at the times [ms] given in the spike_times array.

Public Functions

__init__(self, int size, Experiment experiment)¶

Instanziate a InputNeuron.

This module serves as an External Population for input injection and is created within experiment if not present in the considerd model. This module performes an identity mapping when forward is called.

:param size: Number of input neurons. :param experiment: Experiment to which this module is assigned.

add_to_input_generator(self, NeuronHandle input, grenade.InputGenerator builder)¶

Add the neurons events represented by this instance to grenades input generator.

:param input: Dense spike tensor. These spikes are implictely converted to spike times. TODO: Allow sparse tensors. :param builder: Grenade’s input generator to append the events to.

add_to_network_graph(self, grenade.NetworkBuilder builder)¶

Adds instance to grenade’s network builder.

:param builder: Grenade network builder to add extrenal population to. :returns: External population descriptor.

post_process(self, Optional[DataHandle] hw_spikes, Optional[DataHandle] hw_cadc, Optional[DataHandle] hw_madc)¶

This methods needs to be overridden for every derived module that demands hardware observables.

:returns: Hardware data represented as torch.Tensors. Note that torch.Tensors are required here to enable gradient flow.

register_hw_entity(self)¶: Register instance in member experiment.

Public Members

descriptor¶

size¶

Public Static Attributes

Type¶

class hxtorch.perceptron.nn.Layer¶

Base class of all layers in :mod:hxtorch.nn.

Subclassed by hxtorch.perceptron.nn.MACLayer, hxtorch.perceptron.nn.ReLU

Public Functions

__init__(self, bool mock=False)¶: :param mock: Enable mock mode.

__repr__(self)¶

Public Members

mock¶

hxtorch.spiking.functional.li.LI : public torch.autograd.Function

LI forward mock and backward.

Public Static Functions

backward(ctx, torch.Tensor grad_output)¶: Implements LIF backward.

forward(ctx, torch.Tensor input)¶: Gets overridden.

hxtorch.spiking.functional.lif.LIF : public torch.autograd.Function

LIF forward mock and backward.

Public Static Functions

backward(ctx, torch.Tensor grad_output)¶: Implements LIF backward.

forward(ctx, torch.Tensor input)¶: Gets overridden.

hxtorch.perceptron.nn.Linear : public hxtorch.perceptron.nn.MACLayer , public torch.nn.Linear

Applies a linear transformation to the incoming data on Hicann-X.

Public Functions

__init__(self, Integral in_features, Integral out_features, bool bias=True, Optional[Integral] num_sends=None, Integral wait_between_events=defaults.wait_between_events, bool mock=False, *Integral avg=1, Optional[Callable[[torch.Tensor], torch.Tensor]] input_transform=None, Optional[Callable[[torch.Tensor], torch.Tensor]] weight_transform=clamp_weight_)¶

:param in_features: Size of each input sample :param out_features: Size of each output sample :param bias: If set to True, the layer will learn an additive bias.

:param num_sends: Number of sends of the input. Values greater than 1 result in higher output to the neurons and increases the s/n ratio. For None this is automatically adjusted during initialization. :param wait_between_events: Wait time between two successive vector inputs, in FPGA clock cycles. Shorter wait time can lead to saturation of the synaptic input. :param mock: Enable mock mode. :param avg: Number of neurons to average over. This option is targeted at reducing statistical noise. Beware: We average over different fixed-pattern instances, but they are all configured at the same weight, so they are not trained individually. This could potentially have negative implications. :param input_transform: Function that receives the input and returns a tensor to be used as input to the chip. :param weight_transform: Function that receives the weight and returns a tensor to be used as weight matrix on the chip.

forward(self, input)¶

Public Members

avg¶

Private Members

_matmul¶

hxtorch.spiking.functional.linear.Linear : public torch.autograd.Function

Linear autograd example.

Public Static Functions

backward(ctx, torch.Tensor grad_output)¶

Implement linear backward.

:param grad_output: The backpropagted gradient tensor.

forward(ctx, torch.Tensor input, torch.Tensor weight)¶: Gets overriden.

hxtorch.perceptron.nn.MACLayer : public hxtorch.perceptron.nn.Layer

Layer that performs a multiply accumulate operation.

Subclassed by hxtorch.perceptron.nn.ConvNd, hxtorch.perceptron.nn.Linear

Public Functions

__init__(self, Optional[Integral] num_sends=None, Integral wait_between_events=defaults.wait_between_events, bool mock=False, *Optional[Callable[[torch.Tensor], torch.Tensor]] input_transform=None, Optional[Callable[[torch.Tensor], torch.Tensor]] weight_transform=clamp_weight_)¶

:param num_sends: Number of sends of the input.

Values greater than 1 result in higher output to the neurons and increases the s/n ratio. For None this is automatically adjusted during initialization. :param wait_between_events: Wait time between two successive vector inputs, in FPGA clock cycles. Shorter wait time can lead to saturation of the synaptic input. :param mock: Enable mock mode. :param input_transform: Function that receives the input and returns a tensor to be used as input to the chip. :param weight_transform: Function that receives the weight and returns a tensor to be used as weight matrix on the chip.

reset_parameters(self, Real weight_mean=0., Integral relu_shift=1)¶

Reset parameters to reasonable initialization values.

Method based on Delving deep into rectifiers: Surpassing human-level performance on ImageNet classification - He, K. et al. (2015)

:param weight_mean: Mean value of the weight distribution :param relu_shift: Bit shift assumed in subsequent ConvertingReLU

Public Members

input_transform¶

num_sends¶

wait_between_events¶

weight_transform¶

hxtorch.spiking.transforms.decode.MaxOverTime : public torch.nn.Module

Simple max-over-time decoding.

Public Functions

forward(self, torch.Tensor input)¶

Translate an input tensor of shape (batch_size, time_length, population_size) into a tensor of shape (batch_size, population_size), where the time dimension is discarded by picking the maximum value along the time.

Hence this module performs a ‘max-over-time’ operation.

:param input: The input tensor to transform. expected shape: (batch_size, time_length, population_size) :return: Returns the tensor holding the max-over-time values.

hxtorch.spiking.transforms.decode.MeanOverTime : public torch.nn.Module

Simple mean-over-time decoding.

Public Functions

forward(self, torch.Tensor input)¶

Translate an input tensor of shape (batch_size, time_length, population_size) into a tensor of shape (batch_size, population_size), where the time dimension is discarded by computing the average value along the time.

Hence this module performs a ‘mean-over-time’ operation.

:param input: The input tensor to transform. expected shape: (batch_size, time_length, population_size) :return: Returns the tensor holding the mean-over-time values.

class hxtorch.spiking.utils.model_mapper.MixinHXModelMapper¶

Mapper mixin to map snn models to hxtorch.spiking models.

Public Functions

map_from(self, Any state_dict, Dict mapping, bool map_all=True)¶

Map an SNN model with state dict state_dict to this model.

:param state_dict: The state dict used to map from. :param mapping: The mapping from the keys of this model’s state dict to the keys in state_dict. :param map_all: A boolean value indicating if a state dict key is looked up in state_dict if not present in mapping. This allows to only define a mapping for some keys and load the others implicitly if the key names match. Defaults to true.

mnist.MNIST : public torch.utils.data.TensorDataset

The MNIST dataset.

Public Functions

__init__(self, root, train)¶

:param root: Root directory of the dataset that contains MNIST/processed/training.pt and MNIST/processed/test.pt.

:param train: If True, creates dataset from training.pt, otherwise from test.pt.

mnist.Model : public torch.nn.Module

Simple CNN model to classify written digits from the MNIST database.

Model topology:

Conv2d with 10x10 kernel, stride 5
Linear layer with 128 hidden neurons

Public Functions

__init__(self, bool mock)¶: :param mock: Whether to use a software simulation instead of the ASIC.

forward(self, *x)¶

Public Members

classifier¶

features¶

yinyang_model.Model : public torch.nn.Module

Complete model with encoder, network (snn) and decoder.

Public Functions

__init__(self, torch.nn.Module encoder, torch.nn.Module network, torch.nn.Module decoder, float readout_scale=1.)¶

Initialize the model by assigning encoder, network and decoder.

:param encoder: Module to encode input data :param network: Network module containing layers and parameters / weights :param decoder: Module to decode network output

forward(self, torch.Tensor inputs)¶

Perform forward pass through whole model, i.e.

data -> encoder -> network -> decoder -> output

:param inputs: tensor input data

:returns: Returns tensor output

regularize(self, float reg_readout, float reg_bursts, float reg_w_hidden, float reg_w_output)¶

Get regularization terms for bursts and weights like factor * (thing to be regularized) ** 2.

:param reg_bursts: prefactor of burst / hidden spike regulaization :param reg_weights_hidden: prefactor of hidden weight regularization :param reg_weights_output: prefactor of output weight regularization

:returns: Returns sum of regularization terms

Public Members

decoder¶

encoder¶

network¶

readout_scale¶

scores¶

hxtorch.spiking.backend.module_manager.ModuleManager : public hxtorch.spiking.backend.module_manager.BaseModuleManager

Object representing all nodes in a graph-like data structure.

Public Functions

__init__(self)¶

Initialize a Modules object.

This object holds a list of nodes.

__str__(self)¶: Append string.

add_node(self, Module module, Source sources, Target target)¶

Adds a new module to the manager.

This method adds a node to the internal graph to reporesent the module. It assigned edges to this node holding the data in sources, resp. target. :param module: Module to represented in to the graph. :param sources: The sources to the node representing module. :param targets: The targets of the node representing module.

add_wrapper(self, Wrapper wrapper)¶

Adds a new wrapper to the manager.

This must be called after all modules wrapped by this wrapper are represented in the graph. internal graph to reporesent the module. It assigned edges to this node holding the data in sources, resp. target. :param module: Module to represented in to the graph.

changed_since_last_run(self)¶

Check if any module is marked dirty.

:return: Returns true if at least one module has been marked dirty.

clear(self)¶

Override clear to also clear open sources and open targets.

This method resets the Manager without removing implictly created input modules such that they can be reused.

done(self)¶

Create a list of elements of form (module, sources, targets), which can be looped in the correct order.

:param instance: The instance to work on. :return: Returns the ordered modules in the form (module, sources, targets).

find_edges(self, Any handle)¶

Find all edges with data associated with handle.

:param handle: The edge data to match agains. :return: Returns a list of all edges in the graph which hold the same data handle.

get_id_by_module(self, Module module)¶

Finds the ID of the node which corresponds to module module.

If no ID is found, None is returned. :param module: The module to find the node ID for. :returns: Returns the node ID or None if no ID is found.

get_id_by_wrapper(self, Wrapper wrapper)¶

Finds the ID of the wrapper which corresponds to wrapper wrapper.

If no ID is found, None is returned. :param wrapper: The wrapper module to find the node ID for. :returns: Returns the node ID or None if no ID is found.

get_module_by_id(self, int node_id)¶

Finds the module of the node with ID node_id and returns it.

If multiple modules assigned to this ID are found, only the first one is returned. However, this should never be the case and if so, it is a bug. :param node_id: The ID of the node to find the module for. :returns: Returns the corresponding module.

get_node_id(self)¶

Get the ID of the next node to add.

:returns: Returns the next usable ID of a node to add.

get_wrapper_by_id(self, int wrapper_id)¶

Finds the wrapper of the node with ID wrapper_id and returns it.

If multiple wrapper assigned to this ID are found, only the first one is returned. However, this should never be the case and if so, it is a bug. :param wrapper_id: The ID of the node to find the module for. :returns: Returns the corresponding wrapper.

get_wrapper_id(self)¶

Get the ID of the next wrapper to add.

:returns: Returns the next usable ID of a wrapper to add.

has_module(self, Module module)¶

Checks whether the moudle mdoule is already registered within the graph.

:param module: The module to check its existance for. :return: Returns a bool indicating whether the module exists or not.

input_data(self)¶

Finds all edge data associated to edges with a source node in _open_sources, those nodes are roots.

:return: Returns a list of all input data.

pre_process(self, instance)¶

Handle all preprocessing needed prior to hardware execution.

This includes input module injection as well as setting the dropout masks.

reset_changed_since_last_run(self)¶: Restes all registered modules changed_since_last_run flags.

source_populations(self, Module module)¶

Find the source populations of module module, i.e.

modules which are of type self._population_types. :param module: The module to find the source population. :return: Returns a list of source populations of module.

target_populations(self, Module module)¶

Find the target populations of module module, i.e.

modules which are of type self._population_types. :param module: The module to find the target populations for. :return: Returns a list of target populations of module.

Public Static Attributes

input_type = spiking_module.InputNeuron¶

population_types = (spiking_module.InputNeuron, spiking_module.Neuron,spiking_module.ReadoutNeuron)¶

Private Functions

_get_populations(self, Module module, bool target=False)¶

Find the target, resp.

source populations of module module, i.e. modules which are of type self._population_types. :param module: The module to find the source population (target=False) or the target populations for(target=True) :param target: A bool indicating whether the search is performed for source or target populations. :return: Returns a list of source, resp. target populations of module.

_handle_dropout_mask(self)¶

Method to back-assign spiking mask from Dropout layers to the previous Neuron layer in order to configure the neurons appropriately on hardware.

Note: BatchDropout layers have to be preceded by a Neuron layer.

_handle_inputs(self, instance)¶

On hardware, synapse have external populations as sources.

Hence we have to augment Synapses with InputNeurons.

_handle_wrappers(self)¶

Handle registered wrappers.

This method needs to be called after all modules are registered. It replaces all nodes associated with the nodes in a given wrapper in the graph. All internal target handles are gathered in the wrapper’s node attributes ‘targets’. All external input sources to the wrapper are gathered in the node attributes ‘sources’.

_order(self)¶

This method checks whether the internal graph representation has no cyclic dependencies.

Cyclic dependencies need to be wrapped manually at the moment. TODO: Introduce implicit module wrapping here. Further, a topological sort is performed in order to return the nodes in an order in which all modules can be executed successively. :return: Returns a list of tuples of shape (module, sources, targets), where sources is a tuple of all input sources and targets is a tuple of all output targets of module module.

Private Members

_graph_hash¶

hxtorch.spiking.morphology.Morphology : public ABC

Represents the internal structure of a neuron.

This neuron might be made up of several compartments and the compartments themselves can consist of several neuron circuits.

:note: Currently spike and voltage recording is only supported in the first neuron circuit of the first compartment.

Subclassed by hxtorch.spiking.morphology.SingleCompartmentNeuron

Public Functions

compartments(self)¶: Unplaced coordinate of the logical neuron.

implement_morphology(self, halco.LogicalNeuronOnDLS coord, lola.NeuronBlock neuron_block)¶

Configure the atomic neurons in the given neuron block to represent this morphology.

:param coord: Coordinate of the logical neuron which should be configured. :param neuron_block: The configuration of neurons at coord will be changed such that a neuron with the given morphology is implemented.

logical_neuron(self)¶

Base configuration of the logical neuron.

Default constructed logical neuron, the connections between neuron circuits are configured such that the specified morphology is implemented.

Public Static Functions

disable_leak(halco.LogicalNeuronOnDLS coord, lola.NeuronBlock neuron_block)¶

Disable the leak for the given neuron.

:param coord: Coordinate of the logical neuron for which the leak is disabled. :param neuron_block: Neuron block in which the configuration of the atomic neurons is changed.

disable_spiking(halco.LogicalNeuronOnDLS coord, lola.NeuronBlock neuron_block)¶

Disable spiking for the given neuron.

Disable the threshold comparator and the digital spike output.

:param coord: Coordinate of the logical neuron for which spiking is disabled. :param neuron_block: Neuron block in which the configuration of the atomic neurons is changed.

enable_madc_recording(halco.LogicalNeuronOnDLS coord, lola.NeuronBlock neuron_block, hal.NeuronConfig.ReadoutSource readout_source)¶

Configure neuron such that traces can be recorded with the MADC.

:param coord: Coordinate of the logical neuron for which the recording is enabled. :param neuron_block: Neuron block in which the configuration of the atomic neurons is changed. :param readout_source: Voltage which should be recorded.

set_spike_recording(bool enable, halco.LogicalNeuronOnDLS coord, lola.NeuronBlock neuron_block)¶

Set whether spikes are forwarded digitally.

:param enable: Enable/disable the digital routing of spikes. :param coord: Coordinate of the logical neuron for which the recording is enabled. :param neuron_block: Neuron block in which the configuration of the atomic neurons is changed.

hxtorch.spiking.modules.neuron.Neuron : public hxtorch.spiking.modules.types.Population

Neuron layer.

Caveat: For execution on hardware, this module can only be used in conjuction with a preceding Synapse module.

Subclassed by hxtorch.spiking.modules.iaf_neuron.IAFNeuron, hxtorch.spiking.modules.readout_neuron.ReadoutNeuron

Public Functions

__init__(self, int size, Experiment experiment, Union[Callable, torch.autograd.Function] func=F.LIF, Optional[NamedTuple] params=None, bool enable_spike_recording=True, bool enable_cadc_recording=True, bool enable_madc_recording=False, Optional[int] record_neuron_id=None, Optional[List[halco.LogicalNeuronOnDLS]] placement_constraint=None, Union[Dict[halco.LogicalNeuronOnDLS, float], torch.Tensor, float] trace_offset=0., Union[Dict[halco.LogicalNeuronOnDLS, float], torch.Tensor, float] trace_scale=1., int cadc_time_shift=1, bool shift_cadc_to_first=False, str interpolation_mode="linear", Optional[Morphology] neuron_structure=None)¶

Initialize a Neuron.

This module creates a population of spiking neurons of size size. This module has a internal spiking mask, which allows to disable the event ouput and spike recordings of specific neurons within the layer. This is particularly useful for dropout.

:param size: Size of the population. :param experiment: Experiment to append layer to. :param func: Callable function implementing the module’s forward functionallity or a torch.autograd.Function implementing the module’s forward and backward operation. Defaults to LIF. :param params: Neuron Parameters in case of mock neuron integration of for backward path. If func does have a param argument the params object will get injected automatically. :param enable_spike_recording: Boolean flag to enable or disable spike recording. Note, this does not disable the event out put of neurons. The event output has to be disabled via mask. :param enable_cadc_recording: Enables or disables parallel sampling of the populations membrane trace via the CADC. A maximum sample rate of 1.7us is possible. :param enable_madc_recording: Enables or disables the recording of the neurons record_neuron_id membrane trace via the MADC. Only a single neuron can be recorded. This membrane traces is samples with a significant higher resolution as with the CADC. :param record_neuron_id: The in-population neuron index of the neuron to be recorded with the MADC. This has only an effect when enable_madc_recording is enabled. :param placement_constraint: An optional list of logical neurons defining where to place the module`s neurons on hardware. :param trace_offset: The value by which the measured CADC traces are shifted before the scaling is applied. If this offset is given as float the same value is applied to all neuron traces in this population. One can also provide a torch tensor holding one offset for each individual neuron in this population. The corresponding tensor has to be of size size. Further, the offsets can be supplied in a dictionary where the keys are the logical neuron coordinates and the values are the offsets, i.e. Dict[LogicalNeuronOnDLS, float]. The dictionary has to provide one coordinate for each hardware neuron represented by this population, but might also hold neuron coordinates that do not correspond to this layer. The layer-specific offsets are then picked and applied implicitly. :param trace_scale: The value by which the measured CADC traces are scaled after the offset is applied. If this scale is given as float all neuron traces are scaled with the same value population. One can also provide a torch tensor holding one scale for each individual neuron in this population. The corresponding tensor has to be of size size. Further, the scales can be supplied in a dictionary where the keys are the logical neuron coordinates and the values are the scales, i.e. Dict[LogicalNeuronOnDLS, float]. The dictionary has to provide one coordinate for each hardware neuron represented by this population, but might also hold neuron coordinates that do not correspond to this layer. The layer- specific scales are then picked and applied implicitly. :param cadc_time_shift: An integer indicating by how many time steps the CADC values are shifted in time. A positive value shifts later CADC samples to earlier times and vice versa for a negative value. :param shift_cadc_to_first: A boolean indicating that the first measured CADC value is used as an offset. Note, this disables the param trace_offset. :param interpolation_mode: The method used to interpolate the measured CADC traces onto the given time grid. :param neuron_structure: Structure of the neuron. If not supplied a single neuron circuit is used.

add_to_network_graph(self, grenade.NetworkBuilder builder)¶

Add the layer’s neurons to grenades network builder.

If enable_spike_recording is enabled the neuron’s spikes are recorded according to the layer’s spiking mask. If no spiking mask is given all neuron spikes will be recorded. Note, the event output of the neurons are configured in configure_hw_entity. If enable_cadc_recording is enabled the populations neuron’s are registered for CADC membrane recording. If enable_madc_recording is enabled the neuron with in-population index record_neuron_id will be recording via the MADC. Note, since the MADC can only record a single neuron on hardware, other Neuron layers registering also MADC recording might overwrite the setting here.

:param builder: Grenade’s network builder to add the layer’s population to. :returns: Returns the builder with the population added.

configure_hw_entity(self, int neuron_id, lola.NeuronBlock neuron_block, halco.LogicalNeuronOnDLS coord)¶

Configures a neuron in the given layer with its specific properties.

The neurons digital event outputs are enabled according to the given spiking mask.

TODO: Additional parameterization should happen here, i.e. with population-specific parameters.

:param neuron_id: In-population neuron index. :param neuron_block: The neuron block hardware entity. :param coord: Coordinate of neuron on hardware. :returns: Configured neuron block.

mask(self)¶

Getter for spike mask.

:returns: Returns the current spike mask.

mask(self, torch.Tensor mask)¶

Setter for the spike mask.

:param mask: Spike mask. Must be of shape (self.size,).

post_process(self, Optional[SpikeHandle] hw_spikes, Optional[CADCHandle] hw_cadc, Optional[MADCHandle] hw_madc)¶

User defined post process method called as soon as population-specific hardware observables are returned.

This function has to convert the data types returned by grenade into PyTorch tensors. This function can be overridden by the user if non-default grenade-PyTorch data type conversion is required. Note: This function should return Tuple[Optional[torch.Tensor], …], like (cadc or madc,). This should match the ReadoutTensorHandle signature.

:param hw_spikes: A SpikeHandle holding the population’s spikes recorded by grenade as a sparse tensor. This data can be ignored for this readout neuron. :param hw_cadc: The CADCHandle holding the CADC membrane readout events in a sparse tensor. :param hw_madc: The MADCHandle holding the MADC membrane readout events in a sparse tensor.

:returns: Returns a tuple of optional torch.Tensors holding the hardware data (madc or cadc,)

register_hw_entity(self)¶: Infere neuron ids on hardware and register them.

Public Members

cadc_time_shift¶

descriptor¶

interpolation_mode¶

offset¶

params¶

scale¶

shift_cadc_to_first¶

size¶

unit_ids¶

Public Static Functions

add_to_input_generator(HXModule module, grenade.InputGenerator builder)¶

Add the input to an input module to grenades input generator.

:param module: The module to add the input for. :param builder: Grenade’s logical network builder.

create_default_hw_entity()¶

At the moment, the default neuron is loaded from grenade’s ChipConfig object, which holds the atomic neurons configured as a calibration is loaded in hxtorch.hardware_init().

TODO: - Needed?

Maybe this can return a default neuron, when pop-specific calibration is needed.

Public Static Attributes

ReadoutSource¶

Type¶

Private Members

_changed_since_last_run¶

_enable_cadc_recording¶

_enable_madc_recording¶

_enable_spike_recording¶

_mask¶

_neuron_structure¶

_placement_constraint¶

_record_neuron_id¶

hxtorch.spiking.handle.NeuronHandle : public hxtorch.spiking.handle.TensorHandle

Specialization for HX neuron observables.

Public Functions

__init__(self, Optional[torch.Tensor] spikes=None, Optional[torch.Tensor] v_cadc=None, Optional[torch.Tensor] current=None, Optional[torch.Tensor] v_madc=None)¶

Instantiate a neuron handle able to hold spike and membrane tensors.

:param spikes: Optional spike tensor. :param v_cadc: Optional membrane tensor, holding CADC recordings. :param current: Optional current tensor, holding synpatic current. :param v_madc: Optional membrane tensor, holding MADC recordings.

Public Members

current¶

spikes¶

v_cadc¶

v_madc¶

Private Static Attributes

_carries = ["spikes", "v_cadc", "current", "v_madc"]¶

_obsv_state = "spikes"¶

class hxtorch.spiking.experiment.NeuronPlacement¶

Tracks assignment of pyNN IDs of HXNeuron based populations to the corresponding hardware entities, i.e.

LogicalNeuronOnDLS.

Public Functions

__init__(self)¶

id2logicalneuron(self, Union[List[int], int] neuron_id)¶: Get hardware coordinate from pyNN int :param neuron_id: pyNN neuron int.

register_id(self, Union[List[int], int] neuron_id, halco.LogicalNeuronCompartments shape, Optional[Union[List[halco.LogicalNeuronOnDLS], halco.LogicalNeuronOnDLS]] placement_constraint=None)¶

Register a new ID to placement :param neuron_id: pyNN neuron ID to be registered :param shape: The shape of the neurons on hardware.

:param placement_constraint: A logical neuron or a list of logical neurons, each coresponding to one ID in neuron_id.

Private Functions

_register(self, Union[List[int], int] neuron_id, halco.LogicalNeuronCompartments shape)¶

Register neurons with global IDs neuron_id with creating logical neurons implicitly.

:param neuron_id: An int or list of ints corresponding to the global IDs of the neurons. :param shape: The shape of the neurons on hardware.

_register_with_logical_neurons(self, Union[List[int], int] neuron_id, Union[List[halco.LogicalNeuronOnDLS], halco.LogicalNeuronOnDLS] placement_constraint)¶

Register neurons with global IDs neuron_id with given logical neurons logical_neuron.

:param neuron_id: An int or list of ints corresponding to the global IDs of the neurons. :param placement_constraint: A logical neuron or a list of logical neurons, each coresponding to one ID in neuron_id.

Private Members

_id_2_ln¶

_used_an¶

hxtorch.spiking.transforms.encode.PixelsToSpikeTimes : public torch.nn.Module

Encode image by spike trains.

Public Functions

__init__(self, tau=20, threshold=0.2, t_max=1.0, epsilon=1e-7)¶

Initialize a pixel to spike time transformation.

:param tau: Streching factor of pixel to spike-time transformation. Lager values correspond to later spike times. :param threshold: The threshold under which a pixel is considered non-spiking (resp. spike at time t_max). :param t_max: Maximum spike time. :param epsilon: Safty margin to prevent zero-division.

forward(self, torch.Tensor pic)¶

Turns an image into a spike representation.

Image pixels >= threshold are assigned a spike time according to:

t_spike = \tau * log(pixel / (pixel - threshold))

If a pixel is < threshold it gets assigned the spike time t_max.

:param pic: Image to transform into spike trains. Has to be of shape (color_channel, width, height).

:return: Returns the image represented by spike trains, given as a tensor of shape (spike_time, color_channel, width, height).

Private Members

_epsilon¶

_t_max¶

_tau¶

_threshold¶

hxtorch.spiking.modules.types.Population : public hxtorch.spiking.modules.hx_module.HXModule

Base class for populations on BSS-2.

Subclassed by hxtorch.spiking.modules.batch_dropout.BatchDropout, hxtorch.spiking.modules.neuron.Neuron

hxtorch.spiking.modules.types.Projection : public hxtorch.spiking.modules.hx_module.HXModule

Base class for projections on BSS-2.

Subclassed by hxtorch.spiking.modules.synapse.Synapse

Private Static Attributes

__constants__ = ['in_features', 'out_features']¶

hxtorch.spiking.modules.readout_neuron.ReadoutNeuron : public hxtorch.spiking.modules.neuron.Neuron

Readout neuron layer.

Caveat: For execution on hardware, this module can only be used in conjuction with a preceding Synapse module.

Public Functions

__init__(self, int size, Experiment experiment, Union[Callable, torch.autograd.Function] func=F.LI, Optional[NamedTuple] params=None, bool enable_cadc_recording=True, bool enable_madc_recording=False, Optional[int] record_neuron_id=None, Optional[List[halco.LogicalNeuronOnDLS]] placement_constraint=None, Union[Dict[halco.AtomicNeuronOnDLS, float], torch.Tensor, float] trace_offset=0., Union[Dict[halco.AtomicNeuronOnDLS, float], torch.Tensor, float] trace_scale=1., int cadc_time_shift=1, bool shift_cadc_to_first=False, str interpolation_mode="linear", Optional[Morphology] neuron_structure=None)¶

Initialize a ReadoutNeuron.

This module creates a population of non- spiking neurons of size size and is equivalent to Neuron when its spiking mask is disabled for all neurons.

:param size: Size of the population. :param experiment: Experiment to regsiter the module in. :param func: Callable function implementing the module’s forward functionallity or a torch.autograd.Function implementing the module’s forward and backward operation. Defaults to LI. :param params: Neuron Parameters in case of mock neuron integration of for backward path. If func does have a param argument the params object will get injected automatically. :param enable_cadc_recording: Enables or disables parallel sampling of the populations membrane trace via the CADC. A maximum sample rate of 1.7us is possible. :param enable_madc_recording: Enables or disables the recording of the neurons record_neuron_id membrane trace via the MADC. Only a single neuron can be recorded. This membrane traces is samples with a significant higher resolution as with the CADC. :param record_neuron_id: The in-population neuron index of the neuron to be recorded with the MADC. This has only an effect when enable_madc_recording is enabled. :param placement_constraint: An optional list of logical neurons defining where to place the module`s neurons on hardware. :param trace_offset: The value by which the measured CADC traces are shifted before the scaling is applied. If this offset is given as float the same value is applied to all neuron traces in this population. One can also provide a torch tensor holding one offset for each individual neuron in this population. The corresponding tensor has to be of size size. Further, the offsets can be supplied in a dictionary where the keys are the hardware neuron coordinates and the values are the offsets, i.e. Dict[AtomicNeuronOnDLS, float]. The dictionary has to provide one coordinate for each hardware neuron represented by this population, but might also hold neuron coordinates that do not correspond to this layer. The layer-specific offsets are then picked and applied implicitly. :param trace_scale: The value by which the measured CADC traces are scaled after the offset is applied. If this scale is given as float all neuron traces are scaled with the same value population. One can also provide a torch tensor holding one scale for each individual neuron in this population. The corresponding tensor has to be of size size. Further, the scales can be supplied in a dictionary where the keys are the hardware neuron coordinates and the values are the scales, i.e. Dict[AtomicNeuronOnDLS, float]. The dictionary has to provide one coordinate for each hardware neuron represented by this population, but might also hold neuron coordinates that do not correspond to this layer. The layer- specific scales are then picked and applied implicitly. :param cadc_time_shift: An integer indicating by how many time steps the CADC values are shifted in time. A positive value shifts later CADC samples to earlier times and vice versa for a negative value. :param shift_cadc_to_first: A boolean indicating that the first measured CADC value is used as an offset. Note, this disables the param trace_offset. :param interpolation_mode: The method used to interpolate the measured CADC traces onto the given time grid. :param neuron_structure: Structure of the neuron. If not supplied a single neuron circuit is used.

configure_hw_entity(self, int neuron_id, lola.NeuronBlock neuron_block, halco.LogicalNeuronOnDLS coord)¶

Configures a neuron in the given module with its specific properties.