ml_genn.utils package

Submodules

ml_genn.utils.callback_list module

class ml_genn.utils.callback_list.CallbackList(callbacks, **params)

Bases: object

Class used internally to efficiently handle lists of callback objects

Parameters:

callbacks (Sequence[Callback])

get_data()
on_batch_begin(batch)
Parameters:

batch (int)

on_batch_end(batch, metrics)
Parameters:

batch (int)

on_epoch_begin(epoch)
Parameters:

epoch (int)

on_epoch_end(epoch, metrics)
Parameters:

epoch (int)

on_test_begin()
on_test_end(metrics)
on_timestep_begin(timestep)
Parameters:

timestep (int)

on_timestep_end(timestep)
Parameters:

timestep (int)

on_train_begin()
on_train_end(metrics)

ml_genn.utils.connectivity module

class ml_genn.utils.connectivity.KernelInit(kernel)

Bases: Initializer

get_snippet()

Gets PyGeNN implementation of initializer

class ml_genn.utils.connectivity.PadMode(value)

Bases: Enum

An enumeration.

SAME = 'same'
VALID = 'valid'
ml_genn.utils.connectivity.get_conv_same_padding(in_size, conv_size, stride)
Parameters:

  • in_size (int)

  • conv_size (int)

  • stride (int)

Return type:

int

ml_genn.utils.connectivity.get_param_2d(name, param, default=typing.Tuple[int, int])
Parameters:

  • name (str)

  • param (None | int | Sequence[int])

Return type:

Tuple[int, int]

ml_genn.utils.connectivity.update_target_shape(target, output_shape, flatten_out)
Parameters:

  • target (Population)

  • output_shape (Sequence[int])

  • flatten_out (bool)

ml_genn.utils.data module

class ml_genn.utils.data.PreprocessedSpikes(end_spikes, spike_times)

Bases: tuple

Create new instance of PreprocessedSpikes(end_spikes, spike_times)

end_spikes

Alias for field number 0

spike_times

Alias for field number 1

ml_genn.utils.data.batch_dataset(data, batch_size, size)
Parameters:

  • data (Mapping[Any, Sequence | ndarray])

  • batch_size (int)

  • size (int)

ml_genn.utils.data.batch_spikes(spikes, batch_size)
Parameters:
Return type:

PreprocessedSpikes

ml_genn.utils.data.calc_latest_spike_time(spikes)

Calculate time of the last spike emitted by any neuron

Parameters:

spikes (PreprocessedSpikes) – Spike train

Return type:

float

ml_genn.utils.data.calc_max_spikes(spikes)

Calculate maximum number of spikes emitted by any neuron

Parameters:

spikes (PreprocessedSpikes) – Spike train

Return type:

int

ml_genn.utils.data.calc_start_spikes(end_spikes)
Parameters:

end_spikes (ndarray)

Return type:

ndarray

ml_genn.utils.data.generate_yin_yang_dataset(size, scale, offset=0.0, bias=True, r_small=0.1, r_big=0.5)

Generate Yin-Yang dataset [Kriener2021] in PreprocessedSpikes format. Code copied from https://github.com/lkriener/yin_yang_data_set

Parameters:

  • size (int) – Number of Yin-Yang stimuli to generate

  • scale (float) – Scale factor to apply to spike times

  • offset (float) – Minimum spike time in ms

  • bias (bool) – Should an additional fixed bias spike at offset time be added to each example

  • r_small (float) – Radius of small (eye) circles

  • r_big (float) – Radius of large circles

ml_genn.utils.data.get_dataset_size(data)
Parameters:

data (Mapping[Any, Sequence | ndarray])

Return type:

int | None

ml_genn.utils.data.linear_latency_encode_data(data, max_time, min_time=0.0, thresh=1)

Generate PreprocessedSpikes format stimuli by linearly latency encoding static data

Parameters:

  • data (ndarray) – Data in uint8 format

  • max_time (float) – Spike time for inputs with a value of 0

  • min_time (float) – Spike time for inputs with a value of 255

  • thresh (int) – Threshold values must reach for any spike to be emitted

Return type:

