L'utilisation de MATLAB pour la classification d'images par apprentissage profond représente un processus puissant et relativement intuitif, même pour les débutants qui peuvent rapidement construire et déployer des modèles avec son aide.

Les étapes principales et les fonctions clés impliquées dans la classification d'images par apprentissage profond avec MATLAB :

Préparation et prétraitement des données

Une bonne qualité de données est la base essentielle pour un entraînement de modèle réussi.

1. Organisation des données : Placez les images dans des sous-dossiers distincts pour chaque catégorie, où le nom du dossier correspond à l'étiquette de la catégorie. Par exemple :

jeu_donnees/
    entrainement/
        chat/
            chat001.jpg
            ...
        chien/
            chien001.jpg
            ...
    validation/
        chat/
            ...
        chien/
            ...
    test/
        chat/
            ...
        chien/
            ...

Cette approche permet à imageDatastore de récupérer automatiquement les étiquettes. 2. Chargement des données : Utilisez imageDatastore pour charger les données d'images.

imds = imageDatastore('chemin/vers/vos/donnees', ...
    'IncludeSubfolders', true, ...
    'LabelSource', 'foldernames');

3. Division de l'ensemble de données : Divisez les données en ensembles d'entraînement, de validation et de test.

[imdsEntrainement, imdsValidation, imdsTest] = splitEachLabel(imds, 0.7, 0.15, 0.15, 'randomized');

4. Prétraitement et augmentation des données : Utilisez augmentedImageDatastore pour le redimensionnement des images et l'augmentation, ce qui aide à augmenter la diversité des données et à prévenir le surapprentissage.

tailleImage = [224 224 3]; % Taille d'entrée courante pour les réseaux, comme ImageNet
augimdsEntrainement = augmentedImageDatastore(tailleImage, imdsEntrainement, ...
    'ColorPreprocessing', 'gray2rgb', ... % Conversion en RGB tricanal si les images originales sont en niveaux de gris
    'DataAugmentation', imageDataAugmenter('RandRotation',[-20,20], ... % Rotation aléatoire
    'RandXReflection', true, ... % Retournement horizontal aléatoire
    'RandXTranslation',[-10 10], 'RandYTranslation',[-10 10])); % Translation aléatoire

Pour les ensembles de validation et de test, on effectue généralement seulement un redimensionnement et une normalisation, sans augmentation des données.

Construction du modèle d'apprentissage profond

Vous pouvez choisir de construire un réseau de neurones convolutionnel (CNN) à partir de zéro ou d'utiliser l'apprentissage par transfert avec des modèles pré-entraînés.

• Construction d'un CNN à partir de zéro (adapté aux tâches simples ou lorsque la quantité de données est faible) :

couches = [
    imageInputLayer([28 28 1]) % Couche d'entrée, spécifiant la taille des images
    convolution2dLayer(3, 8, 'Padding', 'same') % Couche de convolution
    batchNormalizationLayer   % Couche de normalisation par lots
    reluLayer                 % Couche d'activation ReLU
    maxPooling2dLayer(2, 'Stride', 2) % Couche de max pooling
    convolution2dLayer(3, 16, 'Padding', 'same')
    batchNormalizationLayer
    reluLayer
    fullyConnectedLayer(10)   % Couche entièrement connectée, nombre de nœuds de sortie correspondant au nombre de classes
    softmaxLayer              % Couche Softmax
    classificationLayer];     % Couche de classification

C'est un exemple simple, vous pouvez augmenter le nombre de couches de convolution, couches entièrement connectées, etc. selon vos besoins.

