abstractnn.affine_engine

Moteur d’expressions affines pour la propagation formelle

Classes

AffineExpression(constant, coefficients, bounds)	Représente une expression affine : y = a0 + sum(aj * xj) avec xj ∈ [lj, uj]
AffineExpressionEngine()	Moteur de manipulation d'expressions affines

class abstractnn.affine_engine.AffineExpression(constant: float, coefficients: Dict[int, float], bounds: Dict[int, Tuple[float, float]])

Représente une expression affine : y = a0 + sum(aj * xj) avec xj ∈ [lj, uj]

__init__(constant: float, coefficients: Dict[int, float], bounds: Dict[int, Tuple[float, float]])

get_bounds() → Tuple[float, float]

Calcule les bornes [min, max] de l’expression affine

__add__(other)

Addition de deux expressions affines

__mul__(scalar)

Multiplication par un scalaire

class abstractnn.affine_engine.AffineExpressionEngine

Moteur de manipulation d’expressions affines

static create_input_expressions(input_data: ndarray, noise_level: float) → List[AffineExpression]

Crée les expressions affines initiales pour l’entrée avec bruit Chaque pixel x_i devient: x_i = 0 + 1*ε_i où ε_i ∈ [value-noise, value+noise]

static linear_layer(expressions: List[AffineExpression], weight: ndarray, bias: ndarray = None) → List[AffineExpression]

Propage à travers une couche linéaire (MatMul + bias)

static conv2d_layer(expressions: List[AffineExpression], weight: ndarray, bias: ndarray = None, input_shape: Tuple[int, int, int, int] = None, stride: Tuple[int, int] = (1, 1), padding: Tuple[int, int] = (0, 0), dilation: Tuple[int, int] = (1, 1)) → Tuple[List[AffineExpression], Tuple[int, int, int, int]]

Propage à travers une couche convolutionnelle 2D

Parameters:

• expressions – Liste d’expressions affines (input flattened)

• weight – Poids de convolution de forme (out_channels, in_channels, kH, kW)

• bias – Biais de forme (out_channels,)

• input_shape – (batch, in_channels, height, width)

• stride – (stride_h, stride_w)

• padding – (pad_h, pad_w)

• dilation – (dilation_h, dilation_w)

Returns:

(expressions de sortie, output_shape)

static maxpool2d_layer(expressions: List[AffineExpression], input_shape: Tuple[int, int, int, int], kernel_size: Tuple[int, int], stride: Tuple[int, int] = None, padding: Tuple[int, int] = (0, 0)) → Tuple[List[AffineExpression], Tuple[int, int, int, int]]

Propage à travers une couche MaxPool2D

Pour MaxPool, on utilise une relaxation: on prend l’expression avec la borne supérieure maximale (approximation conservative)

Parameters:

• expressions – Liste d’expressions affines

• input_shape – (batch, channels, height, width)

• kernel_size – (pool_h, pool_w)

• stride – (stride_h, stride_w), par défaut = kernel_size

• padding – (pad_h, pad_w)

Returns:

(expressions de sortie, output_shape)

static avgpool2d_layer(expressions: List[AffineExpression], input_shape: Tuple[int, int, int, int], kernel_size: Tuple[int, int], stride: Tuple[int, int] = None, padding: Tuple[int, int] = (0, 0)) → Tuple[List[AffineExpression], Tuple[int, int, int, int]]

Propage à travers une couche AvgPool2D (opération linéaire)

Parameters:

• expressions – Liste d’expressions affines

• input_shape – (batch, channels, height, width)

• kernel_size – (pool_h, pool_w)

• stride – (stride_h, stride_w)

• padding – (pad_h, pad_w)

Returns:

(expressions de sortie, output_shape)