Aller au contenu
English

La convolution et les fragments en une leçon

  • Leçon 7
  • 30 min
  • Module 2 : Références de base et classificateurs préentraînés

Où nous en sommes

Les caractéristiques faites à la main décrivent les contours de façon fixe. Un réseau de neurones apprend ses propres caractéristiques. Cette leçon montre comment un CNN examine de petites fenêtres et comment un transformeur de vision examine des fragments. Vous pourrez ainsi lire une fiche de modèle. D'abord, une employée inspecte un grand tapis à travers une petite fenêtre.

Lue depuis YouTube. Rien ne se charge depuis YouTube avant que vous appuyiez sur lecture. Confidentialité
Leçon 7 sur 30 · IA de vision : voir, compter et inspecterLa convolution et les fragments en une leçon

Ce que vous saurez faire

Comprenez ce qu’un réseau convolutif et un transformeur de vision font avec une photo. Vous pourrez choisir un modèle préentraîné et lire sa fiche de modèle (model card). Un autre cours explique comment ces réseaux apprennent; ici, vous voyez ce qu’ils examinent.

Carnet JupyterFaites cette leçon dans un carnet JupyterColab · Kaggle · GitHub · en anglais

Le carnet (notebook) Jupyter fait glisser un filtre à la main. Il applique deux filtres de contours à une vraie photo et découpe une photo en fragments. Il utilise seulement NumPy et télécharge les photos du catalogue (environ 9 Mo). Environ 15 minutes.

Le carnet est en anglais. Colab et Kaggle ouvrent votre propre copie. Il faut un compte Google ou Kaggle gratuit. Vous êtes bloqué ? Consultez le carnet de solution.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 30 minutes

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur

  • Le carnet (dans Colab, Kaggle ou VS Code). Cette leçon n’ajoute rien au projet larkvision.

Testé avec Python 3.12.13 sur macOS.

Un tapis retourné arrive dans l’entrepôt de Hamid. Une employée doit y trouver de petites taches. Elle prend un carton avec un trou carré de la taille de sa main. Elle le pose dans le coin supérieur gauche et regarde seulement à travers le trou. Puis, elle le glisse un peu vers la droite et regarde à nouveau. Rangée par rangée, elle parcourt tout le tapis. Sur un plan du tapis en papier, elle marque chaque endroit où elle a vu une tache.

Elle pose une seule question à chaque endroit : « Y a-t-il une tache dans cette fenêtre? » Son plan de réponses est plus petit que le tapis et montre où sont les taches. C’est exactement ce qu’une convolution fait avec une photo.

Dans la dernière leçon, HOG utilisait une règle fixe pour trouver les contours : droite moins gauche, dessous moins dessus. Une personne l’avait choisie. Elle trouve bien les contours, puis plafonne à 0,487 avec la couleur. Personne n’a écrit de règle pour un rebord, une anse ou une flamme.

Un réseau ne reçoit pas ses règles d’une personne. Il commence avec plusieurs petites grilles de nombres aléatoires. Il fait glisser chacune sur des milliers de photos et modifie un peu les nombres chaque fois qu’il se trompe. Après l’entraînement, les grilles trouvent les motifs les plus utiles. La boucle d’entraînement, dans le cours sur l’apprentissage profond, explique comment il modifie les nombres. Ici, nous examinons ce que font les grilles.

Un filtre (aussi appelé noyau) est une petite grille de nombres, par exemple 3 × 3. Pour l’appliquer, placez-le dans le coin supérieur gauche de la photo. Multipliez chaque nombre du filtre par le pixel sous lui, puis additionnez les neuf produits. Cette somme est un nombre de la sortie. Glissez ensuite le filtre d’un pixel vers la droite et recommencez. Cette somme glissante est une convolution, et sa sortie est une carte de caractéristiques. Cette carte indique à quel point chaque fenêtre correspond au filtre.

L’image contient 6 × 6 pixels gris, inventés pour cet exemple : foncés (10) à gauche, clairs (200) à droite. Le filtre soustrait la colonne gauche de la fenêtre de sa colonne droite, comme le faisait HOG.

