CSC 8607 – Introduction au deep learning

Liste des projets

Projet 1 — Tiny ImageNet (classification 200 classes) avec réseau convolutionnel à blocs simples

Étudiant : DELIÈRE

Dataset : Tiny ImageNet, 200 classes, ~100k images couleur 64×64 (train/val séparés). Tâche : classification multiclasses.

Où le trouver : via HuggingFace Datasets : zh-plus/tiny-imagenet (les images sont déjà au format 64×64). Vous pouvez l’utiliser avec PyTorch en écrivant un Dataset personnalisé qui lit les fichiers retournés par la librairie. Pour toute opération de transformation d’images, utilisez les fonctions de torchvision.transforms.

Modèle à implémenter : réseau convolutionnel en 3 stages, chaque stage étant répété plusieurs fois :

• Entrée : image RGB 3×64×64.
• Stage 1 (répéter N₁ fois) :
  • Convolution 2D (filtre 3×3, padding 1), nombre de canaux = C₁.
  • Batch normalization.
  • ReLU.
  À la fin du stage : Max pooling 2×2 (réduction de moitié des dimensions spatiales).
• Stage 2 (répéter N₂ fois) : identique au stage 1 mais avec C₂ canaux, puis Max pooling 2×2.
• Stage 3 (répéter N₃ fois) : identique, avec C₃ canaux, puis Global Average Pooling (moyenne spatiale).
• Tête : couche linéaire (dimension C₃ vers 200) pour obtenir les logits.

Utilisez les modules standards de PyTorch : nn.Conv2d, nn.BatchNorm2d, nn.ReLU, nn.AdaptiveAvgPool2d et nn.Linear.

Fonction de perte : CrossEntropyLoss.

Hyperparamètres du modèle à régler (2) :

1. Nombre de répétitions par stage : choisissez les triplets (N₁, N₂, N₃) parmi {1,2,3}. Cela change la profondeur du réseau (plus de répétitions = plus de couches).
2. Largeur des stages : fixez (C₁, C₂, C₃) parmi des valeurs comme (64,128,256) ou (48,96,192). Largeur = nombre de canaux de sortie dans les convolutions ; augmenter la largeur accroît la capacité.

Projet 2 — CIFAR-100 (classification 100 classes) avec blocs résiduels simples

Étudiant : JERBI

Dataset : CIFAR-100, 100 classes, images couleur 32×32. Tâche : classification multiclasses.

Où le trouver : via torchvision.datasets.CIFAR100 (téléchargement automatique). Utilisez torchvision.transforms pour le prétraitement et l’augmentation (redimensionnement optionnel, normalisation, recadrage aléatoire, etc.).

Modèle à implémenter : réseau à blocs résiduels (skip connections). Un bloc résiduel prend un tenseur en entrée, applique Convolution→BatchNorm→ReLU→Convolution→BatchNorm, puis additionne l’entrée d’origine au résultat (chemin court) avant ReLU. Quand la taille spatiale ou le nombre de canaux change, utilisez une projection 1×1 sur le chemin court pour aligner les dimensions.

• Entrée : 3×32×32.
• Couche initiale : Convolution 3×3 (padding 1), canaux = C₁, BatchNorm, ReLU.
• Stage 1 : empilement de B₁ blocs résiduels (toutes les convolutions 3×3, padding 1). Pas de changement d’échelle.
• Stage 2 : première convolution du premier bloc avec stride 2 (réduction spatiale), canaux = C₂. Empilez B₂ blocs au total.
• Stage 3 : même principe, stride 2 au début, canaux = C₃, empilez B₃ blocs.
• Global Average Pooling puis couche linéaire vers 100 classes.

Référez-vous aux docs PyTorch pour nn.Conv2d et à la construction d’un skip connection avec addition de tenseurs (torch.add).

Fonction de perte : CrossEntropyLoss.

Hyperparamètres du modèle à régler (2) :

1. Nombre de blocs par stage : choisissez (B₁, B₂, B₃) parmi {(2,2,2), (3,3,3)}. Cela ajuste la profondeur.
2. Nombre de canaux par stage : choisissez (C₁, C₂, C₃) parmi {(64,128,256), (48,96,192)}. Plus de canaux = réseau plus large.

Projet 3 — AG News (classification de textes, 4 classes) avec réseau convolutionnel pour texte (TextCNN)

Étudiant : KJAOUJ

Dataset : AG News, 4 catégories d’actualités, texte en anglais (titre + description). Tâche : classification multiclasses.

Où le trouver : via torchtext (AG_NEWS) ou via HuggingFace Datasets (ag_news). Vous devrez tokeniser le texte, construire un vocabulaire ou utiliser des embeddings pré-entraînés si vous le souhaitez. Pour les séquences, référez-vous à nn.Embedding.

Modèle à implémenter : TextCNN avec plusieurs convolutions 1D en parallèle sur les séquences d’embeddings.

• Convertissez chaque texte en une séquence d’indices, puis en séquence de vecteurs via une Embedding.
• Appliquez en parallèle des Convolutions 1D avec des kernel sizes différents (par exemple 3, 4 et 5). Chaque convolution est suivie de ReLU puis d’un max-over-time pooling (max sur la dimension temporelle) pour résumer chaque carte de caractéristiques en un seul scalaire.
• Concaténez les représentations issues de chaque branche, appliquez un dropout (si souhaité) puis une couche linéaire qui produit 4 logits.

Modules utiles : nn.Conv1d, nn.MaxPool1d, nn.Embedding.

Fonction de perte : CrossEntropyLoss.

Hyperparamètres du modèle à régler (2) :

1. Dimension des embeddings : choisissez parmi {100, 200, 300}. C’est la taille du vecteur représentant chaque mot.
2. Nombre de filtres par taille de noyau : pour chaque convolution (par ex. tailles 3, 4, 5), choisissez le nombre de filtres parmi {50, 100, 150}. Plus de filtres donnent plus de caractéristiques extraites.

Projet 4 — Speech Commands v0.02 (reconnaissance de mots courts) avec CNN sur spectrogrammes log-mel

Étudiant : OUALGHAZI

Dataset : Speech Commands v0.02 (Google), clips audio 1 seconde, plusieurs mots (par ex. “yes”, “no”, “up”, “down”, etc.). Tâche : classification multiclasses (choisissez un sous-ensemble de classes si nécessaire).

Où le trouver : via torchaudio.datasets.SPEECHCOMMANDS. Convertissez chaque audio en spectrogramme log-mel avec les transformations de torchaudio.transforms (MelSpectrogram puis AmplitudeToDB). Le spectrogramme peut être traité comme une “image” (fréquence × temps).

Modèle à implémenter : CNN 2D sur spectrogrammes.

