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

Dans la partie précédente de ce tutoriel, vous avez appris à générer et exporter un modèle 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 ImageClassifierAppUWP.
• 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 [....\ImageClassifierAppUWP\Assets], puis copiez votre modèle à cet emplacement.

5. Remplacez le nom du modèle par model.onnxclassifier.onnx. Cela rend les choses un peu plus claires et les aligne sur le format du didacticiel.

Explorer votre modèle

Familiarisez-vous avec la structure de votre fichier Model.

1. Ouvrez votre classifier.onnx fichier de modèle à l’aide de Netron.

2. Appuyez Data pour ouvrir les propriétés du modèle.

Comme vous pouvez le voir, le modèle nécessite un objet float Tensor (tableau multidimensionnel) 32 bits en entrée et retourne deux sorties : le premier nommé classLabel est un tenseur de chaînes et le second nommé loss est une séquence de correspondances chaîne-vers-flottant qui décrivent la probabilité de chaque classification étiquetée. Vous aurez besoin de ces informations pour afficher correctement la sortie du modèle dans votre application Windows.

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. Ajoutez le code ci-dessous au corps principal de MainPage.xaml.

<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>
            <!--Display the Result-->
            <TextBlock Name="displayOutput" 
                       FontWeight="Bold" 
                       TextWrapping="Wrap"
                       Margin="30,0,0,0"
                       Text="" Width="1471" />
            <Button Name="ProbabilityResult"
                    Content="Probability is:"
                    Width="110"
                    Height="40"
                    IsEnabled="True" 
                    HorizontalAlignment="Left"/>
            <!--Display the Result-->
            <TextBlock Name="displayProbability" 
                       FontWeight="Bold" 
                       TextWrapping="Wrap"
                       Margin="30,0,0,0"
                       Text="" Width="1471" />
            <TextBlock Name="space2" />
            <!--Image preview -->
            <Image Name="UIPreviewImage" Stretch="Uniform" MaxWidth="300" MaxHeight="300"/>
        </StackPanel>
    </Grid>

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 :

• classifier.onnx - il s’agit de votre modèle au format ONNX.
• classifier.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 classifier.onnx fichier et choisissez Properties. Pour Build Action, sélectionnez Content.

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

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

• classifierModel: 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.
• classifierInput: 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. Dans notre cas, l’entrée attend une ImageFeatureValue, classe qui décrit les propriétés de l’image utilisée pour passer dans un modèle.
• classifierOutput: 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. Dans notre cas, la sortie est une séquence de cartes (dictionnaires) de type String et TensorFloat (Float32) appelée Loss.

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

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 ImageClassifierAppUWP.

        // All the required variable declaration
        private classifierModel modelGen;
        private classifierInput input = new classifierModelInput();
        private classifierOutput output;
        private StorageFile selectedStorageFile;
        private string result = "";
        private float resultProbability = 0;

Le résultat se présente comme suit.

// Specify all the using statements which give us the access to all the APIs that we'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;

namespace ImageClassifierAppUWP
{
    public sealed partial class MainPage : Page
    {
        // All the required fields declaration
        private classifierModel modelGen;
        private classifierInput input = new classifierInput();
        private classifierOutput output;
        private StorageFile selectedStorageFile;
        private string result = "";
        private float resultProbability = 0;

À 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 classifier.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. Ajoutez une 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/classifier.onnx"));
            // Instantiate the model. 
            modelGen = await classifierModel.CreateFromStreamAsync(modelFile);
        }

5. À présent, ajoutez un appel à la nouvelle méthode au constructeur de la classe.

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

Le résultat se présente comme suit.

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

        // A method to load a machine learning model.
        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/classifier.onnx"));
            // Instantiate the model. 
            modelGen = await classifierModel.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;
        }

À présent, vous allez implémenter une méthode d’image Bind() pour obtenir la représentation du fichier au format BGRA8 bitmap.

3. 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);
                // bind the input image
                ImageFeatureValue imageTensor = ImageFeatureValue.CreateFromVideoFrame(inputImage);
                input.data = imageTensor;
            }
            catch (Exception e)
            {
            }
        }

