Bereitstellen eines Modells in einer Windows-App mit den Windows Machine Learning-APIs

Artikel
07/11/2023

Im vorherigen Teil dieses Tutorials haben Sie gelernt, wie Sie ein Modell im ONNX-Format erstellen und exportieren. Nachdem Sie nun über dieses Modell verfügen, können Sie es in eine Windows-Anwendung einbetten und lokal auf einem Gerät ausführen, indem Sie WinML-APIs aufrufen.

Sobald wir fertig sind, verfügen Sie über eine funktionierende Bildklassifizierungs-WinML-UWP-App (C#).

Infos zur Beispiel-App

Mit unserem Modell erstellen wir eine App, die Bilder von Lebensmitteln klassifizieren kann. Sie können ein Bild von Ihrem lokalen Gerät auswählen und mithilfe eines lokal gespeicherten ONNX-Klassifizierungsmodells verarbeiten, das Sie im vorherigen Teil erstellt und trainiert haben. Die zurückgegebenen Tags werden neben dem Bild angezeigt, ebenso wie die Konfidenzwahrscheinlichkeit der Klassifizierung.

Wenn Sie dieses Tutorial bis hier durchgearbeitet haben, sollten Sie bereits über die erforderlichen Voraussetzungen für die App-Entwicklung verfügen. Wenn Sie eine Auffrischung Ihrer Kenntnisse benötigen, lesen Sie den ersten Teil dieses Tutorials.

Hinweis

Wenn Sie den vollständigen Beispielcode lieber herunterladen möchten, können Sie die Projektmappendatei klonen. Klonen Sie das Repository, navigieren Sie zu diesem Beispiel, und öffnen Sie die Datei ImageClassifierAppUWP.sln dann mit Visual Studio. Anschließend können Sie mit dem Schritt [Launch the application](#Launch the application) fortfahren.

Erstellen einer WinML-UWP-App (C#)

Im Folgenden erfahren Sie, wie Sie Ihre App und Ihren WinML-Code von Grund auf neu erstellen. Sie lernen Folgendes:

Laden eines Machine Learning-Modells.
Laden eines Bilds im erforderlichen Format.
Binden der Ein- und Ausgaben des Modells.
Auswerten des Modells und Anzeigen aussagekräftiger Ergebnisse.

Sie verwenden auch einfachen XAML-Code, um eine einfache Benutzeroberfläche zu erstellen, damit Sie die Bildklassifizierung testen können.

Erstellen der App

Öffnen Sie Visual Studio, und wählen Sie create a new project aus.

Create a new Visual Studio project

Geben Sie UWP in der Suchleiste ein, und wählen Sie dann Blank APP (Universal Windows aus. Dadurch wird ein neues C#-Projekt für eine UWP-App mit einer Seite ohne vordefinierte Steuerelemente oder ein Layout geöffnet. Wählen Sie Next aus, um ein Konfigurationsfenster für das Projekt zu öffnen.

Create a new UWP app

Gehen Sie im Konfigurationsfenster folgendermaßen vor:

Wählen Sie einen Namen für Ihr Projekt aus. Hier verwenden wir ImageClassifierAppUWP.
Wählen Sie den Speicherort Ihres Projekts aus.
Wenn Sie VS 2019 verwenden, stellen Sie sicher, dass Place solution and project in the same directory deaktiviert ist.
Wenn Sie VS 2017 verwenden, stellen Sie sicher, dass Create directory for solution aktiviert ist.

Drücken Sie create, um das Projekt zu erstellen. Möglicherweise wird das Fenster für die Mindestzielversion angezeigt. Stellen Sie sicher, dass Ihre Mindestversion auf Windows 10, Build 17763 oder höher festgelegt ist.

Um eine App zu erstellen und ein Modell mit einer WinML-App bereitzustellen, benötigen Sie Folgendes:

Navigieren Sie nach dem Erstellen des Projekts zum Projektordner, öffnen Sie den Ressourcenordner [....\ImageClassifierAppUWP\Assets], und kopieren Sie Ihr Modell an diesen Speicherort.
Ändern Sie den Modellnamen von model.onnx in classifier.onnx. Dadurch wird alles etwas übersichtlicher und richtet sich am Format des Tutorials aus.

Untersuchen Ihres Modells

Machen Sie sich mit der Struktur Ihrer Modelldatei vertraut.

Öffnen Sie Ihre Modelldatei classifier.onnx mithilfe von Netron.
Drücken Sie Data, um die Modelleigenschaften zu öffnen.

Model properties

Wie Sie sehen können, benötigt das Modell ein 32-Bit-Tensor-float-Objekt (mehrdimensionales Array) als Eingabe und gibt zwei Ausgaben zurück: Die erste namens classLabel ist ein Tensor von Zeichenfolgen, und die zweite namens loss ist eine Sequenz von Zeichenfolge-zu-Gleitkomma-Zuordnungen, die die Wahrscheinlichkeit für jede bezeichnete Klassifizierung beschreiben. Sie benötigen diese Informationen, um die Modellausgabe erfolgreich in Ihrer Windows-App anzuzeigen.

Untersuchen der Projektmappe

Sehen wir uns Ihre Projektmappe an.

Visual Studio automatisch mehrere cs-code-Dateien innerhalb des Projektmappen-Explorer erstellt. MainPage.xaml enthält den XAML-Code für Ihre Benutzeroberfläche und MainPage.xaml.cs den Anwendungscode. Wenn Sie schon einmal eine UWP-App erstellt haben, sollten Ihnen diese Dateien sehr vertraut sein.

Erstellen der Benutzeroberfläche der Anwendung

Erstellen Sie zunächst eine einfache Benutzeroberfläche für Ihre App.

Doppelklicken Sie auf die Datei MainPage.xaml. In Ihrer leeren App ist die XAML-Vorlage für die Benutzeroberfläche Ihrer App leer, daher müssen Sie einige Benutzeroberflächenfeatures hinzufügen.
Fügen Sie dem Haupttext von MainPage.xaml den folgenden Code hinzu.

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

Windows Machine Learning-Codegenerator

Der Windows Machine Learning-Codegenerator oder mlgen ist eine Visual Studio-Erweiterung, die Ihnen den Einstieg in die Verwendung von WinML-APIs für UWP-Apps erleichtert. Die Erweiterung generiert Vorlagencode, wenn Sie dem UWP-Projekt eine trainierte ONNX-Datei hinzufügen.

Der Codegenerator mlgen von Windows Machine Learning erstellt eine Schnittstelle (für C#, C++/WinRT und C++/CX) mit Wrapperklassen, die die Windows ML-API für Sie aufrufen. Der Generator ermöglicht Ihnen das einfache Laden, Binden und Auswerten eines Modells in Ihrem Projekt. Wir verwenden ihn in diesem Tutorial, damit er viele dieser Funktionen für uns verarbeitet.

Der Codegenerator ist für Visual Studio 2017 und höher verfügbar. Denken Sie daran, dass mlgen in Windows 10, Version 1903 oder höher, nicht mehr im Windows 10 SDK enthalten ist. Daher müssen Sie die Erweiterung herunterladen und installieren. Wenn Sie dieses Tutorial ab der Einführung durchgearbeitet haben, haben Sie dies bereits berücksichtigt, andernfalls sollten Sie die Erweiterung jedoch für VS 2019 oder für VS 2017 herunterladen.

Hinweis

Weitere Informationen zu mlgen finden Sie in der mlgen-Dokumentation.

Installieren Sie mlgen, sofern dies noch nicht geschehen ist.
Klicken Sie mit der rechten Maustaste auf den Ordner Assets im Projektmappen-Explorer in Visual Studio, und wählen Sie dann Add > Existing Item aus.
Navigieren Sie zum Ressourcenordner in ImageClassifierAppUWP [….\ImageClassifierAppUWP\Assets], suchen Sie das ONNX-Modell, das Sie zuvor kopiert haben, und wählen Sie add aus.
Nachdem Sie dem Ressourcenordner im Projektmappen-Explorer in VS ein ONNX-Modell (Name: „classifier“) hinzugefügt haben, sollte das Projekt nun über zwei neue Dateien verfügen:

classifier.onnx – Dies ist Ihr Modell im ONNX-Format.
classifier.cs – Automatisch generierte WinML-Codedatei.

Project structure with ONNX model added

Um sicherzustellen, dass das Modell beim Kompilieren der Anwendung erstellt wird, wählen Sie die Datei classifier.onnx und dann Properties aus. Wählen Sie für Build Action die Option Content aus.

Sehen wir uns nun den neu generierten Code in der Datei „classifier.cs“ an.

Der generierte Code umfasst drei Klassen:

classifierModel: Diese Klasse enthält zwei Methoden für die Modellinstanziierung und Modellauswertung. Sie unterstützt uns bei der Machine Learning-Modelldarstellung sowie einer Sitzung auf dem Systemstandardgerät, bindet die spezifischen Eingaben und Ausgaben an das Modell und wertet das Modell dann asynchron aus.
classifierInput: Diese Klasse initialisiert die Eingabetypen, die das Modell erwartet. Die Modelleingabe hängt von den Modellanforderungen für Eingabedaten ab. In unserem Fall erwartet die Eingabe einen ImageFeatureValue, eine Klasse, die die Eigenschaften des verwendeten Bilds beschreibt, um sie an ein Modell zu übergeben.
classifierOutput: Diese Klasse initialisiert die Typen, die das Modell ausgibt. Die Modellausgabe hängt davon ab, wie sie vom Modell definiert wird. In unserem Fall ist die Ausgabe eine Sequenz von Zuordnungen (Wörterbüchern) vom Typ String und TensorFloat (Float32) namens „loss“.

Sie verwenden diese Klassen jetzt zum Laden, Binden und Auswerten des Modells in unserem Projekt.

Laden des Modells und der Eingaben

Laden des Modells

Doppelklicken Sie auf die Codedatei MainPage.xaml.cs, um den Anwendungscode zu öffnen.
Ersetzen Sie die using-Anweisungen durch Folgendes, um Zugriff auf alle benötigten APIs zu erhalten.

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

Fügen Sie die folgenden Variablendeklarationen nach den using-Anweisungen in Ihrer MainPage-Klasse unter dem Namespace ImageClassifierAppUWP hinzu.

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

Das Ergebnis sieht wie folgt aus.

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

Nun implementieren Sie die LoadModel-Methode. Die Methode greift auf das ONNX-Modell zu und speichert es im Arbeitsspeicher. Anschließend verwenden Sie die CreateFromStreamAsync-Methode, um das Modell als LearningModel-Objekt zu instanziieren. Die LearningModel-Klasse stellt ein trainiertes Machine Learning-Modell dar. Nach der Instanziieren ist LearningModel das anfängliche Objekt, das Sie für die Interaktion mit Windows ML verwenden.

Zum Laden des Modells können Sie mehrere statische Methoden in der LearningModel-Klasse verwenden. In diesem Fall verwenden Sie die CreateFromStreamAsync-Methode.

Die CreateFromStreamAsync-Methode wurde automatisch mit mlgen erstellt, sodass Sie diese Methode nicht implementieren müssen. Sie können diese Methode überprüfen, indem Sie auf die Datei classifier.cs doppelklicken, die von mlgen generiert wird.

Weitere Informationen zur LearningModel-Klasse finden Sie in der Dokumentation zur LearningModel-Klasse. Weitere Informationen zu weiteren Möglichkeiten zum Laden des Modells finden Sie in der Dokumentation zum Laden eines Modells.

Fügen Sie Ihrer Codedatei MainPage.xaml.cs innerhalb der MainPage-Klasse eine loadModel-Methode hinzu.

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

Fügen Sie nun dem Konstruktor der Klasse einen Aufruf der neuen Methode hinzu.

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

Das Ergebnis sieht wie folgt aus.

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

Laden des Bilds

Sie müssen ein Klickereignis definieren, um die Sequenz von vier Methodenaufrufen für die Modellausführung zu initiieren: Konvertierung, Bindung und Auswertung, Ausgabeextraktion und Anzeige der Ergebnisse. Fügen Sie der Codedatei MainPage.xaml.cs innerhalb der MainPage-Klasse die folgende Methode hinzu.

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

Nun implementieren Sie die getImage()-Methode. Diese Methode wählt eine Eingabebilddatei aus und speichert sie im Arbeitsspeicher. Fügen Sie der Codedatei MainPage.xaml.cs innerhalb der MainPage-Klasse die folgende Methode hinzu.

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

Nun implementieren Sie eine Bind()-Bildmethode, um die Darstellung der Datei im BGRA8-Bitmapformat abzurufen.

Fügen Sie der Codedatei MainPage.xaml.cs in der MainPage-Klasse die Implementierung der convert()-Methode hinzu. Die convert-Methode gibt eine Darstellung der Eingabedatei im BGRA8-Format zurück.

// 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)
            {
            }
        }

Das Ergebnis der in diesem Abschnitt durchgeführten Aufgaben sieht wie folgt aus.

        // 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)
            {
            }
        }

Binden und Auswerten des Modells

Nun erstellen Sie eine Sitzung basierend auf dem Modell, binden die Ein- und Ausgabe aus der Sitzung und werten das Modell aus.

Erstellen Sie eine Sitzung, um das Modell zu binden:

Zum Erstellen einer Sitzung verwenden Sie die LearningModelSession-Klasse. Diese Klasse wird verwendet, um Machine Learning-Modelle auszuwerten, und bindet das Modell an ein Gerät, das dann ausgeführt wird und das Modell auswertet. Sie können ein Gerät auswählen, wenn Sie eine Sitzung erstellen, um Ihr Modell auf einem bestimmten Gerät Ihres Computers auszuführen. Die CPU ist das Standardgerät.

Hinweis

Weitere Informationen zum Auswählen eines Geräts finden Sie in der Dokumentation zum Erstellen einer Sitzung.

Binden Sie die Modellein- und -ausgaben:

Zum Binden von Eingabe und Ausgabe verwenden Sie die LearningModelBinding-Klasse. Ein Machine Learning-Modell verfügt über Eingabe-und Ausgabefunktionen, mit denen Informationen an das und aus dem Modell übergeben werden. Beachten Sie, dass erforderliche Features von den Window ML-APIs unterstützt werden müssen. Die LearningModelBinding-Klasse wird auf eine LearningModelSession angewendet, um Werte an benannte Eingabe- und Ausgabefeatures zu binden.

Die Implementierung der Bindung wird automatisch von mlgen generiert, sodass Sie sich nicht darum kümmern müssen. Die Bindung wird durch Aufrufen der vordefinierten Methoden der LearningModelBinding-Klasse implementiert. In unserem Fall wird die Bind-Methode verwendet, um einen Wert an den benannten Featuretyp zu binden.

Derzeit unterstützt Windows ML alle ONNX-Featuretypen wie Tensoren (mehrdimensionale Arrays), Sequenzen (Vektoren von Werten), Zuordnung (Wertpaare von Informationen) und Bilder (bestimmte Formate). Alle Bilder werden in Windows ML in einem Tensorformat dargestellt. Tensorisierung ist der Prozess, bei dem ein Bild in einen Tensor konvertiert wird. Dies erfolgt während der Bindung.

Glücklicherweise müssen Sie sich nicht um die Tensorisierungskonvertierung kümmern. Die ImageFeatureValue-Methode, die Sie im vorherigen Teil verwendet haben, übernimmt sowohl die Konvertierung als auch die Tensorisierung, sodass die Bilder mit dem erforderlichen Bildformat des Modells übereinstimmen.

Hinweis

Weitere Informationen zum Binden eines LearningModel und zu den von WinML unterstützten Featuretypen finden Sie in der Dokumentation zum Binden eines Modells.

Werten Sie das Modell aus:

Nachdem Sie eine Sitzung erstellt haben, um das Modell und die gebundenen Werte an die Eingaben und Ausgaben eines Modells zu binden, können Sie die Eingaben des Modells auswerten und seine Vorhersagen erhalten. Um die Modellausführung ausführen zu können, sollten Sie eine der vordefinierten Auswertungsmethoden für LearningModelSession aufrufen. In unserem Fall verwenden wir die EvaluateAsync-Methode.

Ähnlich wie CreateFromStreamAsync wurde die EvaluateAsync-Methode auch automatisch vom WinML-Codegenerator generiert, sodass Sie diese Methode nicht implementieren müssen. Sie können diese Methode in der Datei classifier.cs überprüfen.

Die EvaluateAsync-Methode wertet das Machine Learning-Modell asynchron mithilfe der Featurewerte aus, die bereits in Bindungen gebunden sind. Sie erstellt eine Sitzung mit LearningModelSession, bindet die Eingabe und Ausgabe mit LearningModelBinding, führt die Modellauswertung aus und ruft die Ausgabefeatures des Modells mithilfe der LearningModelEvaluationResult-Klasse ab.

Hinweis

Weitere Informationen zu weiteren Auswertemethoden zum Ausführen des Modells finden Sie in der Dokumentation zur Klasse LearningModelSession, die zeigt, welche Methoden für die LearningModelSession implementiert werden können.

Fügen Sie der Codedatei MainPage.xaml.cs in der MainPage-Klasse die folgende Methode hinzu, um eine Sitzung zu erstellen und das Modell zu binden und zu bewerten.

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

Extrahieren und Anzeigen der Ergebnisse

Sie müssen nun die Modellausgabe extrahieren und die richtigen Ergebnisse anzeigen. Implementieren Sie dazu die extractResult- und displayResult-Methoden.

Wie Sie zuvor untersucht haben, gibt das Modell zwei Ausgaben zurück: das erste benannte classLabel-Element ist ein Tensor von Zeichenfolgen, der zweite benannte „loss“ ist eine Sequenz von Zeichenfolgen-zu-Gleitkomma-Zuordnungen, die die Wahrscheinlichkeit für jede bezeichnete Klassifizierung beschreiben. Um das Ergebnis und die Wahrscheinlichkeit also erfolgreich anzuzeigen, müssen Sie nur die Ausgabe aus der loss-Ausgabe extrahieren. Sie müssen die höchste Wahrscheinlichkeit für die Rückgabe des richtigen Ergebnisses finden.

Fügen Sie Ihrer Codedatei MainPage.xaml.cs innerhalb der MainPage-Klasse die extractResult-Methode hinzu.

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

Fügen Sie Ihrer Codedatei MainPage.xaml.cs innerhalb der MainPage-Klasse die displayResult-Methode hinzu.

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

Das Ergebnis von Bind and Evaluate (Binden und auswerten) und Extract and display the results (Extrahieren und Ergebnisse anzeigen) des WinML-Codes Ihrer App sieht wie folgt aus.

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

Das ist alles! Sie haben die Windows Machine Learning-App mit einer einfachen Benutzeroberfläche erfolgreich erstellt, um unser Klassifizierungsmodell zu testen. Im nächsten Schritt starten Sie die Anwendung und führen sie lokal auf Ihrem Windows-Gerät aus.

Die Anwendung starten

Nachdem Sie die Anwendungsschnittstelle fertiggestellt, das Modell hinzugefügt und den WinML-Code generiert haben, können Sie die Anwendung testen. Stellen Sie sicher, dass die Dropdownmenüs in der oberen Symbolleiste auf Debug festgelegt sind. Ändern Sie Solution Platform in x64, um das Projekt auf Ihrem lokalen Computer ausführen, wenn Sie ein 64-Bit-Gerät verwenden, oder in x86 für ein 32-Bit-Gerät.

Um Ihre App zu testen, verwenden Sie das folgende Bild, Obst zeigt. Sehen wir uns an, wie unsere App den Inhalt des Bilds klassifiziert.

Example fruit image

Speichern Sie dieses Bild auf Ihrem lokalen Gerät, um die App zu testen. Ändern Sie das Bildformat bei Bedarf in das JPG-Format. Sie können auch ein beliebiges anderes relevantes Bild von Ihrem lokalen Gerät in einem geeigneten Format hinzufügen: Die JPG-, PNG-, BMP- oder GIF-Formate sind zulässig.
Klicken Sie zum Ausführen des Projekts auf der Symbolleiste auf die Schaltfläche Start Debugging, oder drücken Sie F5.
Wenn die Anwendung gestartet wird, drücken Sie Pick Image und wählen das Bild auf Ihrem lokalen Gerät aus.

Pick image dialog

Das Ergebnis wird sofort auf dem Bildschirm angezeigt. Wie Sie sehen können, hat Ihre WinML-App das Bild mit einer Konfidenzbewertung von 99,9 % erfolgreich als Obst oder Gemüse klassifiziert.

Successful image classification

Zusammenfassung

Sie haben soeben Ihre erste Windows Machine Learning-App erstellt: von der Modellerstellung bis zur erfolgreichen Ausführung.

Weitere Ressourcen

Weitere Informationen zu den in diesem Tutorial erwähnten Themen finden Sie in den folgenden Ressourcen:

Windows ML-Tools: Erfahren Sie mehr über Tools wie das Windows ML-Dashboard, WinMLRunner und den Windows ML-Codegenerator mglen.
ONNX-Modell: Erfahren Sie mehr über das ONNX-Format.
Windows ML-Leistung und -Arbeitsspeicher: Erfahren Sie mehr über das Verwalten der App-Leistung mit Windows ML.
Windows Machine Learning-API-Referenz: Erfahren Sie mehr über drei Bereiche von Windows ML-APIs.

Teilen über

Bereitstellen eines Modells in einer Windows-App mit den Windows Machine Learning-APIs

Infos zur Beispiel-App

Erstellen einer WinML-UWP-App (C#)

Erstellen der App

Untersuchen Ihres Modells

Untersuchen der Projektmappe

Erstellen der Benutzeroberfläche der Anwendung

Windows Machine Learning-Codegenerator

Laden des Modells und der Eingaben

Laden des Modells

Laden des Bilds

Binden und Auswerten des Modells

Erstellen Sie eine Sitzung, um das Modell zu binden:

Binden Sie die Modellein- und -ausgaben:

Werten Sie das Modell aus:

Extrahieren und Anzeigen der Ergebnisse

Die Anwendung starten

Zusammenfassung

Weitere Ressourcen

Feedback

Feedback

Zusätzliche Ressourcen