• Entrée : tenseur 1×F×T (ajoutez une dimension “canal” = 1). Normalisez si nécessaire.
• Bloc A : Convolution 2D (3×3, padding 1, canaux = C₁) → Batch normalization → ReLU → Max pooling 2×2.
• Bloc B : Convolution 2D (3×3, padding 1, canaux = C₂) → Batch normalization → ReLU → Max pooling 2×2.
• Bloc C : Convolution 2D (3×3, padding 1, canaux = C₃) → Batch normalization → ReLU → Global Average Pooling.
• Tête : couche linéaire vers le nombre de classes choisies.

Modules utiles : MelSpectrogram, AmplitudeToDB, nn.Conv2d, nn.MaxPool2d.

Fonction de perte : CrossEntropyLoss.

Hyperparamètres du modèle à régler (2) :

1. Nombre de canaux par bloc : fixez (C₁, C₂, C₃) parmi {(32,64,128), (48,96,192)}.
2. Taille de la fenêtre mel-spectrogramme (n_fft ou win_length dans torchaudio) : choisissez une valeur courte ou moyenne (par ex. {400, 512, 640}) qui impacte la résolution temps/fréquence du spectrogramme. Voir la documentation des paramètres dans torchaudio.transforms.MelSpectrogram.

Projet 5 — IMDb (analyse de sentiments binaire) avec BiLSTM et attention

Étudiant : DAVOUST

Dataset : IMDb, critiques de films en anglais, étiquettes positives/négatives. Tâche : classification binaire.

Où le trouver : via torchtext (IMDB) ou HuggingFace Datasets (imdb). Vous devez tokeniser, tronquer/padder les séquences, et construire un vocabulaire ou utiliser des embeddings.

Modèle à implémenter : BiLSTM (long short-term memory bidirectionnel) suivi d’un mécanisme d’attention simple pour agréger la séquence en un vecteur.

• Embedding : transforme les indices de mots en vecteurs.
• BiLSTM : une ou deux couches, renvoie une séquence de sorties (une par pas de temps) dans les deux directions (avant et arrière) concaténées.
• Attention (simple) : apprenez un vecteur de requête (ou une petite couche linéaire) qui produit un poids (score) pour chaque pas de temps ; appliquez un softmax sur ces scores et calculez la moyenne pondérée des sorties BiLSTM. Le résultat est un vecteur fixe.
• Tête : couche linéaire vers 1 logit (utilisez ensuite la perte binaire).

Référez-vous aux docs de nn.LSTM pour les options (bidirectional, num_layers) et à nn.Embedding.

Fonction de perte : BCEWithLogitsLoss (binaire, appliquée au logit de sortie).

Hyperparamètres du modèle à régler (2) :

1. Taille cachée du LSTM (dimension de l’état caché par direction) : choisissez parmi {64, 128, 256}. Cela change la capacité de la mémoire.
2. Nombre de couches LSTM : choisissez 1 ou 2 couches empilées (paramètre num_layers de nn.LSTM). Plus de couches augmentent la profondeur temporelle.

Projet 6 — Tiny ImageNet (200 classes) avec convolutions séparables en profondeur (depthwise + pointwise)

Étudiant : NIAURONIS

Dataset : Tiny ImageNet, 200 classes, ~100 000 images couleur 64×64. Tâche : classification multiclasses.

Où le trouver : via HuggingFace Datasets : zh-plus/tiny-imagenet. Chargez les images et les étiquettes avec un Dataset personnalisé et utilisez torchvision.transforms pour les transformations (normalisation, recadrage, etc.).

Concept à connaître (non vu en cours) : une convolution séparée en profondeur remplace une convolution 3×3 standard par deux étapes : (1) une convolution 3×3 depthwise qui applique un filtre indépendant sur chaque canal d’entrée (pas de mélange entre canaux), puis (2) une convolution 1×1 pointwise qui mélange les canaux et ajuste le nombre de canaux de sortie. Voir la documentation de PyTorch pour nn.Conv2d (paramètre groups pour réaliser la partie depthwise).

Modèle à implémenter : réseau en 3 stages avec blocs “Depthwise 3×3 → Batch normalization → ReLU → Pointwise 1×1 → Batch normalization → ReLU”.

• Entrée : image RGB 3×64×64.
• Stage 1 : répétez B₁ fois le bloc :
  • Convolution 2D 3×3 depthwise (padding 1, groupes = nombre de canaux d’entrée), nombre de canaux conservé.
  • Batch normalization, ReLU.
  • Convolution 2D 1×1 pointwise pour produire 64 canaux.
  • Batch normalization, ReLU.
  À la fin du stage : Max pooling 2×2.
• Stage 2 : même structure, répétez B₂ fois, la convolution 1×1 produit 128 canaux. À la fin : Max pooling 2×2.
• Stage 3 : même structure, répétez B₃ fois, la convolution 1×1 produit 256 canaux. À la fin : Global Average Pooling.
• Tête : couche linéaire (256 → 200).

Fonction de perte : CrossEntropyLoss.

Hyperparamètres du modèle à régler (2) :

1. Nombre de blocs par stage : choisissez (B₁, B₂, B₃) parmi {(1,1,1), (2,2,2)}.
2. Facteur de largeur (multiplicateur des canaux après la convolution 1×1) : multipliez les valeurs de canaux (64, 128, 256) par {0.75 ou 1.0}. Par exemple, avec 0.75, les sorties deviennent (48, 96, 192). Un facteur de largeur ajuste uniformément la taille de toutes les couches de sortie.

Projet 7 — CIFAR-100 (100 classes) avec blocs “goulot d’étranglement” (bottleneck)

Étudiant : ROLAND

Dataset : CIFAR-100, 100 classes, images 32×32. Tâche : classification multiclasses.

Où le trouver : via torchvision.datasets.CIFAR100 (téléchargement automatique) avec transformations de torchvision.transforms.

Concept à connaître : un bloc bottleneck réduit brièvement le nombre de canaux avec une convolution 1×1 (goulot), applique une convolution 3×3 au faible coût, puis ré-augmente les canaux avec une autre convolution 1×1. Cela suit le schéma “1×1 réduction → 3×3 → 1×1 expansion”.

Modèle à implémenter : 3 stages de blocs bottleneck avec connexions résiduelles (addition entrée + sortie du bloc si dimensions égales ; sinon projection 1×1 sur le chemin court).

• Entrée : 3×32×32.
• Couche initiale : Conv 3×3 (padding 1, 64 canaux) → Batch normalization → ReLU.
• Stage 1 (répéter B₁ fois) :
  • Conv 1×1 réduit à 16 canaux.
  • Batch normalization, ReLU.
  • Conv 3×3 (padding 1) conserve 16 canaux.
  • Batch normalization, ReLU.
  • Conv 1×1 étend à 64 canaux.
  • Batch normalization.
  • Addition résiduelle (ou projection 1×1 si nécessaire), ReLU.
• Stage 2 (répéter B₂ fois) : le premier bloc utilise stride 2 dans la conv 3×3 pour réduire l’échelle spatiale, et l’extension finale produit 128 canaux. Les autres blocs du stage gardent stride 1 et 128 canaux.
• Stage 3 (répéter B₃ fois) : même logique, premier bloc stride 2, extension finale 256 canaux.
• Global Average Pooling puis linéaire vers 100 classes.

