Tutoriel : Inspection visuelle automatisée à l’aide de l’apprentissage de transfert avec l’API de classification d’images ML.NET

Article
06/01/2023

Découvrez comment entraîner un modèle Deep Learning personnalisé à l’aide de l’apprentissage de transfert, d’un modèle TensorFlow préentraîné et de l’API de classification d’images ML.NET pour classer les images de surfaces en béton comme étant fissurées ou non.

Dans ce tutoriel, vous allez apprendre à :

Comprendre le problème
En savoir plus sur l’API de classification d’images ML.NET
Comprendre le modèle préentraîné
Utiliser l’apprentissage de transfert pour entraîner un modèle de classification d’images TensorFlow personnalisé
Classifier des images avec le modèle personnalisé

Prérequis

Visual Studio 2022.

Vue d’ensemble de l’exemple d’apprentissage de transfert de classification d’images

Cet exemple est une application console .NET Core C# qui classifie les images à l’aide d’un modèle Deep Learning TensorFlow préentraîné. Le code de cet exemple se trouve dans le navigateur d’exemples.

Comprendre le problème

La classification d’images est un problème de vision par ordinateur. La classification d’images prend une image comme entrée et la catégorise dans une classe prescrite. Des modèles de classification d’images sont couramment formés à l’aide du Deep Learning et des réseaux neuronaux. Pour plus d’informations, consultez Deep Learning et Machine Learning.

Voici quelques scénarios dans lesquels la classification d’images est utile :

Reconnaissance faciale
Détection d’émotions
Diagnostic médical
Détection de points de repère

Ce tutoriel entraîne un modèle de classification d’images personnalisé pour effectuer une inspection visuelle automatisée de ponts afin d’identifier les structures endommagées par des fissures.

API de classification d’images ML.NET

ML.NET fournit différentes façons d’effectuer la classification d’images. Ce tutoriel applique l’apprentissage de transfert à l’aide de l’API Classification d’images. L’API Classification d’images utilise TensorFlow.NET, une bibliothèque de bas niveau qui fournit des liaisons C# pour l’API C++ TensorFlow.

Qu’est-ce que l’apprentissage de transfert ?

L’apprentissage de transfert applique les connaissances acquises lors de la résolution d’un problème à un problème connexe.

L’entraînement d’un modèle de deep learning à partir de zéro nécessite la définition de plusieurs paramètres, une grande quantité de données d’entraînement étiquetées et une grande quantité de ressources de calcul (des centaines d’heures de GPU). L’utilisation d’un modèle préentraîné avec l’apprentissage de transfert vous permet de raccourcir le processus d’entraînement.

Processus d’entraînement

L’API Classification d’images démarre le processus d’entraînement en chargeant un modèle TensorFlow préentraîné. Le processus d’apprentissage se compose de deux étapes :

Phase de goulot d’étranglement
Phase d’apprentissage

Étapes de formation

Phase de goulot d’étranglement

Pendant la phase de goulot d’étranglement, l’ensemble d’images d’entraînement est chargé, et les valeurs de pixels sont utilisées en tant qu’entrée, ou caractéristiques, pour les couches figées du modèle préentraîné. Les couches figées incluent toutes les couches du réseau neuronal jusqu’à l’avant-dernière couche, qu’on appelle de façon informelle couche de goulot d’étranglement. Ces couches sont appelées figées, car aucun entraînement ne se produit sur ces couches, et les opérations sont directes. C’est au niveau de ces couches figées que les modèles de niveau inférieur qui aident un modèle à différencier les différentes classes sont calculés. Plus le nombre de couches est élevé, plus cette étape est gourmande en ressources de calcul. Heureusement, comme il s’agit d’un calcul à usage unique, les résultats peuvent être mis en cache et utilisés dans les exécutions ultérieures lors de l’expérimentation de différents paramètres.

Phase d’apprentissage

