Bereitstellen Ihres ML.NET Modells in einer Windows-App mit den Windows Machine Learning-APIs

Im vorherigen Teil dieses Lernprogramms haben Sie gelernt, wie Sie ein ML.NET 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 Bildklassifizierer-WinML-UWP-App (C#).

Informationen zur Beispiel-App

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

Wenn Sie bisher diesem Lernprogramm folgen, sollten Sie bereits über die erforderlichen Voraussetzungen für die App-Entwicklung verfügen. Wenn Sie eine Aktualisierung benötigen, lesen Sie den ersten Teil dieses Lernprogramms.

Erstellen einer WinML-UWP (C#)

Unten zeigen wir Ihnen, wie Sie Ihre App und WinML-Code von Grund auf neu erstellen. Hier erfahren Sie, wie Sie:

• Laden sie ein Machine Learning-Modell.
• Laden Sie ein Bild im erforderlichen Format.
• Binden Sie die Eingaben und Ausgaben des Modells.
• Bewerten Sie das Modell, und zeigen Sie aussagekräftige Ergebnisse an.

Sie verwenden auch einfaches XAML zum Erstellen einer einfachen GUI, sodass Sie den Bildklassifizierer testen können.

Erstellen der App

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

2. Geben Sie in der Suchleiste die Zeichenfolge UWP ein, und wählen Sie Blank APP (Universal Windowsdann aus. Dadurch wird ein neues C#-Projekt für eine Einseiten-App für die universelle Windows-Plattform (UWP) geöffnet, die keine vordefinierten Steuerelemente oder layouts enthält. Wählen Sie diese Option Next aus, um ein Konfigurationsfenster für das Projekt zu öffnen.

3. Im Konfigurationsfenster:

• Wählen Sie einen Namen für Ihr Projekt aus. Hier verwenden wir classifierMLNETModel.
• 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 die Option deaktiviert ist.
• Wenn Sie VS 2017 verwenden, stellen Sie sicher, dass Create directory for solution aktiviert ist.

Drücken Sie create , um Ihr 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:

4. Navigieren Sie nach dem Erstellen des Projekts zum Projektordner, öffnen Sie den Ressourcenordner [....\classifierMLNETModel\Assets], und kopieren Sie die bestModel.onnx Datei an diesen Speicherort.

Projektlösung erkunden

Lassen Sie uns Ihre Projektlösung erkunden.

Visual Studio hat automatisch mehrere Cs-Code-Dateien im Projektmappen-Explorer erstellt. MainPage.xaml enthält den XAML-Code für Ihre GUI und MainPage.xaml.cs enthält den Anwendungscode. Wenn Sie zuvor eine UWP-App erstellt haben, sollten diese Dateien Ihnen sehr vertraut sein.

Erstellen der Anwendungs-GUI

Zunächst erstellen wir eine einfache GUI für Ihre App.

1. Doppelklicken Sie auf die MainPage.xaml Datei. In Ihrer leeren App ist die XAML-Vorlage für die GUI Ihrer App leer, daher müssen wir einige UI-Features hinzufügen.

2. Ersetzen Sie den Code in MainPage.xaml mit dem folgenden.

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

Hinzufügen des Modells zum Projekt mithilfe des Windows Machine Learning Code Generators

Der Windows Machine Learning Code Generator oder mlgen ist eine Visual Studio-Erweiterung, die Ihnen bei den ersten Schritten mit WinML-APIs in UWP-Apps hilft. Es generiert Vorlagencode, wenn Sie dem UWP-Projekt eine trainierte ONNX-Datei hinzufügen.

Der Codegenerator von Windows Machine Learning erstellt mlgen eine Schnittstelle (für C#, C++/WinRT und C++/CX) mit Wrapperklassen, die die Windows ML-API für Sie aufrufen. Auf diese Weise können Sie ein Modell in Ihrem Projekt ganz einfach laden, binden und auswerten. Wir verwenden es in diesem Tutorial, um viele dieser Funktionen für uns auszuführen.

Der Codegenerator ist für Visual Studio 2017 und höher verfügbar. Bitte beachten Sie, dass mlgen in Windows 10, Version 1903 und 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.

1. Falls noch nicht geschehen, installieren Sie mlgen.

2. Klicken Sie im Projektmappen-Explorer in Visual Studio mit der rechten Maustaste auf den Assets Ordner, und wählen Sie dann aus Add > Existing Item.

3. Navigieren Sie zu dem Ressourcenordner innerhalb ImageClassifierAppUWP [….\ImageClassifierAppUWP\Assets], suchen Sie das ONNX-Modell, das Sie zuvor dort kopiert haben, und wählen Sie dann aus add.

4. Nachdem Sie dem Ressourcenordner im Projektmappen-Explorer in VS ein ONNX-Modell (Name: "Klassifizierer") hinzugefügt haben, sollte das Projekt nun zwei neue Dateien haben:

• bestModel.onnx – Dies ist Ihr Modell im ONNX-Format.
• bestModel.cs – automatisch generierte WinML-Codedatei.

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

Sehen wir uns nun den neu generierten Code in der bestModel.cs Datei an.

Der generierte Code enthält drei Klassen:

• bestModelModel: Diese Klasse enthält zwei Methoden für die Modellinstanziierung und Modellauswertung. Es hilft uns, die Darstellung des Machine Learning-Modells zu erstellen, eine Sitzung auf dem Systemstandardgerät zu erstellen, die spezifischen Eingaben und Ausgaben an das Modell zu binden und das Modell asynchron auszuwerten.
• bestModelInput: Diese Klasse initialisiert die Eingabetypen, die das Modell erwartet. Die Modelleingabe hängt von den Modellanforderungen für Eingabedaten ab.
• bestModelOutput: Diese Klasse initialisiert die Vom Modell ausgegebenen Typen. Die Modellausgabe hängt davon ab, wie es vom Modell definiert wird.

Sie verwenden jetzt diese Klassen, um das Modell in unserem Projekt zu laden, zu binden und auszuwerten.

Tensorkonvertierung

Um den Umgang mit Tensorisierung zu vereinfachen, ändern Sie die Eingabeklasse TensorFloat in ImageFeatureValue.

1. Nehmen Sie die folgenden Änderungen in der bestModel.cs Datei vor:

Der Code:

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

Wird werden:

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

Laden des Modells und der Eingaben

Laden des Modells

1. Doppelklicken Sie auf die MainPage.xaml.cs Codedatei, um den Anwendungscode zu öffnen.

2. Ersetzen Sie die "using"-Anweisungen durch Folgendes, um zugriff auf alle apIs zu erhalten, die Sie benötigen.

// 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. Fügen Sie die folgenden Variablendeklarationen nach den using-Anweisungen in Ihrer MainPage Klasse unter dem Namespace classifierMLNETModelhinzu.

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

Jetzt 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 Instanziierung ist das LearningModel erste 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, daher müssen Sie diese Methode nicht implementieren. Sie können diese Methode überprüfen, indem Sie auf die bestModel.cs von mlgen generierte Datei doppelklicken.

Weitere Informationen zum LearningModel Kurs finden Sie in der LearningModel Class-Dokumentation.

Weitere Informationen zum Laden des Modells finden Sie in der Dokumentation zum Laden eines Modells.

4. Definieren wir die Hauptmethode.

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

5. Fügen Sie die Implementierung der loadModel Methode zu Ihrer MainPage.xaml.cs Codedatei innerhalb der Klasse MainPage 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/bestModel.onnx"));
// Instantiate the model. 
	modelGen = await bestModelModel.CreateFromStreamAsync(modelFile);
}

Laden des Bilds

1. Wir müssen ein Click-Ereignis definieren, um die Abfolge 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();
        }

2. Jetzt implementieren Sie die getImage() Methode. Mit dieser Methode wird eine Eingabebilddatei ausgewählt und im Arbeitsspeicher gespeichert. 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;
        }

Als Nächstes implementieren Sie eine Bildmethode Bind() , um die Darstellung der Datei im Bitmap-BGRA8-Format abzurufen. Zuerst erstellen Sie jedoch eine Hilfsklasse, um die Größe des Bilds zu ändern.

3. Um eine Hilfsdatei zu erstellen, klicken Sie mit der rechten Maustaste auf den Lösungsnamen (ClassifierPyTorch), und wählen Sie Add a new itemdann aus. Wählen Sie im geöffneten Fenster Class aus und geben Sie ihm einen Namen. Hier nennen wir es Helper.

4. In Ihrem Projekt wird eine neue Klassendatei angezeigt. Öffnen Sie diese Klasse, und fügen Sie den folgenden Code hinzu:

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

Jetzt konvertieren wir das Bild in das entsprechende Format.

Die bestModelInput Klasse initialisiert die Eingabetypen, die das Modell erwartet. In unserem Fall haben wir unseren Code so konfiguriert, dass er ein ImageFeatureValue erwartet.

Die ImageFeatureValue Klasse beschreibt die Eigenschaften des Bilds, das zum Übergeben an ein Modell verwendet wird. Um einImageFeatureValue zu erstellen, verwenden Sie die CreateFromVideoFrame Methode. Ausführlichere Informationen dazu, warum dies der Fall ist und wie diese Klassen und Methoden funktionieren, finden Sie in der ImageFeatureValue-Klassendokumentation.

5. Fügen Sie die Implementierung der Methode convert() Ihrer Codedatei MainPage.xaml.cs innerhalb der MainPage-Klasse hinzu. Die Convert-Methode ruft uns eine Darstellung der Eingabedatei in einem BGRA8-Format ab.

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

Binden und Auswerten des Modells

Als Nächstes erstellen Sie eine Sitzung basierend auf dem Modell, binden die Eingabe und Ausgabe aus der Sitzung, und bewerten das Modell.

Erstellen Sie eine Sitzung zum Binden des Modells:

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 und ausgewertet wird. 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. Das Standardgerät ist die CPU.

Binden von Modelleingaben und -ausgaben:

Zum Binden von Eingaben und Ausgaben verwenden Sie die LearningModelBinding Klasse. Ein Machine Learning-Modell verfügt über Eingabe- und Ausgabefeatures, die Informationen an und aus dem Modell übergeben. 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 nicht darauf achten 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.

Auswerten des Modells:

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 die zugehörigen Vorhersagen abrufen. Um die Modellausführung auszuführen, sollten Sie eine der vordefinierten Auswertenmethoden für die LearningModelSession aufrufen. In unserem Fall verwenden wir die EvaluateAsync Methode.

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

Die EvaluateAsync Methode wertet das Machine Learning-Modell asynchron mit den Featurewerten 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.

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

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

Extrahieren und Anzeigen der Ergebnisse

Sie müssen nun die Modellausgabe extrahieren und das richtige Ergebnis anzeigen, was Sie durch Implementieren der Methoden extractResult und displayResult tun werden. Sie müssen die höchste Wahrscheinlichkeit finden, damit die korrekte Bezeichnung zurückgegeben wird.

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

        // 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. Fügen Sie die displayResult Methode ihrer MainPage.xaml.cs Codedatei innerhalb der MainPage Klasse hinzu.

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

Fertig! Sie haben die Windows Machine Learning-App erfolgreich mit einer grundlegenden GUI erstellt, um unser Klassifizierungsmodell zu testen. Der nächste Schritt besteht darin, die Anwendung zu starten und lokal auf Ihrem Windows-Gerät auszuführen.

Starten der Anwendung

Nachdem Sie die Anwendungsschnittstelle abgeschlossen, das Modell hinzugefügt und den Windows ML-Code generiert haben, können Sie die Anwendung testen!

Aktivieren Sie den Entwicklermodus, und testen Sie Ihre Anwendung in Visual Studio. Stellen Sie sicher, dass die Dropdownmenüs in der oberen Symbolleiste auf Debug festgelegt sind. Ändern Sie die Projektmappenplattform in x64, um das Projekt auf dem lokalen Computer auszuführen, wenn es sich um ein 64-Bit-Gerät handelt, oder in x86 für einen 32-Bit-Computer.

Um unsere App zu testen, verwenden wir das folgende Bild von Suppe. Sehen wir uns an, wie unsere App den Inhalt des Bilds klassifiziert.

1. Speichern Sie dieses Bild auf Ihrem lokalen Gerät, um die App zu testen. Ändern Sie bei Bedarf das Bildformat in .jpg. Sie können auch ein anderes relevantes Bild von Ihrem lokalen Gerät in einem .jpg- oder .png-Format hinzufügen.

2. Um das Projekt auszuführen, wählen Sie die Start Debugging Schaltfläche auf der Symbolleiste aus, oder drücken Sie F5.

3. Wenn die Anwendung startet, drücken Sie Pick Image und wählen Sie das Bild auf Ihrem lokalen Gerät aus.

Das Ergebnis wird sofort auf dem Bildschirm angezeigt. Wie Sie sehen können, klassifizierte unsere Windows ML-App das Bild erfolgreich als Suppe.

Zusammenfassung

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

Zusätzliche Ressourcen

Weitere Informationen zu themen, die in diesem Lernprogramm erwähnt werden, finden Sie in den folgenden Ressourcen:

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