Bien sûr. Petite correction d’abord : “RestNet50” → “ResNet50”.

Pour apprendre ces architectures sérieusement, je vous conseille de combiner article scientifique original + documentation d’implémentation + tutoriel pratique.

Ressources par architecture

Architecture	Article de référence	Documentation pratique
VGG16	Very Deep Convolutional Networks for Large-Scale Image Recognition — Simonyan & Zisserman. C’est l’article fondateur de VGG, basé notamment sur l’empilement de convolutions $3\times3$. (arXiv)	Keras VGG16 : API, poids ImageNet, prétraitement, transfer learning. (Keras) PyTorch/TorchVision VGG : implémentation officielle et modèles pré-entraînés. (PyTorch Docs)
ResNet50	Deep Residual Learning for Image Recognition — He et al. C’est la référence pour comprendre les skip/residual connections et le bloc résiduel $F(x)+x$. (CVF Open Access)	Keras ResNet50 : modèle, poids ImageNet et prétraitement. (Keras) TorchVision ResNet50 : documentation et implémentation officielle ; TorchVision précise aussi sa variante ResNet V1.5. (PyTorch Docs)
MobileNetV2	MobileNetV2: Inverted Residuals and Linear Bottlenecks — Sandler et al., CVPR 2018. À étudier pour les depthwise convolutions, les inverted residuals et les linear bottlenecks. (CVF Open Access)	Keras MobileNetV2 et explication des inverted residual blocks. (Keras) TorchVision MobileNetV2. (PyTorch Docs)
EfficientNet-B0	EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks — Tan & Le, ICML 2019. Le concept central est le compound scaling de la profondeur, de la largeur et de la résolution. (Proceedings of Machine Learning Research)	Keras EfficientNetB0 : modèle officiel et poids ImageNet. (Keras) TorchVision EfficientNet-B0 : modèle, poids et prétraitement. (PyTorch Docs)
YOLOv8-nano / YOLOv8n	Contrairement aux quatre précédents, Ultralytics n’a pas publié d’article scientifique formel consacré à YOLOv8 ; l’entreprise recommande sa documentation et son dépôt comme références. (Ultralytics Docs)	La documentation officielle YOLOv8 existe en français et contient spécifiquement yolov8n.pt, ainsi que les variantes détection, segmentation, classification, pose et OBB. (Ultralytics Docs)

Les meilleurs cours et tutoriels pour accompagner ces lectures

1. Stanford CS231n — Deep Learning for Computer Vision
C’est probablement l’une des meilleures ressources universitaires pour comprendre en profondeur les CNN, la classification d’images et les architectures modernes. La version Stanford 2026 est actuellement disponible sur le site officiel du cours. (CS231n) Vous pouvez notamment consulter leur cours consacré aux CNN architectures, utile pour replacer VGG et ResNet dans l’évolution des architectures. (CS231n)

2. DeepLearning.AI — Deep Learning Specialization
Très bon choix si vous préférez un parcours pédagogique progressif. La spécialisation comprend notamment un cours consacré aux Convolutional Neural Networks et traite de la construction et de l’entraînement des CNN. (DeepLearning.AI)

3. Tutoriel officiel TensorFlow — Transfer Learning avec MobileNetV2
Particulièrement intéressant après avoir étudié MobileNetV2 : TensorFlow montre comment charger le réseau pré-entraîné, l’utiliser comme extracteur de caractéristiques, puis effectuer du fine-tuning. (TensorFlow)

4. Guide officiel Keras — Transfer Learning & Fine-Tuning
À lire si vous voulez appliquer VGG16, ResNet50, MobileNetV2 ou EfficientNet-B0 à votre propre dataset sans repartir d’un entraînement complet depuis zéro. (Keras)

Ordre d’apprentissage que je vous recommande

Je les étudierais dans cet ordre :

VGG16 → ResNet50 → MobileNetV2 → EfficientNet-B0 → YOLOv8n

Cet ordre permet de suivre assez naturellement l’évolution des idées :

VGG16
→ comprendre les blocs convolutionnels classiques, pooling, profondeur et extraction hiérarchique de caractéristiques. (arXiv)