À gauche : une grille de 6 sur 6 valeurs de gris, 10 à gauche et 200 à droite; dans les deux dernières rangées, le contour est une colonne plus à droite. Un carré bleu marque la fenêtre de 3 sur 3 à la rangée 1, colonnes 2 à 4. Au milieu : le filtre, trois rangées de moins 1, 0, 1. À droite : la sortie de 4 sur 4 : les rangées 1 et 2 sont 0, 570, 570, 0; la rangée 3 est 0, 380, 570, 190; la rangée 4 est 0, 190, 570, 380. Le premier 570 est marqué.
Un filtre de 3 × 3 glisse sur une image de 6 × 6 (nombres construits). La fenêtre marquée donne la sortie marquée : 570. Les nombres bleus de la sortie marquent un contour du foncé vers le clair.
Description textuelle du diagramme

Trois grilles côte à côte. La grille de l’image contient 6 rangées de 6 valeurs de gris. Les quatre premières rangées sont 10, 10, 10, 200, 200, 200. Les deux dernières sont 10, 10, 10, 10, 200, 200 : le contour s’y déplace d’une colonne vers la droite. Un carré bleu marque la fenêtre couvrant les rangées 1 à 3 et les colonnes 2 à 4. La grille du filtre contient trois rangées, chacune avec moins 1, 0, 1. La grille de sortie contient 4 rangées de 4 nombres. Rangées 1 et 2 : 0, 570, 570, 0. Rangée 3 : 0, 380, 570, 190. Rangée 4 : 0, 190, 570, 380. Le premier 570 est marqué : il vient de la fenêtre marquée.

La fenêtre marquée contient 10, 10, 200 dans chacune de ses trois rangées. Chaque rangée donne −1 × 10 + 0 × 10 + 1 × 200 = 190. Trois rangées donnent 3 × 190 = 570. Une fenêtre d’une seule couleur donne 0 : le −10 et le +10 s’annulent. La sortie est donc élevée exactement là où la fenêtre couvre le contour.

Regardez les rangées inférieures de la sortie : 380 et 190. La fenêtre n’y couvre le contour qu’en partie, parce que celui-ci se déplace. La sortie indique où se trouve le motif et quelle part elle en contient.

Le pas est la taille de chaque déplacement de la fenêtre : un pixel ici. Un pas de 2 réduit de moitié la largeur de la sortie. La sortie est aussi plus petite que l’entrée : 4 × 4 plutôt que 6 × 6. Une fenêtre de 3 × 3 tient seulement 4 fois le long d’un côté de 6.

Le carnet (section 2) applique ce filtre et le même filtre tourné sur le côté à une photo de chaises en fil métallique du catalogue. Les deux filtres appris à droite viennent d’un vrai réseau entraîné, comme l’explique la prochaine section :

Cinq images : une photo de deux chaises blanches en fil métallique sur une terrasse ensoleillée; la réponse au filtre vertical, avec des lignes foncées aux pieds des chaises et aux fils verticaux; la réponse au filtre horizontal, avec des lignes foncées au bord de la terrasse et aux fils horizontaux; la réponse du filtre appris 31, semblable au filtre vertical; la réponse du filtre appris 32, semblable au filtre horizontal.
Ce à quoi réagissent quatre filtres sur une même photo (foncé = forte réaction). Deux filtres sont faits à la main; deux sont des filtres appris de la première couche de ResNet-18. Photo : Timothy Brown, CC BY 2.0, via Open Images.
Description textuelle du diagramme

Cinq images côte à côte. La première est la photo : deux chaises blanches en fil métallique sur une terrasse en pierre ensoleillée, avec une pelouse foncée en haut. La deuxième montre la réponse du filtre vertical fait à la main : les pieds des chaises et les fils verticaux du siège forment des lignes foncées. La troisième montre le filtre horizontal fait à la main : le long bord entre la terrasse et la pelouse, et les fils horizontaux, sont foncés. La quatrième est le filtre appris numéro 31 de ResNet-18 : sa réponse ressemble à celle du filtre vertical, avec des pieds de chaises foncés. La cinquième est le filtre appris numéro 32 : sa ligne la plus forte est le bord de la terrasse, comme le filtre horizontal.

Le filtre vertical réagit aux pieds des chaises et aux fils verticaux. Le filtre horizontal réagit au bord de la terrasse et aux fils horizontaux. Chaque filtre est une question, et chaque carte est la réponse de la photo.

Un réseau de neurones convolutif, ou CNN, contient plusieurs couches de filtres. ResNet-18, un CNN utilisé dans la prochaine leçon, compte 64 filtres dans sa première couche. Chacun mesure 7 × 7 pixels × 3 couleurs. L’équipe du cours les a dessinés à partir des poids du modèle entraîné :

