chop.nn.quantized.modules

chop.nn.quantized.modules.attention

class chop.nn.quantized.modules.attention.BertSelfAttentionInteger(config, q_config: dict = None, out_q_config: dict = None, position_embedding_type=None, bias=True, floor=False, output_tensor_only=False)

Bases: _BertSelfAttentionBase

__init__(config, q_config: dict = None, out_q_config: dict = None, position_embedding_type=None, bias=True, floor=False, output_tensor_only=False) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

chop.nn.quantized.modules.attention_head

class chop.nn.quantized.modules.attention_head.BertSelfAttentionHeadInteger(config, q_config: dict = None)

Bases: _BertSelfAttentionHeadBase

__init__(config, q_config: dict = None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(query_layer: Tensor, key_layer: Tensor, value_layer: Tensor, attention_mask: FloatTensor | None = None) → Tensor

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

chop.nn.quantized.modules.batch_norm1d

class chop.nn.quantized.modules.batch_norm1d.BatchNorm1dInteger(num_features: int, eps: float = 1e-05, momentum: float = 0.1, affine: bool = True, track_running_stats: bool = True, device=None, dtype=None, config=None)

Bases: _BatchNorm1dBase

__init__(num_features: int, eps: float = 1e-05, momentum: float = 0.1, affine: bool = True, track_running_stats: bool = True, device=None, dtype=None, config=None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

chop.nn.quantized.modules.batch_norm2d

class chop.nn.quantized.modules.batch_norm2d.BatchNorm2dInteger(num_features: int, eps: float = 1e-05, momentum: float = 0.1, affine: bool = True, track_running_stats: bool = True, device=None, dtype=None, config=None)

Bases: _BatchNorm2dBase

__init__(num_features: int, eps: float = 1e-05, momentum: float = 0.1, affine: bool = True, track_running_stats: bool = True, device=None, dtype=None, config=None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.batch_norm2d.BatchNorm2dBinary(num_features: int, eps: float = 1e-05, momentum: float = 0.1, affine: bool = True, track_running_stats: bool = True, device=None, dtype=None, config=None)

Bases: _BatchNorm2dBase

__init__(num_features: int, eps: float = 1e-05, momentum: float = 0.1, affine: bool = True, track_running_stats: bool = True, device=None, dtype=None, config=None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

chop.nn.quantized.modules.conv1d

class chop.nn.quantized.modules.conv1d.Conv1dInteger(in_channels: int, out_channels: int, kernel_size: int | Tuple[int], stride: int | Tuple[int] = 1, padding: str | int | Tuple[int] = 0, dilation: int | Tuple[int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config=None)

Bases: _Conv1dBase

__init__(in_channels: int, out_channels: int, kernel_size: int | Tuple[int], stride: int | Tuple[int] = 1, padding: str | int | Tuple[int] = 0, dilation: int | Tuple[int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config=None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.conv1d.Conv1dMinifloatDenorm(in_channels: int, out_channels: int, kernel_size: int | Tuple[int], stride: int | Tuple[int] = 1, padding: str | int | Tuple[int] = 0, dilation: int | Tuple[int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config: dict = None)

Bases: _Conv1dBase

__init__(in_channels: int, out_channels: int, kernel_size: int | Tuple[int], stride: int | Tuple[int] = 1, padding: str | int | Tuple[int] = 0, dilation: int | Tuple[int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config: dict = None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.conv1d.Conv1dLog(in_channels: int, out_channels: int, kernel_size: int | Tuple[int], stride: int | Tuple[int] = 1, padding: str | int | Tuple[int] = 0, dilation: int | Tuple[int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config: dict = None)

Bases: _Conv1dBase

__init__(in_channels: int, out_channels: int, kernel_size: int | Tuple[int], stride: int | Tuple[int] = 1, padding: str | int | Tuple[int] = 0, dilation: int | Tuple[int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config: dict = None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.conv1d.Conv1dMinifloatIEEE(in_channels: int, out_channels: int, kernel_size: int | Tuple[int], stride: int | Tuple[int] = 1, padding: str | int | Tuple[int] = 0, dilation: int | Tuple[int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config: dict = None)

Bases: _Conv1dBase

__init__(in_channels: int, out_channels: int, kernel_size: int | Tuple[int], stride: int | Tuple[int] = 1, padding: str | int | Tuple[int] = 0, dilation: int | Tuple[int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config: dict = None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.conv1d.Conv1dBlockFP(in_channels: int, out_channels: int, kernel_size: int | Tuple[int], stride: int | Tuple[int] = 1, padding: str | int | Tuple[int] = 0, dilation: int | Tuple[int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config: dict = None)

Bases: _Conv1dBase

__init__(in_channels: int, out_channels: int, kernel_size: int | Tuple[int], stride: int | Tuple[int] = 1, padding: str | int | Tuple[int] = 0, dilation: int | Tuple[int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config: dict = None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.conv1d.Conv1dBlockMinifloat(in_channels: int, out_channels: int, kernel_size: int | Tuple[int], stride: int | Tuple[int] = 1, padding: str | int | Tuple[int] = 0, dilation: int | Tuple[int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config: dict = None)

Bases: _Conv1dBase

__init__(in_channels: int, out_channels: int, kernel_size: int | Tuple[int], stride: int | Tuple[int] = 1, padding: str | int | Tuple[int] = 0, dilation: int | Tuple[int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config: dict = None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.conv1d.Conv1dBlockLog(in_channels: int, out_channels: int, kernel_size: int | Tuple[int], stride: int | Tuple[int] = 1, padding: int | Tuple[int] | str = 0, dilation: int | Tuple[int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config: dict = None)

Bases: _Conv1dBase

__init__(in_channels: int, out_channels: int, kernel_size: int | Tuple[int], stride: int | Tuple[int] = 1, padding: int | Tuple[int] | str = 0, dilation: int | Tuple[int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config: dict = None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.conv1d.Conv1dBinary(in_channels: int, out_channels: int, kernel_size: int | Tuple[int], stride: int | Tuple[int] = 1, padding: str | int | Tuple[int] = 0, dilation: int | Tuple[int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config=None)

Bases: _Conv1dBase

__init__(in_channels: int, out_channels: int, kernel_size: int | Tuple[int], stride: int | Tuple[int] = 1, padding: str | int | Tuple[int] = 0, dilation: int | Tuple[int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config=None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.conv1d.Conv1dTernary(in_channels: int, out_channels: int, kernel_size: int | Tuple[int], stride: int | Tuple[int] = 1, padding: int | Tuple[int] | str = 0, dilation: int | Tuple[int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config=None)

Bases: _Conv1dBase

__init__(in_channels: int, out_channels: int, kernel_size: int | Tuple[int], stride: int | Tuple[int] = 1, padding: int | Tuple[int] | str = 0, dilation: int | Tuple[int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config=None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

chop.nn.quantized.modules.conv2d

class chop.nn.quantized.modules.conv2d.Conv2dInteger(in_channels: int, out_channels: int, kernel_size: int | Tuple[int, int], stride: int | Tuple[int, int] = 1, padding: str | int | Tuple[int, int] = 0, dilation: int | Tuple[int, int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config=None)

Bases: _Conv2dBase

__init__(in_channels: int, out_channels: int, kernel_size: int | Tuple[int, int], stride: int | Tuple[int, int] = 1, padding: str | int | Tuple[int, int] = 0, dilation: int | Tuple[int, int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config=None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.conv2d.Conv2dMinifloatDenorm(in_channels: int, out_channels: int, kernel_size: int | Tuple[int, int], stride: int | Tuple[int, int] = 1, padding: str | int | Tuple[int, int] = 0, dilation: int | Tuple[int, int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config: dict = None)

Bases: _Conv2dBase

__init__(in_channels: int, out_channels: int, kernel_size: int | Tuple[int, int], stride: int | Tuple[int, int] = 1, padding: str | int | Tuple[int, int] = 0, dilation: int | Tuple[int, int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config: dict = None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.conv2d.Conv2dMinifloatIEEE(in_channels: int, out_channels: int, kernel_size: int | Tuple[int, int], stride: int | Tuple[int, int] = 1, padding: str | int | Tuple[int, int] = 0, dilation: int | Tuple[int, int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config: dict = None)

Bases: _Conv2dBase

__init__(in_channels: int, out_channels: int, kernel_size: int | Tuple[int, int], stride: int | Tuple[int, int] = 1, padding: str | int | Tuple[int, int] = 0, dilation: int | Tuple[int, int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config: dict = None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.conv2d.Conv2dLog(in_channels: int, out_channels: int, kernel_size: int | Tuple[int, int], stride: int | Tuple[int, int] = 1, padding: str | int | Tuple[int, int] = 0, dilation: int | Tuple[int, int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config: dict = None)

Bases: _Conv2dBase

__init__(in_channels: int, out_channels: int, kernel_size: int | Tuple[int, int], stride: int | Tuple[int, int] = 1, padding: str | int | Tuple[int, int] = 0, dilation: int | Tuple[int, int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config: dict = None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.conv2d.Conv2dBlockFP(in_channels: int, out_channels: int, kernel_size: int | Tuple[int, int], stride: int | Tuple[int, int] = 1, padding: str | int | Tuple[int, int] = 0, dilation: int | Tuple[int, int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config: dict = None)

Bases: _Conv2dBase

__init__(in_channels: int, out_channels: int, kernel_size: int | Tuple[int, int], stride: int | Tuple[int, int] = 1, padding: str | int | Tuple[int, int] = 0, dilation: int | Tuple[int, int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config: dict = None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x: Tensor) → Tensor

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.conv2d.Conv2dBlockMinifloat(in_channels: int, out_channels: int, kernel_size: int | Tuple[int, int], stride: int | Tuple[int, int] = 1, padding: str | int | Tuple[int, int] = 0, dilation: int | Tuple[int, int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config: dict = None)

Bases: _Conv2dBase

__init__(in_channels: int, out_channels: int, kernel_size: int | Tuple[int, int], stride: int | Tuple[int, int] = 1, padding: str | int | Tuple[int, int] = 0, dilation: int | Tuple[int, int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config: dict = None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x: Tensor) → Tensor

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.conv2d.Conv2dBlockLog(in_channels: int, out_channels: int, kernel_size: int | Tuple[int, int], stride: int | Tuple[int, int] = 1, padding: int | Tuple[int, int] | str = 0, dilation: int | Tuple[int, int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config: dict = None)

Bases: _Conv2dBase

__init__(in_channels: int, out_channels: int, kernel_size: int | Tuple[int, int], stride: int | Tuple[int, int] = 1, padding: int | Tuple[int, int] | str = 0, dilation: int | Tuple[int, int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config: dict = None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x: Tensor) → Tensor

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.conv2d.Conv2dBinary(in_channels: int, out_channels: int, kernel_size: int | Tuple[int, int], stride: int | Tuple[int, int] = 1, padding: str | int | Tuple[int, int] = 0, dilation: int | Tuple[int, int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config=None)

Bases: _Conv2dBase

__init__(in_channels: int, out_channels: int, kernel_size: int | Tuple[int, int], stride: int | Tuple[int, int] = 1, padding: str | int | Tuple[int, int] = 0, dilation: int | Tuple[int, int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config=None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.conv2d.Conv2dBinaryScaling(in_channels: int, out_channels: int, kernel_size: int | Tuple[int, int], stride: int | Tuple[int, int] = 1, padding: str | int | Tuple[int, int] = 0, dilation: int | Tuple[int, int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config=None)

Bases: _Conv2dBase

Binary scaling variant of the conv2d transformation layer.

• “bypass”: Bypass quantization for standard linear transformation.

• “data_in_stochastic”, “bias_stochastic”, “weight_stochastic”: Stochastic settings.

• “data_in_bipolar”, “bias_bipolar”, “weight_bipolar”: Bipolar settings.

• “binary_training”: Apply binary scaling during training.

__init__(in_channels: int, out_channels: int, kernel_size: int | Tuple[int, int], stride: int | Tuple[int, int] = 1, padding: str | int | Tuple[int, int] = 0, dilation: int | Tuple[int, int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config=None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x: Tensor) → Tensor

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.conv2d.Conv2dBinaryResidualSign(in_channels: int, out_channels: int, kernel_size: int | Tuple[int, int], stride: int | Tuple[int, int] = 1, padding: str | int | Tuple[int, int] = 0, dilation: int | Tuple[int, int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config=None)

Bases: _Conv2dBase

Binary conv2d layer with redisual sign variant of the linear transformation layer.

• “bypass”: Bypass quantization for standard linear transformation.

• “data_in_stochastic”, “bias_stochastic”, “weight_stochastic”: Stochastic settings.

• “data_in_bipolar”, “bias_bipolar”, “weight_bipolar”: Bipolar settings.

• “binary_training”: Apply binary scaling during training.

• “data_in_levels”: The num of residual layers to use.

• “data_in_residual_sign” : Apply residual sign on input

__init__(in_channels: int, out_channels: int, kernel_size: int | Tuple[int, int], stride: int | Tuple[int, int] = 1, padding: str | int | Tuple[int, int] = 0, dilation: int | Tuple[int, int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config=None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x: Tensor) → Tensor

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.conv2d.Conv2dTernary(in_channels: int, out_channels: int, kernel_size: int | Tuple[int, int], stride: int | Tuple[int, int] = 1, padding: str | int | Tuple[int, int] = 0, dilation: int | Tuple[int, int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config=None)

Bases: _Conv2dBase

__init__(in_channels: int, out_channels: int, kernel_size: int | Tuple[int, int], stride: int | Tuple[int, int] = 1, padding: str | int | Tuple[int, int] = 0, dilation: int | Tuple[int, int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config=None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.conv2d.Conv2dLUT(config: None, in_channels: int, out_channels: int, kernel_size: int | tuple, stride: int | tuple = 1, padding: int | tuple = 0, dilation: int | tuple = 1, groups: int | tuple = 1, bias: bool = True, padding_mode: str = 'zeros', trainer_type: Type[BaseTrainer] = <class 'chop.nn.quantizers.LUTNet.BaseTrainer.LagrangeTrainer'>, mask_builder_type: Type[MaskBase] = <class 'chop.nn.quantizers.LUTNet.MaskBase.MaskExpanded'>, device: str = None)

Bases: Module

mask_builder: MaskBase

__init__(config: None, in_channels: int, out_channels: int, kernel_size: int | tuple, stride: int | tuple = 1, padding: int | tuple = 0, dilation: int | tuple = 1, groups: int | tuple = 1, bias: bool = True, padding_mode: str = 'zeros', trainer_type: Type[BaseTrainer] = <class 'chop.nn.quantizers.LUTNet.BaseTrainer.LagrangeTrainer'>, mask_builder_type: Type[MaskBase] = <class 'chop.nn.quantizers.LUTNet.MaskBase.MaskExpanded'>, device: str = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

in_channels: int

out_channels: int

kernel_size: tuple

stride: tuple

padding: bool

dilation: tuple

mask_builder_type: Type[MaskBase]

groups: tuple

bias: Tensor

padding_mode: str

k: int

input_dim: tuple

device: str | None

input_mask: Tensor

tables_count: int

trainer: BaseTrainer

forward(input: Tensor, targets: tensor = None, initalize: bool = False)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

pre_initialize()

update_initialized_weights()

class chop.nn.quantized.modules.conv2d.Conv2DLogicNets(in_channels: int, out_channels: int, kernel_size: int | Tuple[int, int], stride: int | Tuple[int, int] = 1, padding: str | int | Tuple[int, int] = 0, dilation: int | Tuple[int, int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config=None)

Bases: _Conv2dBase

__init__(in_channels: int, out_channels: int, kernel_size: int | Tuple[int, int], stride: int | Tuple[int, int] = 1, padding: str | int | Tuple[int, int] = 0, dilation: int | Tuple[int, int] = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device=None, dtype=None, config=None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

table_lookup(connected_input: Tensor, input_perm_matrix: Tensor, bin_output_states: Tensor) → Tensor

lut_forward(x: Tensor) → Tensor

construct_mask_index()

calculate_truth_tables()

forward(x: Tensor) → Tensor

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

encode(input: Tensor) → Tensor

decode(input: Tensor) → Tensor

math_forward(input: Tensor) → Tensor

chop.nn.quantized.modules.gelu

class chop.nn.quantized.modules.gelu.GELUInteger(inplace: bool = False, config: dict = None)

Bases: _GELUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

bypass = None

class chop.nn.quantized.modules.gelu.GELUMinifloatDenorm(inplace: bool = False, config: dict = None)

Bases: _GELUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.gelu.GELUMinifloatIEEE(inplace: bool = False, config: dict = None)

Bases: _GELUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.gelu.GELULog(inplace: bool = False, config: dict = None)

Bases: _GELUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.gelu.GELUBlockFP(inplace: bool = False, config: dict = None)

Bases: _GELUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x: Tensor) → Tensor

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.gelu.GELUBlockMinifloat(inplace: bool = False, config: dict = None)

Bases: _GELUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x: Tensor) → Tensor

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.gelu.GELUBlockLog(inplace: bool = False, config: dict = None)

Bases: _GELUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x: Tensor) → Tensor

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.gelu.GELUBinary(inplace: bool = False, config: dict = None)

Bases: _GELUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

bypass = None

class chop.nn.quantized.modules.gelu.GELUTernary(inplace: bool = False, config: dict = None)

Bases: _GELUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

bypass = None

chop.nn.quantized.modules.group_norm

class chop.nn.quantized.modules.group_norm.GroupNormInteger(num_groups: int, num_channels: int, eps: float = 1e-05, affine: bool = True, device=None, dtype=None, config=None)

Bases: _GroupNormBase

__init__(num_groups: int, num_channels: int, eps: float = 1e-05, affine: bool = True, device=None, dtype=None, config=None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

chop.nn.quantized.modules.instance_norm2d

class chop.nn.quantized.modules.instance_norm2d.InstanceNorm2dInteger(num_features: int, eps: float = 1e-05, momentum: float = 0.1, affine: bool = False, track_running_stats: bool = False, device=None, dtype=None, config=None)

Bases: _InstanceNorm2dBase

__init__(num_features: int, eps: float = 1e-05, momentum: float = 0.1, affine: bool = False, track_running_stats: bool = False, device=None, dtype=None, config=None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

chop.nn.quantized.modules.layer_norm

class chop.nn.quantized.modules.layer_norm.LayerNormInteger(normalized_shape, eps: float = 1e-05, elementwise_affine: bool = False, bias: bool = False, device=None, dtype=None, config=None)

Bases: _LayerNormBase

__init__(normalized_shape, eps: float = 1e-05, elementwise_affine: bool = False, bias: bool = False, device=None, dtype=None, config=None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

chop.nn.quantized.modules.linear

class chop.nn.quantized.modules.linear.LinearInteger(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None, config=None, out_config=None, floor=None)

Bases: _LinearBase

__init__(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None, config=None, out_config=None, floor=None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.linear.LinearMinifloatDenorm(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None, config=None)

Bases: _LinearBase

__init__(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None, config=None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.linear.LinearMinifloatIEEE(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None, config=None)

Bases: _LinearBase

__init__(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None, config=None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.linear.LinearLog(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None, config=None)

Bases: _LinearBase

__init__(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None, config=None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.linear.LinearBlockFP(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None, config=None)

Bases: _LinearBase

__init__(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None, config=None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.linear.LinearBlockMinifloat(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None, config=None)

Bases: _LinearBase

__init__(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None, config=None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.linear.LinearBlockLog(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None, config=None)

Bases: _LinearBase

__init__(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None, config=None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.linear.LinearBinary(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None, config=None)

Bases: _LinearBase

__init__(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None, config=None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.linear.LinearBinaryScaling(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None, config=None)

Bases: _LinearBase

Binary scaling variant of the linear transformation layer.

• “bypass”: Bypass quantization for standard linear transformation.

• “data_in_stochastic”, “bias_stochastic”, “weight_stochastic”: Stochastic settings.

• “data_in_bipolar”, “bias_bipolar”, “weight_bipolar”: Bipolar settings.

• “binary_training”: Apply binary scaling during training.

__init__(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None, config=None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.linear.LinearTernary(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None, config=None)

Bases: _LinearBase

__init__(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None, config=None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.linear.LinearBinaryResidualSign(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None, config=None)

Bases: _LinearBase

Binary Linear layer with redisual sign variant of the linear transformation layer.

• “bypass”: Bypass quantization for standard linear transformation.

• “data_in_stochastic”, “bias_stochastic”, “weight_stochastic”: Stochastic settings.

• “data_in_bipolar”, “bias_bipolar”, “weight_bipolar”: Bipolar settings.

• “binary_training”: Apply binary scaling during training.

• “data_in_levels”: The num of residual layers to use.

• “data_in_residual_sign” : Apply residual sign on input

__init__(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None, config=None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x: Tensor) → Tensor

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.linear.LinearLUT(config: None, in_features: int, out_features: int, mask_builder_type: Type[MaskBase] = <class 'chop.nn.quantizers.LUTNet.MaskBase.MaskExpanded'>, trainer_type: Type[BaseTrainer] = <class 'chop.nn.quantizers.LUTNet.BaseTrainer.LagrangeTrainer'>, bias: bool = True, device: str = None)

Bases: Module

mask_builder: MaskBase

__init__(config: None, in_features: int, out_features: int, mask_builder_type: Type[MaskBase] = <class 'chop.nn.quantizers.LUTNet.MaskBase.MaskExpanded'>, trainer_type: Type[BaseTrainer] = <class 'chop.nn.quantizers.LUTNet.BaseTrainer.LagrangeTrainer'>, bias: bool = True, device: str = None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

in_features: int

out_features: int

mask_builder_type: Type[MaskBase]

input_mask: Tensor

tables_count: int

trainer: BaseTrainer

forward(input: Tensor, targets: tensor = None, initalize: bool = False)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

pre_initialize()

update_initialized_weights()

class chop.nn.quantized.modules.linear.LinearLogicNets(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None, config=None, activation_module=None, input_layers=None, output_layers=None)

Bases: _LinearBase

__init__(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None, config=None, activation_module=None, input_layers=None, output_layers=None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

table_lookup(connected_input: Tensor, input_perm_matrix: Tensor, bin_output_states: Tensor) → Tensor

lut_forward(x: Tensor) → Tensor

construct_mask_index()

calculate_truth_tables()

math_forward(input: Tensor) → Tensor

set_fused(fused: bool)

run_layers(input: Tensor, layers) → Tensor

encode(input: Tensor) → Tensor

decode(input: Tensor) → Tensor

forward(x: Tensor) → Tensor

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.linear.LinearMXIntHardware(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None, config=None, out_config=None)

Bases: _LinearBase

__init__(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None, config=None, out_config=None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.linear.LinearMXFP(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None, config=None)

Bases: _LinearBase

__init__(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None, config=None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

classmethod from_linear(linear: Linear, config: dict) → LinearMXFP

Create a LinearMXFP that REUSES the original Linear’s Parameters.

Mirrors LinearMXInt.from_linear for MXFP: shares the existing weight / bias Parameter (preserving DTensor sharding), then quantizes them in place. Used by the rotation-search swap path so LinearMXFP ↔ RotateMXFPLinear swaps stay zero-copy.

load_state_dict(state_dict, strict=True, assign=False)

Load pretrained weights, then quantize them in place.

forward(x)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.linear.LinearMXInt(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None, config=None)

Bases: _LinearBase

__init__(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None, config=None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

classmethod from_linear(linear: Linear, config: dict) → LinearMXInt

Create a LinearMXInt that REUSES the original Linear’s Parameters.

Unlike __init__ which allocates a fresh weight tensor via torch.nn.Linear.__init__, this classmethod shares the original module’s weight and bias Parameters directly. This is critical for tensor-parallel models: if linear.weight is a DTensor shard (from HF’s tp_plan="auto"), re-allocating would lose the sharding and fail the state-dict copy. By sharing the Parameter, the DTensor is preserved and TP dispatch keeps working.

The weight is then quantized in place. mxint_quantizer handles DTensor inputs transparently (each rank quantizes its local shard).

load_state_dict(state_dict, strict=True, assign=False)

Load pretrained weights, then quantize them in place.

forward(x)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.linear.RotateMXIntLinear(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None, config=None)

Bases: LinearMXInt

LinearMXInt + exact Hadamard rotation around the activation quantizer.

Identical to LinearMXInt for weight/bias quantization (and reuses its __init__ / from_linear / load_state_dict). The forward path differs by replacing the plain MXINT activation quantize with mxint_rotate_quantizer: the input is rotated by an exact Hadamard, quantized, and rotated back.

The rotation pair is mathematically a no-op in fp; for the round trip to cancel correctly under the surrounding linears, the upstream weights must be offline-rotated to match (run the rotate pass with online_rotate=True). Typical use: layers whose inputs feed o_proj / down_proj.

Extra config keys (optional):

force_fp32_had: run the Hadamard multiplications in fp32.

forward(x)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.linear.RotateMXFPLinear(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None, config=None)

Bases: LinearMXFP

LinearMXFP + exact Hadamard rotation around the activation quantizer.

Mirrors RotateMXIntLinear for MXFP. Reuses LinearMXFP for weight quantization (and its __init__ / from_linear / load_state_dict); only the forward activation quantize swaps to mxfp_rotate_quantizer.

Extra config keys (optional):

force_fp32_had: run the Hadamard multiplications in fp32.

forward(x)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

chop.nn.quantized.modules.max_pool2d

class chop.nn.quantized.modules.pool2d.AvgPool2dInteger(kernel_size: int | Tuple[int, int], stride: int | Tuple[int, int] | None = None, padding: int | Tuple[int, int] = 0, ceil_mode: bool = False, count_include_pad: bool = True, divisor_override: int | None = None, config=None)

Bases: _AvgPool2dBase

__init__(kernel_size: int | Tuple[int, int], stride: int | Tuple[int, int] | None = None, padding: int | Tuple[int, int] = 0, ceil_mode: bool = False, count_include_pad: bool = True, divisor_override: int | None = None, config=None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.pool2d.AdaptiveAvgPool2dInteger(output_size, config)

Bases: _AdaptiveAvgPool2dBase

__init__(output_size, config) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.pool2d.AvgPool2dBinary(kernel_size: int | Tuple[int, int], stride: int | Tuple[int, int] | None = None, padding: int | Tuple[int, int] = 0, ceil_mode: bool = False, count_include_pad: bool = True, divisor_override: int | None = None, config=None)

Bases: _AvgPool2dBase

__init__(kernel_size: int | Tuple[int, int], stride: int | Tuple[int, int] | None = None, padding: int | Tuple[int, int] = 0, ceil_mode: bool = False, count_include_pad: bool = True, divisor_override: int | None = None, config=None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.pool2d.AvgPool2dTernary(kernel_size: int | Tuple[int, int], stride: int | Tuple[int, int] | None = None, padding: int | Tuple[int, int] = 0, ceil_mode: bool = False, count_include_pad: bool = True, divisor_override: int | None = None, config=None)

Bases: _AvgPool2dBase

__init__(kernel_size: int | Tuple[int, int], stride: int | Tuple[int, int] | None = None, padding: int | Tuple[int, int] = 0, ceil_mode: bool = False, count_include_pad: bool = True, divisor_override: int | None = None, config=None) → None

Initialize internal Module state, shared by both nn.Module and ScriptModule.

chop.nn.quantized.modules.relu

class chop.nn.quantized.modules.relu.ReLUInteger(inplace: bool = False, config: dict = None)

Bases: _ReLUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

bypass = None

class chop.nn.quantized.modules.relu.ReLUMinifloatDenorm(inplace: bool = False, config: dict = None)

Bases: _ReLUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.relu.ReLUMinifloatIEEE(inplace: bool = False, config: dict = None)

Bases: _ReLUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.relu.ReLULog(inplace: bool = False, config: dict = None)

Bases: _ReLUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.relu.ReLUBlockFP(inplace: bool = False, config: dict = None)

Bases: _ReLUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x: Tensor) → Tensor

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.relu.ReLUBlockMinifloat(inplace: bool = False, config: dict = None)

Bases: _ReLUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x: Tensor) → Tensor

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.relu.ReLUBlockLog(inplace: bool = False, config: dict = None)

Bases: _ReLUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x: Tensor) → Tensor

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.relu.ReLUBinary(inplace: bool = False, config: dict = None)

Bases: _ReLUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

bypass = None

class chop.nn.quantized.modules.relu.ReLUTernary(inplace: bool = False, config: dict = None)

Bases: _ReLUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

bypass = None

chop.nn.quantized.modules.rms_norm

class chop.nn.quantized.modules.rms_norm.RMSNorm(normalized_shape, eps: float = 1e-08, elementwise_affine: bool = False, device=None, dtype=None)

Bases: Module

Root Mean Square Layer Normalization

__init__(normalized_shape, eps: float = 1e-08, elementwise_affine: bool = False, device=None, dtype=None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x: Tensor)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.rms_norm.RMSNormInteger(normalized_shape, eps: float = 1e-08, elementwise_affine: bool = False, device=None, dtype=None, config=None)

Bases: _RMSNormBase

__init__(normalized_shape, eps: float = 1e-08, elementwise_affine: bool = False, device=None, dtype=None, config=None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

chop.nn.quantized.modules.selu

class chop.nn.quantized.modules.selu.SELUInteger(inplace: bool = False, config: dict = None)

Bases: _SELUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

bypass = None

class chop.nn.quantized.modules.selu.SELUMinifloatDenorm(inplace: bool = False, config: dict = None)

Bases: _SELUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.selu.SELUMinifloatIEEE(inplace: bool = False, config: dict = None)

Bases: _SELUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.selu.SELULog(inplace: bool = False, config: dict = None)

Bases: _SELUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.selu.SELUBlockFP(inplace: bool = False, config: dict = None)

Bases: _SELUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x: Tensor) → Tensor

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.selu.SELUBlockMinifloat(inplace: bool = False, config: dict = None)

Bases: _SELUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x: Tensor) → Tensor

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.selu.SELUBlockLog(inplace: bool = False, config: dict = None)

Bases: _SELUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x: Tensor) → Tensor

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.selu.SELUBinary(inplace: bool = False, config: dict = None)

Bases: _SELUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

bypass = None

class chop.nn.quantized.modules.selu.SELUTernary(inplace: bool = False, config: dict = None)

Bases: _SELUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

bypass = None

chop.nn.quantized.modules.silu

class chop.nn.quantized.modules.silu.SiLUInteger(inplace: bool = False, config: dict = None)

Bases: _SiLUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

bypass = None

class chop.nn.quantized.modules.silu.SiLUMinifloatDenorm(inplace: bool = False, config: dict = None)

Bases: _SiLUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.silu.SiLUMinifloatIEEE(inplace: bool = False, config: dict = None)

Bases: _SiLUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.silu.SiLULog(inplace: bool = False, config: dict = None)

Bases: _SiLUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.silu.SiLUBlockFP(inplace: bool = False, config: dict = None)

Bases: _SiLUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x: Tensor) → Tensor

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.silu.SiLUBlockMinifloat(inplace: bool = False, config: dict = None)

Bases: _SiLUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x: Tensor) → Tensor

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.silu.SiLUBlockLog(inplace: bool = False, config: dict = None)

Bases: _SiLUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x: Tensor) → Tensor

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.silu.SiLUBinary(inplace: bool = False, config: dict = None)

Bases: _SiLUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

bypass = None

class chop.nn.quantized.modules.silu.SiLUTernary(inplace: bool = False, config: dict = None)

Bases: _SiLUBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

bypass = None

chop.nn.quantized.modules.softplus

class chop.nn.quantized.modules.softplus.SoftplusInteger(inplace: bool = False, config: dict = None)

Bases: _SoftplusBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

bypass = None

class chop.nn.quantized.modules.softplus.SoftplusMinifloatDenorm(inplace: bool = False, config: dict = None)

Bases: _SoftplusBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.softplus.SoftplusMinifloatIEEE(inplace: bool = False, config: dict = None)

Bases: _SoftplusBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.softplus.SoftplusLog(inplace: bool = False, config: dict = None)

Bases: _SoftplusBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.softplus.SoftplusBlockFP(inplace: bool = False, config: dict = None)

Bases: _SoftplusBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x: Tensor) → Tensor

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.softplus.SoftplusBlockMinifloat(inplace: bool = False, config: dict = None)

Bases: _SoftplusBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x: Tensor) → Tensor

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.softplus.SoftplusBlockLog(inplace: bool = False, config: dict = None)

Bases: _SoftplusBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x: Tensor) → Tensor

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.softplus.SoftplusBinary(inplace: bool = False, config: dict = None)

Bases: _SoftplusBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

bypass = None

class chop.nn.quantized.modules.softplus.SoftplusTernary(inplace: bool = False, config: dict = None)

Bases: _SoftplusBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

bypass = None

chop.nn.quantized.modules.softsign

class chop.nn.quantized.modules.softsign.SoftsignInteger(inplace: bool = False, config: dict = None)

Bases: _SoftsignBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

bypass = None

class chop.nn.quantized.modules.softsign.SoftsignMinifloatDenorm(inplace: bool = False, config: dict = None)

Bases: _SoftsignBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.softsign.SoftsignMinifloatIEEE(inplace: bool = False, config: dict = None)

Bases: _SoftsignBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.softsign.SoftsignLog(inplace: bool = False, config: dict = None)

Bases: _SoftsignBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.softsign.SoftsignBlockFP(inplace: bool = False, config: dict = None)

Bases: _SoftsignBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x: Tensor) → Tensor

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.softsign.SoftsignBlockMinifloat(inplace: bool = False, config: dict = None)

Bases: _SoftsignBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x: Tensor) → Tensor

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.softsign.SoftsignBlockLog(inplace: bool = False, config: dict = None)

Bases: _SoftsignBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x: Tensor) → Tensor

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.softsign.SoftsignBinary(inplace: bool = False, config: dict = None)

Bases: _SoftsignBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

bypass = None

class chop.nn.quantized.modules.softsign.SoftsignTernary(inplace: bool = False, config: dict = None)

Bases: _SoftsignBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

bypass = None

chop.nn.quantized.modules.tanh

class chop.nn.quantized.modules.tanh.TanhInteger(inplace: bool = False, config: dict = None)

Bases: _TanhBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

bypass = None

class chop.nn.quantized.modules.tanh.TanhMinifloatDenorm(inplace: bool = False, config: dict = None)

Bases: _TanhBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.tanh.TanhMinifloatIEEE(inplace: bool = False, config: dict = None)

Bases: _TanhBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.tanh.TanhLog(inplace: bool = False, config: dict = None)

Bases: _TanhBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

class chop.nn.quantized.modules.tanh.TanhBlockFP(inplace: bool = False, config: dict = None)

Bases: _TanhBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x: Tensor) → Tensor

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.tanh.TanhBlockMinifloat(inplace: bool = False, config: dict = None)

Bases: _TanhBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x: Tensor) → Tensor

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.tanh.TanhBlockLog(inplace: bool = False, config: dict = None)

Bases: _TanhBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x: Tensor) → Tensor

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class chop.nn.quantized.modules.tanh.TanhBinary(inplace: bool = False, config: dict = None)

Bases: _TanhBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

bypass = None

class chop.nn.quantized.modules.tanh.TanhTernary(inplace: bool = False, config: dict = None)

Bases: _TanhBase

__init__(inplace: bool = False, config: dict = None)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

bypass = None

chop.nn.quantized.utils

chop.nn.quantized.utils.extract_required_config(self, config: dict)

chop.nn.quantized.utils.get_stats(config: dict, stat_name: str) → float | None

chop.nn.quantized.utils.quantiser_passthrough(x: Tensor)