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)
Parameters:

spikes (PreprocessedSpikes)

Return type:

float

ml_genn.utils.data.calc_max_spikes(spikes)
Parameters:

spikes (PreprocessedSpikes)

Return type:

int

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

end_spikes (ndarray)

Return type:

ndarray

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)
Parameters:

  • data (ndarray)

  • max_time (float)

  • min_time (float)

  • thresh (int)

Return type:

List[PreprocessedSpikes]

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

  • data (ndarray)

  • tau_eff (float)

  • thresh (float)

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)
Parameters:

  • events (ndarray)

  • ordering (Sequence[str])

  • shape (Tuple)

  • dt (float | None)

  • histogram_thresh (int | None)

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_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(genn_name, value_transform=None)

Bases: object

Parameters:

genn_name (str)

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)