Une fois les valeurs de sortie de la phase de goulot d’étranglement calculées, elles sont utilisées comme entrée pour réentraîner la couche finale du modèle. Ce processus est itératif et s’exécute pour le nombre de fois spécifié par les paramètres de modèle. Au cours de chaque exécution, la perte et la précision sont évaluées. Ensuite, les ajustements appropriés sont effectués pour améliorer le modèle dans le but de minimiser la perte et d’optimiser la précision. Une fois l’entraînement terminé, deux formats de modèle sont générés. L’une d’elles est la version .pb du modèle, et l’autre est la version sérialisée ML.NET .zip du modèle. Lorsque vous travaillez dans des environnements pris en charge par ML.NET, il est recommandé d’utiliser la version .zip du modèle. Toutefois, dans les environnements où ML.NET n’est pas pris en charge, vous avez la possibilité d’utiliser la version .pb.

Comprendre le modèle préentraîné

Le modèle préentraîné utilisé dans ce tutoriel est la variante à 101 couches du modèle Réseau résiduel (ResNet) v2. Le modèle d’origine est entraîné pour classifier les images en mille catégories. Le modèle prend comme entrée une image de taille 224 x 224 et génère les probabilités de classe pour chacune des classes sur lesquelles il est entraîné. Une partie de ce modèle est utilisée pour entraîner un nouveau modèle à l’aide d’images personnalisées, afin d’effectuer des prédictions entre deux classes.

Création d’une application de console

Maintenant que vous avez une compréhension générale de l’apprentissage de transfert et de l’API Classification d’images, il est temps de créer l’application.

Créez une application console C# appelée « DeepLearning_ImageClassification_Binary ». Cliquez sur le bouton Suivant.
Choisissez .NET 6 comme framework à utiliser. Cliquez sur le bouton Créer.
Installez le package NuGet Microsoft.ML :

Notes

Cet exemple utilise la dernière version stable des packages NuGet mentionnés, sauf indication contraire.
1. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur votre projet, puis sélectionnez Gérer les packages NuGet.
2. Choisissez « nuget.org » comme source du package.
3. Sélectionnez l’onglet Parcourir.
4. Cochez la case Inclure la préversion.
5. Recherchez Microsoft.ML.
6. Sélectionnez le bouton Installer.
7. Cliquez sur le bouton OK dans la boîte de dialogue Aperçu des modifications, puis sur le bouton J’accepte dans la boîte de dialogue Acceptation de la licence si vous acceptez les termes du contrat de licence pour les packages répertoriés.
8. Répétez ces étapes pour les packages NuGet Microsoft.ML.Vision, SciSharp.TensorFlow.Redist version 2.3.1 et Microsoft.ML.ImageAnalytics.

Préparer et comprendre les données

Notes

Les jeux de données de ce tutoriel proviennent de Maguire, Marc; Dorafshan, Sattar; and Thomas, Robert J., « SDNET2018: A concrete crack image dataset for machine learning applications » (2018). Browse all Datasets. Paper 48. https://digitalcommons.usu.edu/all_datasets/48

SDNET2018 est un jeu de données d’image qui contient des annotations pour les structures en béton fissurées et non fissurées (ponts, murs et trottoirs).

Exemples de pont de jeu de données SDNET2018

Les données sont organisées en trois sous-répertoires :

D contient des images de ponts
P contient des images de trottoirs
W contient des images de murs

Chacun de ces sous-répertoires contient deux sous-répertoires préfixés supplémentaires :

C est le préfixe utilisé pour les surfaces fissurées
U est le préfixe utilisé pour les surfaces non fissurées

Dans ce tutoriel, seules des images de pont sont utilisées.

Téléchargez le jeu de données et décompressez-le.
Créez un répertoire nommé « assets » dans votre projet pour enregistrer vos fichiers de jeu de données.
Copiez les sous-répertoires CD et UD du répertoire que vous venez de décompresser vers le répertoire assets.

Créer des classes d’entrée et de sortie

Ouvrez le fichier Program.cs et remplacez les instructions using existantes en haut du fichier par les éléments suivants :

