axon_sdk package

Subpackages

• axon_sdk.compilation package
  • Submodules
  • axon_sdk.compilation.compiler module
    • Connection
    • ExecutionPlan
    • InjectorNetwork
      • InjectorNetwork.add_neuron()
      • InjectorNetwork.add_subnetwork()
      • InjectorNetwork.connect_neurons()
      • InjectorNetwork.instance_count
      • InjectorNetwork.neurons
      • InjectorNetwork.neurons_with_module_uid
      • InjectorNetwork.recurse_neurons_with_module_uid()
      • InjectorNetwork.subnetworks
      • InjectorNetwork.top_module_neurons
      • InjectorNetwork.uid
    • InputTrigger
    • LoadOpModuleScaffold
    • NeuronHeader
    • OpModuleScaffold
    • OutputReader
    • Plug
    • build_stick_net()
    • compile_computation()
    • fill_op_scafold()
    • flatten()
    • get_input_triggers()
    • get_output_reader()
    • init_plug_dict()
    • instantiate_stick_modules()
    • spawn_stick_module()
    • wire_modules()
  • axon_sdk.compilation.example module
  • axon_sdk.compilation.scalar module
    • OpType
      • OpType.Add
      • OpType.Div
      • OpType.Load
      • OpType.Mul
      • OpType.Neg
      • OpType.Pow
    • Scalar
      • Scalar.draw_comp_graph()
    • can_proceed()
    • trace()
  • Module contents
• axon_sdk.networks package
  • Subpackages
    • axon_sdk.networks.connecting package
      • Submodules
      • axon_sdk.networks.connecting.synchronizer module
      • Module contents
    • axon_sdk.networks.functional package
      • Submodules
      • axon_sdk.networks.functional.adder module
      • axon_sdk.networks.functional.divider module
      • axon_sdk.networks.functional.exponential module
      • axon_sdk.networks.functional.integrator module
      • axon_sdk.networks.functional.linear_combinator module
      • axon_sdk.networks.functional.multiplier module
      • axon_sdk.networks.functional.natural_log module
      • axon_sdk.networks.functional.scalar_multiplier module
      • axon_sdk.networks.functional.signed_multipler_norm module
      • axon_sdk.networks.functional.signed_multiplier module
      • axon_sdk.networks.functional.signflip module
      • axon_sdk.networks.functional.subtractor module
      • Module contents
    • axon_sdk.networks.memory package
      • Submodules
      • axon_sdk.networks.memory.constant module
      • axon_sdk.networks.memory.inverting_memory module
      • axon_sdk.networks.memory.memory module
      • axon_sdk.networks.memory.signed_constant module
      • axon_sdk.networks.memory.signed_memory module
      • Module contents
  • Module contents
• axon_sdk.primitives package
  • Submodules
  • axon_sdk.primitives.elements module
    • Neuron and Synapse Primitives
    • AbstractNeuron
      • AbstractNeuron.Vt
      • AbstractNeuron.Vreset
      • AbstractNeuron.tm
      • AbstractNeuron.tf
      • AbstractNeuron.V
      • AbstractNeuron.ge
      • AbstractNeuron.gf
      • AbstractNeuron.gate
      • AbstractNeuron.uid
      • AbstractNeuron.receive_synaptic_event()
      • AbstractNeuron.uid
      • AbstractNeuron.update_and_spike()
    • ExplicitNeuron
      • ExplicitNeuron.spike_times
      • ExplicitNeuron.out_synapses
      • ExplicitNeuron.receive_synaptic_event()
      • ExplicitNeuron.reset()
      • ExplicitNeuron.uid
      • ExplicitNeuron.update_and_spike()
    • Synapse
      • Synapse.pre_neuron
      • Synapse.post_neuron
      • Synapse.type
      • Synapse.weight
      • Synapse.delay
      • Synapse.uid
      • Synapse.uid
  • axon_sdk.primitives.encoders module
    • Data Encoding
    • DataEncoder
      • DataEncoder.Tmin
      • DataEncoder.Tcod
      • DataEncoder.Tmax
      • DataEncoder.decode_interval()
      • DataEncoder.encode_value()
  • axon_sdk.primitives.events module
    • Spike Event Scheduling
    • SpikeEvent
      • SpikeEvent.time
      • SpikeEvent.affected_neuron
      • SpikeEvent.synapse_type
      • SpikeEvent.weight
    • SpikeEventQueue
      • SpikeEventQueue.add_event()
      • SpikeEventQueue.pop_events()
  • axon_sdk.primitives.helpers module
    • Utilities
    • flatten_nested_list()
  • axon_sdk.primitives.networks module
    • Spiking Network Composition
    • SpikingNetworkModule
      • SpikingNetworkModule._neurons
      • SpikingNetworkModule._subnetworks
      • SpikingNetworkModule._uid
      • SpikingNetworkModule._instance_count
      • SpikingNetworkModule.add_neuron()
      • SpikingNetworkModule.add_subnetwork()
      • SpikingNetworkModule.connect_neurons()
      • SpikingNetworkModule.instance_count
      • SpikingNetworkModule.neurons
      • SpikingNetworkModule.neurons_with_module_uid
      • SpikingNetworkModule.recurse_neurons_with_module_uid()
      • SpikingNetworkModule.subnetworks
      • SpikingNetworkModule.top_module_neurons
      • SpikingNetworkModule.uid
    • flatten_nested_list()
  • Module contents
