API Reference: hxtorch

hxtorch from Python

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.

Protected Attributes

_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.

Protected Attributes

_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

Protected Functions

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

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

Protected Functions

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

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.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

Protected Attributes

_matmul

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.perceptron.nn.ReLU : public hxtorch.perceptron.nn.Layer , public torch.nn.ReLU

Applies a rectified linear unit to the input.

Subclassed by hxtorch.perceptron.nn.ConvertingReLU

Public Functions

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

forward(self, torch.Tensor input)

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 represent 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 represent 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.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 represent 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 represent 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 implicitly 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 against. :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 module module is already registered within the graph.

:param module: The module to check its existence 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)

Protected 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.

Protected Attributes

_graph_hash

hxtorch.spiking.datasets.yinyang.YinYangDataset : public Dataset

YinYang dataset.

Public Functions

__init__(self, float r_small=0.1, float r_big=0.5, int size=1000, int seed=42, Optional[torch.nn.Module] transform=None)

Instantiate the YinYang dataset.

This dataset provides data points on a 2-dimensional plane within a yin-yang sign. Each data point is assigned to one of three classes: The eyes, the yin or the yang. :param r_small: The radius of the eyes in the yin-yang sign. :param r_big: The radius of the whole sign. :param size: The size of the dataset, i.e. number of data points within the sign. :param seed: Random seed. :param transform: An optional transformation applied to the returned samples.

__getitem__(self, int index)

Get an item from the dataset.

:param index: Index of the item in the dataset. :returns: Returns a tuple (sample, target), where sample is an array with values (x, y, 1 - x, 1 - y).

__len__(self)

dist_to_left_dot(self, int x, int y)

Compute the distance to the left dot.

:param x: The x-coordinate. :param y: The y-coordinate. :returns: Returns the distance to the left dot.

dist_to_right_dot(self, int x, int y)

Compute the distance to the right dot.

:param x: The x-coordinate. :param y: The y-coordinate. :returns: Returns the distance to the right dot.

get_sample(self, Optional[int] goal=None)

Sample one data point from the yin-yang sign with goal class goal.

If goal is None any sample of any class is returned. :param goal: The target class of the sample to return. If None is given, any sample regardless of its class is returned. :returns: Returns a tuple (x coordinate, y coordinate, class), where the coordinates are on the xy-plane.

which_class(self, float x, float y)

Assign a sample on the xy-plane with coordinates (x, y) to its class.

:param x: The x-coordinate. :param y: The y-coordinate. :returns: An integer indicating the samples class.

Public Members

class_names

r_big

r_small

rng

transform

Private Members

__cs

__vals

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.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.routing.PortfolioRouter())

Instantiate a new experiment, representing 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 corresponding module’s post_process method.

last_run_chip_configs(self)

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

grenade_network

grenade_network_graph

has_madc_recording

hw_routing_func

id_counter

injection_inside_realtime

injection_inside_realtime_begin

injection_inside_realtime_end

injection_post_realtime

injection_pre_realtime

injection_pre_static_config

inter_batch_entry_wait

Protected Functions

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

_generate_hooks(self): Handle injected config (not supported yet)

_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.

_get_population_observables(self, grenade.network.NetworkGraph network_graph, grenade.signal_flow.OutputData result_map, runtime)

Takes the grenade 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 calls 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 corresponding 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.

Protected Attributes

_batch_size

_chip

_last_run_chip_configs

_populations

_projections

_static_config_prepared

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

Parameters for IAF integration and backward path.

Public Static Attributes

alpha = 50.0

method = "superspike"

tau_mem_inv = .Tensor

tau_ref = torch.tensor(0.)

tau_syn_inv = .Tensor

v_reset = torch.tensor(0.)

v_th = torch.tensor(1.)

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.functional.li.CUBALIParams : public NamedTuple

Parameters for CUBA LI integration and backward path.

Public Static Attributes

tau_mem_inv = .Tensor

tau_syn_inv = .Tensor

v_leak = torch.tensor(0.)

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.CUBALIFParams : public NamedTuple

Parameters for CUBA LIF integration and backward path.

Public Static Attributes

alpha = 50.0

method = "superspike"

tau_mem_inv = .Tensor

tau_ref = torch.tensor(0.)

tau_syn_inv = .Tensor

v_leak = torch.tensor(0.)

v_reset = torch.tensor(0.)

v_th = torch.tensor(1.)

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.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.spiking.functional.superspike.SuperSpike : public torch.autograd.Function

Define Surrogate Gradient ‘SuperSpike’ (negative side of Fast Sigmoid) See: https://arxiv.org/abs/1705.11146.

Public Static Functions

backward(ctx, torch.Tensor grad_output)

Implements surrogate gradient ‘SuperSpike’ for backward.

:param grad_output: Back-propagated gradient.

:returns: SuperSpike gradient multiplied to back-propagated gradient.

forward(ctx, torch.Tensor input, float alpha)

Forward function, generating spikes at positions > 0.