Reportez-vous à la documentation de nn.Conv2d pour implémenter les convolutions 1×1 et 3×3 et à torch.add pour l’addition résiduelle.

Fonction de perte : CrossEntropyLoss.

Hyperparamètres du modèle à régler (2) :

1. Nombre de blocs par stage : choisissez (B₁, B₂, B₃) parmi {(2,2,2), (3,3,3)}.
2. Facteur de goulot (rapport de réduction dans la conv 1×1) : choisissez la réduction à {16 ou 32} canaux dans les stages où la sortie est respectivement {64 ou 128} canaux. Un facteur plus petit signifie un goulot plus étroit (plus de compression avant le 3×3).

Projet 8 — CelebA (multi-étiquettes visage, 5 attributs) avec CNN multi-label

Étudiant : BEN TALEB ALI

Dataset : CelebA, images de visages et ~40 attributs binaires. Tâche : prédire 5 attributs binaires simultanément (multi-label). Choisissez précisément 5 attributs (par exemple : Smiling, Wearing_Hat, Male, Young, Eyeglasses).

Où le trouver : via torchvision.datasets.CelebA (téléchargement après acceptation des conditions). Redimensionnez les images à 64×64 et normalisez-les.

Modèle à implémenter : CNN 2D à trois blocs convolutifs puis tête multi-sorties.

• Entrée : image RGB 3×64×64.
• Bloc 1 : Conv 3×3 (padding 1, 64 canaux) → Batch normalization → ReLU → Max pooling 2×2.
• Bloc 2 : Conv 3×3 (padding 1, 128 canaux) → Batch normalization → ReLU → Max pooling 2×2.
• Bloc 3 : Conv 3×3 (padding 1, 256 canaux) → Batch normalization → ReLU → Global Average Pooling.
• Tête : couche linéaire (256 → 5) pour produire 5 logits indépendants (un par attribut).

Fonction de perte : BCEWithLogitsLoss (multi-label, appliquez-la à chaque logit avec les étiquettes {0,1}).

Hyperparamètres du modèle à régler (2) :

1. Nombre de canaux dans le bloc 3 : choisissez 192 ou 256 pour la convolution du bloc 3 (les blocs 1 et 2 restent à 64 et 128).
2. Probabilité de dropout appliquée juste avant la couche linéaire finale : choisissez {0.0, 0.2, 0.4}. Le dropout désactive aléatoirement des unités pour régulariser le modèle.

Projet 9 — Yelp Polarity (sentiment binaire) avec GRU et max-pooling global

Étudiant : GALSTIAN

Dataset : Yelp Polarity, critiques en anglais avec étiquette positive/négative. Tâche : classification binaire.

Où le trouver : via HuggingFace Datasets : yelp_polarity. Préparez une tokenisation simple (par mots), tronquez ou paddez les séquences à une longueur fixe et construisez un vocabulaire. Utilisez nn.Embedding pour représenter les mots.

Modèle à implémenter : Embedding → GRU → Global Max Pooling → Linéaire.

• Embedding : transforme les indices en vecteurs de taille 200.
• GRU : une couche unidirectionnelle (paramètre num_layers=1 et bidirectional=False) avec taille cachée H.
• Global Max Pooling : prenez le maximum sur la dimension temporelle des sorties du GRU pour obtenir un vecteur fixe de taille H.
• Tête : couche linéaire (H → 1) pour produire un logit binaire.

Voir la documentation de nn.GRU et nn.Embedding.

Fonction de perte : BCEWithLogitsLoss.

Hyperparamètres du modèle à régler (2) :

1. Taille cachée du GRU H : choisissez parmi {128, 256, 384}.
2. Longueur maximale de séquence (après tronquage/padding) : choisissez parmi {128, 256, 400}. Cela affecte la quantité de texte réellement lue par le modèle.

Projet 10 — UCI HAR (reconnaissance d’activités humaines, capteurs 1D) avec CNN 1D résiduel

Étudiant : UNG

Dataset : UCI Human Activity Recognition (HAR), signaux 1D issus d’accéléromètres/gyroscopes, plusieurs activités (par ex. : marcher, s’asseoir, etc.). Tâche : classification multiclasses.

Où le trouver : sur le dépôt UCI Machine Learning Repository (UCI HAR Dataset). Téléchargez les fichiers fournis (train/test), chargez-les avec un Dataset personnalisé PyTorch et normalisez chaque canal. La structure des fichiers est décrite dans le README du dataset.

Modèle à implémenter : CNN 1D avec blocs résiduels (skip connections) adaptés à des entrées de forme C×T (C canaux de capteurs, T pas de temps).

• Entrée : C×T (par exemple 9 canaux si vous concaténez accéléromètre/gyroscope, selon votre préparation).
• Couche initiale : Conv1d kernel 7, stride 2, padding 3, 64 canaux → Batch normalization → ReLU → MaxPool1d kernel 3, stride 2.
• Stage 1 (répéter B₁ fois) : chaque bloc = Conv1d 3×1 (padding 1) 64→64 → Batch normalization → ReLU → Conv1d 3×1 64→64 → Batch normalization → addition résiduelle → ReLU.
• Stage 2 (répéter B₂ fois) : premier bloc avec stride 2 dans la première conv pour réduire T, canaux 128 ; blocs suivants stride 1, canaux 128, avec projections 1×1 si nécessaire.
• Stage 3 (répéter B₃ fois) : même logique, 256 canaux.
• Global Average Pooling 1D puis linéaire vers le nombre d’activités (par ex. 6).

Reportez-vous à nn.Conv1d, nn.MaxPool1d et à l’addition de tenseurs pour la connexion résiduelle.

Fonction de perte : CrossEntropyLoss.

Hyperparamètres du modèle à régler (2) :

1. Nombre de blocs par stage : choisissez (B₁, B₂, B₃) parmi {(1,1,1), (2,2,2)}.
2. Taille du noyau des convolutions dans les blocs : choisissez {3 ou 5}. Utilisez la même taille de noyau dans tous les blocs afin de garder un design cohérent.

Projet 11 — Tiny ImageNet (200 classes) avec convolutions dilatées (atrous) pour agrandir le champ réceptif

Étudiant : BOUTKRIDA

Dataset : Tiny ImageNet, 200 classes, ~100 000 images couleur 64×64. Tâche : classification multiclasses.

Où le trouver : via HuggingFace Datasets : zh-plus/tiny-imagenet. Chargez les images/étiquettes et utilisez torchvision.transforms pour normaliser et recadrer si nécessaire.

Concept : une convolution dilatée (dilated ou atrous) insère des “trous” dans le noyau (paramètre dilation de nn.Conv2d) afin d’agrandir le champ réceptif sans augmenter le nombre de paramètres.

