Extraction de caractéristiques par convolutions

À partir de données ayant une structure spatiale (localement corrélées), des caractéristiques peuvent être extraites par convolutions.

Sur les Images

Cela a également du sens pour les séries temporelles qui ont une structure dans le temps.

Une convolution comme multiplication de matrices creuses

Qu’est-ce qu’une convolution : Exemple en 2D

Composition pour apprendre des caractéristiques de plus haut niveau

Les caractéristiques locales peuvent être combinées pour apprendre des caractéristiques de plus haut niveau.

Construisons un détecteur de maison

Architecture

Idées Utiliser la structure des entrées pour limiter le nombre de paramètres sans limiter l’expressivité du réseau

• Pour les entrées avec des corrélations spatiales (ou temporelles), les caractéristiques peuvent être extraites avec des convolutions de noyaux locaux

• Une convolution peut être vue comme une couche entièrement connectée avec :

  • beaucoup de poids fixés exactement à \(0\)
  • beaucoup de poids partagés entre les positions

\(\rightarrow\) fortement régularisée !

CNN classique de LeCun

L’architecture de LeNet-5 (LeCun et al., 1989), appelons-la le CNN classique

Vocabulaire CNN

Nous travaillons avec des tenseurs 4D pour les images 2D, des tenseurs 3D pour les séries temporelles nD (par ex. plusieurs enregistrements simultanés), des tenseurs 2D pour les séries temporelles 1D

Dans Pytorch, les tenseurs suivent la convention Batch-Canal-Hauteur-Largeur (BCHW, canal en premier). D’autres frameworks, comme TensorFlow ou CNTK, utilisent BHWC (canal en dernier).

CNN en pratique

Code Pytorch pour implémenter un CNN : Conv1D Conv2D, MaxPool1D MaxPool2D, AveragePooling, etc…

conv_model  = nn.Sequential(
    *conv_relu_maxpool(cin=3, cout=32,
                       csize=3, cstride=1, cpad=1,
                       msize=2, mstride=2, mpad=0),
    *conv_relu_maxpool(cin=3, cout=64,
                       csize=3, cstride=1, cpad=1,
                       msize=2, mstride=2, mpad=0), 
)

def conv_relu_maxpool(cin, cout, csize, cstride, cpad, msize, mstride, mpad):
    return [nn.Conv2d(cin, cout, csize, cstride, cpad),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(msize, mstride, mpad)
            ]

fc_model = nn.Sequential(
    *linear_relu(output_size, 256),
    nn.Linear(256, num_classes)
)

dummy_output = conv_model(torch.zeros((1, 3, height, width)))
output_size = np.prod(dummy_output.shape[1:] )

CNN en pratique

Tout doit être placé dans une sous-classe de nn.Module :

class MyModel(torch.nn.Module):
    def __init__(self, ....):
        super(MyModel, self).__init__()
        self.conv_model = nn.Sequential(...)
        output_size = ...
        self.fc_model = nn.Sequential(...)

    def forward(self, inputs):
        conv_features = self.conv_model(inputs)
        conv_features = conv_features.view(inputs.shape[0], -1)
        return self.fc_model(conv_features)

Vous pouvez (devriez 😁 ) utiliser la couche récemment introduite de nn.Flatten

CDNN Multicolonnes

Introduit dans (Ciresan, Meier, & Schmidhuber, 2012), ensemble de CNNs entraînés avec augmentation de données

SuperVision

Introduit dans (Krizhevsky, Sutskever, & Hinton, 2012), l’“étincelle” donnant naissance à la renaissance des réseaux de neurones.

SuperVision

La première couche a appris à extraire des caractéristiques significatives

ZFNet

Vainqueur ILSVRC’13. Introduit dans (Zeiler & Fergus, 2014)

• A introduit des techniques de visualisation pour inspecter quelles caractéristiques sont apprises.

• Études d’ablation sur AlexNet : les couches FC ne sont pas si importantes

• A introduit l’idée du préentraînement supervisé (préentraînement sur ImageNet, ajustement du softmax pour Caltech-101, Caltech-256, Pascal 2012)

• SGD mini-batch(128), momentum(0.9), taux d’apprentissage (0.01) planification manuelle

Deconvnet calcule approximativement le gradient de la perte par rapport à l’entrée (Simonyan, Vedaldi, & Zisserman, 2014). Il diffère dans la façon dont le ReLu est intégré.

VGG

Second à ILSVRC’14. Introduit par (Simonyan & Zisserman, 2015).

• 16 couches : 13 convolutives, 3 entièrement connectées
• Uniquement convolutions \(3\times3\), pooling \(2\times2\)
• Convolutions \(3\times3\) empilées \(\equiv\) convolution \(5\times5\) avec moins de paramètres
  • Si \(c_{in}=K, c_{out}=K\), convolution \(5\times5\) \(\rightarrow\) \(25K^2\) paramètres
  • Si \(c_{in}=K, c_{out}=K\), 2 convolutions \(3\times3\) empilées \(\rightarrow\) \(18K^2\) paramètres