Le résultat du travail effectué dans cette section se présente comme suit.

        // 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, we begin the model execution. 
            // Bind the model input
            await imageBind();
            // Model evaluation
            await evaluate();
            // Extract the results
            extractResult();
            // Display the results  
            await displayResult();
        }

        // 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;
        }

        // 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);

                // bind the input image
                ImageFeatureValue imageTensor = ImageFeatureValue.CreateFromVideoFrame(inputImage);
                input.data = 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é.

Actuellement, Windows ML prend en charge tous les types de fonctionnalités ONNX tels que Tensors (tableaux multidimensionnels), Séquences (vecteurs de valeurs), Map (paires valeur d’informations) et Images (formats spécifiques). Toutes les images seront représentées dans Windows ML dans un format tensoriel. La tensorisation est le processus de conversion d’une image en un tenseur et se produit pendant le lien.

Heureusement, vous n’avez pas à vous occuper de la conversion de la tensorisation. La ImageFeatureValue méthode que vous avez utilisée dans la partie précédente prend en charge à la fois la conversion et la tensorisation, de sorte que les images correspondent au format d’image requis du modèle.

É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 classifier.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()
        {
            output = await modelGen.EvaluateAsync(input);
        }

Extraire et afficher les résultats

Vous devez maintenant extraire la sortie du modèle et afficher les résultats appropriés. Vous allez le faire en implémentant les méthodes extractResult et displayResult.

Comme vous l’avez exploré plus tôt, le modèle renvoie deux sorties : la première nommée classLabel est un tenseur de chaînes de caractères et la seconde nommée loss est une séquence de mappages de chaîne à valeur float qui décrit la probabilité de chaque classification étiquetée. Ainsi, pour afficher correctement le résultat et la probabilité, il nous suffit d’extraire la sortie de la sortie de perte. Nous devons trouver la probabilité la plus élevée pour retourner le résultat correct.

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

        private void extractResult()
        {
        // A method to extract output (result and a probability) from the "loss" output of the model 
            var collection = output.loss;
            float maxProbability = 0;
            string keyOfMax = "";

            foreach (var dictionary in collection)
            {
                foreach (var key in dictionary.Keys)
                {
                    if (dictionary[key] > maxProbability)
                    {
                        maxProbability = dictionary[key];
                        keyOfMax = key;
                    }
                }
            }
            result = keyOfMax;
            resultProbability = maxProbability;
        }

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

        // A method to display the results
        private async Task displayResult()
        {
            displayOutput.Text = result.ToString();
            displayProbability.Text = resultProbability.ToString();
        }

Le résultat des parties Lier et évaluer et Extraire et afficher les résultats du code WinML de notre application se présentent comme suit.

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

        // A method to extract output (string and a probability) from the "loss" output of the model 
        private void extractResult()
        {
            var collection = output.loss;
            float maxProbability = 0;
            string keyOfMax = "";

            foreach (var dictionary in collection)
            {
                foreach (var key in dictionary.Keys)
                {
                    if (dictionary[key] > maxProbability)
                    {
                        maxProbability = dictionary[key];
                        keyOfMax = key;
                    }
                }
            }
            result = keyOfMax;
            resultProbability = maxProbability;
        }

        // A method to display the results
        private async Task displayResult()
        {
            displayOutput.Text = result.ToString();
            displayProbability.Text = resultProbability.ToString();
        }

Et voilà ! Vous avez créé avec succès l'application d'apprentissage automatique Windows avec une interface utilisateur graphique 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 WinML, vous pouvez tester l’application. Vérifiez que les menus déroulants de la barre d’outils supérieure sont définis sur Debug. Changez Solution Platform en x64 pour exécuter le projet sur votre machine locale si votre appareil est en 64 bits, ou x86 s'il est en 32 bits.

Pour tester notre application, vous allez utiliser l’image ci-dessous des fruits. Voyons comment notre application classifie le contenu de l’image.

1. Enregistrez cette image sur votre appareil local pour tester l’application. Modifiez le format de l’image en jpg si nécessaire. Vous pouvez également ajouter n’importe quelle autre image pertinente à partir de votre appareil local dans un format approprié : .jpg, .png, .bmpou .gif formats.

2. Pour exécuter le projet, appuyez sur le Start Debugging bouton de 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 WinML a correctement classé l’image en tant que fruits ou légumes, avec une évaluation de confiance de 99,9%.

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.