Modèle à implémenter : réseau en 3 stages, chaque stage composé de blocs : Conv2d (3×3) → Batch normalization → ReLU. Les convolutions des stages 2 et 3 utilisent une dilation > 1. Réduction spatiale entre les stages par MaxPool.

• Entrée : 3×64×64.
• Stage 1 : répéter B₁ fois : Conv 3×3, padding 1, 64 canaux, dilation 1 → Batch normalization → ReLU. Puis MaxPool 2×2.
• Stage 2 : répéter B₂ fois : Conv 3×3, padding ajusté, 128 canaux, dilation D₂ → Batch normalization → ReLU. Puis MaxPool 2×2.
• Stage 3 : répéter B₃ fois : Conv 3×3, padding ajusté, 256 canaux, dilation D₃ → Batch normalization → ReLU. Puis Global Average Pooling.
• Tête : linéaire 256 → 200.

Fonction de perte : CrossEntropyLoss.

Hyperparamètres du modèle à régler (2) :

1. Nombre de blocs par stage : choisissez (B₁, B₂, B₃) parmi {(2,2,2), (3,3,3)}.
2. Dilation par stage : choisissez (D₂, D₃) parmi {(2,2), (2,3)}. Ajustez le padding en conséquence pour conserver les dimensions avant pooling.

Projet 12 — CIFAR-100 (100 classes) avec Group Normalization au lieu de Batch Normalization

Étudiant : CHARFEDDINE

Dataset : CIFAR-100, 100 classes, 32×32. Tâche : classification multiclasses.

Où le trouver : via torchvision.datasets.CIFAR100. Utilisez torchvision.transforms pour le prétraitement et l’augmentation.

Concept : Group Normalization normalise par groupes de canaux (voir nn.GroupNorm) et est moins sensible à la taille de batch que Batch Normalization.

Modèle à implémenter : réseau convolutionnel en 3 stages avec blocs Conv 3×3 → GroupNorm → ReLU. Réduction spatiale par stride 2 en début de stage 2 et 3 (dans la convolution).

• Entrée : 3×32×32.
• Stage 1 : deux blocs : Conv 3×3, 64 canaux, stride 1 → GroupNorm → ReLU (répéter deux fois).
• Stage 2 : premier bloc Conv 3×3, 128 canaux, stride 2 → GroupNorm → ReLU, puis un second bloc identique avec stride 1.
• Stage 3 : premier bloc Conv 3×3, 256 canaux, stride 2 → GroupNorm → ReLU, puis un second bloc identique avec stride 1.
• Global Average Pooling → linéaire 256 → 100.

Fonction de perte : CrossEntropyLoss.

Hyperparamètres du modèle à régler (2) :

1. Nombre de groupes pour GroupNorm : choisissez {8, 16}. Le nombre de groupes doit diviser le nombre de canaux du bloc.
2. Nombre de blocs par stage : choisissez {2 ou 3 blocs} dans chaque stage (si 3, ajoutez un bloc Conv→GroupNorm→ReLU supplémentaire avec stride 1).

Projet 13 — Food-101 (classification 101 classes) avec CNN à quatre stages

Étudiant : PILLET

Dataset : Food-101, 101 catégories de plats, ~101k images diverses. Tâche : classification multiclasses.

Où le trouver : via torchvision.datasets.Food101. Redimensionnez les images à 128×128 pour limiter le coût mémoire et normalisez-les.

Modèle à implémenter : CNN 2D avec 4 stages, blocs Conv 3×3 → Batch normalization → ReLU, et réduction spatiale par MaxPool entre les stages.

• Entrée : 3×128×128.
• Stage 1 : répéter N₁ fois : Conv 3×3, 64 canaux, padding 1 → Batch normalization → ReLU. Puis MaxPool 2×2.
• Stage 2 : répéter N₂ fois : Conv 3×3, 128 canaux → Batch normalization → ReLU. Puis MaxPool 2×2.
• Stage 3 : répéter N₃ fois : Conv 3×3, 256 canaux → Batch normalization → ReLU. Puis MaxPool 2×2.
• Stage 4 : répéter N₄ fois : Conv 3×3, 256 canaux → Batch normalization → ReLU. Puis Global Average Pooling.
• Tête : linéaire 256 → 101.

Fonction de perte : CrossEntropyLoss.

Hyperparamètres du modèle à régler (2) :

1. Répétitions par stage : choisissez (N₁, N₂, N₃, N₄) parmi {(1,1,2,2), (2,2,2,2)}.
2. Canaux du stage 4 : choisissez 256 ou 384 canaux pour les convolutions du stage 4 (les autres stages restent à 64, 128, 256).

Projet 14 — Oxford-IIIT Pet (37 races de chats/chiens) avec blocs à attention de canal (Squeeze-and-Excitation)

Étudiant : RAKI

Dataset : Oxford-IIIT Pet, 37 classes (races de chats et de chiens), images de tailles variées. Tâche : classification multiclasses.

Où le trouver : via torchvision.datasets.OxfordIIITPet. Redimensionnez chaque image à 128×128 et normalisez-la (moyenne/écart-type usuels des images RGB). Utilisez les transformations de torchvision.transforms.

Modèle à implémenter : réseau convolutionnel en 3 stages, chaque bloc est : Convolution 3×3 → Batch normalization → ReLU → Squeeze-and-Excitation (SE). Réduction spatiale par max pooling entre les stages. La tête applique un global average pooling puis une couche linéaire vers 37 classes.

• Entrée : image RGB 3×128×128.
• Stage 1 :
  • Deux blocs identiques. Chaque bloc utilise une convolution 3×3 (padding 1) avec 64 canaux, suivie d’une batch normalization et de ReLU, puis d’un module SE (décrit plus bas) paramétré pour 64 canaux.
  • Après le second bloc : MaxPool 2×2.
• Stage 2 :
  • Deux blocs identiques. Chaque bloc utilise une convolution 3×3 (padding 1) avec 128 canaux, batch normalization, ReLU, puis module SE pour 128 canaux.
  • Après le second bloc : MaxPool 2×2.
• Stage 3 :
  • Deux blocs identiques. Chaque bloc utilise une convolution 3×3 (padding 1) avec 256 canaux, batch normalization, ReLU, puis module SE pour 256 canaux.
  • Après le dernier bloc : Global Average Pooling spatial (sortie de taille 256).
• Tête : couche linéaire 256 → 37 (logits de classification).

Fonction de perte : CrossEntropyLoss.

Détails du module Squeeze-and-Excitation (SE)

Le module SE rééchelonne par canal les cartes de caractéristiques en apprenant des poids compris entre 0 et 1 pour chaque canal. Il comporte deux étapes : compression (squeeze) et excitation.

1. Squeeze (compression) : appliquez une moyenne globale spatiale par canal pour résumer chaque carte en un scalaire. Utilisez nn.AdaptiveAvgPool2d(output_size=1).
   Si l’entrée du SE a la forme (N, C, H, W), la sortie du squeeze a la forme (N, C, 1, 1).
