Pourquoi utiliser ce module ?

Les convolutions standards (par exemple, 3x3) constituent la brique de base des réseaux de neurones convolutifs (CNN), mais elles présentent deux limites fondamentales :

1. Champ réceptionnel contraint par la taille du noyau : Chaque position ne perçoit qu'un voisinage de la taille du noyau. La sémantique profonde repose sur l'accumulation de couches, ce qui est inefficace.
2. Traitement homogène de tous les filtres : Chaque canal de sortie est calculé de la même manière, favorisant l'apprentissage de motifs redondants.

La convolution auto-calibrée (SC-Conv) introduit une opération d'auto-calibrage multi-échelle à l'intérieur de la couche de convolution. Cela permet à chaque position spatiale ou temporelle de percevoir implicitement un contexte plus large lors de la transformation des caractéristiques, sans ajouter de paramètres entraînables supplémentaires.

Ce module implémente cete idée à la fois sous forme de SCConv1d (pour les signaux temporels) et SCConv2d (pour les images). Ils peuvent tous deux remplacer directement les couches de convolution standards correspondantes.

Architecture et principe de fonctionnement

Flux de données principle (exemple avec SCConv1d)

Entrée X [B, C, L]
    │
    ├──────────────────────────────────┐
    │                                 │
    ▼                                 ▼
