qualia_plugin_snn.postprocessing.EnergyEstimationMetric module

Provide the EnergyEstimationMetric postprocessing module based on Lemaire et al., 2022.

class qualia_plugin_snn.postprocessing.EnergyEstimationMetric.SpikeCounter[source]

Bases: object

Holds the statistics and properties of an input or output tensor of a layer after inference.

Parameters:

spike_count – Number of spikes recorded
tensor_sum – Sum of elements of the tensor
size – Number of elements in the tensor
binary – True if all elements are binary (0 or 1), False otherwise
sample_count – Number of times the tensor has been updated

spike_count: int | float | bool

tensor_sum: int | float | bool

size: int

binary: bool

sample_count: int

__init__(spike_count: int | float | bool, tensor_sum: int | float | bool, size: int, binary: bool, sample_count: int) → None

Parameters:

spike_count (int | float | bool)
tensor_sum (int | float | bool)
size (int)
binary (bool)
sample_count (int)

Return type:

None

class qualia_plugin_snn.postprocessing.EnergyEstimationMetric.EnergyEstimationMetricLoggerFields[source]

Bases: NamedTuple

Interface object for CSV logging.

Should contain the same fields as EnergyMetrics and returned by EnergyMetrics.asnamedtuple().

Parameters:

name – Layer name
mem_pot – Energy for potential memory read/write
mem_weights – Energy for weights memory read
mem_bias – Energy for bias memory read
mem_io – Energy for input/output memory read/write
ops – Energy for synaptic operations
addr – Energy for event address computation
input_spikerate – Average input spike rate per timestep
output_spikerate – Average output spike rate per timestep
input_is_binary – If input tensor only contains binary values, i.e., spikes
output_is_binary – If output tensor only contains binary values, i.e., spikes
is_sj – If the layer is a SpikingJelly layer and has been processed as part of a Spiking Neural Network

name: str: Layer name

mem_pot: float: Energy for potential memory read/write

mem_weights: float: Energy for weights memory read

mem_bias: float: Energy for bias memory read

mem_io: float: Energy for input/output memory read/write

mem_total: float: Energy for potential, weights, bias and input/output read/write, i.e., Erdram + Ewrram

ops: float: Energy for synaptic operations

addr: float: Energy for event address computation

opsaddr: float: Energy for synaptic operations and event address computation, i.e., Eops+addr

total: float: Total energy, i.e., energy for memory read/write, synaptic operations and event adress computation

input_spikerate: float: Average input spike rate per timestep

output_spikerate: float: Average output spike rate per timestep

input_count: int | float | bool: Input count per timestep

output_count: int | float | bool: Output count per timestep

input_is_binary: bool: If input tensor only contains binary values, i.e., spikes

output_is_binary: bool: If output tensor only contains binary values, i.e., spikes

is_sj: bool | Literal['Hybrid']: If the layer is a SpikingJelly layer and has been processed as part of a Spiking Neural Network

static __new__(_cls, name: str, mem_pot: float, mem_weights: float, mem_bias: float, mem_io: float, mem_total: float, ops: float, addr: float, opsaddr: float, total: float, input_spikerate: float, output_spikerate: float, input_count: Number, output_count: Number, input_is_binary: bool, output_is_binary: bool, is_sj: bool | Literal['Hybrid'])

Create new instance of EnergyEstimationMetricLoggerFields(name, mem_pot, mem_weights, mem_bias, mem_io, mem_total, ops, addr, opsaddr, total, input_spikerate, output_spikerate, input_count, output_count, input_is_binary, output_is_binary, is_sj)

Parameters:

name (str)
mem_pot (float)
mem_weights (float)
mem_bias (float)
mem_io (float)
mem_total (float)
ops (float)
addr (float)
opsaddr (float)
total (float)
input_spikerate (float)
output_spikerate (float)
input_count (Number)
output_count (Number)
input_is_binary (bool)
output_is_binary (bool)
is_sj (bool | Literal['Hybrid'])

class qualia_plugin_snn.postprocessing.EnergyEstimationMetric.EnergyMetrics[source]

Bases: object

Holds the computed average energy per inference for each layer.

Parameters:

name – Layer name
mem_pot – Energy for potential memory read/write
mem_weights – Energy for weights memory read
mem_bias – Energy for bias memory read
mem_io – Energy for input/output memory read/write
ops – Energy for synaptic operations
addr – Energy for event address computation
input_spikerate – Average input spike rate per timestep
output_spikerate – Average output spike rate per timestep
input_count – Input count per timestep
output_count – Output count per timestep
input_is_binary – If input tensor only contains binary values, i.e., spikes
output_is_binary – If output tensor only contains binary values, i.e., spikes
is_sj – If the layer is a SpikingJelly layer and has been processed as part of a Spiking Neural Network

name: str: Layer name

mem_pot: float: Energy for potential memory read/write

mem_weights: float: Energy for weights memory read

mem_bias: float: Energy for bias memory read

mem_io: float: Energy for input/output memory read/write

ops: float: Energy for synaptic operations

addr: float: Energy for event address computation

input_spikerate: float | None: Average input spike rate per timestep

output_spikerate: float | None: Average output spike rate per timestep

input_count: int | float | bool | None: Input count per timestep

output_count: int | float | bool | None: Output count per timestep

input_is_binary: bool: If input tensor only contains binary values, i.e., spikes