2. Excitation : passez ce vecteur (aplatir en (N, C)) dans une petite MLP à deux couches linéaires de tailles C → C/r → C, avec ReLU entre les deux couches et une sigmoïde à la fin.
   • Première couche linéaire : dimension d’entrée = C, dimension de sortie = ceil(C / r). (Si C / r n’est pas entier, arrondissez à l’entier supérieur. Ne descendez jamais en dessous de 1.)
   • Activation ReLU.
   • Deuxième couche linéaire : dimension d’entrée = ceil(C / r), dimension de sortie = C.
   • Activation sigmoïde pour obtenir des coefficients dans [0, 1].
   Référez-vous à nn.Linear pour implémenter ces couches.
3. Recalibrage : redimensionnez/broadcast les C poids obtenus à la forme (N, C, 1, 1) et multipliez-les canal-par-canal avec l’entrée du module SE (opération de type * en PyTorch).

Exemples de tailles de la MLP :

• Dans un bloc avec C = 64 canaux et r = 16 : MLP = 64 → 4 → 64.
• Dans un bloc avec C = 128 canaux et r = 8 : MLP = 128 → 16 → 128.
• Dans un bloc avec C = 256 canaux et r = 16 : MLP = 256 → 16 → 256.

Hyperparamètres du modèle à régler (2) :

1. Ratio de réduction r du module SE : choisissez {8, 16}. Cela contrôle la taille du goulot de la MLP (C/r). Un ratio plus grand (16) rend la MLP plus compacte, donc une excitation plus contrainte.
2. Nombre de blocs par stage : choisissez {2 ou 3}. Si vous choisissez 3 :
   • Dans le stage 1 et le stage 2, insérez un bloc supplémentaire avant le MaxPool 2×2.
   • Dans le stage 3, insérez un bloc supplémentaire avant le global average pooling.
   • Chaque bloc ajouté est identique (mêmes canaux et même module SE).

Projet 15 — ESC-50 (50 classes de sons environnementaux) avec CNN 2D sur spectrogrammes log-mel

Étudiant : HADDAOUI

Dataset : ESC-50, 2 000 enregistrements audio de 5 secondes, 50 classes (40 exemples par classe). Tâche : classification multiclasses.

Où le trouver :
• Dépôt officiel : github.com/karolpiczak/ESC-50 (contient les fichiers .wav et le fichier d’annotations meta/esc50.csv). Utilisez les colonnes fold, category et filename pour créer vos splits train/val/test et vos étiquettes.
• Alternative prête à l’emploi : jeu de données HuggingFace : yangwang825/esc50.

Prétraitement audio (recommandé) : chargez les WAV, convertissez en mono, rééchantillonnez à 16 000 Hz, puis calculez un mel-spectrogramme (paramètres fixes : n_mels=64, n_fft=400, win_length=400, hop_length=160) et appliquez AmplitudeToDB (échelle log). Ces étapes se font avec torchaudio et ses transforms (MelSpectrogram, AmplitudeToDB). Traitez ensuite le spectrogramme comme une “image” 1×Fréquences×Temps.

Modèle à implémenter : CNN 2D à trois blocs convolutionnels suivis d’un global average pooling et d’une couche linéaire.

• Entrée : tenseur 1×64×T (1 canal, 64 bandes mel, T pas de temps). Normalisez le spectrogramme (par ex. normalisation par feature).
• Bloc A : Convolution 2D (3×3, padding 1, C₁ canaux) → Batch normalization → ReLU → Max pooling 2×2.
• Bloc B : Convolution 2D (3×3, padding 1, C₂ canaux) → Batch normalization → ReLU → Max pooling 2×2.
• Bloc C : Convolution 2D (3×3, padding 1, C₃ canaux) → Batch normalization → ReLU → Global Average Pooling.
• Tête : couche linéaire (C₃ → 50) pour produire les logits.

Fonction de perte : CrossEntropyLoss.

Hyperparamètres du modèle à régler (2) :

1. Nombre de canaux par bloc : choisissez (C₁, C₂, C₃) parmi {(32, 64, 128) ou (48, 96, 192)}.
2. Taille de noyau des convolutions : choisissez {3×3 ou 5×5}. Si vous choisissez 5×5, utilisez padding=2 pour conserver la taille spatiale avant le pooling.

Projet 16 — 20 Newsgroups (20 catégories de textes) avec BiGRU et attention moyenne pondérée

Étudiant : AMDOUNI

Dataset : 20 Newsgroups, 20 catégories de forums texte. Tâche : classification multiclasses.

Où le trouver : via scikit-learn (fetch_20newsgroups) ou HuggingFace Datasets (newsgroup). Nettoyez le texte (minuscule, suppression ponctuation basique), tokenizez, tronquez/paddez à une longueur fixe, construisez un vocabulaire.

Modèle à implémenter : Embedding → BiGRU → attention simple → Linéaire (20).

• Embedding : dimension 200.
• BiGRU : une couche bidirectionnelle, taille cachée H par direction (la sortie par pas de temps a une dimension 2H).
• Attention : calculez un score par pas de temps avec une petite couche linéaire appliquée sur 2H, puis appliquez softmax pour obtenir des poids ; faites la somme pondérée des sorties temporelles (vecteur 2H).
• Tête : linéaire 2H → 20.

Voir nn.GRU (paramètre bidirectional=True) et nn.Embedding.

Fonction de perte : CrossEntropyLoss.

Hyperparamètres du modèle à régler (2) :

1. Taille cachée H du GRU (par direction) : choisissez {128, 192, 256}.
2. Longueur maximale de séquence (après tronquage/padding) : choisissez {256, 400, 512}.

Projet 17 — Tiny ImageNet (200 classes) avec blocs résiduels pré-activation (BatchNorm/ReLU avant convolution)

Étudiant : ZRIGA

Dataset : Tiny ImageNet, 200 classes, environ 100 000 images couleur 64×64. Tâche : classification multiclasses.

Où le trouver : via HuggingFace Datasets : zh-plus/tiny-imagenet. Chargez les images et étiquettes, redimensionnez à 64×64 si nécessaire et normalisez-les avec les transformations de torchvision.transforms.

Modèle à implémenter : réseau convolutionnel avec blocs résiduels pré-activation. Dans un bloc pré-activation, l’ordre est Batch Normalization → ReLU → Convolution, et l’addition résiduelle se fait sur la sortie de la seconde convolution. Lorsque la résolution ou le nombre de canaux change, utilisez une projection 1×1 sur le chemin court pour faire correspondre les dimensions.

• Entrée : image RGB 3×64×64.
• Couche d’initialisation : Convolution 3×3, 64 canaux, stride 1, padding 1 (pas de pooling ici).
• Stage 1 (résolution inchangée) : empilez B₁ blocs. Chaque bloc contient :
  • BatchNorm 2D → ReLU → Convolution 3×3 (64 → 64, stride 1, padding 1).
  • BatchNorm 2D → ReLU → Convolution 3×3 (64 → 64, stride 1, padding 1).
  • Addition résiduelle (chemin court = identité, pas de projection ici).