:param input: Tensor holding v_mem - v_th, of > 0 a spike at the corresponding entry is generated. Saved for backward. :param alpha: Parameter controlling the slope of the surrogate derivative. Saved for backward.

:returns: A boolean tensor holding True at the entries for neurons emitting a spike.

hxtorch.spiking.functional.unterjubel.Unterjubel : public torch.autograd.Function

Unterjubel hardware observables to allow correct gradient flow.

Public Static Functions

backward(torch.Tensor ctx, torch.Tensor grad_output)

Backward the gradient.

:param grad_output: The backwarded gradient.

:returns: Returns simply the back-propagated gradient at first position.

forward(ctx, torch.Tensor input, torch.Tensor input_prime)

Returns input_prime instead of input to inject input_prime but direct the gradient to input.

:param input: Input tensor. :param input_prime: The returned tensor.

:returns: Returns the primed tensor. Thereby, this tensor is forwarded while the gradient is directed to to input.

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.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 synaptic current. :param v_madc: Optional membrane tensor, holding MADC recordings.

Public Members

current

spikes

v_cadc

v_madc

Protected Static Attributes

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

_obsv_state = "spikes"

hxtorch.spiking.handle.ReadoutNeuronHandle : public hxtorch.spiking.handle.TensorHandle

Specialization for HX neuron observables.

Public Functions

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

Instantiate a readout neuron handle able to hold MADC, current, and CADC data.

This handle defines the CADC values as the observable state, this can be changed by deriving this class.

:param v_cadc: Optional membrane tensor, holding CADC recordings. :param current: Optional current tensor, holding synaptic current. :param v_madc: Optional membrane tensor, holding MADC recordings.

Public Members

current

v_cadc

v_madc

Protected Static Attributes

_carries = ["v_cadc", "current", "v_madc"]

_obsv_state = "v_cadc"

hxtorch.spiking.handle.SynapseHandle : public hxtorch.spiking.handle.TensorHandle

Specialization for HX synapses.

Public Functions

__init__(self, Optional[torch.Tensor] graded_spikes=None)

Instantiate a synapse handle able to hold a graded spikes tensors as input to neurons.

:param graded_spikes: Optional tensor holding graded spikes.

Public Members

graded_spikes

Protected Static Attributes

_carries = ["graded_spikes"]

_obsv_state = "graded_spikes"

hxtorch.spiking.handle.TensorHandle : public metaclass , public hxtorch.spiking.handle.HandleMeta

Base class for HX tensor handles.

New tensor handles have to be derived from this class. The name of tensors the tensor handle ‘carries’ has to be indicated in the class member ‘_carries’. For all elements in this list a property is created implicitly.

The observable state of the tensor handle is defined in ‘_obsv_state’ and defines which tensor is passed to the subsequent layer as input. Member ‘_obsv_state’ has to be in ‘_carries’.

Subclassed by hxtorch.spiking.handle.NeuronHandle, hxtorch.spiking.handle.ReadoutNeuronHandle, hxtorch.spiking.handle.SynapseHandle

Public Functions

__init__(self): Instantiate a new HX handle holding references to torch tensors.

clear(self): Set all data in handle to ‘None’.

holds(self, str name)

Checks whether the tensor handle already holds a tensor with key name.

:param name: Key of reference to tensor. :return: Returns a bool indicating whether the data present at key name is not None.

observable_state(self)

Getter for observable state.

:return: Returns the tensor associated with ‘_obsv_state’

observable_state_identifier(self)

Getter for observable state identifier.

:return: Returns the identifier string associated with the observable state of the handle.

observable_state_identifier(self, str identifier)

Setter for observable state identifier.

This identifier has to be in _carries.

put(self, *tensors, **kwargs)

Fill the tensor handle with actual data given by tensors or kwargs.

If tensors are given as positional arguments the tensors are assigned in the order given by class member ‘_carries’. Keyword arguments are assigned to the corresponding key. Therefore, the key has to be in ‘_carries.’

:param tensors: Tensors which are assigned to the tensor handle. The given tensors are associated with the elements in ‘_carries’ in successive order.

:keyword param kwargs: Assigns the items in kwargs to the elements in the tensor handle associated with the corresponding kwargs keys.

Public Members

data

Protected Attributes

_obsv_state

Protected Static Attributes

_carries = []

_obsv_state = None

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, grenade.common.ExecutionInstanceID execution_instance=grenade.common.ExecutionInstanceID())

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 functionality or a torch.autograd.Function implementing the module’s forward and backward operation. Defaults to batch_dropout. :param execution_instance: Execution instance to place to.

extra_repr(self): Add additional information.

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 boolean spike mask of size self.size.

Public Members

extra_args

mask

size

Public Static Attributes

output_type = NeuronHandle

Protected Attributes

_changed_since_last_run

_dropout

_mask

class hxtorch.spiking.modules.entity_on_execution_instance.EntityOnExecutionInstance

Mixin of execution instance property for use in modules.

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

