Uw model implementeren in een Windows-app met de Windows Machine Learning-API's

In het vorige deel van deze zelfstudie hebt u geleerd hoe u een model in ONNX-indeling bouwt en exporteert. Nu u dat model hebt, kunt u het insluiten in een Windows-toepassing en lokaal uitvoeren op een apparaat door WinML-API's aan te roepen.

Zodra we klaar zijn, hebt u een werkende Afbeeldingsclassificatie WinML UWP-app (C#).

Over de voorbeeld-app

Met behulp van ons model maken we een app waarmee afbeeldingen van voedsel kunnen worden geclassificeerd. Hiermee kunt u een afbeelding van uw lokale apparaat selecteren en verwerken door een lokaal opgeslagen CLASSIFICATIE ONNX-model dat u in het vorige deel hebt gemaakt en getraind. De geretourneerde tags worden naast de afbeelding weergegeven, evenals de betrouwbaarheidskans van de classificatie.

Als u deze zelfstudie tot nu toe hebt gevolgd, moet u al beschikken over de vereiste vereisten voor app-ontwikkeling. Als u een opfrisser nodig hebt, bekijkt u het eerste deel van deze handleiding.

Opmerking

Als u liever de volledige voorbeeldcode downloadt, kunt u het oplossingsbestand klonen. Kloon de opslagplaats, navigeer naar dit voorbeeld en open het ImageClassifierAppUWP.sln bestand met Visual Studio. Vervolgens kunt u doorgaan naar de stap [De toepassing starten](#Launch de toepassing).

Een WinML UWP (C#) maken

Hieronder ziet u hoe u uw app en WinML-code helemaal zelf kunt maken. U leert het volgende:

• Een machine learning-model laden.
• Laad een afbeelding in de vereiste indeling.
• Bind de invoer en uitvoer van het model.
• Evalueer het model en geef zinvolle resultaten weer.

U gebruikt ook basic XAML om een eenvoudige GUI te maken, zodat u de afbeeldingsclassificatie kunt testen.

De app maken

1. Open Visual Studio en kies create a new project.

2. Typ UWP en selecteer Blank APP (Universal Windowsvervolgens in de zoekbalk ). Hiermee opent u een nieuw C#-project voor een UWP-app (Universal Windows Platform) met één pagina die geen vooraf gedefinieerde besturingselementen of indeling heeft. Selecteer Next deze optie om een configuratievenster voor het project te openen.

3. In het configuratievenster:

• Kies een naam voor uw project. Hier gebruiken we ImageClassifierAppUWP.
• Kies de locatie van uw project.
• Als u VS 2019 gebruikt, controleert u of Place solution and project in the same directory dit selectievakje is uitgeschakeld.
• Als u VS 2017 gebruikt, zorg ervoor dat Create directory for solution is aangevinkt.

Druk create om uw project te maken. Het venster met de minimale doelversie kan opduiken. Zorg ervoor dat uw minimale versie is ingesteld op Windows 10 build 17763 of hoger.

Als u een app wilt maken en een model wilt implementeren met een WinML-app, hebt u het volgende nodig:

4. Nadat het project is aangemaakt, gaat u naar de projectmap, opent u de map Assets [...\ImageClassifierAppUWP\Assets], en kopieert u uw model naar deze locatie.

5. Wijzig de modelnaam van model.onnx in classifier.onnx. Dit maakt het iets duidelijker en stemt deze beter af op de indeling van de handleiding.

Uw model verkennen

Laten we vertrouwd raken met de structuur van het modelbestand.

1. Open uw classifier.onnx modelbestand door middel van Netron.

2. Druk Data om de modeleigenschappen te openen.

Zoals u kunt zien, vereist het model een 32-bits Tensor-floatobject (multidimensionale matrix) als invoer en retourneert twee uitvoerwaarden: de eerste benoemde classLabel is tensor van tekenreeksen en de tweede benoemde loss is een reeks tekenreeks-naar-float-kaarten die de waarschijnlijkheid voor elke gelabelde classificatie beschrijven. U hebt deze informatie nodig om de modeluitvoer in uw Windows-app weer te geven.

Projectoplossing verkennen

Laten we uw projectoplossing verkennen.

Visual Studio heeft automatisch verschillende cs-code-bestanden gemaakt in Solution Explorer. MainPage.xaml bevat de XAML-code voor uw GUI en MainPage.xaml.cs bevat uw toepassingscode. Als u eerder een UWP-app hebt gemaakt, moeten deze bestanden u goed kennen.

De toepassings-GUI maken

Laten we eerst een eenvoudige GUI voor uw app maken.

1. Dubbelklik op het MainPage.xaml bestand. In uw lege app is de XAML-sjabloon voor de GUI van uw app leeg, dus we moeten enkele UI-functies toevoegen.

2. Voeg de onderstaande code toe aan de hoofdtekst van 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>

Windows Machine Learning-codegenerator

Windows Machine Learning Code Generator of mlgen is een Visual Studio-extensie om u te helpen aan de slag te gaan met WinML-API's in UWP-apps. Er wordt sjablooncode gegenereerd wanneer u een getraind ONNX-bestand toevoegt aan het UWP-project.

De codegenerator mlgen van Windows Machine Learning maakt een interface (voor C#, C++/WinRT en C++/CX) met wrapperklassen die de Windows ML-API voor u aanroepen. Hierdoor kunt u eenvoudig een model in uw project laden, binden en evalueren. We gebruiken het in deze handleiding om veel van die functies voor ons af te handelen.

Codegenerator is beschikbaar voor Visual Studio 2017 en hoger. Houd er rekening mee dat mlgen in Windows 10, versie 1903 en hoger niet meer is opgenomen in de Windows 10 SDK, dus u moet de extensie downloaden en installeren. Als u deze zelfstudie sinds de inleiding hebt gevolgd, hebt u dit al afgehandeld, maar als dat niet het geval is, moet u de download uitvoeren voor VS 2019 of voor VS 2017.

Opmerking

Raadpleeg de mlgen-documentatie voor meer informatie over mlgen

1. Als u dat nog niet hebt gedaan, installeert u mlgen.

2. Klik met de rechtermuisknop op de Assets map in Solution Explorer in Visual Studio en selecteer Add > Existing Item.

3. Navigeer naar de map assets binnen ImageClassifierAppUWP [….\ImageClassifierAppUWP\Assets], zoek het ONNX-model dat u daar eerder hebt gekopieerd, en selecteer add.

4. Nadat u een ONNX-model (naam: 'classifier') hebt toegevoegd aan de map assets in Solution Explorer in VS, moet het project nu twee nieuwe bestanden hebben.

• classifier.onnx - dit is uw model in ONNX-indeling.
• classifier.cs – automatisch gegenereerd WinML-codebestand.

5. Als u ervoor wilt zorgen dat het model wordt gebouwd wanneer u onze toepassing compileert, selecteert u het classifier.onnx bestand en kiest u Properties. Selecteer Build Action voor Content.

Laten we nu de zojuist gegenereerde code in het classifier.cs-bestand verkennen.

De gegenereerde code bevat drie klassen:

• classifierModel: Deze klasse bevat twee methoden voor modelinstantie en modelevaluatie. Het helpt ons om de weergave van het machine learning-model te maken, een sessie te maken op het standaardapparaat van het systeem, de specifieke invoer en uitvoer aan het model te binden en het model asynchroon te evalueren.
• classifierInput: Met deze klasse worden de invoertypen geïnitialiseerd die het model verwacht. De modelinvoer is afhankelijk van de modelvereisten voor invoergegevens. In ons geval verwacht de invoer een ImageFeatureValue, een klasse die de eigenschappen beschrijft van de afbeelding die wordt gebruikt om door te geven aan een model.
• classifierOutput: Met deze klasse worden de typen geïnitialiseerd die door het model worden uitgevoerd. De modeluitvoer is afhankelijk van hoe het wordt gedefinieerd door het model. In ons geval zal de uitvoer een reeks mappen (woordenboeken) van het type String en TensorFloat (Float32) zijn, die loss worden genoemd.

U gebruikt deze klassen nu om het model in ons project te laden, te binden en te evalueren.

Het model en de invoer laden

Het model laden

1. Dubbelklik op het MainPage.xaml.cs codebestand om de toepassingscode te openen.

2. Vervang de instructies 'using' door het volgende om toegang te krijgen tot alle API's die u nodig hebt.

// 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. Voeg de volgende variabeledeclaraties toe na de using-instructies in uw MainPage klasse, onder de naamruimte 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;

Het resultaat ziet er als volgt uit.

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

Nu gaat u de LoadModel methode implementeren. De methode opent het ONNX-model en slaat het op in het geheugen. Vervolgens gebruikt u de CreateFromStreamAsync methode om het model te instantiëren als een LearningModel object. De LearningModel klasse vertegenwoordigt een getraind machine learning-model. Zodra LearningModel is geïnstantieerd, is het het eerste object dat u gebruikt om te communiceren met Windows ML.

Als u het model wilt laden, kunt u verschillende statische methoden in de LearningModel klasse gebruiken. In dit geval gebruikt u de CreateFromStreamAsync methode.

De CreateFromStreamAsync methode is automatisch gemaakt met mlgen, dus u hoeft deze methode niet te implementeren. U kunt deze methode controleren door te dubbelklikken op het classifier.cs bestand dat is gegenereerd door mlgen.

Raadpleeg de LearningModel voor meer informatie over de klas. Raadpleeg de documentatie over een model laden voor meer informatie over aanvullende manieren om het model te laden

4. Voeg een loadModel methode toe aan uw MainPage.xaml.cs codebestand in de MainPage klasse.

        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. Voeg nu een aanroep naar de nieuwe methode toe aan de constructor van de klasse.

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

Het resultaat ziet er als volgt uit.

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

De afbeelding laden

1. We moeten een klik-gebeurtenis definiëren om de reeks vier methode-aanroepen voor modeluitvoering te initiëren: conversie, binding en evaluatie, uitvoerextractie en weergave van de resultaten. Voeg de volgende methode toe aan uw MainPage.xaml.cs codebestand in de MainPage klasse.

        // 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. Nu gaat u de getImage() methode implementeren. Met deze methode selecteert u een invoerafbeeldingsbestand en slaat u het op in het geheugen. Voeg de volgende methode toe aan uw MainPage.xaml.cs codebestand in de MainPage klasse.

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

U gaat nu een afbeeldingsmethode Bind() implementeren om de weergave van het bestand in de bitmap-BGRA8-indeling op te halen.

3. Voeg de implementatie van de convert() methode toe aan uw MainPage.xaml.cs codebestand in de klasse MainPage. Met de conversiemethode krijgen we een weergave van het invoerbestand in een BGRA8-indeling.

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

Het resultaat van het werk dat in deze sectie is uitgevoerd, ziet er als volgt uit.

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

Het model binden en evalueren

Vervolgens maakt u een sessie op basis van het model, verbindt u de invoer en uitvoer van de sessie en evalueert u het model.

Maak een sessie om het model te binden:

Als u een sessie wilt maken, gebruikt u de LearningModelSession klasse. Deze klasse wordt gebruikt om machine learning-modellen te evalueren en verbindt het model met een apparaat dat vervolgens het model uitvoert en evalueert. U kunt een apparaat selecteren wanneer u een sessie maakt om uw model uit te voeren op een specifiek apparaat van uw computer. Het standaardapparaat is de CPU.

Opmerking

Raadpleeg de documentatie een sessie maken voor meer informatie over het kiezen van een apparaat.

Modelinvoer en -uitvoer binden:

Als u invoer en uitvoer wilt binden, gebruikt u de LearningModelBinding klasse. Een machine learning-model heeft invoer- en uitvoerfuncties, die informatie doorgeven aan en uit het model. Houd er rekening mee dat de vereiste functies moeten worden ondersteund door de Windows ML-API's. De LearningModelBinding klasse wordt toegepast op een LearningModelSession om waarden te binden aan benoemde invoer- en uitvoerfuncties.

De implementatie van de binding wordt automatisch gegenereerd door mlgen, dus u hoeft er niet voor te zorgen. De binding wordt geïmplementeerd door de vooraf gedefinieerde methoden van de LearningModelBinding klasse aan te roepen. In ons geval wordt de Bind methode gebruikt om een waarde te binden aan het benoemde functietype.

Op dit moment ondersteunt Windows ML alle ONNX-functietypen, zoals Tensors (multidimensionale matrices), Reeksen (vectoren van waarden), Kaart (waardeparen informatie) en Afbeeldingen (specifieke indelingen). Alle afbeeldingen worden weergegeven in Windows ML in een tensor-indeling. Tensorisatie is het proces van het converteren van een afbeelding naar een tensor en vindt plaats tijdens het binden.

Gelukkig hoeft u niet voor tensorisatieconversie te zorgen. De ImageFeatureValue methode die u in het vorige deel hebt gebruikt, zorgt voor zowel conversie als tensorisatie, zodat de afbeeldingen overeenkomen met de vereiste afbeeldingsindeling van het model.

Opmerking

Voor meer informatie over het binden van een LearningModel en over typen functies die worden ondersteund door WinML, raadpleegt u de documentatie van een Bind a-model .

Evalueer het model:

Nadat u een sessie hebt gemaakt om het model en de gebonden waarden te binden aan de invoer en uitvoer van een model, kunt u de invoer van het model evalueren en de voorspellingen ervan ophalen. Als u de uitvoering van het model wilt uitvoeren, moet u een van de vooraf gedefinieerde evaluatiemethoden aanroepen op de LearningModelSession. In ons geval gebruiken we de EvaluateAsync methode.

CreateFromStreamAsyncNet als bij , is de EvaluateAsync methode ook automatisch gegenereerd door WinML Code Generator, dus u hoeft deze methode niet te implementeren. U kunt deze methode bekijken in het classifier.cs bestand.

De EvaluateAsync methode evalueert het machine learning-model asynchroon met behulp van de functiewaarden die al in bindingen zijn gebonden. Hiermee maakt u een sessie met LearningModelSession, verbindt u de invoer en uitvoer met LearningModelBinding, voert u de modelevaluatie uit en haalt u de uitvoerfuncties van het model op met behulp van de LearningModelEvaluationResult klasse.

Opmerking

Als u meer wilt weten over andere evaluatiemethoden om het model uit te voeren, controleert u welke methoden op de LearningModelSession-klasse kunnen worden geïmplementeerd door de documentatie van de LearningModelSession-klasse te bekijken.

1. Voeg de volgende methode toe aan uw MainPage.xaml.cs codebestand in de Klasse MainPage om een sessie te maken, het model te binden en te evalueren.

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

De resultaten extraheren en weergeven

U moet nu de modeluitvoer extraheren en de juiste resultaten weergeven. U doet dit door de extractResult en displayResult methoden te implementeren.

Zoals u eerder hebt verkend, retourneert het model twee uitvoer: de eerste benoemde classLabel is tensor van tekenreeksen en het tweede benoemde verlies is een reeks tekenreeks-naar-float-kaarten die de waarschijnlijkheid voor elke gelabelde classificatie beschrijft. Dus om het resultaat en de waarschijnlijkheid goed weer te geven, hoeft u alleen maar de uitvoer uit de verliesuitvoer te extraheren. We moeten de hoogste waarschijnlijkheid vinden om het juiste resultaat te retourneren.

1. Voeg de extractResult methode toe aan uw MainPage.xaml.cs codebestand in de MainPage klasse.

        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. Voeg de displayResult methode toe aan uw MainPage.xaml.cs codebestand in de MainPage klasse.

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

Het resultaat van bind en evalueren en het extraheren en weergeven van de resultatenonderdelen van de WinML-code van onze app ziet er als volgt uit.

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

Dat is het! U hebt de Windows Machine Learning-app gemaakt met een basis-GUI om ons classificatiemodel te testen. De volgende stap is het starten van de toepassing en het lokaal uitvoeren op uw Windows-apparaat.

De toepassing starten

Nadat u de toepassingsinterface hebt voltooid, het model hebt toegevoegd en de WinML-code hebt gegenereerd, kunt u de toepassing testen. Zorg ervoor dat de vervolgkeuzelijsten in de bovenste werkbalk zijn ingesteld op Debug. Wijzig Solution Platform naar x64 om het project op uw lokale machine uit te voeren als uw apparaat 64-bits is, of naar x86 als het 32-bits is.

Als u onze app wilt testen, gebruikt u de onderstaande afbeelding van fruit. Laten we eens kijken hoe de app de inhoud van de afbeelding classificeert.

1. Sla deze afbeelding op uw lokale apparaat op om de app te testen. Wijzig indien nodig de afbeeldingsindeling in jpg. U kunt ook andere relevante afbeeldingen van uw lokale apparaat toevoegen in een geschikte indeling: .jpg, .png, .bmpof .gif indelingen.

2. Als u het project wilt uitvoeren, drukt u op de Start Debugging knop op de werkbalk of drukt u op F5.

3. Wanneer de toepassing wordt gestart, drukt u op Pick Image en selecteert u de afbeelding op uw lokale apparaat.

Het resultaat wordt direct op het scherm weergegeven. Zoals u ziet, heeft onze WinML-app de afbeelding geclassificeerd als fruit of groenten, met een betrouwbaarheidsclassificatie van 99,9%.

Samenvatting

U hebt zojuist uw eerste Windows Machine Learning-app gemaakt, van het maken van modellen tot een geslaagde uitvoering.

Aanvullende informatiebronnen

Ga naar de volgende bronnen voor meer informatie over onderwerpen die in deze zelfstudie worden genoemd:

• Windows ML-hulpprogramma's: meer informatie over hulpprogramma's zoals het Windows ML-dashboard, WinMLRunner en de mglen Windows ML-codegenerator.
• ONNX-model: meer informatie over de ONNX-indeling.
• Windows ML-prestaties en -geheugen: meer informatie over het beheren van app-prestaties met Windows ML.
• Naslaginformatie over de Windows Machine Learning-API: meer informatie over drie gebieden van Windows ML-API's.