• Stage 2 (réduction de moitié des dimensions spatiales) : empilez B₂ blocs. Dans le premier bloc du stage :
  • BatchNorm 2D → ReLU → Convolution 3×3 (64 → C₂, stride 2, padding 1) pour réduire la résolution.
  • BatchNorm 2D → ReLU → Convolution 3×3 (C₂ → C₂, stride 1, padding 1).
  • Chemin court : Convolution 1×1 (64 → C₂, stride 2) pour aligner résolution et canaux.
  Pour les blocs suivants du même stage, utilisez stride 1 dans les deux convolutions et un chemin court identité.
• Stage 3 (réduction de moitié des dimensions spatiales) : même principe que le stage 2 mais avec C₃ canaux. Dans le premier bloc, mettez stride 2 dans la première convolution et dans la projection 1×1 du chemin court.
• Tête : Global Average Pooling (moyenne spatiale) → couche linéaire (C₃ → 200) pour produire les logits.

Modules utiles : nn.BatchNorm2d, nn.ReLU, nn.Conv2d, nn.AdaptiveAvgPool2d. Pour l’addition du chemin résiduel : torch.add.

Fonction de perte : CrossEntropyLoss.

Hyperparamètres du modèle à régler (2) :

1. Nombre de blocs par stage : choisissez (B₁, B₂, B₃) parmi {(2, 2, 2), (3, 3, 3)}. Plus de blocs = réseau plus profond.
2. Nombre de canaux par stage : choisissez (C₂, C₃) parmi {(128, 256) ou (96, 192)}. Le stage 1 reste à 64 canaux (valeur fixée).

Projet 18 — SVHN (numéros de maison, 10 classes) avec CNN à blocs et downsampling par stride

Étudiant : ZEGANG KETCHAKEU

Dataset : SVHN, images couleur 32×32 de chiffres (scènes naturelles), 10 classes. Tâche : classification multiclasses.

Où le trouver : via torchvision.datasets.SVHN (split train et test disponibles). Normalisez les images.

Modèle à implémenter : CNN 3 stages ; chaque stage contient deux blocs Conv 3×3 → Batch normalization → ReLU. La première convolution du stage 2 et du stage 3 utilise stride = 2 pour réduire l’échelle spatiale (au lieu d’un MaxPool).

• Entrée : 3×32×32.
• Stage 1 : deux blocs à 64 canaux, stride 1.
• Stage 2 : premier bloc 128 canaux avec stride 2, second bloc 128 canaux stride 1.
• Stage 3 : premier bloc 256 canaux avec stride 2, second bloc 256 canaux stride 1, puis Global Average Pooling.
• Tête : linéaire 256 → 10.

Fonction de perte : CrossEntropyLoss.

Hyperparamètres du modèle à régler (2) :

1. Nombre de canaux : choisissez les triplets {(64,128,256) ou (48,96,192)} pour les trois stages.
2. Ajout d’un troisième bloc par stage : choisissez {oui ou non}. Si oui, ajoutez un bloc Conv→Batch normalization→ReLU supplémentaire avec le même nombre de canaux et stride 1 dans chaque stage.

Projet 19 — Tiny ImageNet (200 classes) avec modules “Inception-like” multibranches

Étudiant : KHALFALLAH

Dataset : Tiny ImageNet, 64×64, 200 classes. Tâche : classification multiclasses.

Où le trouver : via HuggingFace Datasets : zh-plus/tiny-imagenet.

Concept : un module “multibranches” applique en parallèle des convolutions de tailles différentes, puis concatène les sorties le long de la dimension des canaux (voir torch.cat pour la concaténation de tenseurs).

Modèle à implémenter : enchaînement de M modules identiques ; chaque module comporte 3 branches en parallèle : Conv 1×1 (réduction des canaux) → ReLU ; Conv 3×3 (padding 1) → ReLU ; MaxPool 3×3 (stride 1, padding 1) suivi d’une Conv 1×1 → ReLU. Concaténez les trois sorties (dimension des canaux), puis appliquez Batch normalization. Réduisez l’échelle spatiale par MaxPool 2×2 après chaque 2 modules. Terminez par Global Average Pooling puis linéaire vers 200.

• Au début, appliquez une Conv 3×3, 64 canaux, padding 1.
• Dans chaque module, fixez la sortie concaténée à 192 canaux en choisissant des largeurs appropriées dans les trois branches (par exemple 64 + 64 + 64).

Fonction de perte : CrossEntropyLoss.

Hyperparamètres du modèle à régler (2) :

1. Nombre total de modules M : choisissez {4, 6}. Insérez un MaxPool 2×2 après les modules 2 et 4 si M=6 (ou seulement après le module 2 si M=4).
2. Répartition des canaux par branche : choisissez entre { (64,64,64) ou (48,72,72) } pour (branche 1×1, branche 3×3, branche pool+1×1) afin que la concaténation fasse 192 canaux.

Projet 20 — Flowers-102 (102 classes de fleurs) avec connexions denses (dense connections)

Étudiant : SLESINSKI

Dataset : Oxford Flowers-102, 102 classes, images variées. Tâche : classification multiclasses.

Où le trouver : via torchvision.datasets.Flowers102. Redimensionnez toutes les images à 128×128 et normalisez-les (moyennes/écarts-types RGB usuels). Utilisez torchvision.transforms pour le prétraitement et l’augmentation.

Idée des connexions denses : à l’intérieur d’un dense block, chaque bloc produit de nouveaux canaux qui sont concaténés (pas additionnés) aux entrées existantes. Ainsi, si l’entrée a C canaux, chaque bloc ajoute G nouveaux canaux (appelé taux de croissance), et la sortie du dense block grossit progressivement. La concaténation se fait sur la dimension “canaux”. Reportez-vous à torch.cat pour concaténer des tenseurs.

Modèle à implémenter : enchaînement DenseBlock 1 → Transition 1 → DenseBlock 2 → Transition 2 → DenseBlock 3 → Tête.

• Entrée : image RGB 3×128×128.
• Couche initiale : Conv2d 3×3, 64 canaux, stride 1, padding 1 → BatchNorm2d → ReLU.
  Voir nn.Conv2d, nn.BatchNorm2d, nn.ReLU.

Dense block (détails)

Un dense block répète K fois la séquence suivante, en réutilisant toutes les sorties précédentes par concaténation :

1. Entrée du bloc courant : concaténation de toutes les sorties des blocs précédents du même dense block et de l’entrée du dense block. Si la première entrée du dense block a C_in canaux, alors l’entrée du bloc i (en commençant à 1) a C_in + (i-1)·G canaux.
2. BN → ReLU → Conv 3×3 (padding 1, stride 1) produisant exactement G nouveaux canaux (taux de croissance). La sortie de ce bloc a donc G canaux.
3. Concaténez (dimension “canaux”) l’entrée du bloc avec ses G nouveaux canaux pour former l’entrée du bloc suivant.

