axon_sdk.compilation package

Submodules

axon_sdk.compilation.compiler module

class axon_sdk.compilation.compiler.Connection(pre: Plug, post: Plug)

Bases: object

class axon_sdk.compilation.compiler.ExecutionPlan(net: SpikingNetworkModule, triggers: list[InputTrigger], reader: OutputReader)

Bases: object

class axon_sdk.compilation.compiler.InjectorNetwork(encoder: DataEncoder, module_name: str | None = None)

Bases: SpikingNetworkModule

add_neuron(Vt: float, tm: float, tf: float, Vreset: float = 0.0, neuron_name: str | None = None) → ExplicitNeuron

Create and add a neuron to this module.

Parameters:

• Vt (float) – Threshold voltage.

• tm (float) – Membrane time constant.

• tf (float) – Synaptic decay time constant.

• Vreset (float, optional) – Reset voltage after spike. Defaults to 0.0.

• neuron_name (str, optional) – Optional name for this neuron.

Returns:

The newly created neuron.

Return type:

ExplicitNeuron

add_subnetwork(subnet: SpikingNetworkModule) → None

Add a nested spiking network module.

Parameters:

subnet (SpikingNetworkModule) – The submodule to add.

connect_neurons(pre_neuron: ExplicitNeuron, post_neuron: ExplicitNeuron, synapse_type: str, weight: float, delay: float)

Connect two neurons via a synapse.

Parameters:

• pre_neuron (ExplicitNeuron) – Presynaptic neuron.

• post_neuron (ExplicitNeuron) – Postsynaptic neuron.

• synapse_type (str) – Type of synapse (‘V’, ‘ge’, ‘gf’, ‘gate’, etc.).

• weight (float) – Synaptic weight.

• delay (float) – Synaptic delay in seconds.

property instance_count: int

Returns: int: Instance index assigned at construction.

property neurons: list[ExplicitNeuron]

Recursively collect all neurons from this module and its submodules.

Returns:

List of all neurons in the hierarchy.

Return type:

list[ExplicitNeuron]

property neurons_with_module_uid: dict[ExplicitNeuron, str]

Get a mapping from all neurons in the hierarchy to their parent module UID.

Returns:

Mapping from neuron to module UID.

Return type:

dict[ExplicitNeuron, str]

recurse_neurons_with_module_uid() → list[dict[ExplicitNeuron, str]]

Recursively build a list of dictionaries mapping each neuron to its module UID.

Returns:

One dictionary per neuron/module pair.

Return type:

list[dict[ExplicitNeuron, str]]

property subnetworks: list[Self]

Returns: list[SpikingNetworkModule]: Submodules contained in this module.

property top_module_neurons: list[ExplicitNeuron]

Returns neurons belonging to current module, without taking submodules into account

property uid: str

Returns: str: Unique identifier of this module.

class axon_sdk.compilation.compiler.InputTrigger(value: float, norm: float, neuron_header: NeuronHeader)

Bases: object

class axon_sdk.compilation.compiler.LoadOpModuleScaffold(value: float, optype: OpType, inps: list[Plug], outp: list[Plug])

Bases: OpModuleScaffold

class axon_sdk.compilation.compiler.NeuronHeader(plus: ExplicitNeuron, minus: ExplicitNeuron)

Bases: object

class axon_sdk.compilation.compiler.OpModuleScaffold(optype: OpType, inps: list[Plug], outp: list[Plug])

Bases: object

class axon_sdk.compilation.compiler.OutputReader(header: NeuronHeader, norm: float)

Bases: object

class axon_sdk.compilation.compiler.Plug(node: Scalar)

Bases: object

axon_sdk.compilation.compiler.build_stick_net(flat_ops: list[OpModuleScaffold], flat_connections: list[Connection], norm: float) → SpikingNetworkModule

axon_sdk.compilation.compiler.compile_computation(root: Scalar, max_range: float) → ExecutionPlan

axon_sdk.compilation.compiler.fill_op_scafold(op: OpModuleScaffold, norm: float) → None

Input ‘op’ is modified in place.

The argument ‘op’ is filled with an instance of the STICK module that implements the computation, and its plugs are wired to neurons of that module.

axon_sdk.compilation.compiler.flatten(root: Scalar) → tuple[list[OpModuleScaffold], list[Connection], Plug]

axon_sdk.compilation.compiler.get_input_triggers(ops: list[OpModuleScaffold], norm: float) → list[InputTrigger]

axon_sdk.compilation.compiler.get_output_reader(plug: Plug, norm: float) → OutputReader | None

axon_sdk.compilation.compiler.init_plug_dict(nodes: list[Scalar]) → dict[Scalar, Plug]

axon_sdk.compilation.compiler.instantiate_stick_modules(ops: list[OpModuleScaffold], net: SpikingNetworkModule, norm: float) → SpikingNetworkModule

axon_sdk.compilation.compiler.spawn_stick_module(op: ~axon_sdk.compilation.compiler.OpModuleScaffold, norm: float, encoder=<axon_sdk.primitives.encoders.DataEncoder object>) → tuple[SpikingNetworkModule | None, list[NeuronHeader], NeuronHeader | None]

axon_sdk.compilation.compiler.wire_modules(conns: list[Connection], net: SpikingNetworkModule) → SpikingNetworkModule

axon_sdk.compilation.example module

axon_sdk.compilation.scalar module

class axon_sdk.compilation.scalar.OpType(value)

Bases: Enum

Add = (2, '+')

Div = (6, '/')

Load = (1, 'load')

Mul = (3, '*')

Neg = (5, '-1*')

Pow = (4, '**')

class axon_sdk.compilation.scalar.Scalar(data, prev=(), op=load)

Bases: object

draw_comp_graph(outfile='graph', format='svg', rankdir='LR')

format: png | svg | … rankdir: TB (top to bottom graph) | LR (left to right)

axon_sdk.compilation.scalar.can_proceed(value) → bool

axon_sdk.compilation.scalar.trace(root) → tuple[list[Scalar], list[tuple[Scalar, Scalar]]]

Module contents