64 petits carrés colorés en 4 rangées de 16. Plusieurs montrent des bandes claires et foncées à différents angles; certains montrent des taches de couleur ou un seul point coloré. Deux carrés sont marqués en bleu : le numéro 31 et le numéro 32.
Les 64 filtres de la première couche de ResNet-18 (timm resnet18.a1_in1k, poids sous licence Apache-2.0), chacun agrandi à partir de 7 × 7 pixels. Personne ne les a conçus : ils viennent de l'entraînement sur des photos d'ImageNet. Marqués : les filtres 31 et 32.
Description textuelle du diagramme

Une grille de 64 petits carrés colorés, en 4 rangées de 16 (8 rangées de 8 sur un téléphone). Plusieurs carrés montrent des bandes, claires d’un côté et foncées de l’autre, à différents angles : ce sont des filtres de contours, comme ceux de HOG. D’autres montrent des taches de couleur : vert contre violet, ou orange contre bleu. Quelques-uns montrent un seul point clair sur du gris. Deux carrés sont marqués en bleu : le filtre 31, avec des bandes verticales, et le filtre 32, avec des bandes horizontales. Ce sont les deux filtres appris de la photo ci-dessus.

Plusieurs filtres appris ressemblent aux filtres de contours à différents angles utilisés par HOG. D’autres réagissent aux couleurs, ou à une couleur à côté d’une autre. Personne ne les a conçus. L’entraînement a trouvé que ces 64 questions sont les plus utiles pour la première couche.

Puis, le réseau répète l’idée. La deuxième couche fait glisser ses filtres sur les cartes de caractéristiques de la première couche, pas sur la photo. Elle trouve donc des motifs de contours : un coin, une courbe, un motif de bandes. Entre les couches, un pas de 2 ou une étape de regroupement (pooling) réduit la carte de moitié. Le regroupement maximal garde le plus grand nombre de chaque bloc de 2 × 2. Chaque filtre suivant couvre donc une plus grande partie de la photo. Les couches profondes réagissent à des parties entières : le rebord d’une tasse, un pied de chaise, une flamme.

La première rangée de ce diagramme suit une photo de 224 × 224 dans ResNet-18. La deuxième rangée présente l’autre architecture, le sujet de la prochaine section :

Deux rangées de cases reliées par des flèches. Un CNN (ResNet-18) : photo de 224 sur 224 sur 3; première couche, 64 filtres de 7 sur 7, donnant des cartes de 112 sur 112 sur 64 de contours et de couleurs; d'autres couches, des filtres de filtres, 28 sur 28 sur 128, coins et textures; dernier bloc, 7 sur 7 sur 512, parties comme les rebords, les anses et les pieds; moyenne de chacune des 512 cartes, donnant 512 nombres; dernière couche, un score par classe. Un transformeur de vision : photo de 224 sur 224 sur 3; découpée en 196 fragments de 16 sur 16; chaque fragment devient une liste de nombres, un jeton; blocs de transformeur, où chaque fragment examine tous les autres; un résumé de la photo; dernière couche, un score par classe.
Un CNN examine d'abord de petites fenêtres, et sa vue s'élargit couche par couche. Un transformeur de vision découpe la photo en fragments, et chaque fragment peut utiliser n'importe quel autre dès le premier bloc. Les deux terminent par une dernière couche qui donne un score par classe.
Description textuelle du diagramme

Deux rangées de six cases chacune, reliées par des flèches. Première rangée, un CNN (ResNet-18), dont la vue s’élargit couche par couche. Case 1 : la photo, 224 sur 224 pixels sur 3 couleurs. Case 2 : la première couche, 64 filtres de 7 sur 7, donne 64 cartes de 112 sur 112, pour les contours et les couleurs. Case 3 : d’autres couches, des filtres de filtres, donnent 128 cartes de 28 sur 28, pour les coins et les textures. Case 4 : le dernier bloc donne 512 cartes de 7 sur 7, pour des parties comme les rebords, les anses et les pieds. Case 5 : la moyenne de chacune des 512 cartes donne 512 nombres. Case 6 : la dernière couche donne un score par classe. Deuxième rangée, un transformeur de vision, où chaque fragment peut utiliser n’importe quel autre dès le début. Case 1 : la photo. Case 2 : découpée en 196 fragments de 16 sur 16 pixels. Case 3 : chaque fragment devient une liste de nombres, un jeton. Case 4 : blocs de transformeur, où chaque fragment examine tous les autres. Case 5 : un résumé de la photo. Case 6 : la dernière couche donne un score par classe.