Après K blocs, la sortie du dense block a C_in + K·G canaux.

Transition (détails)

Une transition réduit à la fois le nombre de canaux et la résolution spatiale :

• BN → ReLU → Conv 1×1 qui réduit les canaux de moitié (arrondi à l’entier inférieur).
• Average Pooling 2×2 (stride 2) pour diviser largeur et hauteur par 2.

Exemple : si la sortie du dense block a 160 canaux, la transition produit 80 canaux avant le pooling (puis réduit H et W de moitié).

Architecture complète (tailles fixes quand non listées parmi les hyperparamètres)

• DenseBlock 1 avec K blocs (voir hyperparamètres). Entrée : 64 canaux ⇒ sortie : 64 + K·G canaux.
• Transition 1 : Conv 1×1 à ⌊(64 + K·G)/2⌋ canaux → AvgPool 2×2.
• DenseBlock 2 avec K blocs. Entrée : ⌊(64 + K·G)/2⌋ ⇒ sortie : ⌊(64 + K·G)/2⌋ + K·G.
• Transition 2 : Conv 1×1 à ⌊(⌊(64 + K·G)/2⌋ + K·G)/2⌋ canaux → AvgPool 2×2.
• DenseBlock 3 avec K blocs. Entrée : ⌊(⌊(64 + K·G)/2⌋ + K·G)/2⌋ ⇒ sortie : entrée + K·G.
• Tête : AdaptiveAvgPool2d(output_size=1) → aplatir → Linear vers 102 classes.
  Voir nn.AdaptiveAvgPool2d et nn.Linear.

Fonction de perte : CrossEntropyLoss.

Hyperparamètres du modèle à régler (2) :

1. Taux de croissance G (nouveaux canaux ajoutés par bloc) : choisissez 12 ou 24.
2. Nombre de blocs K par dense block : choisissez 4 ou 6. Utilisez la même valeur K pour les trois dense blocks.

Remarques de mise en œuvre :

• Tenez un liste/concat des tenseurs à l’intérieur d’un dense block pour alimenter chaque bloc avec torch.cat (dimension canaux).
• Utilisez padding 1 pour toutes les convolutions 3×3 afin de conserver la taille spatiale à l’intérieur des dense blocks (la réduction spatiale ne se fait que dans les transitions).
• Gardez l’ordre BN → ReLU → Conv dans les blocs denses, comme décrit ci-dessus.

Projet 21 — Stanford Cars (196 modèles de voitures) avec tête à Spatial Pyramid Pooling (SPP)

Étudiant : OUEDERNI

Dataset : Stanford Cars, 196 classes de modèles de voitures, images couleur de tailles variées. Tâche : classification multiclasses.

Où le trouver : via torchvision.datasets.StanfordCars (annotations incluses) ou via un dataset équivalent sur HuggingFace. Redimensionnez (optionnel) ou travaillez en taille variable ; normalisez les images avec torchvision.transforms.

Concept (SPP) : la Spatial Pyramid Pooling produit un vecteur de taille fixe quelle que soit la taille d’entrée en appliquant plusieurs poolings avec des grilles de sortie différentes, puis en concaténant. Vous pouvez implémenter l’équivalent avec plusieurs nn.AdaptiveMaxPool2d aux tailles de sortie 1×1, 2×2 et 4×4, puis aplatir et concaténer.

Modèle à implémenter : CNN 2D en 3 stages, puis tête SPP.

• Entrée : image RGB 3×H×W (H et W variables ou fixées à 224).
• Couche d’initialisation : Conv 3×3 (padding 1, 64 canaux) → BatchNorm → ReLU.
• Stage 1 : deux blocs (Conv 3×3, 64 canaux → BatchNorm → ReLU), puis MaxPool 2×2.
• Stage 2 : deux blocs (Conv 3×3, 128 canaux → BatchNorm → ReLU), puis MaxPool 2×2.
• Stage 3 : deux blocs (Conv 3×3, 256 canaux → BatchNorm → ReLU).
• Tête SPP :
  • Trois branches de pooling : AdaptiveMaxPool2d(1), AdaptiveMaxPool2d(2), AdaptiveMaxPool2d(4).
  • Aplatissez chaque branche et concaténez (dimension totale = 256×(1×1 + 2×2 + 4×4) = 256×21).
  • Couche linéaire : (256×21) → 196.

Modules utiles : nn.Conv2d, nn.BatchNorm2d, nn.ReLU, nn.AdaptiveMaxPool2d, nn.Linear.

Fonction de perte : CrossEntropyLoss.

Hyperparamètres du modèle à régler (2) :

1. Nombre de blocs par stage : choisissez {2 ou 3} blocs Conv→BatchNorm→ReLU dans chacun des trois stages (si 3, ajoutez un bloc avant le pooling dans les stages 1 et 2, et à la fin du stage 3).
2. Type de pooling dans la tête SPP : choisissez entre {AdaptiveMaxPool2d ou AdaptiveAvgPool2d} pour les trois niveaux (1, 2, 4). Utilisez le même type pour tous les niveaux.

Projet 22 — CUB-200-2011 (oiseaux, 200 espèces) avec convolutions groupées (grouped convolutions)

Étudiant : DUMANGE

Dataset : CUB-200-2011, 200 classes d’oiseaux, images couleur, annotations disponibles. Tâche : classification multiclasses.

Où le trouver : via un dataset prêt à l’emploi sur HuggingFace (caltech_birds2011) ou depuis le site officiel. Redimensionnez les images à 224×224 et normalisez-les.

Concept : une grouped convolution divise les canaux d’entrée et de sortie en G groupes ; chaque groupe est convolué indépendamment (paramètre groups de nn.Conv2d). Cela réduit les connexions et le coût, et peut augmenter la diversité des filtres.

Modèle à implémenter : CNN 2D à 3 stages, où la deuxième convolution de chaque bloc est une grouped convolution.

• Entrée : 3×224×224.
• Couche d’initialisation : Conv 3×3 (64 canaux, padding 1) → BatchNorm → ReLU.
• Stage 1 : deux blocs identiques :
  • Conv 3×3 (64 → 64, padding 1) → BatchNorm → ReLU.
  • Conv 3×3 (64 → 64, padding 1, groups = G) → BatchNorm → ReLU.
  Puis MaxPool 2×2.
• Stage 2 : deux blocs identiques (canaux 128), même schéma, puis MaxPool 2×2.
• Stage 3 : deux blocs identiques (canaux 256), même schéma, puis Global Average Pooling et linéaire 256 → 200.

Remarque : pour que groups=G soit valide, le nombre de canaux de la convolution doit être divisible par G.

Fonction de perte : CrossEntropyLoss.

Hyperparamètres du modèle à régler (2) :