using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using Microsoft.ML;
using static Microsoft.ML.DataOperationsCatalog;
using Microsoft.ML.Vision;

Sous la classe Program dans Program.cs, créez une classe appelée ImageData. Cette classe est utilisée pour représenter les données initialement chargées.
```
class ImageData
{
    public string ImagePath { get; set; }

    public string Label { get; set; }
}
```
ImageData contient les propriétés suivantes :
- ImagePath est le chemin d’accès complet où l’image est stockée.
- Label est la catégorie à laquelle appartient l’image. Il s’agit de la valeur à prédire.
Créer des classes pour vos données d’entrée et de sortie
1. Sous la classe ImageData, définissez le schéma de vos données d’entrée dans une nouvelle classe appelée ModelInput.
```
class ModelInput
{
    public byte[] Image { get; set; }
    
    public UInt32 LabelAsKey { get; set; }

    public string ImagePath { get; set; }

    public string Label { get; set; }
}
```
  ModelInput contient les propriétés suivantes :
  - Image est la représentation byte[] de l’image. Le modèle s’attend à ce que les données d’image soient de ce type pour l’entraînement.
  - LabelAsKey est la représentation numérique du Label.
  - ImagePath est le chemin d’accès complet où l’image est stockée.
  - Label est la catégorie à laquelle appartient l’image. Il s’agit de la valeur à prédire.
  Seuls Image et LabelAsKey sont utilisés pour entraîner le modèle et effectuer des prédictions. Les propriétés ImagePath et Label sont conservées par commodité pour accéder au nom et à la catégorie du fichier image d’origine.
2. Ensuite, sous la classe ModelInput, définissez le schéma de vos données de sortie dans une nouvelle classe appelée ModelOutput.
```
class ModelOutput
{
    public string ImagePath { get; set; }

    public string Label { get; set; }

    public string PredictedLabel { get; set; }
}
```
  ModelOutput contient les propriétés suivantes :
  - ImagePath est le chemin d’accès complet où l’image est stockée.
  - Label est la catégorie d’origine à laquelle appartient l’image. Il s’agit de la valeur à prédire.
  - PredictedLabel est la valeur prédite par le modèle.
  Comme pour ModelInput, seul le PredictedLabel est requis pour effectuer des prédictions, car il contient la prédiction effectuée par le modèle. Les propriétés ImagePath et Label sont conservées par commodité pour accéder au nom et à la catégorie du fichier image d’origine.

Créer un répertoire d’espace de travail

Lorsque les données d’entraînement et de validation ne changent pas souvent, il est recommandé de mettre en cache les valeurs de goulot d’étranglement calculées pour les exécutions ultérieures.

Dans votre projet, créez un répertoire appelé workspace pour stocker les valeurs de goulot d’étranglement calculées et la version .pb du modèle.

Définir des chemins d’accès et initialiser les variables

Sous les instructions using, définissez l’emplacement de vos ressources, les valeurs de goulot d’étranglement calculées et la version .pb du modèle.

var projectDirectory = Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "../../../"));
var workspaceRelativePath = Path.Combine(projectDirectory, "workspace");
var assetsRelativePath = Path.Combine(projectDirectory, "assets");

Initialiser la variable mlContext avec une nouvelle instance de MLContext.
```
MLContext mlContext = new MLContext();
```
La classe MLContext est un point de départ pour toutes les opérations ML.NET, et l’initialisation de mlContext crée un environnement ML.NET qui peut être partagé par les objets de flux de travail de création de modèle. Sur le plan conceptuel, elle est similaire à DbContext dans Entity Framework.

Chargement des données

Créer une méthode d’utilitaire de chargement de données

Les images sont stockées dans deux sous-répertoires. Avant de charger les données, elles doivent être mises en forme dans une liste d’objets ImageData. Pour cela, créez la méthode LoadImagesFromDirectory.

IEnumerable<ImageData> LoadImagesFromDirectory(string folder, bool useFolderNameAsLabel = true)
{

}