List[PreprocessedSpikes]

ml_genn.utils.data.log_latency_encode_data(data, tau_eff, thresh)

Generate PreprocessedSpikes format stimuli by log-latency encoding static data

\[\begin{split}T(x)= \begin{cases} \tau_\text{eff} log\left(\frac{x}{x - \nu}\right) & x > \nu \\ \infty & otherwise \end{cases}\end{split}\]
Parameters:

  • data (ndarray) – Data in uint8 format

  • tau_eff (float) – Scaling factor

  • thresh (float) – Threshold values must reach for any spike to be emitted

Return type:

List[PreprocessedSpikes]

ml_genn.utils.data.permute_dataset(data, indices)
Parameters:

  • data (Mapping[Any, Sequence | ndarray])

  • indices (Sequence[int] | ndarray)

ml_genn.utils.data.preprocess_spikes(times, ids, num_neurons)
Parameters:

  • times (ndarray)

  • ids (ndarray)

  • num_neurons (int)

Return type:

PreprocessedSpikes

ml_genn.utils.data.preprocess_tonic_spikes(events, ordering, shape, time_scale=0.001, dt=None, histogram_thresh=None)

Preprocess a Tonic format spike train into PreprocessedSpikes format

Parameters:

  • events (ndarray) – Structured array containing events

  • ordering (Sequence[str]) – Names of fields in events array

  • shape (Tuple) – Shape of sensor events came from

  • time_scale – Scale to apply to event times, typically to convert from microseconds to milliseconds

  • dt (float | None) – Timestep to discretise events to

  • histogram_thresh (int | None) – Minimum number of source events required to trigger spike in downsampled dt

Return type:

PreprocessedSpikes

ml_genn.utils.data.split_dataset(data, split)
Parameters:

  • data (Mapping[Any, Sequence | ndarray])

  • split (float)

Return type:

Tuple[Mapping[Any, Sequence | ndarray], Mapping[Any, Sequence | ndarray]]

ml_genn.utils.decorators module

ml_genn.utils.decorators.network_default_params(f)

ml_genn.utils.filter module

class ml_genn.utils.filter.ExampleFilter(f)

Bases: object

Parameters:

f (Sequence | ndarray | integer | int | None)

get_batch_mask(batch, batch_size)
Parameters:

  • batch (int)

  • batch_size (int)

Return type:

ndarray

ml_genn.utils.filter.get_neuron_filter_mask(f, shape)
Parameters:

f (Sequence | slice | ndarray | integer | int | None)

Return type:

ndarray

ml_genn.utils.model module

class ml_genn.utils.model.CustomUpdateModel(model, param_vals={}, var_vals={}, var_refs={}, egp_vals={}, egp_refs={})

Bases: Model

add_egp_ref(name, type, value)
add_var_ref(name, type, value)
append_update_code(code)
has_egp_ref(name)
has_var_ref(name)
process()
set_var_ref_access_mode(name, access_mode)
class ml_genn.utils.model.Model(model, param_vals={}, var_vals={}, egp_vals={})

Bases: object

Parameters:

  • model (MutableMapping[str, Any])

  • param_vals (MutableMapping[str, Number | Sequence[Number] | ndarray | Initializer])

  • var_vals (MutableMapping[str, Number | Sequence[Number] | ndarray | Initializer])

  • egp_vals (MutableMapping[str, Number | Sequence[Number] | ndarray])

add_egp(name, type, value)
Parameters:

  • name (str)

  • type (str)

  • value (Number | Sequence[Number] | ndarray)

add_param(name, type, value)
Parameters:

  • name (str)

  • type (str)

  • value (Number | Sequence[Number] | ndarray | Initializer)

add_var(name, type, value, access_mode=pygenn.VarAccess.READ_WRITE)
Parameters:

  • name (str)

  • type (str)

  • value (Number | Sequence[Number] | ndarray | Initializer)

  • access_mode (int)

has_egp(name)
has_param(name)
has_var(name)
make_param_var(param_name, access_mode=pygenn.VarAccess.READ_ONLY)
Parameters:

  • param_name (str)

  • access_mode (int)