• 140 millions de paramètres, taille de batch(256), Momentum(0.9), Weight decay(\(0.0005\)), Dropout(0.5) dans FC, taux d’apprentissage(\(0.01\)) divisé \(3\) fois par \(10\)
• Initialisation de \(B,C,D,E\) à partir de \(A\) entraîné. Init de \(A\) aléatoire \(\mathcal{N}(0, 10^{-2}), b=0\). A remarqué (Glorot & Bengio, 2010) après soumission.
• peut gérer une taille d’entrée variable en changeant les couches FC en conv \(7\times 7\), conv\(1\times1\).

À la recherche de la simplicité

Introduit dans (Springenberg, Dosovitskiy, Brox, & Riedmiller, 2015).

• utilise uniquement des convolutions, avec différents strides, pas de max pooling
• introduit la visualisation par “rétropropagation guidée”

GoogLeNet (inception v1)

Vainqueur ILSVR’14. Introduit par (Szegedy et al., 2014).

Idée Détection de caractéristiques multi-échelles et réduction de dimensionnalité

• 22 couches, \(6.8\)M paramètres
• entraîné en parallèle, SGD asynchrone, momentum(0.9), planification du taux d’apprentissage (\(4\%\) tous les 8 epochs)
• en test : moyenne de Polyak et ensemble de \(7\) modèles
• têtes auxiliaires pour atténuer le gradient qui s’évanouit

Réseaux Résiduels (ResNet)

Vainqueur ILSVRC’15. Introduit dans (He, Zhang, Ren, & Sun, 2016a)

Réseaux Résiduels (ResNet)

Variations autour des connexions de saut de couche

Réseaux Highway (Srivastava, Greff, & Schmidhuber, 2015)

• Utilise des “portes” (comme dans LSTM, voir cours sur RNN) :
  • Porte de transformation \(T(x) = \sigma(W_T x + b_T)\)
  • Porte de transport \(C(x) = \sigma(f_c(x))\)

\[ y = T(x).H(x) + C(x).x \]

DenseNets

Autres réseaux

Fitnet [Romero(2015)], Wideresnet(2017), Mobilenetv1, v2, v3 [Howard(2019)] : recherche de la meilleure architecture, EfficientNet (Tan & Le, 2020)

Voir aussi :

• Papers with code
• SOTA bench

Nombre de filtres

Vous devriez augmenter le nombre de filtres tout au long du réseau :

• la première couche extrait des caractéristiques de bas niveau
• les couches supérieures composent sur le dictionnaire de caractéristiques des couches inférieures

Exemples :

• LeNet-5 (1998) : \(6 5\times5\), \(16 5\times5\)
  
• AlexNet (2012) : \(96 11\times11\), \(256 5\times5\), \(2\times(384 3\times3)\), \(256 3\times3\)
  
• VGG (2014) : \(64-128-256-512\), tous \(3\times 3\)
  
• ResNet (2015) : \(64-128-256-512\), tous \(3\times 3\)
• Inception (2015) : \(32-64-80-192-288-768-1280-2048\), \(1\times1, 3\times3, '5\times5'\)

EfficientNet (Tan & Le, 2020) étudie les stratégies de mise à l’échelle des modèles convolutifs.

Champ récepteur effectif (1/3)

Champ récepteur effectif (2/3)

Champ récepteur effectif (3/3)

Convolutions A-trou

Le champ récepteur effectif peut grandir plus vite avec des convolutions a-trou (ou convolution dilatée) (Yu & Koltun, 2016):

Illustration de ce guide sur l’arithmétique convolutive. Le constructeur de Conv2D accepte un argument dilation

Faciliter la circulation du gradient

Vous pouvez vérifier la norme du gradient par rapport aux paramètres des premières couches pour diagnostiquer les vanishing gradient

• Connexions en court-circuit (par ex. ResNet, DenseNet, Highway)

• têtes auxiliaires (par ex. GoogleNet)

Jeu de données CIFAR-100

• Le jeu de données CIFAR-100 est composé de \(100\) classes avec \(600\) images par classe.
  
• Les images sont en RGB de \(32\times 32\)

• L’ensemble d’entraînement contient \(500\times 100\) images, et l’ensemble de test contient \(100 \times 100\) images.

Architecture du modèle et configuration de l’optimisation

Nombre de paramètres : \(\simeq 2M\)
Temps par epoch (1080Ti) : 17s, 42min temps d’entraînement Si appliquée, seuls les poids des couches de convolution et linéaires sont régularisés (pas les biais, ni les coefficients de la normalisation par lots)

Résultats

References

Voir plutôt le document en ligne references.pdf