ResNet50
→ comprendre pourquoi augmenter simplement la profondeur devient difficile, puis comment les connexions résiduelles permettent d’entraîner des réseaux beaucoup plus profonds. (CVF Open Access)

MobileNetV2
→ comprendre comment rendre un CNN beaucoup plus léger grâce aux convolutions depthwise separable et aux inverted residuals. (CVF Open Access)

EfficientNet-B0
→ comprendre comment optimiser simultanément largeur + profondeur + résolution, au lieu d’agrandir arbitrairement une seule dimension du réseau. (Proceedings of Machine Learning Research)

YOLOv8n
→ passer de la classification d’images aux problèmes de détection d’objets, avec un modèle conçu pour un bon compromis rapidité/accuracy et une tête de détection anchor-free. (Ultralytics Docs)

Si votre objectif est un projet universitaire, mémoire ou PFE, je peux aussi vous préparer un parcours beaucoup plus précis : pour chacune des 5 architectures, architecture couche par couche + schéma + concepts à comprendre + article à lire + tutoriel Python/PyTorch ou TensorFlow + exercices pratiques.

Oui. Et le point le plus important est le suivant : le fichier CSV ne contient généralement pas les images. Pour rendre votre dataset réellement portable, il faut conserver les images + le CSV dans une même arborescence, et mettre dans le CSV uniquement des chemins relatifs.

Pour un dataset de classification CNN, je vous recommande cette structure :

text
mon_dataset/
│
├── dataset.csv
│
├── images/
│   ├── train/
│   │   ├── classe_1/
│   │   ├── classe_2/
│   │   └── classe_3/
│   │
│   ├── val/
│   │   ├── classe_1/
│   │   ├── classe_2/
│   │   └── classe_3/
│   │
│   └── test/
│       ├── classe_1/
│       ├── classe_2/
│       └── classe_3/
│
└── README.txt

Votre CSV peut alors ressembler à ceci :

csv
image_path,label,split
images/train/chat/img_001.jpg,chat,train
images/train/chat/img_002.jpg,chat,train
images/train/chien/img_003.jpg,chien,train
images/val/chat/img_101.jpg,chat,val
images/test/chien/img_201.jpg,chien,test

Ainsi, si vous envoyez le dossier mon_dataset à votre ami ou si vous le copiez sur un autre PC, aucun chemin absolu du type :

text
C:\Users\Ahmed\Desktop\dataset\...

ne sera enregistré. C'est ce qui rend le dataset portable.

Étape 1 — Vérifier l'organisation actuelle

Supposons que votre dataset soit déjà partitionné comme ceci :

text
dataset_original/
├── train/
│   ├── cats/
│   ├── dogs/
│   └── birds/
├── val/
│   ├── cats/
│   ├── dogs/
│   └── birds/
└── test/
    ├── cats/
    ├── dogs/
    └── birds/

C'est déjà une excellente organisation pour commencer.

Vous n'avez pas besoin de déplacer les images si cette structure vous convient.

---

Étape 2 — Créer automatiquement le CSV

Voici un script Python simple :

python
from pathlib import Path
import pandas as pd

# Chemin vers le dossier principal du dataset
dataset_dir = Path("dataset_original")

data = []

# Partitions attendues
splits = ["train", "val", "test"]

# Extensions acceptées
extensions = {".jpg", ".jpeg", ".png", ".bmp", ".webp"}

for split in splits:

    split_dir = dataset_dir / split

    if not split_dir.exists():
        continue

    # Chaque sous-dossier représente une classe
    for class_dir in split_dir.iterdir():

        if not class_dir.is_dir():
            continue

        label = class_dir.name

        for image_path in class_dir.rglob("*"):

            if image_path.suffix.lower() in extensions:

                relative_path = image_path.relative_to(dataset_dir)

                data.append({
                    "image_path": relative_path.as_posix(),
                    "label": label,
                    "split": split
                })

# Création du DataFrame
df = pd.DataFrame(data)

# Sauvegarde
csv_path = dataset_dir / "dataset.csv"

df.to_csv(csv_path, index=False)

