U gegevensanalysemodel implementeren in de Windows-app met Windows ML-API's

In het vorige deel van deze zelfstudie hebt u geleerd hoe u een model in ONNX-indeling bouwt en exporteert. Nu laten we u zien hoe u uw geëxporteerde model insluit in een Windows-toepassing en het lokaal uitvoert op een apparaat door Windows ML-API's aan te roepen.

Op het moment dat we klaar zijn, hebt u een werkende app voor gegevensanalyse.

Over de voorbeeld-app

In deze stap van de zelfstudie maakt u een app die tabelgegevens van Irises kan analyseren. Met de app kunt u het Excel-bestand toevoegen met de vereiste invoergegevens of handmatig de invoerparameters invoeren: de lengte en breedte van irissen sepal en petal in cm. Deze functies worden verwerkt door een lokaal opgeslagen neuraal netwerk ONNX-model dat u in het vorige deel hebt gebouwd en getraind. Op basis van de modeluitvoer geeft de app het juiste Iris-type weer.

Hier begeleiden we je door dat proces.

Opmerking

Als u ervoor kiest om het vooraf gedefinieerde codevoorbeeld te gebruiken, kunt u het oplossingsbestand klonen. Kloon de opslagplaats, navigeer naar dit voorbeeld en open het Iris Data Analysis.csproj-bestand met Visual Studio. Ga verder naar het onderdeel Toepassing starten van deze pagina om het in gebruik te zien.

Hieronder leert u hoe u uw app maakt en Windows ML-code toevoegt.

