Déployer votre modèle ML.NET dans une application Windows avec les API Windows Machine Learning

Dans la partie précédente de ce didacticiel, vous avez appris à générer et exporter un modèle ML.NET au format ONNX. Maintenant que vous disposez de ce modèle, vous pouvez l’incorporer dans une application Windows et l’exécuter localement sur un appareil en appelant des API WinML.

Une fois que nous avons terminé, vous disposez d’une application WinML UWP de classifieur d’image de travail (C#).

À propos de l’exemple d’application

À l’aide de notre modèle, nous allons créer une application qui peut classifier des images d’aliments. Il vous permet de sélectionner une image à partir de votre appareil local et de la traiter par un modèle ONNX de classification stockée localement que vous avez créé et entraîné dans la partie précédente. Les balises retournées sont affichées en regard de l’image, ainsi que la probabilité de confiance de la classification.

Si vous suivez ce didacticiel jusqu’à présent, vous devez déjà disposer des prérequis nécessaires au développement d’applications. Si vous avez besoin d’un actualiseur, consultez la première partie de ce didacticiel.

Créer une application UWP WinML (C#)

Ci-dessous, nous allons vous montrer comment créer votre application et votre code WinML à partir de zéro. Vous allez apprendre à :

• Chargez un modèle Machine Learning.
• Chargez une image au format requis.
• Lier les entrées et sorties du modèle.
• Évaluez le modèle et affichez des résultats significatifs.

Vous utiliserez également le code XAML de base pour créer une interface graphique graphique simple, afin de pouvoir tester le classifieur d’image.

Créer l’application

1. Ouvrez Visual Studio et choisissez create a new project.

2. Dans la barre de recherche, tapez UWP , puis sélectionnez Blank APP (Universal Windows). Cela ouvre un nouveau projet C# pour une application Universal Windows Platform (UWP) qui n’a pas de disposition ni de contrôles prédéfinis. Sélectionnez cette option Next pour ouvrir une fenêtre de configuration pour le projet.

3. Dans la fenêtre de configuration :

• Choisissez un nom pour votre projet. Ici, nous utilisons classifierMLNETModel.
• Choisissez l’emplacement du projet.
• Si vous utilisez VS 2019, vérifiez qu’il Place solution and project in the same directory est désactivé.
• Si vous utilisez VS 2017, assurez-vous que Create directory for solution est coché.

Appuyez sur create pour créer votre projet. La fenêtre de version cible minimale peut s’afficher. Vérifiez que votre version minimale est définie sur Windows 10 build 17763 ou version ultérieure.

Pour créer une application et déployer un modèle avec une application WinML, vous avez besoin des éléments suivants :

4. Une fois le projet créé, accédez au dossier du projet, ouvrez le dossier des ressources [....\classifierMLNETModel\Assets], puis copiez votre bestModel.onnx fichier à cet emplacement.

Explorer la solution de projet

Examinons votre solution de projet.

Visual Studio a créé automatiquement plusieurs fichiers cs-code dans l’Explorateur de solutions. MainPage.xaml contient le code XAML de votre interface utilisateur graphique et MainPage.xaml.cs contient le code de votre application. Si vous avez déjà créé une application UWP, ces fichiers doivent vous être familiers.

Créer l’interface utilisateur de l’application

Tout d’abord, créons une interface graphique graphique simple pour votre application.

1. Double-cliquez sur le MainPage.xaml fichier. Dans votre application vide, le modèle XAML de l’interface utilisateur utilisateur de votre application est vide. Nous devons donc ajouter certaines fonctionnalités d’interface utilisateur.

2. Remplacez le code de MainPage.xaml par ce qui suit.

<Page
    x:Class="classifierMLNETModel.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:classifierMLNETModel"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">

       <Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">

	
        <StackPanel Margin="1,0,-1,0">
            <TextBlock x:Name="Menu" 
                       FontWeight="Bold" 
                       TextWrapping="Wrap"
                       Margin="10,0,0,0"
                       Text="Image Classification"/>
            <TextBlock Name="space" />
            <Button Name="recognizeButton"
                    Content="Pick Image"
                    Click="OpenFileButton_Click" 
                    Width="110"
                    Height="40"
                    IsEnabled="True" 
                    HorizontalAlignment="Left"/>
            <TextBlock Name="space3" />
            <Button Name="Output"
                    Content="Result is:"
                    Width="110"
                    Height="40"
                    IsEnabled="True" 
                    HorizontalAlignment="Left" 
                    VerticalAlignment="Top">
            </Button>
            <!--Dispaly the Result-->
            <TextBlock Name="displayOutput" 
                       FontWeight="Bold" 
                       TextWrapping="Wrap"
                       Margin="25,0,0,0"
                       Text="" Width="1471" />
            <TextBlock Name="space2" />
            <!--Image preview -->
            <Image Name="UIPreviewImage" Stretch="Uniform" MaxWidth="300" MaxHeight="300"/>
        </StackPanel>
    </Grid> 
</Page>

Ajouter le modèle au projet à l’aide du générateur de code Windows Machine Learning

Windows Machine Learning Code Generator ou mlgen est une extension Visual Studio pour vous aider à commencer à utiliser des API WinML sur des applications UWP. Il génère le code du modèle lorsque vous ajoutez un fichier ONNX entraîné dans le projet UWP.

Le générateur de code mlgen de Windows Machine Learning crée une interface (pour C#, C++/WinRT et C++/CX) avec des classes wrapper qui appellent l’API Windows ML pour vous. Cela vous permet de charger, lier et évaluer facilement un modèle dans votre projet. Nous allons l’utiliser dans ce tutoriel pour gérer un grand nombre de ces fonctions pour nous.

Le générateur de code est disponible pour Visual Studio 2017 et versions ultérieures. N’oubliez pas que dans Windows 10, version 1903 et ultérieure, mlgen n’est plus inclus dans le Kit de développement logiciel (SDK) Windows 10. Vous devez donc télécharger et installer l’extension. Si vous avez suivi ce tutoriel depuis l’introduction, vous l’aurez déjà fait, mais si ce n’est pas le cas, vous devez télécharger pour VS 2019 ou pour VS 2017.

1. Si ce n’est déjà fait, installez mlgen.

2. Cliquez avec le bouton droit sur le Assets dossier dans l’Explorateur de solutions dans Visual Studio, puis sélectionnez Add > Existing Item.

3. Accédez au dossier des ressources à l’intérieur ImageClassifierAppUWP [….\ImageClassifierAppUWP\Assets], recherchez le modèle ONNX que vous avez copié précédemment, puis sélectionnez add.

4. Après avoir ajouté un modèle ONNX (nom : « classifieur ») dans le dossier ressources de l’Explorateur de solutions dans VS, le projet doit maintenant avoir deux nouveaux fichiers :

• bestModel.onnx - il s’agit de votre modèle au format ONNX.
• bestModel.cs : fichier de code WinML généré automatiquement.

5. Pour vous assurer que le modèle est généré lorsque vous compilez notre application, sélectionnez le bestModel.onnx fichier et choisissez Properties. Pour Build Action, sélectionnez Content.

À présent, examinons le code nouvellement généré dans le bestModel.cs fichier.

Le code généré comprend trois classes :

• bestModelModel: cette classe inclut deux méthodes pour l’instanciation du modèle et l’évaluation du modèle. Il nous aidera à créer la représentation du modèle Machine Learning, à créer une session sur l’appareil système par défaut, à lier les entrées et sorties spécifiques au modèle et à évaluer le modèle de manière asynchrone.
• bestModelInput: cette classe initialise les types d’entrée attendus par le modèle. L’entrée du modèle dépend des exigences du modèle pour les données d’entrée.
• bestModelOutput: cette classe initialise les types que le modèle génère. La sortie du modèle dépend de la façon dont il est défini par le modèle.

Vous allez maintenant utiliser ces classes pour charger, lier et évaluer le modèle dans notre projet.

Conversion de Tenseur

Pour faciliter la gestion de la tensorisation, changez la classe d'entrée TensorFloat en ImageFeatureValue.

1. Apportez les modifications suivantes dans le fichier bestModel.cs :

Le code :

public sealed class bestModelInput
    {
        public TensorFloat input; // shape(-1,3,32,32)
    }

Deviendra :

public sealed class bestModelInput
    {
        public ImageFeatureValue input; // shape(-1,3,32,32)
    }

Charger le modèle et les entrées

Charger le modèle

1. Double-cliquez sur le MainPage.xaml.cs fichier de code pour ouvrir le code de l’application.

2. Remplacez les instructions « using » par ce qui suit pour obtenir un accès à toutes les API dont vous aurez besoin.

// Specify all the using statements which give us the access to all the APIs that you'll need
using System;
using System.Threading.Tasks;
using Windows.AI.MachineLearning;
using Windows.Graphics.Imaging;
using Windows.Media;
using Windows.Storage;
using Windows.Storage.Pickers;
using Windows.Storage.Streams;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Media.Imaging;

3. Ajoutez les déclarations de variables suivantes après les instructions using à l’intérieur de votre classe MainPage sous l’espace de noms classifierMLNETModel.

		// All the required fields declaration
		private bestModelModel modelGen;
		private bestModelInput image = new bestModelInput();
		private bestModelOutput results;
		private StorageFile selectedStorageFile;
		private string label = "";
		private float probability = 0;
		private Helper helper = new Helper();

		public enum Labels
		{
			desert,
			soup,
			vegetable_fruit,
		}

À présent, vous allez implémenter la LoadModel méthode. La méthode accède au modèle ONNX et la stocke en mémoire. Ensuite, vous allez utiliser la CreateFromStreamAsync méthode pour instancier le modèle en tant qu’objet LearningModel . La LearningModel classe représente un modèle Machine Learning entraîné. Une fois instancié, il s’agit LearningModel de l’objet initial que vous utilisez pour interagir avec Windows ML.

Pour charger le modèle, vous pouvez utiliser plusieurs méthodes statiques dans la LearningModel classe. Dans ce cas, vous allez utiliser la CreateFromStreamAsync méthode.

La CreateFromStreamAsync méthode a été créée automatiquement avec mlgen. Vous n’avez donc pas besoin d’implémenter cette méthode. Vous pouvez passer en revue cette méthode en double-cliquant sur le bestModel.cs fichier généré par mlgen.

Pour en savoir plus sur LearningModel la classe, consultez la documentation de la classe LearningModel.

Pour en savoir plus sur les autres façons de charger le modèle, consultez la documentation Charger un modèle

4. Définissons la méthode principale.

// The main page to initialize and execute the model.
public MainPage()
{
	this.InitializeComponent();
	loadModel();
}

5. Ajoutez l’implémentation de la loadModel méthode à votre MainPage.xaml.cs fichier de code à l’intérieur de la MainPage classe.

private async Task loadModel()
{
// Get an access the ONNX model and save it in memory. 
	StorageFile modelFile = await StorageFile.GetFileFromApplicationUriAsync(new Uri($"ms-appx:///Assets/bestModel.onnx"));
// Instantiate the model. 
	modelGen = await bestModelModel.CreateFromStreamAsync(modelFile);
}

Charger l’image

1. Nous devons définir un événement click pour lancer la séquence de quatre appels de méthode pour l’exécution du modèle : conversion, liaison et évaluation, extraction de sortie et affichage des résultats. Ajoutez la méthode suivante à votre MainPage.xaml.cs fichier de code à l’intérieur de la MainPage classe.

        // Waiting for a click event to select a file 
        private async void OpenFileButton_Click(object sender, RoutedEventArgs e)
        {
            if (!await getImage())
            {
                return;
            }
            // After the click event happened and an input selected, begin the model execution. 
            // Bind the model input
            await imageBind();
            // Model evaluation
            await evaluate();
            // Extract the results
            extractResult();
            // Display the results  
            await displayResult();
        }

2. À présent, vous allez implémenter la getImage() méthode. Cette méthode sélectionne un fichier image d’entrée et l’enregistre en mémoire. Ajoutez la méthode suivante à votre MainPage.xaml.cs fichier de code à l’intérieur de la MainPage classe.

        // A method to select an input image file
        private async Task<bool> getImage()
        {
            try
            {
                // Trigger file picker to select an image file
                FileOpenPicker fileOpenPicker = new FileOpenPicker();
                fileOpenPicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
                fileOpenPicker.FileTypeFilter.Add(".jpg");
                fileOpenPicker.FileTypeFilter.Add(".png");
                fileOpenPicker.ViewMode = PickerViewMode.Thumbnail;
                selectedStorageFile = await fileOpenPicker.PickSingleFileAsync();
                if (selectedStorageFile == null)
                {
                    return false;
                }
            }
            catch (Exception)
            {
                return false;
            }
            return true;
        }

Ensuite, vous allez implémenter une méthode Bind() d’image pour récupérer la représentation du fichier au format BGRA8 bitmap. Mais tout d’abord, vous allez créer une classe d’assistance pour redimensionner l’image.

3. Pour créer un fichier d’assistance, cliquez avec le bouton droit sur le nom de la solution (ClassifierPyTorch), puis choisissez Add a new item. Dans la fenêtre Ouvrir, sélectionnez Class et donnez-lui un nom. Ici, nous l’appelons Helper.

4. Un nouveau fichier de classe va apparaître dans votre projet. Ouvrez cette classe, puis ajoutez le code suivant :

using System; 
using System.Threading.Tasks; 
using Windows.Graphics.Imaging; 
using Windows.Media; 

namespace classifierPyTorch 
{ 
    public class Helper 
    { 
        private const int SIZE = 32;  
        VideoFrame cropped_vf = null; 
 
        public async Task<VideoFrame> CropAndDisplayInputImageAsync(VideoFrame inputVideoFrame) 
        { 
            bool useDX = inputVideoFrame.SoftwareBitmap == null; 

            BitmapBounds cropBounds = new BitmapBounds(); 
            uint h = SIZE; 
            uint w = SIZE; 
            var frameHeight = useDX ? inputVideoFrame.Direct3DSurface.Description.Height : inputVideoFrame.SoftwareBitmap.PixelHeight; 
            var frameWidth = useDX ? inputVideoFrame.Direct3DSurface.Description.Width : inputVideoFrame.SoftwareBitmap.PixelWidth; 
 
            var requiredAR = ((float)SIZE / SIZE); 
            w = Math.Min((uint)(requiredAR * frameHeight), (uint)frameWidth); 
            h = Math.Min((uint)(frameWidth / requiredAR), (uint)frameHeight); 
            cropBounds.X = (uint)((frameWidth - w) / 2); 
            cropBounds.Y = 0; 
            cropBounds.Width = w; 
            cropBounds.Height = h; 
 
            cropped_vf = new VideoFrame(BitmapPixelFormat.Bgra8, SIZE, SIZE, BitmapAlphaMode.Ignore); 
 
            await inputVideoFrame.CopyToAsync(cropped_vf, cropBounds, null); 
            return cropped_vf; 
        } 
    } 
} 

À présent, nous allons convertir l’image au format approprié.

La classe bestModelInput initialise les types d’entrée attendues par le modèle. Dans notre cas, nous avons configuré notre code pour attendre un ImageFeatureValue.

La classe ImageFeatureValue décrit les propriétés de l’image utilisée à transmettre dans un modèle. Pour créer unImageFeatureValue, vous utilisez la méthode CreateFromVideoFrame. Pour plus d’informations sur la raison pour laquelle cela est le cas et la façon dont ces classes et méthodes fonctionnent, consultez la documentation de la classe ImageFeatureValue.

5. Ajoutez l’implémentation de la convert() méthode à votre MainPage.xaml.cs fichier de code à l’intérieur de la classe MainPage. La méthode convert nous obtient une représentation du fichier d’entrée au format BGRA8.

// A method to convert and bind the input image.  
        private async Task imageBind()
        {
            UIPreviewImage.Source = null;
            try
            {
                SoftwareBitmap softwareBitmap;
                using (IRandomAccessStream stream = await selectedStorageFile.OpenAsync(FileAccessMode.Read))
                {
                    // Create the decoder from the stream 
                    BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
                    // Get the SoftwareBitmap representation of the file in BGRA8 format
                    softwareBitmap = await decoder.GetSoftwareBitmapAsync();
                    softwareBitmap = SoftwareBitmap.Convert(softwareBitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
                }
                // Display the image
                SoftwareBitmapSource imageSource = new SoftwareBitmapSource();
                await imageSource.SetBitmapAsync(softwareBitmap);
                UIPreviewImage.Source = imageSource;

				// Encapsulate the image within a VideoFrame to be bound and evaluated
            	VideoFrame inputImage = VideoFrame.CreateWithSoftwareBitmap(softwareBitmap);
              	// Resize the image size to 224x224 
              	inputImage=await helper.CropAndDisplayInputImageAsync(inputImage);
              	// Bind the model input with image
              	ImageFeatureValue imageTensor = ImageFeatureValue.CreateFromVideoFrame(inputImage);
				image.input1 = imageTensor;

				// Encapsulate the image within a VideoFrame to be bound and evaluated
				VideoFrame inputImage = VideoFrame.CreateWithSoftwareBitmap(softwareBitmap);
				// Bind the input image
				ImageFeatureValue imageTensor = ImageFeatureValue.CreateFromVideoFrame(inputImage);
				image.modelInput = imageTensor;

            }
            catch (Exception e)
            {
            }
        }

Lier et évaluer le modèle

Ensuite, vous allez créer une session basée sur le modèle, lier l’entrée et la sortie de la session, puis évaluer le modèle.

Créez une session pour lier le modèle :

Pour créer une session, vous utilisez la LearningModelSession classe. Cette classe est utilisée pour évaluer les modèles Machine Learning et lie le modèle à un appareil qui s’exécute et évalue le modèle. Vous pouvez sélectionner un appareil lorsque vous créez une session pour exécuter votre modèle sur un appareil spécifique de votre ordinateur. L’appareil par défaut est le processeur.

Lier des entrées et sorties de modèle :

Pour lier l’entrée et la sortie, vous utilisez la LearningModelBinding classe. Un modèle Machine Learning a des fonctionnalités d’entrée et de sortie, qui transmettent des informations dans et hors du modèle. N’oubliez pas que les fonctionnalités requises doivent être prises en charge par les API Windows ML. La LearningModelBinding classe est appliquée à une LearningModelSession pour lier des valeurs aux fonctionnalités d'entrée et de sortie nommées.

L’implémentation de la liaison est générée automatiquement par mlgen. Vous n’avez donc pas à vous en occuper. La liaison est implémentée en appelant les méthodes prédéfinies de la LearningModelBinding classe. Dans notre cas, il utilise la Bind méthode pour lier une valeur au type de fonctionnalité nommé.

Évaluez le modèle :

Après avoir créé une session pour lier le modèle et les valeurs limitées aux entrées et sorties d’un modèle, vous pouvez évaluer les entrées du modèle et obtenir ses prédictions. Pour exécuter l’exécution du modèle, vous devez appeler l’une des méthodes évaluées prédéfinies sur learningModelSession. Dans notre cas, nous allons utiliser la EvaluateAsync méthode.

Similaire à CreateFromStreamAsync, la EvaluateAsync méthode a également été générée automatiquement par Le générateur de code WinML. Vous n’avez donc pas besoin d’implémenter cette méthode. Vous pouvez passer en revue cette méthode dans le bestModel.cs fichier.

La EvaluateAsync méthode évalue de façon asynchrone le modèle Machine Learning à l’aide des valeurs de fonctionnalité déjà liées dans les liaisons. Il crée une session avec LearningModelSession, lie l’entrée et la sortie avec LearningModelBinding, exécute l’évaluation du modèle et obtient les fonctionnalités de sortie du modèle à l’aide de la LearningModelEvaluationResult classe.

1. Ajoutez la méthode suivante à votre MainPage.xaml.cs fichier de code à l’intérieur de la classe MainPage pour créer une session, lier et évaluer le modèle.

        // A method to evaluate the model
        private async Task evaluate()
        {
            results = await modelGen.EvaluateAsync(image);
        }

Extraire et afficher les résultats

Vous devez maintenant extraire la sortie du modèle et afficher le résultat correct, ce que vous allez effectuer en implémentant les méthodes extractResult et displayResult. Vous devez trouver la probabilité la plus élevée pour retourner l’étiquette adéquate.

1. Ajoutez la extractResult méthode à votre MainPage.xaml.cs fichier de code à l’intérieur de la MainPage classe.

        // A method to extract output from the model 
        private void extractResult()
        {
            // Retrieve the results of evaluation
            var mResult = results.modelOutput as TensorFloat;
            // convert the result to vector format
            var resultVector = mResult.GetAsVectorView();
            
            probability = 0;
            int index = 0;
            // find the maximum probability
            for(int i=0; i<resultVector.Count; i++)
            {
                var elementProbability=resultVector[i];
                if (elementProbability > probability)
                {
                    index = i;
                }
            }
            label = ((Labels)index).ToString();
        }

2. Ajoutez la displayResult méthode à votre MainPage.xaml.cs fichier de code à l’intérieur de la MainPage classe.

        private async Task displayResult() 
        {
            displayOutput.Text = label; 
        }

Et voilà ! Vous avez créé avec succès l’application Windows Machine Learning avec une interface graphique utilisateur de base pour tester notre modèle de classification. L’étape suivante consiste à lancer l’application et à l’exécuter localement sur votre appareil Windows.

Lancer l’application

Une fois que vous avez terminé l’interface de l’application, ajouté le modèle et généré le code Windows ML, vous pouvez tester l’application.

Activez le mode développeur et testez votre application à partir de Visual Studio. Assurez-vous que les menus déroulants de la barre d’outils supérieure sont définis sur Debug. Remplacez la plateforme de solution par la plateforme x64 pour exécuter le projet sur votre ordinateur local s’il s’agit d’un appareil 64 bits, ou par la plateforme x86 s’il s’agit d’un appareil 32 bits.

Pour tester notre application, utilisons l’image ci-dessous de soupe. Voyons comment notre application classifie le contenu de l’image.

1. Enregistrez cette image sur votre appareil local pour tester l’application. Remplacez le format d’image par .jpg si nécessaire. Vous pouvez également ajouter toute autre image pertinente à partir de votre appareil local dans un format .jpg ou .png.

2. Pour exécuter le projet, sélectionnez le bouton Start Debugging dans la barre d’outils ou appuyez sur F5.

3. Lorsque l’application démarre, appuyez sur Pick Image et sélectionnez l’image à partir de votre appareil local.

Le résultat s’affiche immédiatement sur l’écran. Comme vous pouvez le voir, notre application Windows ML a correctement classé l’image en tant que soupe.

Résumé

Vous venez de créer votre première application Windows Machine Learning, de la création de modèle à l’exécution réussie.

Ressources additionnelles

Pour en savoir plus sur les rubriques mentionnées dans ce tutoriel, consultez les ressources suivantes :

• Outils Windows ML : Découvrez plus d’outils tels que le tableau de bord Windows ML, WinMLRunner et le générateur de code Windows ML mglen .
• Modèle ONNX : En savoir plus sur le format ONNX.
• Performances et mémoire windows ML : découvrez comment gérer les performances des applications avec Windows ML.
• Informations de référence sur l’API Windows Machine Learning : En savoir plus sur trois domaines des API Windows ML.