process()
property reset_vars
set_param_dynamic(name, dynamic=True)
Parameters:

  • name (str)

  • dynamic (bool)

set_var_access_mode(name, access_mode)
Parameters:

  • name (str)

  • access_mode (int)

class ml_genn.utils.model.NeuronModel(model, output_var_name, param_vals={}, var_vals={}, egp_vals={})

Bases: Model

add_additional_input_var(name, type, init_val)
append_reset_code(code)
append_sim_code(code)
static from_val_descriptors(model, output_var_name, inst, dt, param_vals={}, var_vals={}, egp_vals={})
property output_var
prepend_reset_code(code)
prepend_sim_code(code)
replace_reset_code(source, target)
Parameters:

  • source (str)

  • target (str)

replace_sim_code(source, target)
Parameters:

  • source (str)

  • target (str)

replace_threshold_condition_code(source, target)
Parameters:

  • source (str)

  • target (str)

class ml_genn.utils.model.SynapseModel(model, param_vals={}, var_vals={}, egp_vals={}, neuron_var_refs={})

Bases: Model

static from_val_descriptors(model, inst, dt, param_vals={}, var_vals={}, egp_vals={}, neuron_var_refs={})
process()
class ml_genn.utils.model.WeightUpdateModel(model, param_vals={}, var_vals={}, pre_var_vals={}, post_var_vals={}, egp_vals={}, pre_neuron_var_refs={}, post_neuron_var_refs={})

Bases: Model

add_post_neuron_var_ref(name, type, target)
add_pre_neuron_var_ref(name, type, target)
append_pre_event_syn_code(code)
append_pre_spike_syn_code(code)
append_synapse_dynamics(code)
process()
property reset_post_vars
property reset_pre_vars

ml_genn.utils.module module

ml_genn.utils.module.get_module_classes(globals, base_class)
Parameters:

  • globals (Mapping[str, Any])

  • base_class (Type)

Return type:

Dict[str, Any]

ml_genn.utils.module.get_object(obj, base_class, description, dictionary)
Parameters:

  • base_class (Type[T])

  • description (str)

  • dictionary (Mapping[str, T])

Return type:

T | None

ml_genn.utils.module.get_object_mapping(obj, keys, base_class, description, dictionary)
Parameters:

  • base_class (Type)

  • description (str)

Return type:

dict

ml_genn.utils.network module

ml_genn.utils.network.get_network_dag(inputs, outputs)
ml_genn.utils.network.get_underlying_conn(obj)
Parameters:

obj (InputLayer | Layer | Population)

Return type:

Connection

ml_genn.utils.network.get_underlying_pop(obj)
Parameters:

obj (InputLayer | Layer | Population)

Return type:

Population

ml_genn.utils.snippet module

class ml_genn.utils.snippet.ConnectivitySnippet(snippet, matrix_type, weight, delay, pre_ind, post_ind, trainable)

Bases: tuple

Create new instance of ConnectivitySnippet(snippet, matrix_type, weight, delay, pre_ind, post_ind, trainable)

delay

Alias for field number 3

matrix_type

Alias for field number 1

post_ind

Alias for field number 5

pre_ind

Alias for field number 4

snippet

Alias for field number 0

trainable

Alias for field number 6

weight

Alias for field number 2

class ml_genn.utils.snippet.ConstantValueDescriptor

Bases: object

class ml_genn.utils.snippet.InitializerSnippet(snippet, param_vals, egp_vals)

Bases: tuple

Create new instance of InitializerSnippet(snippet, param_vals, egp_vals)

egp_vals

Alias for field number 2

param_vals

Alias for field number 1

snippet

Alias for field number 0

ml_genn.utils.value module

class ml_genn.utils.value.ValueDescriptor(*args)

Bases: object

get_transformed(instance, dt)
ml_genn.utils.value.get_genn_var_name(inst, name)
ml_genn.utils.value.get_values(inst, name_types, dt, vals={})
ml_genn.utils.value.is_value_array(value)
ml_genn.utils.value.is_value_constant(value)
ml_genn.utils.value.is_value_initializer(value)
ml_genn.utils.value.set_values(inst, vals)