Regardez la case 5 de la première rangée. Après le dernier bloc, ResNet-18 calcule la moyenne de chacune de ses 512 cartes. Chaque photo devient 512 nombres qui décrivent les parties qu’elle contient. La dernière couche les transforme en scores pour les 1 000 classes d’ImageNet. Dans la prochaine leçon, nous remplaçons cette dernière couche par la nôtre.

Fragments : comment un transformeur de vision lit une photo

Section intitulée « Fragments : comment un transformeur de vision lit une photo »

Un transformeur de vision, ou ViT, vient des transformeurs qui lisent du texte. Un transformeur de texte lit des mots. Le ViT transforme donc une photo en « mots » : il la découpe en carrés de 16 × 16 pixels, appelés fragments (patches). Une photo de 224 × 224 contient 14 × 14 = 196 fragments. Chaque fragment contient 16 × 16 pixels × 3 couleurs = 768 nombres.

Une photo d'une tasse blanche de café, de 224 sur 224 pixels, avec une grille blanche de 14 sur 14 carrés. La rangée 7 est marquée en bleu. À droite, les 14 fragments de la rangée 7, agrandis, sur une ligne : fond clair, rebord de la tasse, café noir, côté blanc de la tasse, fond.
Une photo découpée en 196 fragments de 16 × 16 pixels. Un transformeur de vision les lit l'un après l'autre, comme les mots d'une phrase : ici, les 14 fragments de la rangée 7. Photo : Joris de Vrede, CC BY 2.0, via Open Images.
Description textuelle du diagramme

À gauche, une photo d’une tasse blanche de café, découpée par des lignes blanches en une grille de 14 sur 14 carrés. La septième rangée de carrés, qui traverse le café, est marquée en bleu. À droite, les 14 carrés de cette rangée sont agrandis, sur une ligne de gauche à droite : deux de fond clair, puis le bord foncé du rebord, cinq de café noir, puis le côté blanc de la tasse et le fond. Le modèle lit ainsi les 196 carrés de la photo.

Chaque fragment devient une liste de nombres, un jeton (token). L’ordre compte, donc chaque jeton reçoit aussi sa position dans la grille. Puis, les blocs de transformeur travaillent sur tous les jetons. Leur principal outil est l’attention : chaque fragment prend de l’information des autres fragments qui comptent le plus pour lui. Un fragment de l’anse de la tasse peut utiliser un fragment de son rebord dès le premier bloc. Dans un CNN, deux parties aussi éloignées se rencontrent seulement dans les couches profondes.

L’attention étape par étape, dans le cours sur l’apprentissage profond, montre comment l’attention fonctionne avec des mots. Les fragments fonctionnent de la même façon.

L’architecture du ViT connaît moins de choses sur les photos que celle d’un CNN. Le filtre glissant d’un CNN suppose que les pixels voisins vont ensemble et qu’un motif signifie la même chose partout. Un ViT doit l’apprendre à partir des données. Les ViT ont donc généralement besoin de plus de photos d’entraînement, ou d’un long entraînement sur un très grand jeu de données, avant de surpasser un CNN. Les deux architectures sont utilisées, et les CNN plus récents empruntent des idées aux transformeurs. ConvNeXt, que vous découvrirez dans la prochaine leçon, est un CNN de ce type.

Une fiche de modèle (model card) est la page qui décrit un modèle préentraîné. Elle décrit le modèle, ses données d’entraînement, l’entrée attendue et sa licence. Lisez-la avant d’utiliser un modèle. Les noms des modèles dans le répertoire de timm donnent déjà une bonne partie de cette information. Cette bibliothèque de modèles d’images est celle du cours :

Nom du modèle Comment le lire Paramètres Entrée
resnet18.a1_in1k ResNet avec 18 couches; recette d’entraînement « a1 »; entraîné sur ImageNet-1k 11,7 millions 224 × 224
resnet50.a1_in1k ResNet avec 50 couches; mêmes recette et données 25,6 millions 224 × 224
efficientnet_b0.ra_in1k EfficientNet, dans sa plus petite taille « B0 »; recette « ra »; ImageNet-1k 5,3 millions 224 × 224
convnext_atto.d2_in1k ConvNeXt, dans sa très petite taille « atto »; recette « d2 »; ImageNet-1k 3,7 millions 224 × 224
vit_small_patch16_224.augreg_in21k_ft_in1k Un petit ViT avec des fragments de 16 pixels, pour des images de 224 pixels; entraîné sur ImageNet-21k, puis réglé finement sur ImageNet-1k 22,1 millions 224 × 224