AvgPool1d(r)                       K3(X) — BN
[B, C, L//r]                      [B, C, L]
    │                                 │
    ▼                                 │
K2(·) — BN                           │
[B, C, L//r]                         │
    │                                 │
interpolate↑(linéaire)               │
[B, C, L]                            │
    │                                 │
    X' = Up(K2(Pool(X)))              │
    │                                 │
    └──────→ σ( X + X' ) ◄───────────┘
              Poids de calibrage
                │
          Y' = K3(X) · σ(X + X')
                │
             K4(Y') — BN
                │
             Sortie [B, C, L//stride]

Trois concepts de conception clés

① Espace latent à basse résolution (chemin K2)
L'entrée est compressée par un facteur r via AvgPool1d(r). La convolution est appliquée sur cette représentation à plus grande échelle, puis interpolée à la taille originale. Chaque point de la représentation à basse résolution correspond à une fenêtre plus longue dans la séquence originale, offrant naturellement un champ réceptionnel élargi.

② Fusion par résidu d'auto-calibrage
Le contexte à basse résolution X' est ajouté sous forme de résidu à l'entrée originale X, puis passé dans une fonction sigmoïde. Cela génère des poids de calibrage par position :

calibrate = σ(X + X')

Cette conception préserve mieux l'information spatiale originale tout en introduisant un signal de calibrage à large champ réceptionnel.

③ Zéro paramètre supplémentaire
Les sous-modules K2, K3 et K4 constituent ensemble la SC-Conv. Leur nombre total de paramètres est exactement équivalent à celui de trois convolutions standard remplaçant la couche d'origine (dans l'architecture SCBottleneck originale, les canaux sont divisés en deux branches). Dans le cas d'un remplacement direct d'une Conv1d, la quantité de paramètres est environ 3 fois supérieure, ce qui offre un gain significatif en champ réceptionnel effectif. Pour conserver strictement le même nombre de paramètres, il faut réduire le nombre de canaux de moitié avant de les traiter en deux branches.

Interfaces des modules

SCConv1d

SCConv1d(
    in_channels: int,        # Nombre de canaux d'entrée/sortie (doivent être égaux)
    kernel_size: int = 3,    # Taille du noyau de convolution
    stride:      int = 1,    # Pas de la couche K4 (peut servir à un sous-échantillonnage)
    padding:     int = 1,    # Rembourrage (aligné sur kernel_size=3)
    dilation:    int = 1,    # Taux de dilatation
    groups:      int = 1,    # Nombre de groupes pour la convolution
    pooling_r:   int = 4,    # Taux de sous-échantillonnage pour l'auto-calibrage r
    norm_layer        = None # Par défaut: nn.BatchNorm1d
)

Entrée : [B, C, L]
Sortie : [B, C, L // stride]

SCConv2d

SCConv2d(
    in_channels: int,        # Nombre de canaux d'entrée/sortie (doivent être égaux)
    kernel_size: int = 3,    # Taille du noyau de convolution
    stride:      int = 1,    # Pas de la couche K4
    padding:     int = 1,    # Rembourrage
    dilation:    int = 1,    # Taux de dilatation
    groups:      int = 1,    # Nombre de groupes pour la convolution
    pooling_r:   int = 4,    # Taux de sous-échantillonnage pour l'auto-calibrage r
    norm_layer        = None # Par défaut: nn.BatchNorm2d
)

Entrée : [B, C, H, W]
Sortie : [B, C, H // stride, W // stride]

Contrainte importante : in_channels doit être égal à out_channels. La SC-Conv réalise l'auto-calibrage en réorganisant les filtres existants de manière hétérogène. Toute transformation de canaux doit être effectuée en dehors de la SC-Conv, par exemple avec une convolution 1x1.

Exemples d'utilisation

Dans un réseau de classification d'images (2D)

Usage typique : remplacer une convolution 3x3 dans un BasicBlock ou Bottleneck de ResNet.

from sc_conv import SCConv2d
import torch.nn as nn

# Remplacement direct d'une Conv2d standard
# ancien_module = nn.Conv2d(64, 64, kernel_size=3, padding=1, bias=False)
nouveau_module = SCConv2d(
    in_channels=64,
    kernel_size=3,
    padding=1,
    pooling_r=4,
)

# Intégration dans un Bottleneck simplifié
class BottleneckAvecSC(nn.Module):
    def __init__(self, canaux):
        super().__init__()
        self.upscale = nn.Conv2d(canaux, canaux, 1, bias=False)
        self.norm_up = nn.BatchNorm2d(canaux)
        self.activ = nn.ReLU(inplace=True)
        # La convolution 3x3 originale est remplacée par SCConv2d (BN intégré)
        self.conv_auto_calibree = SCConv2d(canaux, kernel_size=3, padding=1)

    def forward(self, x):
        out = self.activ(self.norm_up(self.upscale(x)))
        out = self.activ(self.conv_auto_calibree(out))
        return out + x

Dans un réseau pour signaux temporels (1D)

Applicable au diagnostic de pannes par vibrations, à l'analyse d'ECG, au traitement audio, etc.

from sc_conv import SCConv1d
import torch.nn as nn

# Remplacement d'un bloc de convolution 1D standard
# ancien_bloc = nn.Sequential(
#     nn.Conv1d(32, 32, kernel_size=3, padding=1, bias=False),
#     nn.BatchNorm1d(32),
#     nn.ReLU(inplace=True),
# )

# Nouveau bloc avec SCConv1d (BN intégré) + ReLU
nouveau_bloc = nn.Sequential(
    SCConv1d(in_channels=32, kernel_size=3, padding=1, pooling_r=4),
    nn.ReLU(inplace=True),
)

Gestion de l'augmentation de canaux (combinaison 1x1 + SCConv)

Pour augmenter les canaux et appliquer l'auto-calibrage simultanément, utiliser d'abord une Conv 1x1 pour aligner les canaux, puis appliquer la SCConv.

from sc_conv import SCConv1d
import torch.nn as nn

class AugmentationCanalAvecSC(nn.Module):
    """Augmentation de 32 à 64 canaux avec auto-calibrage"""
    def __init__(self):
        super().__init__()
        # Étape 1 : Conv 1x1 pour la transformation des canaux (32 → 64)
        self.projection = nn.Sequential(
            nn.Conv1d(32, 64, kernel_size=1, bias=False),
            nn.BatchNorm1d(64),
            nn.ReLU(inplace=True),
        )
        # Étape 2 : SC-Conv pour l'auto-calibrage sur canaux constants (64 → 64)
        self.auto_calibrage = SCConv1d(
            in_channels=64,
            kernel_size=3,
            padding=1,
            pooling_r=4,
        )
        self.activation = nn.ReLU(inplace=True)

    def forward(self, x):
        return self.activation(self.auto_calibrage(self.projection(x)))

Hyper-paramètre clé : pooling_r

Le paramètre pooling_r est le taux de sous-échantillonnage r utilisé pour l'auto-calibrage. Il détermine directement l'amplification du champ réceptionnel dans le chemin K2.

• pooling_r=4 est la valeur optimale issue des ablations dans l'article original, applicable à la majorité des cas.
• Pour des séquences d'entrée courtes (longueur < 64), l'utilisation de pooling_r=2 est conseillée pour éviter une longueur trop faible après sous-échantillonnage.
• Des valeurs de r plus élevées ne sont pas recommandées dans les dernières couches du réseau où la résolution des cartes de caractéristiques est déjà très petite.

Comparaison avec d'autres méthodes d'attention

L'avantage unique de la SC-Conv réside dans le fait qu'elle n'insère pas un "plugin" d'attention supplémentaire dans le réseau, mais qu'elle réorganise directement la manière dont les filtres de la couche de convolution elle-même sont exploités. Elle permet d'étendre le champ réceptionnel et de calibrer les caractéristiques sans paramètres supplémentaires.

Vérification rapide

Exécutez la commande suivante pour vérifier le bon fonctionnemetn du module :

python sc_conv.py

Résultat attendu :

=======================================================
 Démo SCConv1d — Signal de vibration
=======================================================
  Entrée : (8, 64, 1024)
  Sortie : (8, 64, 1024)
  Paramètres SCConv1d : 73,728
  Conv1d standard ×3 : 73,728  (Équivalent K2+K3+K4)
  Ratio de surcoût param. : 1.000x  (≈1, zéro paramètre supplémentaire)

=======================================================
 Démo SCConv2d — Caractéristique d'image
=======================================================
  Entrée : (4, 256, 56, 56)
  Sortie : (4, 256, 56, 56)
  Paramètres SCConv2d : 1,769,472
  Conv2d standard ×3 : 1,769,472  (Équivalent K2+K3+K4)
  Ratio de surcoût param. : 1.000x  (≈1, zéro paramètre supplémentaire)

Toutes les démos réussies ✓

Citation

Si ce module est utile pour votre recherche, veuillez citer l'article original :

@inproceedings{liu2020improving,
  title     = {Improving Convolutional Networks with Self-Calibrated Convolutions},
  author    = {Liu, Jiang-Jiang and Hou, Qibin and Cheng, Ming-Ming
               and Wang, Changhu and Feng, Jiashi},
  booktitle = {CVPR},
  year      = {2020}
}

Implémentation

"""
Modules de convolution auto-calibrante amovible (implémentation unifiée 1D & 2D)

Source de l'article :
    "Improving Convolutional Networks with Self-Calibrated Convolutions"
    Jiang-Jiang Liu, Qibin Hou, Ming-Ming Cheng, Changhu Wang, Jiashi Feng
    CVPR 2020

【Principes de conception】
    - Zéro paramètre supplémentaire : Le nombre de paramètres de la SC-Conv est identique à celui de la convolution standard qu'elle remplace.
    - Zéro modification d'architecture : Remplace directement n'importe quelle couche Conv1d / Conv2d, les hyper-paramètres restent inchangés.
    - Amovible : Supporte tout scénario où in_channels == out_channels.

【Modes supportés】
    SCConv1d  — Signaux temporels / de vibration 1D (roulements, ECG, audio…)
    SCConv2d  — Caractéristiques d'images 2D (réseaux dorsaux tels que ResNet)

【Méthode d'utilisation】
    # 2D (image) : Remplacement direct de la Conv 3×3 dans un Bottleneck de ResNet
    ancien = nn.Conv2d(64, 64, kernel_size=3, padding=1, bias=False)
    nouveau = SCConv2d(in_channels=64, kernel_size=3, padding=1)

    # 1D (signal) : Remplacement de n'importe quelle couche de convolution 1D à canaux constants
    ancien = nn.Conv1d(32, 32, kernel_size=3, padding=1, bias=False)
    nouveau = SCConv1d(in_channels=32, kernel_size=3, padding=1)
"""

import torch
import torch.nn as nn
import torch.nn.functional as F


__all__ = ['SCConv1d', 'SCConv2d']


# ============================================================
#  SCConv1d — Convolution auto-calibrée 1D
# ============================================================

class SCConv1d(nn.Module):
    """
    Self-Calibrated Convolution (version 1D).

    Applicable à l'extraction de caractéristiques pour des séquences temporelles,
    de vibration ou audio. Remplacer une Conv1d standard par ce module permet
    d'élargir significativement le champ réceptionnel temporel de chaque position
    sans ajouter de paramètres.

    Flux principal (correspond à Fig.2 chemin X1 / Eq.2-5 du papier) :
        1. Chemin K2 : AvgPool1d(r) ↓  →  Conv1d  →  BN
                       Interpolate ↑  →  Obtient le contexte basse fréquence X'
        2. Poids de calibrage : σ( identité + X' )
        3. Chemin K3 : Conv1d(X)  ×  poids de calibrage  →  Y'
        4. Chemin K4 : Conv1d(Y') →  Sortie

    Paramètres
    ----------
    in_channels : int
        Nombre de canaux d'entrée/sortie (doivent être égaux)
    kernel_size : int, défaut 3
        Taille du noyau de convolution
    stride : int, défaut 1
        Pas de la couche K4 (peut servir au sous-échantillonnage)
    padding : int, défaut 1
        Rembourrage pour les convolutions des différents chemins
    dilation : int, défaut 1
        Taux de dilatation pour la convolution
    groups : int, défaut 1
        Nombre de groupes pour la convolution
    pooling_r : int, défaut 4
        Taux de sous-échantillonnage r pour l'auto-calibrage (valeur optimale du papier : 4)
    norm_layer : callable, défaut nn.BatchNorm1d
        Fonction de construction pour la couche de normalisation

    Exemple
    -------
    >>> module_sc = SCConv1d(in_channels=64, kernel_size=3, padding=1, pooling_r=4)
    >>> x = torch.randn(8, 64, 1024)
    >>> sortie = module_sc(x)   # [8, 64, 1024], forme conservée
    """

    def __init__(self,
                 in_channels: int,
                 kernel_size: int = 3,
                 stride: int = 1,
                 padding: int = 1,
                 dilation: int = 1,
                 groups: int = 1,
                 pooling_r: int = 4,
                 norm_layer=None):
        super(SCConv1d, self).__init__()

        if norm_layer is None:
            norm_layer = nn.BatchNorm1d

        # Le nombre de plans de sortie est égal au nombre de canaux d'entrée
        num_planes = in_channels

        # ── Chemin 1 : Réduction d'échelle et extraction de contexte à basse fréquence
        self.downscale_path = nn.Sequential(
            nn.AvgPool1d(kernel_size=pooling_r, stride=pooling_r),
            nn.Conv1d(in_channels, num_planes,
                      kernel_size=kernel_size, stride=1,
                      padding=padding, dilation=dilation,
                      groups=groups, bias=False),
            norm_layer(num_planes),
        )

        # ── Chemin 2 : Extraction de caractéristiques à l'échelle originale
        self.feature_extract_path = nn.Sequential(
            nn.Conv1d(in_channels, num_planes,
                      kernel_size=kernel_size, stride=1,
                      padding=padding, dilation=dilation,
                      groups=groups, bias=False),
            norm_layer(num_planes),
        )

        # ── Chemin 3 : Convolution de sortie après calibrage
        self.output_path = nn.Sequential(
            nn.Conv1d(num_planes, num_planes,
                      kernel_size=kernel_size, stride=stride,
                      padding=padding, dilation=dilation,
                      groups=groups, bias=False),
            norm_layer(num_planes),
        )

    def forward(self, input_tensor: torch.Tensor) -> torch.Tensor:
        """
        Paramètres
        ----------
        input_tensor : Tensor, forme [B, C, L]

        Retourne
        -------
        output : Tensor, forme [B, C, L//stride]
        """
        original_features = input_tensor  # [B, C, L]

        # Contexte basse fréquence : sous-échantillonnage -> convolution -> sur-échantillonnage
        context_downscaled = self.downscale_path(input_tensor)  # [B, C, L//r]
        context_upscaled = F.interpolate(context_downscaled,
                                         size=original_features.size(2),
                                         mode='linear',
                                         align_corners=False)  # [B, C, L]

        # Calcul des poids de calibrage
        calibration_weights = torch.sigmoid(original_features + context_upscaled)  # [B, C, L]

        # Caractéristiques à l'échelle originale calibrées -> convolution finale
        calibrated_features = torch.mul(self.feature_extract_path(input_tensor), calibration_weights)  # [B, C, L]
        output = self.output_path(calibrated_features)  # [B, C, L//stride]
        return output


# ============================================================
#  SCConv2d — Convolution auto-calibrée 2D
# ============================================================

class SCConv2d(nn.Module):
    """
    Self-Calibrated Convolution (version 2D, implémentation fidèle au papier original).

    Applicable aux cartes de caractéristiques d'images. Peut remplacer directement
    une couche Conv2d 3×3 dans les réseaux dorsaux tels que ResNet ou ResNeXt,
    sans modifier aucun hyper-paramètre.

    Flux principal (correspond à Fig.2 chemin X1 / Eq.2-5 du papier) :
        1. Chemin K2 : AvgPool2d(r,r) ↓  →  Conv2d  →  BN
                       F.interpolate ↑   →  Obtient le contexte basse fréquence X'
        2. Poids de calibrage : σ( identité + X' )
        3. Chemin K3 : Conv2d(X)  ×  poids de calibrage  →  Y'
        4. Chemin K4 : Conv2d(Y') →  Sortie

    Paramètres
    ----------
    in_channels : int
        Nombre de canaux d'entrée/sortie (doivent être égaux)
    kernel_size : int, défaut 3
        Taille du noyau de convolution
    stride : int, défaut 1
        Pas de la couche K4 (peut servir au sous-échantillonnage spatial)
    padding : int, défaut 1
        Rembourrage pour les convolutions
    dilation : int, défaut 1
        Taux de dilatation pour la convolution
    groups : int, défaut 1
        Nombre de groupes pour la convolution
    pooling_r : int, défaut 4
        Taux de sous-échantillonnage r pour l'auto-calibrage (valeur optimale du papier : 4)
    norm_layer : callable, défaut nn.BatchNorm2d
        Fonction de construction pour la couche de normalisation

    Exemple
    -------
    >>> module_sc = SCConv2d(in_channels=256, kernel_size=3, padding=1, pooling_r=4)
    >>> x = torch.randn(2, 256, 56, 56)
    >>> sortie = module_sc(x)   # [2, 256, 56, 56], forme conservée
    """

    def __init__(self,
                 in_channels: int,
                 kernel_size: int = 3,
                 stride: int = 1,
                 padding: int = 1,
                 dilation: int = 1,
                 groups: int = 1,
                 pooling_r: int = 4,
                 norm_layer=None):
        super(SCConv2d, self).__init__()

        if norm_layer is None:
            norm_layer = nn.BatchNorm2d

        num_planes = in_channels

        # ── Chemin 1 : Réduction d'échelle et contexte à basse fréquence
        self.downscale_path = nn.Sequential(
            nn.AvgPool2d(kernel_size=pooling_r, stride=pooling_r),
            nn.Conv2d(in_channels, num_planes,
                      kernel_size=kernel_size, stride=1,
                      padding=padding, dilation=dilation,
                      groups=groups, bias=False),
            norm_layer(num_planes),
        )

        # ── Chemin 2 : Extraction de caractéristiques à l'échelle originale
        self.feature_extract_path = nn.Sequential(
            nn.Conv2d(in_channels, num_planes,
                      kernel_size=kernel_size, stride=1,
                      padding=padding, dilation=dilation,
                      groups=groups, bias=False),
            norm_layer(num_planes),
        )

        # ── Chemin 3 : Convolution de sortie après calibrage
        self.output_path = nn.Sequential(
            nn.Conv2d(num_planes, num_planes,
                      kernel_size=kernel_size, stride=stride,
                      padding=padding, dilation=dilation,
                      groups=groups, bias=False),
            norm_layer(num_planes),
        )

    def forward(self, input_tensor: torch.Tensor) -> torch.Tensor:
        """
        Paramètres
        ----------
        input_tensor : Tensor, forme [B, C, H, W]

        Retourne
        -------
        output : Tensor, forme [B, C, H//stride, W//stride]
        """
        original_features = input_tensor  # [B, C, H, W]

        # Contexte basse fréquence
        context_downscaled = self.downscale_path(input_tensor)  # [B, C, H//r, W//r]
        context_upscaled = F.interpolate(context_downscaled,
                                         size=original_features.shape[2:],
                                         mode='bilinear',
                                         align_corners=False)  # [B, C, H, W]

        # Calcul des poids de calibrage
        calibration_weights = torch.sigmoid(original_features + context_upscaled)  # [B, C, H, W]

        # Caractéristiques calibrées -> convolution finale
        calibrated_features = torch.mul(self.feature_extract_path(input_tensor), calibration_weights)  # [B, C, H, W]
        output = self.output_path(calibrated_features)  # [B, C, H//s, W//s]
        return output


# ============================================================
#  Démos et vérifications
# ============================================================

def demo_1d():
    """Scénario 1D : diagnostic de panne par vibration"""
    print("=" * 55)
    print(" Démo SCConv1d — Signal de vibration")
    print("=" * 55)

    device = 'cuda' if torch.cuda.is_available() else 'cpu'
    batch, canaux, longueur = 8, 64, 1024

    module_sc = SCConv1d(in_channels=canaux, kernel_size=3, padding=1,
                         pooling_r=4).to(device)
    entree = torch.randn(batch, canaux, longueur).to(device)

    with torch.no_grad():
        sortie = module_sc(entree)

    param_sc = sum(p.numel() for p in module_sc.parameters())
    param_base = sum(p.numel() for p in
                     nn.Conv1d(canaux, canaux, 3, padding=1, bias=False).parameters())

    print(f"  Entrée : {tuple(entree.shape)}")
    print(f"  Sortie : {tuple(sortie.shape)}")
    print(f"  Paramètres SCConv1d : {param_sc:,}")
    print(f"  Conv1d standard ×3 : {param_base*3:,}  (Équivalent K2+K3+K4)")
    print(f"  Ratio de surcoût param. : {param_sc/(param_base*3):.3f}x  (≈1, zéro paramètre supplémentaire)")
    print()


def demo_2d():
    """Scénario 2D : classification d'image / remplacement dans un Bottleneck ResNet"""
    print("=" * 55)
    print(" Démo SCConv2d — Caractéristique d'image")
    print("=" * 55)

    device = 'cuda' if torch.cuda.is_available() else 'cpu'
    batch, canaux, hauteur, largeur = 4, 256, 56, 56

    module_sc = SCConv2d(in_channels=canaux, kernel_size=3, padding=1,
                         pooling_r=4).to(device)
    entree = torch.randn(batch, canaux, hauteur, largeur).to(device)

    with torch.no_grad():
        sortie = module_sc(entree)

    param_sc = sum(p.numel() for p in module_sc.parameters())
    param_base = sum(p.numel() for p in
                     nn.Conv2d(canaux, canaux, 3, padding=1, bias=False).parameters())

    print(f"  Entrée : {tuple(entree.shape)}")
    print(f"  Sortie : {tuple(sortie.shape)}")
    print(f"  Paramètres SCConv2d : {param_sc:,}")
    print(f"  Conv2d standard ×3 : {param_base*3:,}  (Équivalent K2+K3+K4)")
    print(f"  Ratio de surcoût param. : {param_sc/(param_base*3):.3f}x  (≈1, zéro paramètre supplémentaire)")
    print()


if __name__ == '__main__':
    demo_1d()
    demo_2d()
    print("Toutes les démos réussies ✓")