Een Windows ML Desktop-app (C#) maken

Als u een werkende Windows ML-app wilt maken, moet u het volgende doen:

• Een machine learning-model laden.
• Bind de invoer en uitvoer van het model.
• Evalueer het model en geef zinvolle resultaten weer.

U moet ook een eenvoudige gebruikersinterface maken om een betere gebruikerservaring te bieden.

Een nieuw project openen in Visual Studio

1. Laten we beginnen. Open Visual Studio en kies Create a new project.

2. Kies C# in de zoekbalk als uw taal, Windows als doelplatform en Dektop als projecttype. Selecteer NUnit Test Project (.NET Core) dit als projecttype en selecteer next om een configuratievenster voor het project te openen.

3. Ga als volgt te werk in het configuratievenster:

• Geef uw project een naam. Hier noemen we irisgegevensanalyse.
• Kies de locatie van uw project.
• Als u VS2019 gebruikt, zorg er dan voor dat Create directory for solution is ingeschakeld.
• Als u VS2017 gebruikt, controleert u of Place solution and project in the same directory dit selectievakje is uitgeschakeld.

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, versie 1809 (10.0; build 17763) of hoger.

4. Nadat het project is gemaakt, gaat u naar de projectmap, opent u het mapje[….\DataClassifier\Assets]assets en kopieert u uw Network.onnx bestand naar deze locatie.

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.

Hoewel we ons Network.onnx bestand aan de assets-map hebben toegevoegd, moeten we het goed aan dit project toevoegen.

1. Klik met de rechtermuisknop op de map Assets in Solution Explorer en selecteer Add > Existing Item.
2. Navigeer naar de map Assets in Iris Data Analysis [….\Iris Data Analysis \Assets], zoek het bestand dat u daar eerder hebt gekopieerd en selecteer Network.onnx model.
3. Als u ervoor wilt zorgen dat het model wordt gebouwd wanneer u uw toepassing compileert, klikt u met de rechtermuisknop op het Network.onnx bestand en selecteert u Properties. Stel de Build Action in op Content.

U moet ook een nieuw cs-codeklassebestand maken om ruimte te bieden voor extra machine learning-code, waaronder klassen en methoden waarmee Windows ML-API's worden aangeroepen.

4. Klik met de rechtermuisknop op de naam van de oplossing in Visual Studio en kies add en new item. Selecteer Class en geef deze een naam in het geopende venster. Hier gebruiken IrisModel.cswe het. Er zal een nieuw klassebestand binnen uw project verschijnen.

.

Machine Learning-code maken

In deze stap maken we alle klassen en methoden waarmee de Windows Machine Learning-API's worden aangeroepen. Hiermee kunt u een ONNX Machine Learning-model in uw project laden, binden en evalueren.

1. Dubbelklik op het IrisModel.cs bestand.

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

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

Machine Learning-klassen initialiseren

We moeten IrisModel.cs verschillende klassen toevoegen om u te laten communiceren met Windows Machine Learning-API's.

We gebruiken de LearningModel klasse om toegang te krijgen tot het getrainde machine learning-model. Deze klasse maakt deel uit van de Windows.AI.MachineLearning naamruimte en vertegenwoordigt een getraind machine learning-model. Zodra het object is geïnstantieerd, gebruikt u het LearningModel als het hoofdobject om te communiceren met Windows ML API.

Als u het leermodel wilt evalueren, moet u een evaluatiesessie maken. Hiervoor 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. Wanneer u een sessie met deze API maakt, kunt u ook een apparaat selecteren om uw model uit te voeren (de standaardwaarde is uw CPU).

Daarnaast moet u de labels van de uitvoer van uw Machine Learning-modellen opgeven. U kunt deze labels later verbinden met de voorspelde uitvoer van het model.

Opmerking

Raadpleeg de LearningModel en de LearningModelSession voor meer informatie over de en klassen.

3. Kopieer de volgende code naar het IrisModel.cs bestand.

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

Het model laden

Vervolgens moet u het machine learning-model laden en een sessie maken, die u gaat doen met de klassen die u zojuist hebt gedefinieerd. Als u het model wilt laden, gebruikt u verschillende statische methoden van de LearningModel klasse. In ons geval gebruiken we LoadFromStorageFileAsync, waarmee u een ONNX-model van ISorageFile asynchroon kunt laden.

Opmerking

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

1. Kopieer de volgende code naar het IrisModel.cs bestand.

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

De modelinvoertensor definiëren

Nu definiëren we de juiste invoer op basis van uw modelvereisten. Het netwerkmodel dat u in het vorige deel hebt gemaakt, heeft vier invoerwaarden. Elke invoerwaarde vertegenwoordigt de mogelijke grootten van vier kenmerken van irissen: kelklengte in cm, kelkbreedte in cm, kroonbladlengte in cm en kroonbladbreedte in cm. Op basis van deze invoer retourneert het model het iristype dat het beste past bij deze parameters. U moet de grootte van invoerwaarden beperken tot de geldige logische waarden. Voor deze zelfstudie gebruiken we het volgende:

• kelkbladlengte - 1cm tot 100cm
• Kelkbladbreedte – 1cm tot 8cm
• lengte van bloemblaadjes – 0,5cm tot 10cm
• bloembladbreedte – 0,1cm tot 5cm

1. Kopieer de volgende code naar het IrisModel.cs bestand.

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

Windows ML-API's accepteren invoerwaarden van de vier beschrijvende klassen die worden ondersteund door ONNX-modellen: tensors, reeksen, kaarten en afbeeldingen. In dit geval vereist het model een 32-bits tensor float-object in een vorm van float32[batch_size,4]. Omdat de batchgrootte 1 is, is de invoertensorvorm [1x4].

Als u een tensor-invoer wilt maken, gebruikt u de TensorFloat-klasse .

De TensorFloat klasse maakt deel uit van de Windows.AI.MachineLearning naamruimte en wordt gebruikt om een 32-bits float tensor-object te definiëren: een tensor van 32-bits drijvendekommawaarden. Deze klasse bevat verschillende nuttige methoden om een tensor te bouwen. In uw geval gebruikt u de methode CreateFromArray om een tensor-invoer te maken in de exacte grootte die uw model nodig heeft. We voegen die aanroep toe binnen de evaluatiemethode.

Het model binden en evalueren

Nu u de modelinvoertensor hebt gedefinieerd en het getrainde model en de sessie hebt geïnstantieerd, is het tijd om een methode te maken om het getrainde machine learning-model te binden en te evalueren.

Deze methode is het belangrijkste onderdeel van een machine learning-app. Het bevat de tensorisatie van de invoerwaarden en binding van de modelinvoer. U gebruikt dit model later in uw toepassingscode om uw model te evalueren.

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 LearningModelBinding klasse heeft verschillende vooraf gedefinieerde methoden die u kunt gebruiken om waarden te binden aan deze benoemde functies. Hier gebruikt u de Bind methode om waarden aan uw model te binden.

Als u uw model wilt evalueren en er resultaten van wilt ontvangen, roept u de vooraf gedefinieerde evauatiemethoden aan van LearningModelSession - in uw geval, de Evaluate methode. Deze methode biedt de functionaliteit die u nodig hebt en evalueert het machine learning-model met behulp van de functiewaarden die door de LearningModelBinding klasse worden geleverd.

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.

De resultaten extraheren en weergeven

Het model retourneert de voorspelde waarden in tensor-indeling als een Tensor float-uitvoer. U moet nu de modeluitvoer extraheren en de juiste resultaten weergeven. Hiervoor converteert u de tensor-indeling naar een vector door de GetAsVectorView() functie uit te voeren op de prediceerde uitvoer.

Het model retourneert drie waarschijnlijkheidswaarden, die elk één specifiek iristype vertegenwoordigen. Je moet het label retourneren met de hoogste kans.

1. Kopieer de volgende code naar het IrisModel.cs bestand.

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

U hebt nu het machine learning-onderdeel van uw code voltooid. U kunt uw model nu eenvoudig integreren met de Windows-toepassing. In het laatste deel van deze zelfstudie hebben we een eenvoudige Windows-GUI en besturingscode opgegeven om het model te testen, met behulp van de methoden die u al hebt gemaakt.

De toepassings-GUI maken

1. Als u een GUI-app-code voor uw app wilt maken, dubbelklikt u op het MainPage.xaml codebestand en opent u een vooraf gedefinieerde sjabloon voor uw GUI.

2. Kopieer de onderstaande code naar MainPage.xamlonder de “Background="{ThemeResource ApplicationPageBackgroundThemeBrush}" " Height="939"> regel.

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

Het toepassingsbeheer maken

De toepassingsbeheercode, MainPage.xaml.csbevat de hoofdmethode voor het uitvoeren van de app en verschillende stappen om uw model uit te voeren en de uitvoer uit te voeren:

1. U installeert een nieuw object van de IrisModel klasse dat u eerder in deze zelfstudie hebt gemaakt.
2. U roept de Evaluate() methode aan die u in het vorige deel voor het model hebt gemaakt. Deze methode wordt vier keer toegepast, één keer op elk van de invoerparameters: kelkbladlengte, kelkbladbreedte, bloembladlengte en bloembladbreedte.

De app geeft het resultaat weer op basis van het algoritme voor machine learning-voorspelling.

1. Als u een toepassingsbeheercode wilt maken, dubbelklikt u op het MainPage.xaml.cs codebestand en voegt u de volgende code toe.

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

De toepassing starten

U bent nu klaar om uw toepassing te starten en de resultaten te bekijken.

Schakel de ontwikkelaarsmodus in en test uw toepassing vanuit Visual Studio. Zorg ervoor dat de vervolgkeuzelijsten in de bovenste werkbalk zijn ingesteld op Debug. Wijzig het Solution Platform in x64 om het project uit te voeren op uw lokale computer als uw apparaat 64-bits is of x86 als het 32-bits is.

De app-GUI bevat vier schuifregelaars om de invoer van de vereiste parameters te wijzigen. Elke wijziging in de invoer genereert een nieuwe uitvoer op basis van het voorspellingsalgoritmen. De uitvoer wordt weergegeven onder de invoerschuifregelaars.

nl-NL: U kunt zien dat de opgegeven invoer van kelkbladlengte = 40 mm, kelkbladbreedte = 50, bloembladlengte = 75 en bloembladbreedte = 15, de door de app gegenereerde invoer van het type Iris-versicolor is!

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.