À l’intérieur de LoadImagesFromDirectory, ajoutez le code suivant pour obtenir tous les chemins d’accès aux fichiers des sous-répertoires :
```
var files = Directory.GetFiles(folder, "*",
    searchOption: SearchOption.AllDirectories);
```
Ensuite, effectuez une itération dans chacun des fichiers à l’aide d’une instruction foreach.
```
foreach (var file in files)
{

}
```
Dans l’instruction foreach, vérifiez que les extensions de fichier sont prises en charge. L’API Classification d’images prend en charge les formats JPEG et PNG.
```
if ((Path.GetExtension(file) != ".jpg") && (Path.GetExtension(file) != ".png"))
    continue;
```

Ensuite, obtenez l’étiquette du fichier. Si le paramètre useFolderNameAsLabel est défini sur true, le répertoire parent où le fichier est enregistré est utilisé comme étiquette. Sinon, il s’attend à ce que l’étiquette soit un préfixe du nom de fichier ou du nom de fichier lui-même.

var label = Path.GetFileName(file);

if (useFolderNameAsLabel)
    label = Directory.GetParent(file).Name;
else
{
    for (int index = 0; index < label.Length; index++)
    {
        if (!char.IsLetter(label[index]))
        {
            label = label.Substring(0, index);
            break;
        }
    }
}

Enfin, créez une instance de ModelInput.

yield return new ImageData()
{
    ImagePath = file,
    Label = label
};

Préparer les données

Appelez la méthode utilitaire LoadImagesFromDirectory pour obtenir la liste des images utilisées pour l’entraînement après l’initialisation de la variable mlContext.
```
IEnumerable<ImageData> images = LoadImagesFromDirectory(folder: assetsRelativePath, useFolderNameAsLabel: true);
```
Ensuite, chargez les images dans une IDataView à l’aide de la méthode LoadFromEnumerable.
```
IDataView imageData = mlContext.Data.LoadFromEnumerable(images);
```
Les données sont chargées dans l’ordre dans lequel elles ont été lues à partir des répertoires. Pour équilibrer les données, mélangez-les à l’aide de la méthode ShuffleRows.
```
IDataView shuffledData = mlContext.Data.ShuffleRows(imageData);
```
Les modèles Machine Learning s’attendent à ce que l’entrée soit au format numérique. Par conséquent, un prétraitement doit être effectué sur les données avant l’entraînement. Créez une EstimatorChain composée des transformations MapValueToKey et LoadRawImageBytes. La transformation MapValueToKey prend la valeur catégorielle dans la colonne Label, la convertit en valeur KeyType numérique et la stocke dans une nouvelle colonne appelée LabelAsKey. LoadImages prend les valeurs de la colonne ImagePath ainsi que le paramètre imageFolder pour charger des images pour l’entraînement.
```
var preprocessingPipeline = mlContext.Transforms.Conversion.MapValueToKey(
        inputColumnName: "Label",
        outputColumnName: "LabelAsKey")
    .Append(mlContext.Transforms.LoadRawImageBytes(
        outputColumnName: "Image",
        imageFolder: assetsRelativePath,
        inputColumnName: "ImagePath"));
```
Utilisez la méthode Fit pour appliquer les données à preprocessingPipelineEstimatorChain, puis la méthode Transform, qui retourne une IDataView contenant les données prétraitées.
```
IDataView preProcessedData = preprocessingPipeline
                    .Fit(shuffledData)
                    .Transform(shuffledData);
```
Pour entraîner un modèle, il est important de disposer d’un jeu de données d’entraînement ainsi que d’un jeu de données de validation. Le modèle est entraîné sur le jeu d’entraînement. La mesure dans laquelle il effectue de bonnes prédictions sur des données invisibles est mesurée par les performances par rapport au jeu de validation. En fonction des résultats de ces performances, le modèle apporte des ajustements à ce qu’il a appris dans un effort d’amélioration. Le jeu de validation peut provenir du fractionnement de votre jeu de données d’origine ou d’une autre source qui a été mise de côté au préalable à cet effet. Dans ce cas, le jeu de données prétraité est divisé en jeux d’apprentissage, de validation et de test.
```
TrainTestData trainSplit = mlContext.Data.TrainTestSplit(data: preProcessedData, testFraction: 0.3);
TrainTestData validationTestSplit = mlContext.Data.TrainTestSplit(trainSplit.TestSet);
```
L’exemple de code ci-dessus effectue deux fractionnements. Tout d’abord, les données prétraitées sont fractionnées, et 70 % sont utilisées pour l’entraînement, tandis que les 30 % des données restantes sont utilisées pour la validation. Ensuite, le jeu de validation de 30 % est divisé en jeux de validation et de test, où 90 % des données sont utilisées pour la validation et 10 % pour les tests.

