qualia_plugin_snn.learningmodel.pytorch.QuantizedSResNetStride module

Contains the template for a quantized residual spiking neural network.

class qualia_plugin_snn.learningmodel.pytorch.QuantizedSResNetStride.CreateNeuron[source]

Bases: Protocol

Signature for create_neuron from qualia_plugin_snn.learningmodel.pytorch.SNN.create_neuron().

Used to pass neuron builder to BasicBlock.

__call__(quant_params: QuantizationConfigDict) → Module[source]

Instanciate a spiking neuron.

Parameters:

quant_params (QuantizationConfigDict) – Optional quantization configuration dict in case of quantized network, see qualia_core.learningmodel.pytorch.layers.Quantizer.Quantizer

Returns:

A spiking neuron instance

Return type:

Module

__init__(*args, **kwargs)
class qualia_plugin_snn.learningmodel.pytorch.QuantizedSResNetStride.QuantizedBasicBlockBuilder[source]

Bases: Protocol

Signature for basicblockbuilder.

Used to bind hyperparameters constant across all the ResNet blocks.

__call__(in_planes: int, planes: int, kernel_size: int, pool_size: int, stride: int, padding: int) → QuantizedBasicBlock[source]

Build a QuantizedBasicBlock.

Parameters:

  • in_planes (int) – Number of input channels

  • planes (int) – Number of filters (i.e., output channels) in the main branch Conv layers

  • kernel_size (int) – kernel_size for the main branch Conv layers

  • pool_size (int) – kernel_size for the MaxPool layers, no MaxPool layer added if 1

  • stride (int) – kernel_size for the MaxPool layers, no MaxPool layer added if 1

  • padding (int) – Padding for the main branch Conv layers

Returns:

A QuantizedBasicBlock

Return type:

QuantizedBasicBlock

__init__(*args, **kwargs)
class qualia_plugin_snn.learningmodel.pytorch.QuantizedSResNetStride.QuantizedBasicBlock[source]

Bases: Module

A single quantized ResNetv1 block.

Should have topology identical to qualia_plugin_snn.learningmodel.pytorch.SResNet.BasicBlock but with layers replaced with their quantized equivalent.

Structure is:

                 |
             /        \
         |                 |
   QuantizedConv           |
         |                 |
QuantizedBatchNorm         |
         |                 |
 QuantizedMaxPool   QuantizedConv
         |                 |
    QuantizedIF  QuantizedBatchNorm
         |                 |
   QuantizedConv  QuantizedMaxPool
         |                 |
QuantizedBatchNorm   QuantizedIF
         |                 |
    QuantizedIF            |
         |                 |
             \       /
                 |
            QuantizedAdd

Main (left) branch QuantizedConv use kernel_size=kernel_size, while residual (right) branch QuantizedConv use kernel_size=1.

QuantizedBatchNorm layers will be absent if batch_norm == False

QuantizedMaxPool layer will be absent if pool_size == 1.

Residual (right) branch QuantizedConv layer will be asbent if in_planes==planes, except if force_projection_with_pooling==True and pool_size != 1.

__init__(sjlayers_t: ModuleType, in_planes: int, planes: int, kernel_size: int, pool_size: int, stride: int, padding: int, batch_norm: bool, bn_momentum: float, force_projection_with_pooling: bool, create_neuron: CreateNeuron, step_mode: str, quant_params: QuantizationConfigDict) → None[source]

Construct QuantizedBasicBlock.

Parameters:

  • sjlayers_t (ModuleType) – Module containing the aliased quantized layers to use (1D or 2D)

  • in_planes (int) – Number of input channels

  • planes (int) – Number of filters (i.e., output channels) in the main branch QuantizedConv layers

  • kernel_size (int) – kernel_size for the main branch QuantizedConv layers

  • stride (int) – kernel_size for the QuantizedMaxPool layers, no QuantizedMaxPool layer added if 1

  • padding (int) – Padding for the main branch QuantizedConv layers

  • batch_norm (bool) – If True, add BatchNorm layer after each QuantizedConv layer

  • bn_momentum (float) – QuantizedBatchNorm layer momentum

  • force_projection_with_pooling (bool) – If True, residual QuantizedConv layer is kept when stride != 1 even if in_planes == planes

  • create_neuron (CreateNeuron) – qualia_plugin_snn.learningmodel.pytorch.SNN.SNN.create_neuron() method to instantiate a spiking neuron

  • step_mode (str) – SpikingJelly step_mode from qualia_plugin_snn.learningmodel.pytorch.SNN.SNN.step_mode

  • quant_params (QuantizationConfigDict) – Quantization configuration dict, see qualia_core.learningmodel.pytorch.layers.Quantizer.Quantizer

  • pool_size (int)