1. Nombre de groupes G dans les convolutions groupées : choisissez {2, 4}. Assurez-vous que 64, 128 et 256 sont divisibles par G.
2. Nombre de blocs par stage : choisissez {2 ou 3}. Si 3, ajoutez un bloc supplémentaire avant le pooling (stages 1 et 2) ou avant le GAP (stage 3).

Projet 23 — Tiny ImageNet (200 classes) avec blocs résiduels + Dropout2d dans les blocs

Étudiant : LAURET

Dataset : Tiny ImageNet, 200 classes, images 64×64. Tâche : classification multiclasses.

Où le trouver : via HuggingFace Datasets : zh-plus/tiny-imagenet. Normalisez les images (moyenne/écart-type RGB usuels).

Modèle à implémenter : réseau en blocs résiduels (deux convolutions 3×3 par bloc) avec insertion de nn.Dropout2d à l’intérieur des blocs pour régulariser.

• Entrée : 3×64×64.
• Couche initiale : Conv 3×3 (64 canaux, padding 1) → BatchNorm → ReLU.
• Bloc résiduel (forme générale) :
  • Conv 3×3 (C → C, stride 1, padding 1) → BatchNorm → ReLU → Dropout2d.
  • Conv 3×3 (C → C, stride 1, padding 1) → BatchNorm.
  • Addition résiduelle (projection 1×1 si changement de dimensions) → ReLU.
• Stage 1 : C=64, empilez B₁ blocs, stride 1.
• Stage 2 : C=128, premier bloc avec stride 2 (réduction spatiale), puis B₂−1 blocs stride 1.
• Stage 3 : C=256, même principe (stride 2 au premier bloc), total B₃ blocs.
• Tête : Global Average Pooling → linéaire 256 → 200.

Modules utiles : nn.Conv2d, nn.BatchNorm2d, nn.Dropout2d, nn.AdaptiveAvgPool2d, nn.Linear.

Fonction de perte : CrossEntropyLoss.

Hyperparamètres du modèle à régler (2) :

1. Taux de Dropout2d à l’intérieur des blocs : choisissez {0.1, 0.3} (même valeur dans tous les blocs).
2. Nombre de blocs par stage : choisissez (B₁, B₂, B₃) parmi {(2,2,2), (3,3,3)}.

Projet 24 — Caltech-101 (101 classes d’objets) avec blocs « inverted residual » (expansion 1×1 → depthwise 3×3 → projection 1×1)

Étudiant : RAMSIS

Dataset : Caltech-101, ~9 000 images, 101 classes + une classe arrière-plan (optionnelle). Tâche : classification multiclasses.

Où le trouver : via torchvision.datasets.Caltech101. Redimensionnez à 160×160 et normalisez.

Concept : un bloc inverted residual suit la séquence : (1) expansion 1×1 qui augmente le nombre de canaux d’un facteur t, (2) convolution depthwise 3×3 (groupes = canaux, voir groups dans nn.Conv2d), (3) projection 1×1 qui ramène à la largeur souhaitée. Si le stride vaut 1 et que les canaux d’entrée = canaux de sortie, ajoutez une connexion résiduelle (addition entrée + sortie).

Modèle à implémenter : enchaînement de stages de blocs inverted residual.

• Entrée : 3×160×160.
• Couche d’initialisation : Conv 3×3 (32 canaux, stride 2, padding 1) → BatchNorm → ReLU.
• Stage 1 : répéter R₁ blocs avec canaux de sortie = 32, stride 1.
• Stage 2 : premier bloc stride 2, canaux de sortie = 64 ; puis R₂−1 blocs stride 1 à 64 canaux.
• Stage 3 : premier bloc stride 2, canaux de sortie = 128 ; puis R₃−1 blocs stride 1 à 128 canaux.
• Tête : Global Average Pooling → linéaire 128 → 101.

Activations : utilisez ReLU6 (ou ReLU) après les convolutions 1×1 d’expansion et la depthwise 3×3 ; la projection 1×1 est suivie d’aucune activation. Voir nn.ReLU6.

Fonction de perte : CrossEntropyLoss.

Hyperparamètres du modèle à régler (2) :

1. Facteur d’expansion t dans les blocs inverted residual : choisissez {4, 6}. Le nombre de canaux dans la convolution depthwise est alors t × (canaux d’entrée du bloc).
2. Nombre de répétitions par stage : choisissez (R₁, R₂, R₃) parmi {(2,2,2), (3,3,3)}.

Projet 25 — EuroSAT RGB (classification de scènes satellitaires, 10 classes) avec convolutions dilatées au dernier stage

Étudiant : BEN-GELOUNE

Dataset : EuroSAT RGB, 10 classes (différents types d’occupation du sol), images 64×64 issues de Sentinel-2. Tâche : classification multiclasses.

Où le trouver : via un dataset prêt à l’emploi sur HuggingFace (eurosat, configuration rgb), ou via des miroirs publics. Les images sont 64×64 ; normalisez-les.

Concept : les convolutions dilatées (dilated) agrandissent le champ réceptif sans augmenter le nombre de paramètres (paramètre dilation de nn.Conv2d). Utilisez-les uniquement dans le dernier stage pour capter un contexte plus large.

Modèle à implémenter : CNN 2D en 3 stages (Conv→BatchNorm→ReLU répétés), dilatation au stage 3.

• Entrée : 3×64×64.
• Stage 1 : deux blocs, chacun : Conv 3×3 (64 canaux, stride 1, padding 1, dilation 1) → BatchNorm → ReLU ; puis MaxPool 2×2 après le second bloc.
• Stage 2 : deux blocs à 128 canaux, mêmes paramètres (dilation 1), puis MaxPool 2×2.
• Stage 3 : deux blocs à 256 canaux, chaque Conv 3×3 utilise dilation D et un padding égal à D pour conserver la taille (stride 1). Pas de MaxPool ici.
• Tête : Global Average Pooling → linéaire 256 → 10.

Modules utiles : nn.Conv2d (paramètres dilation et padding), nn.BatchNorm2d, nn.MaxPool2d, nn.AdaptiveAvgPool2d, nn.Linear.

Fonction de perte : CrossEntropyLoss.

Hyperparamètres du modèle à régler (2) :

1. Dilation D au stage 3 : choisissez {2, 3}. Ajustez le padding à D pour garder la même taille spatiale.
2. Nombre de blocs par stage : choisissez {2 ou 3}. Si 3, ajoutez un bloc supplémentaire (même configuration) avant le pooling des stages 1 et 2, et avant le GAP du stage 3.

# Exemple minimal (vous adapterez ces valeurs à votre projet)
dataset:
  name: "CIFAR100"
  root: "./data"
  download: true

model:
  type: "cnn_basic"
  num_classes: 100
  # hyperparamètres du modèle (exemples)
  channels: [64, 128, 256]
  blocks_per_stage: [2, 2, 2]

train:
  seed: 42
  batch_size: 64
  epochs: 20

paths:
  runs_dir: "./runs"
  artifacts_dir: "./artifacts"