Public Functions

__init__(self, grenade.common.ExecutionInstanceID execution_instance): :param execution_instance: Execution instance to place to.

Public Members

execution_instance

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 functionality 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.PopulationOnNetwork, Tuple[torch.Tensor]] hw_map): Inject hardware observables into TensorHandles or execute forward in mock-mode.

extra_repr(self): Add additional information.

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 associated with this layer after ‘hxtorch.run’ is executed.

func(self)

func(self, Optional[Callable] function)

Assign a PyTorch-differentiable function to the module.

   :param function: The function describing the modules f

post_process(self, Optional[SpikeHandle] hw_spikes, Optional[CADCHandle] hw_cadc, Optional[MADCHandle] hw_madc, float runtime)

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

:param hw_spikes: The optional SpikeHandle holding raw spike data from hardware. :param hw_cadc: The optional CADCHandle holding raw CADC measurements from hardware. :param hw_madc: The optional MADCHandle holding raw MADC measurements from hardware. :param runtime: The requested runtime of the experiment on hardware in s. :param dt: The expected temporal resolution in hxtorch. :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

output_type = TensorHandle

Protected 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, **kwargs, hw_data=…)’ stripped down to ‘func(input, hw_data=…).

_wrap_func(self, function)

Protected Attributes

_changed_since_last_run

_func

_func_is_wrapped

_func_name

_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 wraps 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 describe 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 functionality 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 occurs multiple times, it is post-fixed _i, where i is an integer 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.PopulationOnNetwork, 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 tuple of output handles, each corresponding to one module. The order is defined by modules. :param hw_map: The hardware data map.

extra_repr(self): Add additional information.

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.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 conjunction with a preceding Synapse module.

Public Functions

__init__(self, int size, Experiment experiment, Union[Callable, torch.autograd.Function] func=F.IAF, grenade.common.ExecutionInstanceID execution_instance=grenade.common.ExecutionInstanceID(), 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 output 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 functionality or a torch.autograd.Function implementing the module’s forward and backward operation. Defaults to LIF. :param execution_instance: Execution instance to place to. :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

output_type = NeuronHandle

Protected Static Attributes

_cadc_readout_source = lola.AtomicNeuron.Readout.Source.membrane

_madc_readout_source = \hal.NeuronConfig.ReadoutSource.membrane

hxtorch.spiking.modules.input_neuron.InputNeuron : public hxtorch.spiking.modules.hx_module.HXModule , public hxtorch.spiking.modules.entity_on_execution_instance.EntityOnExecutionInstance

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

Public Functions

__init__(self, int size, Experiment experiment, grenade.common.ExecutionInstanceID execution_instance=grenade.common.ExecutionInstanceID())

Instantiate a InputNeuron.

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

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

add_to_input_generator(self, NeuronHandle input, grenade.network.InputGenerator builder)

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

:param input: Dense spike tensor. These spikes are implicitly 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.network.NetworkBuilder builder)

Adds instance to grenade’s network builder.

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

extra_repr(self): Add additional information.

post_process(self, Optional[SpikeHandle] hw_spikes, Optional[CADCHandle] hw_cadc, Optional[MADCHandle] hw_madc, float runtime)

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

:param hw_spikes: The optional SpikeHandle holding raw spike data from hardware. :param hw_cadc: The optional CADCHandle holding raw CADC measurements from hardware. :param hw_madc: The optional MADCHandle holding raw MADC measurements from hardware. :param runtime: The requested runtime of the experiment on hardware in s. :param dt: The expected temporal resolution in hxtorch. :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

output_type = NeuronHandle

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 conjunction 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, grenade.common.ExecutionInstanceID execution_instance=grenade.common.ExecutionInstanceID(), 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 output 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 functionality or a torch.autograd.Function implementing the module’s forward and backward operation. Defaults to LIF. :param execution_instance: Execution instance to place to. :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.network.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.

extra_repr(self): Add additional information.

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, float runtime)

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. :param runtime: The requested runtime of the experiment on hardware in s.

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

register_hw_entity(self): Infer 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.network.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

output_type = NeuronHandle

Protected Attributes

_changed_since_last_run

_enable_cadc_recording

_enable_madc_recording

_enable_spike_recording

_mask

_neuron_structure

_placement_constraint

_record_neuron_id

Protected Static Attributes

_cadc_readout_source = lola.AtomicNeuron.Readout.Source.membrane

_madc_readout_source = \hal.NeuronConfig.ReadoutSource.membrane

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 conjunction with a preceding Synapse module.

Public Functions

__init__(self, int size, Experiment experiment, Union[Callable, torch.autograd.Function] func=F.LI, grenade.common.ExecutionInstanceID execution_instance=grenade.common.ExecutionInstanceID(), 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 register the module in. :param func: Callable function implementing the module’s forward functionality or a torch.autograd.Function implementing the module’s forward and backward operation. Defaults to LI. :param execution_instance: Execution instance to place to. :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.