• Apprentissage par transfert (fortement recommandé, surtout si vous n'avez pas une quantité de données particulièrement importante) :

net = googlenet; % Chargement du modèle GoogLeNet pré-entraîné, d'autres options comme resnet50, efficientnetb0, etc.
grapheCouches = layerGraph(net); % Obtention du graphe des couches du réseau
% Modification des dernières couches entièrement connectées et de classification pour s'adapter à votre nombre de classes
nbClasses = numel(categories(imdsEntrainement.Etiquettes));
nouvelleCoucheFC = fullyConnectedLayer(nbClasses, 'Name', 'nouvelle_fc');
nouvelleCoucheClassif = classificationLayer('Name', 'nouvelle_sortie_classif');
grapheCouches = replaceLayer(grapheCouches, 'loss3-classifier', nouvelleCoucheFC);
grapheCouches = replaceLayer(grapheCouches, 'output', nouvelleCoucheClassif);
% Configuration des options d'entraînement, généralement avec un taux d'apprentissage plus faible pour le réglage fin
options = trainingOptions('adam', ...
    'InitialLearnRate', 0.0001, ... % Le taux d'apprentissage est généralement plus faible pour le réglage fin
    ... % Autres options
    );

Configuration des options d'entraînement et entraînement du modèle

Utilisez la fonction trainingOptions pour configurer les paramètres d'entraînement.

options = trainingOptions('sgdm', ... % Algorithme d'optimisation, peut aussi être 'adam', 'rmsprop', etc.
    'MaxEpochs', 10, ...              % Nombre maximal d'époques d'entraînement
    'MiniBatchSize', 32, ...          % Taille des mini-lots
    'InitialLearnRate', 0.001, ...    % Taux d'apprentissage initial
    'ValidationData', augimdsValidation, ... % Spécification des données de validation
    'ValidationFrequency', 50, ...    % Validation effectuée à quelle fréquence (en itérations)
    'Verbose', false, ...             % Affichage ou non du processus d'entraînement dans la fenêtre de commande
    'Plots', 'training-progress');    % Affichage du graphique de progression d'entraînement

Utilisez la fonction trainNetwork pour commencer l'entraînement du modèle.

net = trainNetwork(augimdsEntrainement, couches, options); % Pour l'entraînement à partir de zéro
% Ou pour l'apprentissage par transfert
net = trainNetwork(augimdsEntrainement, grapheCouches, options);

Pendant l'entraînement, MATLAB affiche un graphique de progression où vous pouvez observer en temps réel les changements de précision et de perte sur les ensembles d'entraînement et de validation.

Évaluation des performances et prédiction

Une fois l'entraînement terminé, vous devez évaluer les performances finales du modèle sur un ensemble de test indépendant.

% Effectue des prédictions de classification sur l'ensemble de test
[YPrevue, scores] = classify(net, augimdsTest);
YTest = imdsTest.Etiquettes; % Récupère les étiquettes réelles de l'ensemble de test

% Calcule la précision
precision = mean(YPrevue == YTest);
fprintf('Précision du test : %.2f%%\n', precision * 100);

% Dessine une matrice de confusion pour analyser la classification de chaque catégorie
figure;
confusionchart(YTest, YPrevue);
title('Matrice de confusion pour les données de test');

Le modèle entraîné peut être utilisé pour prédire de nouvelles images.

% Prédiction pour une image unique
img = imread('chemin/vers/votre_nouvelle_image.jpg');
imgRedimensionnee = imresize(img, net.Couches(1).TailleEntree(1:2)); % Redimensionnement à la taille d'entrée du réseau
[etiquette, score] = classify(net, imgRedimensionnee);

% Affichage de l'image et du résultat de prédiction
figure;
imshow(img);
title(['Prédit : ', char(etiquette), ', Confiance : ', num2str(max(score)*100, '%.2f'), '%']);

Conseils pratiques et points d'attention

• Les données sont essentielles : La qualité, la quantité et la diversité des données influencent directement les performances du modèle. L'augmentation des données est un moyen efficace d'améliorer la capacité de généralisation du modèle.
• Commencez par l'apprentissage par transfert : Sauf si vous disposez d'une quantité massive de données, commencer avec des modèles pré-entraînés (comme GoogLeNet, ResNet, EfficientNet, etc.) pour le réglage fin est généralement plus rapide et plus efficace que l'entraînement à partir de zéro.
• Utilisez l'accélération GPU : Si vous avez un GPU, MATLAB essaie automatiquement de l'utiliser pour accélérer l'entraînement (nécessite la Parallel Computing Toolbox).
• Ajustement des hyperparamètres : Le taux d'apprentissage (InitialLearnRate), la taille de lot (MiniBatchSize), le nombre d'époques (MaxEpochs) sont des hyperparamètres importants qui doivent être ajustés selon la situation. Vous pouvez utiliser l'application Experiment Manager de MATLAB pour effectuer systématiquement l'ajustement des hyperparamètres.
• Comprendre le surapprentissage : Si la précision d'entraînement est élevée mais que la précision de validation/test est faible, le modèle est probablement en surapprentissage. Vous pouvez y remédier en augmentant l'augmentation des données, en ajoutant des couches Dropout, en utilisant une régularisation L2, en réduisant la complexité du modèle ou en arrêtant l'entraînement prématurément.
• Visualisation et interprétabilité : Utilisez des outils comme Grad-CAM pour visualiser les régions de l'image que le réseau prend en compte, ce qui aide à comprendre les décisions du modèle et à le déboguer.

Exploration avancée

Lorsque vous maîtrisez le processus de base, vous pouvez également explorer :

• Utilisation de l'application Deep Network Designer : Concevoir, modifier et entraîner des réseaux via une interface graphique en mode glisser-déposer, très adoptée aux débutants pour comprendre visuellement la structure des réseaux.
• Autres tâches de vision par ordinateur : Comme la détection d'objets (en utilisant trainFasterRCNNObjectDetector ou trainYOLOv2ObjectDetector), la segmentation sémantique, etc.
• Déploiement du modèle : Déployer le modèle entraîné sur des dispositifs embarqués, des systèmes d'entreprise ou générer du code.