print(f"CSV créé : {csv_path}")
print(f"Nombre total d'images : {len(df)}")
print(df.head())

Le résultat sera par exemple :

text
                         image_path    label  split
0  train/cats/cat_001.jpg             cats   train
1  train/cats/cat_002.jpg             cats   train
2  train/dogs/dog_001.jpg             dogs   train
3  val/cats/cat_100.jpg               cats   val
4  test/dogs/dog_200.jpg              dogs   test

---

Étape 3 — Pourquoi utiliser des chemins relatifs ?

Prenons cette ligne :

csv
train/cats/cat_001.jpg,cats,train

Sur votre PC, votre dataset peut être situé ici :

text
D:\DeepLearning\dataset_original\

Sur le PC de votre ami :

text
C:\Users\Ali\Documents\dataset_original\

Sur Google Colab :

text
/content/dataset_original/

Cela ne pose aucun problème.

Dans Python, on reconstruit simplement le chemin complet :

python
from pathlib import Path

dataset_dir = Path("dataset_original")

image_relative_path = "train/cats/cat_001.jpg"

image_path = dataset_dir / image_relative_path

print(image_path)

Vous obtenez automatiquement :

text
dataset_original/train/cats/cat_001.jpg

C'est beaucoup mieux qu'enregistrer dans le CSV :

text
D:\DeepLearning\dataset_original\train\cats\cat_001.jpg

car ce chemin ne fonctionnerait que sur votre ordinateur.

---

Étape 4 — Vérifier le CSV

Je vous conseille de faire quelques contrôles avant de commencer vos CNN.

python
import pandas as pd

df = pd.read_csv("dataset_original/dataset.csv")

print(df.head())
print()
print(df.info())

Vous pouvez regarder les classes :

python
print(df["label"].value_counts())

Par exemple :

text
cats     1500
dogs     1480
birds    1420

Puis vérifier les partitions :

python
print(df["split"].value_counts())

Par exemple :

text
train    3080
val       660
test      660

Encore plus intéressant :

python
print(
    pd.crosstab(
        df["label"],
        df["split"]
    )
)

Vous pourriez obtenir :

text
split   test  train  val
label
birds    210   1000  210
cats     225   1050  225
dogs     225   1030  225

Cela permet de vérifier immédiatement si les classes sont correctement réparties.

---

Étape 5 — Vérifier que toutes les images existent

C'est une étape que je recommande fortement.

python
from pathlib import Path
import pandas as pd

dataset_dir = Path("dataset_original")

df = pd.read_csv(dataset_dir / "dataset.csv")

missing_files = []

for relative_path in df["image_path"]:

    full_path = dataset_dir / relative_path

    if not full_path.exists():
        missing_files.append(relative_path)

print(f"Images manquantes : {len(missing_files)}")

if missing_files:
    print(missing_files[:10])

Vous voulez idéalement obtenir :

text
Images manquantes : 0

---

Étape 6 — Utiliser directement ce CSV pour vos CNN

Votre organisation devient alors indépendante de VGG16, ResNet50, MobileNetV2 ou EfficientNet-B0.

Vous pourrez utiliser exactement le même CSV pour tous vos modèles.

Par exemple :

python
df = pd.read_csv("dataset_original/dataset.csv")

train_df = df[df["split"] == "train"].copy()
val_df   = df[df["split"] == "val"].copy()
test_df  = df[df["split"] == "test"].copy()

Vous obtenez alors trois DataFrames :

python
print(len(train_df))
print(len(val_df))
print(len(test_df))

Ils pourront être utilisés pour construire vos DataLoaders PyTorch ou vos pipelines TensorFlow/Keras.

---

Étape 7 — Encoder les classes

Pour entraîner un CNN, vous aurez souvent besoin de convertir :

text
cat
dog
bird

en nombres :

text
cat  -> 0
dog  -> 1
bird -> 2

Vous pouvez ajouter une colonne class_id.

python
classes = sorted(df["label"].unique())

class_to_id = {
    class_name: idx
    for idx, class_name in enumerate(classes)
}

df["class_id"] = df["label"].map(class_to_id)

print(class_to_id)

Par exemple :

python
{
    "bird": 0,
    "cat": 1,
    "dog": 2
}

Votre CSV devient :

csv
image_path,label,class_id,split
train/cats/cat_001.jpg,cat,1,train
train/dogs/dog_001.jpg,dog,2,train
train/birds/bird_001.jpg,bird,0,train
val/cats/cat_100.jpg,cat,1,val

Je préfère cette version :

text
image_path | label | class_id | split

car elle est très pratique pour le Deep Learning.

---

Étape 8 — Sauvegarder également la correspondance des classes

Vous pouvez créer un deuxième petit fichier :

text
classes.csv

avec :

csv
class_id,class_name
0,bird
1,cat
2,dog

Python :

python
classes_df = pd.DataFrame({
    "class_id": list(class_to_id.values()),
    "class_name": list(class_to_id.keys())
})

classes_df.to_csv(
    dataset_dir / "classes.csv",
    index=False
)

Vous aurez donc :

text
dataset_original/
│
├── dataset.csv
├── classes.csv
│
├── train/
├── val/
└── test/

C'est particulièrement utile lorsque vous entraînerez plusieurs architectures.

---

Étape 9 — Préparer le dataset à partager

Une fois terminé, compressez simplement le dossier complet :

text
dataset_original.zip

Il doit contenir :

text
dataset_original.zip
│
└── dataset_original/
    ├── dataset.csv
    ├── classes.csv
    ├── train/
    ├── val/
    └── test/

Votre ami décompresse :

text
dataset_original.zip

puis fait simplement :

python
import pandas as pd
from pathlib import Path

DATASET_ROOT = Path("dataset_original")

df = pd.read_csv(DATASET_ROOT / "dataset.csv")

Et toutes les images pourront être retrouvées avec :

python
image_path = DATASET_ROOT / df.iloc[0]["image_path"]

Aucun changement manuel du CSV n'est nécessaire.

---

Structure que je vous recommande pour votre projet CNN

Si vous prévoyez de comparer VGG16, ResNet50, MobileNetV2 et EfficientNet-B0, je structurerais votre projet comme ceci :

text
mon_projet/
│
├── dataset/
│   ├── dataset.csv
│   ├── classes.csv
│   ├── train/
│   ├── val/
│   └── test/
│
├── notebooks/
│   ├── 01_exploration.ipynb
│   ├── 02_vgg16.ipynb
│   ├── 03_resnet50.ipynb
│   ├── 04_mobilenetv2.ipynb
│   └── 05_efficientnet_b0.ipynb
│
├── models/
│
├── results/
│
└── README.md

Le principe devient :

text
                    dataset.csv
                         │
             ┌───────────┼───────────┐
             ↓           ↓           ↓
           train        val        test
             │           │           │
             └───────────┼───────────┘
                         ↓
                  preprocessing
                         ↓
       ┌─────────────────┼──────────────────┐
       ↓                 ↓                  ↓
     VGG16           ResNet50         MobileNetV2
                                             ↓
                                      EfficientNet-B0

Cela permet d'utiliser exactement les mêmes images et partitions pour chaque architecture, ce qui est important pour comparer correctement leurs performances.

Mon format de CSV recommandé

Je partirais finalement sur ceci :

csv
image_path,label,class_id,split
train/cats/cat_001.jpg,cat,0,train
train/cats/cat_002.jpg,cat,0,train
train/dogs/dog_001.jpg,dog,1,train
val/cats/cat_101.jpg,cat,0,val
test/dogs/dog_201.jpg,dog,1,test

C'est simple, lisible, compatible Windows/Linux/Colab, facile à partager, et très facile à utiliser ensuite avec PyTorch, TensorFlow/Keras, VGG16, ResNet50, MobileNetV2 et EfficientNet-B0.

Une précision importante : si par « annoté » vous voulez dire détection d'objets avec des bounding boxes plutôt que simple classification par classe, alors il faudra un CSV légèrement différent avec, par exemple, xmin, ymin, xmax, ymax et class_id. Pour YOLOv8, la structure sera également différente.