L’équipe du cours a compté les paramètres avec timm. Un paramètre est un nombre que le réseau a appris, par exemple une valeur dans un filtre. ImageNet-1k est un jeu public d’environ 1,3 million de photos réparties en 1 000 classes. ImageNet-21k est plus grand, avec environ 21 000 classes.

Quand vous lisez une fiche, cherchez cinq éléments :

  1. L’entrée : la taille de la photo et sa préparation. Cela comprend un redimensionnement, un recadrage et une normalisation des couleurs. Pour chaque canal, on soustrait une moyenne et on divise par un écart-type.
  2. Les données d’entraînement : ce que le modèle a vu. Un modèle entraîné sur ImageNet a vu beaucoup de tasses et de chaises, mais peu de palettes.
  3. La taille : le nombre de paramètres et la taille du fichier. Ils déterminent la mémoire nécessaire et le temps de calcul sur votre processeur.
  4. Les résultats : les scores de la fiche concernent ses propres données de test, pas vos photos. Traitez-les comme une affirmation du fournisseur et mesurez les résultats sur vos données.
  5. La licence : celle du code, des poids et des données d’entraînement. Un module ultérieur examine ce que les conditions d’ImageNet signifient pour un produit.

Erreur courante

La préparation de la photo ne respecte pas la fiche de modèle

Symptôme : vous chargez ResNet-18 et lui donnez des photos converties en nombres de 0 à 1. Rien ne plante. Le modèle donne une réponse pour chaque photo. Mais beaucoup de réponses diffèrent de celles obtenues avec la préparation indiquée dans la fiche.

Cause : la fiche indique de redimensionner, de recadrer à 224 × 224, puis de normaliser chaque canal. La moyenne est (0,485, 0,456, 0,406) et l’écart-type est (0,229, 0,224, 0,225), selon ImageNet. Le modèle a appris à partir de photos préparées ainsi. L’équipe du cours a essayé les deux préparations sur les 160 photos de test du catalogue. Sans l’étape de normalisation, la première réponse du modèle a changé pour 49 d’entre elles.

Correction : laissez la bibliothèque construire la préparation à partir de la fiche. Dans timm : config = timm.data.resolve_data_config({}, model=model), puis transform = timm.data.create_transform(**config). Le carnet Jupyter de la prochaine leçon fait cela.

Conséquence pour le travail en IA : une mauvaise préparation ne donne aucun message d’erreur, seulement de moins bonnes réponses. Vérifiez-la chaque fois que vous changez de modèle ou qu’une nouvelle caméra envoie des photos d’une autre taille.

  • Un CNN (ResNet, EfficientNet, ConvNeXt) est un bon choix par défaut pour peu de photos et un processeur. Son architecture suppose déjà que les pixels voisins vont ensemble. Il a donc besoin de moins de photos pour s’adapter.
  • Un ViT est un bon choix s’il a été entraîné sur un très grand jeu de données. Vous devez aussi pouvoir supporter sa taille. Il est également utile pour comparer des parties éloignées de la photo. Beaucoup de modèles récents qui relient photos et texte utilisent des ViT, comme vous le verrez dans le prochain module.
  • Le coût : plus de paramètres demandent plus de mémoire et plus de millisecondes par photo. Donnent-ils aussi de meilleures réponses sur les photos de Larkfield? Il faut le mesurer, pas le supposer.

La section 5 du carnet contient deux tâches et deux cellules de vérification.

  1. Écrivez le filtre de contours horizontaux horizontal. Il soustrait la rangée du haut d’une fenêtre de 3 × 3 de sa rangée du bas.
  2. Placez conv2d(grid, horizontal) dans out_h.
  3. Un modèle découpe une photo de 224 × 224 en fragments de 32 × 32 pixels. Placez le nombre de fragments dans n_patches_32.
  4. Exécutez les deux cellules de vérification.