output_is_binary: bool: If output tensor only contains binary values, i.e., spikes

is_sj: bool | Literal['Hybrid']: If the layer is a SpikingJelly layer and has been processed as part of a Spiking Neural Network

property mem_total: float: Energy for potential, weights, bias and input/output read/write. Erdram + Ewrram.

property opsaddr: float: Energy for synaptic operations and event address computation. Eops+addr.

property total: float: Total energy. Energy for memory read/write, synaptic operations and event adress computation.

asnamedtuple() → EnergyEstimationMetricLoggerFields[source]

Return the data from this class as a NamedTuple for use with the CSV logger.

Instanciate a EnergyEstimationMetricLoggerFields object with all of this class fields and properties and return it.

Returns:: the EnergyEstimationMetricLoggerFields with all data from this object copied into it
Return type:: EnergyEstimationMetricLoggerFields

Parameters:

name (str)
mem_pot (float)
mem_weights (float)
mem_bias (float)
mem_io (float)
ops (float)
addr (float)
input_spikerate (float | None)
output_spikerate (float | None)
input_count (int | float | bool | None)
output_count (int | float | bool | None)
input_is_binary (bool)
output_is_binary (bool)
is_sj (bool | Literal['Hybrid'])

Return type:

None

class qualia_plugin_snn.postprocessing.EnergyEstimationMetric.EnergyEstimationMetric[source]

Bases: PostProcessing[Module]

Analytical energy estimation metric.

From An Analytical Estimation of Spiking Neural Networks Energy Efficiency, Lemaire et al. ICONIP2022.

@inproceedings{EnergyEstimationMetricICONIP2022,
    title = {An Analytical Estimation of Spiking Neural Networks Energy Efficiency},
    author = {Lemaire, Edgar and Cordone, Loïc and Castagnetti, Andrea
              and Novac, Pierre-Emmanuel and Courtois, Jonathan and Miramond, Benoît},
    booktitle = {Proceedings of the 29th International Conference on Neural Information Processing},
    pages = {574--587},
    year = {2023},
    doi = {10.1007/978-3-031-30105-6_48},
    series = {ICONIP},
}

Supports sequential (non-residual) formal and spiking convolutional neural networks with the following layers:

torch.nn.Conv1d
torch.nn.Conv2d
torch.nn.Linear
torch.nn.ReLU for formal neural networks
spikingjelly.activation_based.neuron.IFNode for spiking neural networks
spikingjelly.activation_based.neuron.LIFNode for spiking neural networks

energy_values: Final[dict[int, dict[str, float]]] = {8: {'add': 0.03, 'mul': 0.2}, 32: {'add': 0.1, 'mul': 3.1}}

Energy values for different bit widths and operations.

Default from Computing’s Energy Problem (and what we can do about it), Mark Horowitz, ISSCC 2014.

__init__(mem_width: int, fifo_size: int = 0, total_spikerate_exclude_nonbinary: bool = True, op_estimation_type: dict[str, str] | None = None, sram_estimation_type: str | None = None) → None[source]

Construct qualia_plugin_snn.postprocessing.EnergyEstimationMetric.EnergyEstimationMetric.

Parameters:

mem_width (int) – Memory access size in bits, e.g. 16 for 16-bit quantization
fifo_size (int) – Size of the input/output FIFOs for each layer in SPLEAT
total_spikerate_exclude_nonbinary (bool) – If True, exclude non-binary inputs/outputs from total spikerate computation
op_estimation_type (dict[str, str] | None) – Optional estimation type for the energy values, one of ‘ICONIP’, ‘saturation’, ‘linear’, ‘quadratic’, defaults to ‘ICONIP’, see _set_energy_values() and _set_op_estimation_type()
sram_estimation_type (str | None) – Optional SRAM estimation algorithm, ‘old’ (ICONIP2022) or ‘new’ (T. Louis), defaults to ‘old’, see :meth:``_e_ram`

Return type:

None

_set_op_estimation_type(bit_width: int, op_type: str, op_estimation_type: str | int) → float[source]

Set the estimation type for the energy values.

If op_estimation_type is not in [‘ICONIP’, ‘saturation’, ‘linear’, ‘quadratic’], raise ValueError.

If op_estimation_type is ‘’ICONIP’, use the energy values from the ICONIP 2022 paper (i.e. 32-bit values).

If op_estimation_type is ‘saturation’, use self.energy_values[8][type] for 8-bit and below, and self.energy_values[32][type] for bit widths between 9 and 32.

If op_estimation_type is ‘linear’, use self.energy_values[8][type] and self.energy_values[32][type] to estimate the energy values by solving a linear equation: y = m*bit_width + c.

If op_estimation_type is ‘quadratic’, use self.energy_values[8][type] and self.energy_values[32][type] to estimate the energy values by solving a quadratic equation: y = a*bit_width^2 + b*bit_width + c.

Parameters:

bit_width (int) – Bit width to compute energy for
op_type (str) – Operation type, e.g., ‘add’ or ‘mul’
op_estimation_type (str | int) – The estimation type for the energy values, one of ‘ICONIP’, ‘saturation’, ‘linear’, ‘quadratic’

Returns:

Energy for the given bit width, operation and estimation type

Raises:

ValueError – When op_estimation_type is invalid, or bit_width is out of bounds for ‘saturation’ op_estimation_type

Return type: