Déployer le modèle d’analyse des données dans l’application Windows avec des API Windows ML

Dans la partie précédente de ce tutoriel, vous avez appris à générer et exporter un modèle au format ONNX. À présent, nous allons vous montrer comment incorporer votre modèle exporté dans une application Windows et l’exécuter localement sur un appareil en appelant des API Windows ML.

Au moment où nous avons terminé, vous disposez d’une application d’analyse des données opérationnelle.

À propos de l’exemple d’application

Dans cette étape du tutoriel, vous allez créer une application qui peut analyser les données tabulaires d’Iris. L’application vous permet d’ajouter le fichier Excel avec les informations d’entrée requises ou d’entrer manuellement les paramètres d’entrée , la longueur et la largeur du sépale et du pétale d’Iris en cm. Ces fonctionnalités seront traitées par un modèle ONNX de réseau neuronal stocké localement que vous avez créé et entraîné dans la partie précédente. En fonction de la sortie du modèle, l’application affiche le type Iris approprié.

Ici, nous allons vous guider tout au long de ce processus.

Remarque

Si vous choisissez d’utiliser l’exemple de code prédéfini, vous pouvez cloner le fichier solution. Clonez le dépôt, accédez à cet exemple et ouvrez le fichier Iris Data Analysis.csproj avec Visual Studio. Passez à la partie Lancer l’application de cette page pour la voir en cours d’utilisation.

Ci-dessous, nous allons vous guider dans la création de votre application et l’ajout de code Windows ML.

Créer une application Windows ML Desktop (C#)

Pour créer une application Windows ML fonctionnelle, vous devez effectuer les opérations suivantes :

Chargez un modèle Machine Learning.
Lier les entrées et sorties du modèle.
Évaluez le modèle et affichez des résultats significatifs.

Vous devez également créer une interface utilisateur de base pour offrir une meilleure expérience utilisateur.

Ouvrez un nouveau projet dans Visual Studio.

Commençons. Ouvrez Visual Studio et choisissez Create a new project.

Créer un projet Visual Studio

Dans la barre de recherche, choisissez C# comme langue, Windows comme plateforme cible et Dektop comme type de projet. Sélectionnez NUnit Test Project (.NET Core) comme type de projet, puis sélectionnez next pour ouvrir une fenêtre de configuration pour le projet.

Créer une application projet de test NUnit

Dans la fenêtre de configuration, suivez les étapes ci-dessous :

Nommez votre projet. Ici, nous l’appelons Iris Data Analysis.
Choisissez l’emplacement du projet.
Si vous utilisez VS 2019, vérifiez que la case Create directory for solution est cochée.
Si vous utilisez VS2017, vérifiez qu’il Place solution and project in the same directory est désactivé.

Appuyez sur create pour créer votre projet. La fenêtre de version cible minimale peut s’afficher. Assurez-vous que la version minimale est définie sur Windows 10 version 1809 (10.0, build 17763) ou ultérieure.

Une fois le projet créé, accédez au dossier du projet, ouvrez le dossier des ressources[….\DataClassifier\Assets], puis copiez votre fichier Network.onnx à 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.

Même si nous avons ajouté notre Network.onnx fichier au dossier des ressources, nous devons l’ajouter correctement à ce projet.

Cliquez avec le bouton droit sur le dossier Ressources dans l’Explorateur de solutions, puis sélectionnez Add > Existing Item.
Accédez au dossier Assets à l’intérieur Iris Data Analysis [….\Iris Data Analysis \Assets], recherchez le Network.onnx model fichier que vous avez copié précédemment, puis sélectionnez Add.
Pour garantir la génération du modèle lorsque vous compilez votre application, cliquez avec le bouton droit sur le Network.onnx fichier et sélectionnez Properties. Définissez Build Action sur Content.

Vous devez également créer un fichier de classe cs-code pour prendre en charge du code Machine Learning supplémentaire, qui inclut des classes et des méthodes qui appellent des API Windows ML.

Cliquez avec le bouton droit sur le nom de la solution dans Visual Studio, puis choisissez add et new item. Dans la fenêtre ouverte, sélectionnez-la Class et donnez-lui un nom - ici, nous utilisons IrisModel.cs. Un nouveau fichier de classe apparaîtra dans le cadre de votre projet.

Ajoutez un nouveau fichier de classe à votre projet VS .

Créer du code Machine Learning

Dans cette étape, nous allons créer toutes les classes et méthodes qui appelleront les API Windows Machine Learning. Celles-ci vous permettent de charger, de lier et d’évaluer un modèle Machine Learning ONNX dans votre projet.

Double-cliquez sur le IrisModel.cs fichier.
Remplacez les instructions using par ce qui suit pour obtenir l’accès à toutes les API dont vous aurez besoin.

using System;
using System.Linq;
using System.Threading.Tasks;
using Windows.AI.MachineLearning;
using Windows.Storage;

Initialiser des classes Machine Learning

Nous devons ajouter plusieurs classes à IrisModel.cs pour vous aider à interagir avec les API Windows Machine Learning.

Pour accéder au modèle Machine Learning entraîné, nous allons utiliser la LearningModel classe. Cette classe fait partie de l’espace Windows.AI.MachineLearning de noms et représente un modèle Machine Learning entraîné. Une fois LearningModel instancié, c'est l'objet principal que vous utilisez pour interagir avec les API Windows ML.

Pour évaluer le modèle d’apprentissage, vous devez créer une session d’évaluation. Pour ce faire, 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. Lorsque vous créez une session avec cette API, vous pouvez également sélectionner un appareil pour exécuter votre modèle (la valeur par défaut est votre processeur).

En outre, vous devez spécifier les étiquettes de la sortie de vos modèles Machine Learning. Vous pouvez connecter ces étiquettes à la sortie prédite du modèle ultérieurement.

Remarque

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

Copiez le code suivant dans le IrisModel.cs fichier.

class IrisModel
    {
        private LearningModel _learning_model;
        private LearningModelSession _session;
        private String[] _labels = { "Iris-setosa", "Iris-versicolor", "Iris-virginica"};

Charger le modèle

Ensuite, vous devez charger le modèle Machine Learning et créer une session, que vous allez faire avec les classes que vous venez de définir. Pour charger le modèle, vous allez utiliser plusieurs méthodes statiques de la LearningModel classe. Dans notre cas, nous allons utiliser LoadFromStorageFileAsync, ce qui vous permet de charger un modèle ONNX de ISorageFile manière asynchrone.

Remarque

Pour en savoir plus sur les autres méthodes de chargement du modèle, consultez la documentation Charger un modèle.

Copiez le code suivant dans le IrisModel.cs fichier.

public async Task Initialize()
{
    // Load and create the model and session
    var modelFile = await StorageFile.GetFileFromApplicationUriAsync(new Uri($"ms-appx:///Assets//Network.onnx"));
    _learning_model = await LearningModel.LoadFromStorageFileAsync(modelFile);
    _session = new LearningModelSession(_learning_model);
}

Définir le tensoreur d’entrée de modèle

À présent, nous allons définir l’entrée correcte en fonction des exigences de votre modèle. Le modèle réseau que vous avez créé dans la partie précédente a quatre valeurs d’entrée. Chaque valeur d’entrée représente les tailles possibles de quatre caractéristiques d’iris : longueur de sépale en cm, largeur sépale en cm, longueur pétale en cm et largeur pétale en cm. En fonction de cette entrée, le modèle retourne le type d’iris qui correspond le mieux à ces paramètres. Pour ce didacticiel, vous devez limiter la taille des valeurs d’entrée aux valeurs logiques valides. Pour ce didacticiel, nous allons utiliser les éléments suivants :

longueur sépale - 1cm à 100cm
largeur de sépale – 1cm à 8cm
Longueur pétale - 0,5cm à 10cm
Largeur pétale – 0,1cm à 5cm

Copiez le code suivant dans le IrisModel.cs fichier.

private float _sepal_length = 1.0f;
public float Sepal_Length
{
    get
    {
        return _sepal_length;
    }
    set
    {
        // validate range [1,10]
        if (value >= 1 && value <= 10)
        {
            _sepal_length = value;
        }
    }
}

private float _sepal_width = 1.0f;
public float Sepal_Width
{
    get
    {
        return _sepal_width;
    }
    set
    {
        // validate range [1, 8]
        if (value >= 1 && value <= 8)
        {
            _sepal_width = value;
        }
    }
}

private float _petal_length = 0.5f;
public float Petal_Length
{
    get
    {
        return _petal_length;
    }
    set
    {
        // validate range [0.5, 10]
        if (value >= 0.5 && value <= 10)
        {
            _petal_length = value;
        }
    }
}

private float _petal_width = 0.1f;
public float Petal_Width
{
    get
    {
        return _petal_width;
    }
    set
    {
        // validate range [0.1, 5]
        if (value >= 0.1 && value <= 5)
        {
            _petal_width = value;
        }
    }
}

Les API Windows ML acceptent les valeurs d’entrée des quatre classes descriptives prises en charge par les modèles ONNX : tenseurs, séquences, mappages et images. Dans ce cas, le modèle nécessite un objet tensoriel float 32 bits sous la forme de float32[taille_lot, 4]. Étant donné que la taille du lot est 1, la forme de tenseur d’entrée est [1x4].

Pour créer une entrée tenseur, vous utiliserez la classe TensorFloat.

La TensorFloat classe fait partie de l’espace de noms Windows.AI.MachineLearning et est utilisée pour définir un objet tenseur 32 bits à virgule flottante, un tenseur de valeurs à virgule flottante 32 bits. Cette classe contient plusieurs méthodes utiles pour générer un tensoriel. Dans votre cas, vous allez utiliser la méthode CreateFromArray pour générer une entrée tensorielle de la taille exacte requise par votre modèle. Nous ajouterons cet appel dans la méthode d’évaluation.

Lier et évaluer le modèle

Maintenant que vous avez défini le tensoreur d’entrée du modèle et instancié le modèle et la session entraînés, il est temps de créer une méthode pour lier et évaluer le modèle Machine Learning entraîné.

Cette méthode est la partie clé d’une application Machine Learning. Il inclut la tensorisation des valeurs d'entrée et la liaison de l'entrée du modèle. Vous utiliserez ce modèle plus loin dans votre code d’application pour évaluer votre 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.

La LearningModelBinding classe a plusieurs méthodes prédéfinies que vous pouvez utiliser pour lier des valeurs à ces fonctionnalités nommées. Ici, vous allez utiliser la Bind méthode pour lier des valeurs à votre modèle.

Pour évaluer votre modèle et recevoir les résultats de celui-ci, vous appelez la méthode d'évaluation prédéfinie LearningModelSession - dans votre cas, la méthode Evaluate. Cette méthode fournit les fonctionnalités dont vous avez besoin, en évaluant le modèle Machine Learning à l’aide des valeurs de fonctionnalité fournies par la LearningModelBinding classe.

Remarque

Pour en savoir plus sur les autres méthodes d’évaluation en vue d’exécuter le modèle, vérifiez les méthodes qui peuvent être implémentées sur le LearningModelSession en consultant la documentation de la classe LearningModelSession.

Extraire et afficher les résultats

Le modèle retourne les valeurs prédites au format tensor en tant que sortie flottante Tensor. Vous devez maintenant extraire la sortie du modèle et afficher les résultats appropriés. Pour ce faire, vous allez convertir le format tensoriel en vecteur en exécutant la GetAsVectorView() fonction sur la sortie prédicée.

Le modèle retourne trois valeurs de probabilité, chacune représentant un type d’iris spécifique. Vous devez retourner l’étiquette avec la probabilité la plus élevée.

Copiez le code suivant dans le IrisModel.cs fichier.

internal String Evaluate()
{
    // input tensor shape is [1x4]
    long[] shape = new long[2];
    shape[0] = 1;
    shape[1] = 4;

    // set up the input tensor
    float[] input_data = new float[4];
    input_data[0] = _sepal_length;
    input_data[1] = _sepal_width;
    input_data[2] = _petal_length;
    input_data[3] = _petal_width;
    TensorFloat tensor_float = TensorFloat.CreateFromArray(shape, input_data);

    // bind the tensor to "input"
    var binding = new LearningModelBinding(_session);
    binding.Bind("input", tensor_float);

    // evaluate
    var results = _session.Evaluate(binding, "");

    // get the results
    TensorFloat prediction = (TensorFloat)results.Outputs.First().Value;
    var prediction_data = prediction.GetAsVectorView();

    // find the highest predicted value
    int max_index = 0;
    float max_value = 0;
    for (int i = 0; i < prediction_data.Count; i++)
    {
        var val = prediction_data.ElementAt(i);
        if (val > max_value)
        {
            max_value = val;
            max_index = i;
        }
    }

    // return the label corresponding to the highest predicted value
    return _labels.ElementAt(max_index);
}

Vous avez maintenant terminé la partie Machine Learning de votre code. À présent, vous pouvez facilement intégrer votre modèle à l’application Windows. Dans la dernière partie de ce tutoriel, nous avons fourni une interface utilisateur graphique Windows de base et un code de contrôle pour tester le modèle, à l’aide des méthodes que vous avez déjà créées.

Créer l’interface utilisateur de l’application

Pour créer un code d’application GUI pour votre application, double-cliquez sur le MainPage.xaml fichier de code et ouvrez un modèle prédéfini pour votre interface utilisateur graphique.
Copiez-collez le code ci-dessous dans MainPage.xaml, sous la ligne “Background="{ThemeResource ApplicationPageBackgroundThemeBrush}" " Height="939">.

    <Grid Margin="30,30,30,30">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
        </Grid.RowDefinitions>
        <TextBlock x:Name="title" HorizontalAlignment="Left" Text="Data Analysis App - Windows ML" TextWrapping="Wrap" VerticalAlignment="Top" FontSize="32" TextDecorations="Underline" FontWeight="Bold"/>
        <TextBlock x:Name="subtitle" HorizontalAlignment="Left" Text="Provide the input :" TextWrapping="Wrap" VerticalAlignment="Top" FontSize="20" Grid.Row="1" FontWeight="Bold"/>
        <Grid Grid.Row="2">
            <Grid.RowDefinitions>
                <RowDefinition Height="Auto"/>
                <RowDefinition Height="Auto"/>
                <RowDefinition Height="Auto"/>
                <RowDefinition Height="Auto"/>
            </Grid.RowDefinitions>
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="Auto"/>
                <ColumnDefinition Width="Auto"/>
            </Grid.ColumnDefinitions>
            <TextBlock x:Name="sepal_length" Text="sepal length in mm [range of 10 - 100]:" VerticalAlignment="Center"/>
            <TextBlock x:Name="sepal_width" Text="sepal width in mm [range of 10 - 80]:" VerticalAlignment="Center" Grid.Row="1"/>
            <TextBlock x:Name="petal_length" Text="petal length in mm [range of 5 - 100]:" VerticalAlignment="Center" Grid.Row="2"/>
            <TextBlock x:Name="petal_width" Text="sepal width in mm [range of 1 - 50]:" VerticalAlignment="Center" Grid.Row="3"/>

            <Slider x:Name="sepal_length_input" Minimum="10" Maximum="100" Orientation="Horizontal" Grid.Column="1" Width="200" ValueChanged="sepal_length_input_ValueChanged"/>
            <Slider x:Name="sepal_width_input" Minimum="10" Maximum="80" Orientation="Horizontal" Grid.Row="1" Grid.Column="1" Width="200" ValueChanged="sepal_width_input_ValueChanged"/>
            <Slider x:Name="petal_length_input" Minimum="5" Maximum="100" Orientation="Horizontal" Grid.Row="2" Grid.Column="1" Width="200" ValueChanged="petal_length_input_ValueChanged"/>
            <Slider x:Name="petal_width_input" Minimum="1" Maximum="50" Orientation="Horizontal" Grid.Row="3" Grid.Column="1" Width="200" ValueChanged="petal_width_input_ValueChanged"/>
        </Grid>
        <TextBlock x:Name="output" Text="Output:" FontSize="20" FontWeight="Bold" Grid.Row="3"/>
        <Grid Grid.Row="4">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="Auto"/>
                <ColumnDefinition Width="Auto"/>
            </Grid.ColumnDefinitions>
            <TextBlock x:Name="output_subtitle" Text="Based on the information provided, the Iris type is:"/>
            <TextBlock x:Name="model_output" Text="Model output" FontStyle="Italic"  Grid.Column="1" Margin="10,0,0,0"/>
        </Grid>
    </Grid>

Créer le contrôle d’application

Le code de contrôle d’application inclut MainPage.xaml.csla méthode principale pour exécuter l’application et plusieurs étapes pour exécuter votre modèle et exécuter la sortie :

Vous allez instancier un nouvel objet de la IrisModel classe que vous avez créée précédemment dans ce didacticiel.
Vous appellerez la méthode Evaluate() que vous avez créée dans la partie précédente, sur le modèle. Cette méthode sera appliquée quatre fois, une sur chacun des paramètres d’entrée : longueur sépale, largeur sépale, longueur pétale et largeur pétale.

L’application affiche le résultat en fonction de l’algorithme de prédiction machine learning.

Pour créer un code de contrôle d’application, double-cliquez sur le MainPage.xaml.cs fichier de code et ajoutez le code suivant.

using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
// The Blank Page item template is documented at https://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x409

namespace Iris_Data_Analysis
{
    /// <summary>
    /// An empty page that can be used on its own or navigated to within a Frame.
    /// </summary>
    public sealed partial class MainPage : Page
    {
        private IrisModel _iris_model;

        public MainPage()
        {
            this.InitializeComponent();
            _iris_model = new IrisModel();
#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
            _iris_model.Initialize();
#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
        }

        private void sepal_length_input_ValueChanged(object sender, RangeBaseValueChangedEventArgs e)
        {
            if (_iris_model != null)
            {
                _iris_model.Sepal_Length = (float)sepal_length_input.Value / 10.0f;
                model_output.Text = _iris_model.Evaluate();
            }
        }

        private void sepal_width_input_ValueChanged(object sender, RangeBaseValueChangedEventArgs e)
        {
            if (_iris_model != null)
            {
                _iris_model.Sepal_Width = (float)sepal_width_input.Value / 10.0f;
                model_output.Text = _iris_model.Evaluate();
            }
        }

        private void petal_length_input_ValueChanged(object sender, RangeBaseValueChangedEventArgs e)
        {
            if (_iris_model != null)
            {
                _iris_model.Petal_Length = (float)petal_length_input.Value / 10.0f;
                model_output.Text = _iris_model.Evaluate();
            }
        }

        private void petal_width_input_ValueChanged(object sender, RangeBaseValueChangedEventArgs e)
        {
            if (_iris_model != null)
            {
                _iris_model.Petal_Width = (float)petal_width_input.Value / 10.0f;
                model_output.Text = _iris_model.Evaluate();
            }
        }
    }
}

Lancer l’application

Vous êtes maintenant prêt à lancer votre application et à voir les résultats.

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.

L’interface graphique utilisateur de l’application inclut quatre curseurs pour modifier l’entrée des paramètres requis. Toute modification de l’entrée génère une nouvelle sortie basée sur l’algorithme de prédiction. La sortie s’affiche sous les curseurs d’entrée.

Vous pouvez voir que l’entrée donnée de la longueur du sépale = 40mm, la largeur du sépale = 50, la longueur pétale = 75 et la largeur pétale = 15, l’application a généré l’entrée du type Iris-versicolor !

Classification réussie de votre application

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.

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2025-06-10

Partager via

Déployer le modèle d’analyse des données dans l’application Windows avec des API Windows ML

À propos de l’exemple d’application

Créer une application Windows ML Desktop (C#)

Ouvrez un nouveau projet dans Visual Studio.

Explorer la solution de projet

Créer du code Machine Learning

Initialiser des classes Machine Learning

Charger le modèle

Définir le tensoreur d’entrée de modèle

Lier et évaluer le modèle

Extraire et afficher les résultats

Créer l’interface utilisateur de l’application

Créer le contrôle d’application

Lancer l’application

Résumé

Ressources additionnelles

Commentaires

Ressources supplémentaires