Un moyen de comprendre l’objectif de ces partitions de données est de les considérer comme le passage d’un examen. Lorsque vous étudiez pour un examen, vous passez en revue vos notes, vos livres ou autres ressources pour vous familiariser avec les concepts de l’examen. C’est à cela que sert l’entraînement. Ensuite, vous pouvez passer un examen de révision pour valider vos connaissances. C’est là que le jeu de validation intervient. Vous souhaitez vérifier que vous avez une bonne compréhension des concepts avant de passer l’examen réel. Sur la base de ces résultats, vous prenez note de ce que vous avez mal compris ou que vous ne comprenez pas bien, et incorporez vos modifications à mesure que vous révisez pour l’examen réel. Enfin, vous passez l’examen. C’est pour cela que le jeu de test est utilisé. Vous n’avez jamais vu les questions qui se trouvent à l’examen, et utilisez maintenant ce que vous avez appris lors de la formation et de la validation pour appliquer vos connaissances à la tâche qui se présente à vous.

Attribuez aux partitions leurs valeurs respectives pour les données d’apprentissage, de validation et de test.

IDataView trainSet = trainSplit.TrainSet;
IDataView validationSet = validationTestSplit.TrainSet;
IDataView testSet = validationTestSplit.TestSet;

Définir le pipeline d’entraînement

L’entraînement du modèle se compose de deux étapes. Tout d’abord, l’API Classification d’images est utilisée pour entraîner le modèle. Ensuite, les étiquettes encodées dans la colonne PredictedLabel sont reconverties en leur valeur catégorielle d’origine à l’aide de la transformation MapKeyToValue.

Créez une variable pour stocker un ensemble de paramètres obligatoires et facultatifs pour un ImageClassificationTrainer.
```
var classifierOptions = new ImageClassificationTrainer.Options()
{
    FeatureColumnName = "Image",
    LabelColumnName = "LabelAsKey",
    ValidationSet = validationSet,
    Arch = ImageClassificationTrainer.Architecture.ResnetV2101,
    MetricsCallback = (metrics) => Console.WriteLine(metrics),
    TestOnTrainSet = false,
    ReuseTrainSetBottleneckCachedValues = true,
    ReuseValidationSetBottleneckCachedValues = true
};
```
Un ImageClassificationTrainer prend plusieurs paramètres facultatifs :
- FeatureColumnName est la colonne utilisée comme entrée pour le modèle.
- LabelColumnName est la colonne pour la valeur à prédire.
- ValidationSet est le IDataView contenant les données de validation.
- Arch définit les architectures de modèle préentraînées à utiliser. Ce tutoriel utilise la variante à 101 couches du modèle ResNetv2.
- MetricsCallback lie une fonction pour suivre la progression pendant l’entraînement.
- TestOnTrainSet indique au modèle de mesurer les performances par rapport au jeu d’entraînement lorsqu’aucun jeu de validation n’est présent.
- ReuseTrainSetBottleneckCachedValues indique au modèle s’il faut utiliser les valeurs mises en cache de la phase de goulot d’étranglement dans les exécutions suivantes. La phase de goulot d’étranglement est un calcul direct à usage unique qui est gourmand en calculs la première fois qu’il est effectué. Si les données d’apprentissage ne changent pas et que vous souhaitez effectuer des expériences à l’aide d’un nombre différent d’époques ou de tailles de lot, l’utilisation des valeurs mises en cache réduit considérablement la durée nécessaire à l’entraînement d’un modèle.
- ReuseValidationSetBottleneckCachedValues est similaire à ReuseTrainSetBottleneckCachedValues, à l’exception que dans ce cas, il s’agit du jeu de données de validation.
- WorkspacePath définit le répertoire où stocker les valeurs de goulot d’étranglement calculées et la version .pb du modèle.