Afficher la réponse
horizontal = np.array([[-1, -1, -1], [0, 0, 0], [1, 1, 1]])
out_h = conv2d(grid, horizontal)
n_patches_32 = (224 // 32) ** 2
print(out_h.astype(int)); print(n_patches_32)
[[ 0 0 0 0]
[ 0 0 0 0]
[ 0 -190 -190 -190]
[ 0 -190 -190 -190]]
49

Le filtre horizontal réagit seulement là où quelque chose change de haut en bas. Dans la grille, cela arrive seulement là où le contour se déplace d’une colonne, dans les rangées du bas. La valeur est négative parce que le changement va du clair (en haut) au sombre (en bas). Avec des fragments de 32 pixels, un côté contient 7 fragments. La photo contient donc 7 × 7 = 49 fragments. Cela donne 4 fois moins de jetons, chacun avec 4 fois plus de pixels.

Vérifiez votre compréhension

Une fenêtre de 3 × 3 contient les rangées (10, 10, 200), (10, 10, 200) et (10, 200, 200). Que donne le filtre dont les rangées sont (−1, 0, 1)? Montrez les étapes.

Afficher la réponse

Multipliez et additionnez, rangée par rangée. Rangée 1 : −10 + 0 + 200 = 190. Rangée 2 : 190. Rangée 3 : −10 + 0 + 200 = 190. Le total est 570. Le filtre soustrait la colonne de gauche de la colonne de droite. Il donne donc un grand nombre partout où la fenêtre est plus sombre à gauche qu’à droite.

Vérifiez votre compréhension

Les filtres de la première couche de ResNet-18 ressemblent à des filtres de contours et de couleurs. Pourquoi une couche profonde du même réseau peut-elle réagir à une anse entière, alors que chaque filtre est petit?

Afficher la réponse

Chaque couche travaille sur les cartes de caractéristiques de la couche précédente, pas sur la photo. Un filtre de la deuxième couche combine donc des contours pour former des coins et des courbes. Un filtre ultérieur les combine pour former des parties d’objets. Entre les couches, les pas et le regroupement réduisent les cartes de moitié. Un petit filtre sur une petite carte couvre donc une grande partie de la photo. Les couches profondes voient des parties comme une anse ou un rebord.

Vérifiez votre compréhension

Tomás lit `vit_small_patch16_224` et `convnext_atto` sur deux fiches de modèle. Il dit : « Le ViT a 22 millions de paramètres et le ConvNeXt en a 3,7 millions. Le ViT sera donc meilleur pour notre catalogue. » Que vérifiez-vous avant d'être d'accord?

Afficher la réponse

Les paramètres indiquent la taille d’un modèle, pas sa qualité sur les photos de Larkfield. Vérifiez les données d’entraînement de chaque modèle et l’entrée attendue (224 × 224 dans les deux cas ici). Vérifiez sa préparation des photos, sa licence et son temps par photo sur notre processeur. Ensuite, mesurez les deux sur les mêmes photos du catalogue avec le tableau comparatif. Un modèle plus grand demande plus de mémoire et de temps. Il est meilleur seulement si le tableau le montre.

Récapitulatif

  • Une convolution fait glisser un petit filtre sur la photo, multiplie et additionne. Sa carte de caractéristiques a une valeur élevée là où la fenêtre correspond au filtre : 570 au contour de l’exemple détaillé.
  • Un CNN apprend ses filtres à partir de photos. Les 64 premiers filtres de ResNet-18 réagissent aux contours et aux couleurs. Les couches profondes réagissent aux parties d’objets, car chaque couche travaille sur les cartes de la couche précédente.
  • Un transformeur de vision découpe une photo de 224 × 224 en 196 fragments de 16 × 16. Grâce à l’attention, chaque fragment peut utiliser tous les autres.
  • Une fiche de modèle donne l’entrée, sa préparation, les données d’entraînement, la taille et la licence. ResNet-18 a 11,7 millions de paramètres; ConvNeXt-Atto en a 3,7 millions.
  • Sans l’étape de normalisation de la fiche, la première réponse de ResNet-18 a changé sur 49 des 160 photos, sans erreur.

Vous pouvez maintenant comprendre ce qu’un modèle préentraîné observe et ce qu’il attend. Mais ResNet-18 répond avec les 1 000 classes d’ImageNet, pas les 8 de Larkfield. Ensuite, vous garderez ses filtres appris et entraînerez seulement une nouvelle dernière couche sur le catalogue.

Leçon suivante : L'apprentissage par transfert