Return type:

None

expansion: int = 1

Unused

forward(input: Tensor) → Tensor[source]

Forward of quantized ResNet block.

Parameters:

input (Tensor) – Input tensor

Returns:

Output tensor

Return type:

Tensor

class qualia_plugin_snn.learningmodel.pytorch.QuantizedSResNetStride.QuantizedSResNetStride[source]

Bases: SNN

Quantized residual spiking neural network template.

Should have topology identical to qualia_plugin_snn.learningmodel.pytorch.SResNetStride.SResNetStride but with layers replaced with their quantized equivalent.

__init__(input_shape: tuple[int, ...], output_shape: tuple[int, ...], filters: list[int], kernel_sizes: list[int], pool_sizes: list[int], num_blocks: list[int], strides: list[int], paddings: list[int], quant_params: QuantizationConfig, prepool: int = 1, postpool: str = 'max', batch_norm: bool = False, bn_momentum: float = 0.1, force_projection_with_pooling: bool = True, neuron: RecursiveConfigDict | None = None, timesteps: int = 2, dims: int = 1, basicblockbuilder: QuantizedBasicBlockBuilder | None = None) → None[source]

Construct QuantizedSResNet.

Structure is:

  QuantizedInput
         |
 QuantizedAvgPool
         |
   QuantizedConv
         |
QuantizedBatchNorm
         |
    QuantizedIF
         |
QuantizedBasicBlock
         |
         …
         |
QuantizedBasicBlock
         |
QuantizedGlobalPool
         |
      Flatten
         |
  QuantizedLinear
Parameters:

  • input_shape (tuple[int, ...]) – Input shape

  • output_shape (tuple[int, ...]) – Output shape

  • filters (list[int]) – List of out_channels for QuantizedConv layers inside each QuantizedBasicBlock group, must be be of the same size as num_blocks, first element is for the first QuantizedConv layer at the beginning of the network

  • kernel_sizes (list[int]) – List of kernel_size for QuantizedConv layers inside each QuantizedBasicBlock group, must be of the same size as num_blocks, first element is for the first QuantizedConv layer at the beginning of the network

  • pool_size – List of kernel_size for QuantizedMaxPool layers inside each QuantizedBasicBlock group, must be of the same size as num_blocks, stride is applied only to the first QuantizedBasicBlock of the group, next QuantizedBasicBlock in the group use a stride of 1, first element is the stride of the first QuantizedConv layer at the beginning of the network

  • num_blocks (list[int]) – List of number of QuantizedBasicBlock in each group, also defines the number of QuantizedBasicBlock groups inside the network

  • strides (list[int]) – List of stride for first QuantizedConv layers inside each QuantizedBasicBlock group, must be of the same size as num_blocks, first element is for the first Conv layer at the beginning of the network

  • paddings (list[int]) – List of padding for QuantizedConv layer inside each QuantizedBasicBlock group, must be of the same size as num_blocks, first element is for the first QuantizedConv layer at the beginning of the network

  • prepool (int) – QuantizedAvgPool layer kernel_size to add at the beginning of the network, no layer added if 0

  • postpool (str) – Quantized global pooling layer type after all QuantizedBasicBlock, either max for QuantizedMaxPool or avg for QuantizedAvgPool

  • batch_norm (bool) – If True, add a QuantizedBatchNorm layer after each QuantizedConv layer, otherwise no layer added

  • bn_momentum (float) – QuantizedBatchNorm momentum

  • force_projection_with_pooling (bool) – If True, residual QuantizedConv layer is kept when stride != 1 even if in_planes == planes inside a QuantizedBasicBlock

  • neuron (RecursiveConfigDict | None) – Spiking neuron configuration, see qualia_plugin_snn.learningmodel.pytorch.SNN.SNN.__init__()

  • timesteps (int) – Number of timesteps

  • dims (int) – Either 1 or 2 for 1D or 2D convolutional network.

  • basicblockbuilder (QuantizedBasicBlockBuilder | None) – Optional function with QuantizedBasicBlockBuilder.__call__() signature to build a basic block after binding constants common across all basic blocks

  • pool_sizes (list[int])

  • quant_params (QuantizationConfig)

Return type:

None

in_planes: int
neuron1: Module
forward(input: Tensor) → Tensor[source]
Parameters:

input (Tensor)

Return type:

Tensor