Définissez le pipeline d’entraînement EstimatorChain, qui se compose à la fois du mapLabelEstimator et du ImageClassificationTrainer.

var trainingPipeline = mlContext.MulticlassClassification.Trainers.ImageClassification(classifierOptions)
    .Append(mlContext.Transforms.Conversion.MapKeyToValue("PredictedLabel"));

Utilisez la méthode Fit pour effectuer l’apprentissage de votre modèle.
```
ITransformer trainedModel = trainingPipeline.Fit(trainSet);
```

Utiliser le modèle

Maintenant que vous avez entraîné votre modèle, il est temps de l’utiliser pour classifier des images.

Créez une méthode utilitaire appelée OutputPrediction pour afficher des informations de prédiction dans la console.

private static void OutputPrediction(ModelOutput prediction)
{
    string imageName = Path.GetFileName(prediction.ImagePath);
    Console.WriteLine($"Image: {imageName} | Actual Value: {prediction.Label} | Predicted Value: {prediction.PredictedLabel}");
}

Classifier une seule image

Créez une méthode appelée ClassifySingleImage pour créer et générer une prédiction d’image unique.
```
void ClassifySingleImage(MLContext mlContext, IDataView data, ITransformer trainedModel)
{

}
```
Créez un PredictionEngine à l’intérieur de la méthode ClassifySingleImage. PredictionEngine est une API utile qui vous permet de passer et d’exécuter une prédiction sur une seule instance de données.
```
PredictionEngine<ModelInput, ModelOutput> predictionEngine = mlContext.Model.CreatePredictionEngine<ModelInput, ModelOutput>(trainedModel);
```
Pour accéder à une instance de ModelInput unique, convertissez le dataIDataView en IEnumerable à l’aide de la méthode CreateEnumerable, puis obtenez la première observation.
```
ModelInput image = mlContext.Data.CreateEnumerable<ModelInput>(data,reuseRowObject:true).First();
```

Utilisez la méthode Predict pour classer l’image.

ModelOutput prediction = predictionEngine.Predict(image);

Extrayez la prédiction dans la console avec la méthode OutputPrediction.

Console.WriteLine("Classifying single image");
OutputPrediction(prediction);

Appelez ClassifySingleImage en dessous de l’appel à la méthode Fit avec le jeu d’images de test.
```
ClassifySingleImage(mlContext, testSet, trainedModel);
```

Classifier plusieurs images

Ajoutez une nouvelle méthode appelée ClassifyImages sous la méthode ClassifySingleImage pour effectuer et générer plusieurs prédictions d’image.
```
void ClassifyImages(MLContext mlContext, IDataView data, ITransformer trainedModel)
{

}
```
Créez un IDataView contenant les prédictions à l’aide de la méthode Transform. Ajoutez le code suivant dans la méthode ClassifyImages.
```
IDataView predictionData = trainedModel.Transform(data);
```
Pour effectuer une itération sur les prédictions, convertissez le predictionDataIDataView en IEnumerable à l’aide de la méthode CreateEnumerable, puis obtenez les 10 premières observations.
```
IEnumerable<ModelOutput> predictions = mlContext.Data.CreateEnumerable<ModelOutput>(predictionData, reuseRowObject: true).Take(10);
```

Itérer et émettre les étiquettes d’origine et prédites pour les prédictions.