• axon_sdk.visualization package
  • Submodules
  • axon_sdk.visualization.chronogram module
    • build_array()
    • plot_chronogram()
  • axon_sdk.visualization.server module
    • Handler
      • Handler.MessageClass
      • Handler.address_string()
      • Handler.copyfile()
      • Handler.date_time_string()
      • Handler.default_request_version
      • Handler.disable_nagle_algorithm
      • Handler.do_GET()
      • Handler.do_HEAD()
      • Handler.end_headers()
      • Handler.error_content_type
      • Handler.error_message_format
      • Handler.extensions_map
      • Handler.finish()
      • Handler.flush_headers()
      • Handler.guess_type()
      • Handler.handle()
      • Handler.handle_expect_100()
      • Handler.handle_one_request()
      • Handler.list_directory()
      • Handler.log_date_time_string()
      • Handler.log_error()
      • Handler.log_message()
      • Handler.log_request()
      • Handler.monthname
      • Handler.parse_request()
      • Handler.protocol_version
      • Handler.rbufsize
      • Handler.responses
      • Handler.send_error()
      • Handler.send_head()
      • Handler.send_header()
      • Handler.send_response()
      • Handler.send_response_only()
      • Handler.server_version
      • Handler.setup()
      • Handler.sys_version
      • Handler.timeout
      • Handler.translate_path()
      • Handler.version_string()
      • Handler.wbufsize
      • Handler.weekdayname
    • find_available_port()
    • is_port_available()
    • open_browser()
    • start_server()
    • start_server_on_port()
  • axon_sdk.visualization.topovis module
    • color_for_synapse()
    • format_edges()
    • format_groups()
    • format_nodes()
    • generate_mapping_neuron_to_net()
    • get_groups_to_display()
    • get_neurons_and_synapses_to_display()
    • vis_topology()
  • Module contents

Submodules

axon_sdk.simulator module

Simulator

This module defines the main Simulator class for executing spiking neural networks built with the STICK model. It provides methods for input application, event propagation, spike/voltage logging, and value decoding.

Key components: - Simulator: core class for managing simulation execution. - decode_output: utility to read a signed value from STICK output neurons. - count_spikes: utility to count total emitted spikes in a simulation.

The simulator works in discrete time with configurable timestep dt, executing all synaptic and neuron dynamics via event-based updates and logging internal state.

class axon_sdk.simulator.Simulator(net: SpikingNetworkModule, encoder: DataEncoder, dt: float = 0.001)

Bases: object

Core simulation engine for executing STICK spiking neural networks.

net

The spiking neural network to simulate.

Type:

SpikingNetworkModule

encoder

Object for converting values to spike intervals and back.

Type:

DataEncoder

dt

Simulation time resolution in seconds.

Type:

float

spike_log

Records spike times per neuron UID.

Type:

dict[str, list[float]]

voltage_log

Records membrane voltages over time.

Type:

dict[str, list[tuple]]

event_queue

Queue of scheduled synaptic events.

Type:

SpikeEventQueue

apply_input_spike(neuron: ExplicitNeuron, t: float)

Apply a single spike input to a neuron at a specified time.

Parameters:

• neuron (ExplicitNeuron) – Target neuron to spike.

• t (float) – Time at which spike occurs.

apply_input_value(value: float, neuron: ExplicitNeuron, t0: float = 0)

Apply a normalized value as spike interval input to a given neuron.

Parameters:

• value (float) – Value in [0, 1] to encode and inject.

• neuron (ExplicitNeuron) – Target neuron for injection.

• t0 (float, optional) – Time offset for input spike injection. Defaults to 0.

classmethod init_with_plan(plan: ExecutionPlan, encoder: DataEncoder, dt: float = 0.001) → Self

Construct a simulator using an execution plan.

Parameters:

• plan (ExecutionPlan) – Precompiled network with input triggers.

• encoder (DataEncoder) – Encoder used to encode input values.

• dt (float, optional) – Timestep in seconds. Defaults to 0.001.

Returns:

Initialized simulator instance.

Return type:

Simulator

launch_visualization()

Launch interactive topology and chronogram visualizations of the simulation.

Requires VIS=1 in environment variables.

simulate(simulation_time: float)

Run the network simulation for a given total duration.

Parameters:

simulation_time (float) – Total simulation duration in seconds.

Logs:

• Spike times in self.spike_log

• Voltage traces in self.voltage_log

axon_sdk.simulator.count_spikes(sim: Simulator) → int

Count the total number of spikes emitted by all neurons in a simulation.

Parameters:

sim (Simulator) – Simulator instance.

Returns:

Total number of spikes across all neurons.

Return type:

int

axon_sdk.simulator.decode_output(sim: Simulator, reader: OutputReader) → float | None

Decode the final signed output value from two STICK neurons after simulation.

Parameters:

• sim (Simulator) – Simulator instance with spike log.

• reader (OutputReader) – Decoder object with read neuron handles and normalization.

Returns:

The decoded signed value, or None if no output was produced.

Return type:

Optional[float]

Raises:

ValueError – If more than 2 spikes or invalid combinations are detected.

Module contents

Axon SDK

Axon is a Python-based simulation toolkit for spike-timing-based computation using the STICK (Spike Timing Interval Computational Kernel) model.

It provides: - Primitives for defining STICK neurons and synapses. - Tools for composing symbolic spiking networks. - Compilation routines to map symbolic models to executable primitives. - A simulator for event-driven execution and visualization of spike dynamics.

This SDK is part of the Neucom platform developed by Neucom ApS.