Console.WriteLine("Classifying multiple images");
foreach (var prediction in predictions)
{
    OutputPrediction(prediction);
}

Enfin, appelez ClassifyImages sous la méthode ClassifySingleImage() avec le jeu de tests d’images.
```
ClassifyImages(mlContext, testSet, trainedModel);
```

Exécution de l'application

Exécutez votre application console. La sortie devrait ressembler à ce qui suit. Des messages d’avertissement ou de traitement peuvent s’afficher, mais nous les avons supprimés dans les résultats suivants pour plus de clarté. Par souci de concision, la sortie a été condensée.

Phase de goulot d’étranglement

Aucune valeur n’est imprimée pour le nom de l’image, car les images sont chargées en tant que byte[] ; par conséquent, il n’y a pas de nom d’image à afficher.

Phase: Bottleneck Computation, Dataset used:      Train, Image Index: 279
Phase: Bottleneck Computation, Dataset used:      Train, Image Index: 280
Phase: Bottleneck Computation, Dataset used: Validation, Image Index:   1
Phase: Bottleneck Computation, Dataset used: Validation, Image Index:   2

Phase d’apprentissage

Phase: Training, Dataset used: Validation, Batch Processed Count:   6, Epoch:  21, Accuracy:  0.6797619
Phase: Training, Dataset used: Validation, Batch Processed Count:   6, Epoch:  22, Accuracy:  0.7642857
Phase: Training, Dataset used: Validation, Batch Processed Count:   6, Epoch:  23, Accuracy:  0.7916667

Sortie de la classification d’images

Classifying single image
Image: 7001-220.jpg | Actual Value: UD | Predicted Value: UD

Classifying multiple images
Image: 7001-220.jpg | Actual Value: UD | Predicted Value: UD
Image: 7001-163.jpg | Actual Value: UD | Predicted Value: UD
Image: 7001-210.jpg | Actual Value: UD | Predicted Value: UD

Après l’inspection de l’image 7001-220.jpg, vous pouvez voir qu’elle n’est en fait pas fissurée.

Image de jeu de données SDNET2018 utilisée pour la prédiction

Félicitations ! Vous avez maintenant créé un modèle Deep Learning pour classifier des images.

Améliorer le modèle

Si vous n’êtes pas satisfait des résultats de votre modèle, vous pouvez essayer d’améliorer ses performances en essayant certaines des approches suivantes :

Plus de données : plus un modèle apprend d’exemples, mieux il fonctionne. Téléchargez le jeu de données SDNET2018 complet et utilisez-le pour effectuer l’apprentissage.
Augmenter les données : une technique courante pour ajouter de la variété aux données consiste à augmenter les données en prenant une image et en appliquant différentes transformations (pivoter, retourner, déplacer, rogner). Cela ajoute des exemples plus variés pour le modèle à apprendre.
Entraîner plus longtemps : plus vous l’entraînez, plus le modèle est ajusté. L’augmentation du nombre d’époques peut améliorer les performances de votre modèle.
Expérimenter avec les hyperparamètres : en plus des paramètres utilisés dans ce tutoriel, d’autres paramètres peuvent être paramétrés pour améliorer potentiellement les performances. La modification du taux d’apprentissage, qui détermine l’ampleur des mises à jour apportées au modèle après chaque époque, peut améliorer les performances.
Utiliser une autre architecture de modèle : selon la nature de vos données, le modèle qui peut le mieux apprendre ses caractéristiques peut différer. Si vous n’êtes pas satisfait des performances de votre modèle, essayez de modifier l’architecture.

Étapes suivantes

Dans ce tutoriel, vous avez appris à créer un modèle Deep Learning personnalisé à l’aide de l’apprentissage de transfert, d’un modèle TensorFlow de classification d’images préentraîné et de l’API de classification d’images ML.NET pour classer les images de surfaces en béton comme étant fissurées ou non.

Passez au tutoriel suivant pour en savoir plus.

Détection d’objet

Partager via