Bereitstellen des Datenanalysemodells in der Windows-App mit Windows ML-APIs

Im vorherigen Teil dieses Lernprogramms haben Sie gelernt, wie Sie ein Modell im ONNX-Format erstellen und exportieren. Nun zeigen wir Ihnen, wie Sie Ihr exportiertes Modell in eine Windows-Anwendung einbetten und lokal auf einem Gerät ausführen, indem Sie Windows ML-APIs aufrufen.

Wenn wir fertig sind, verfügen Sie über eine funktionierende Datenanalyse-App.

Informationen zur Beispiel-App

In diesem Schritt des Lernprogramms erstellen Sie eine App, die tabellarische Daten von Irises analysieren kann. Mit der App können Sie die Excel-Datei mit den erforderlichen Eingabeinformationen hinzufügen oder die Eingabeparameter manuell eingeben – die Länge und Breite der Kelchblätter und Kronblätter der Iris in cm. Diese Merkmale werden von einem lokal gespeicherten ONNX-Modell verarbeitet, das Sie im vorherigen Teil erstellt und trainiert haben. Basierend auf der Modellausgabe zeigt die App den richtigen Iristyp an.

Hier führen wir Sie durch diesen Prozess.

Nachfolgend erfahren Sie, wie Sie Ihre App erstellen und Windows ML-Code hinzufügen.

Erstellen einer Windows ML-Desktop-App (C#)

Um eine funktionierende Windows ML-App zu erstellen, müssen Sie die folgenden Schritte ausführen:

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

Außerdem müssen Sie eine einfache Benutzeroberfläche erstellen, um eine bessere Benutzererfahrung zu bieten.

Öffnen eines neuen Projekts in Visual Studio

1. Fangen wir an. Öffnen Sie Visual Studio, und wählen Sie Create a new project.

2. Wählen Sie C# in der Suchleiste als Sprache, Windows als Zielplattform und Dektop als Projekttyp aus. Wählen Sie NUnit Test Project (.NET Core) als Projekttyp aus, und wählen Sie next aus, um ein Konfigurationsfenster für das Projekt zu öffnen.

3. Gehen Sie im Konfigurationsfenster wie folgt vor:

• Geben Sie dem Projekt einen Namen. Hier nennen wir sie Iris-Datenanalyse.
• Wählen Sie den Speicherort Ihres Projekts aus.
• Wenn Sie VS 2019 verwenden, stellen Sie sicher, dass Create directory for solution aktiviert ist.
• Wenn Sie VS2017 verwenden, stellen Sie sicher, dass Place solution and project in the same directory die Option deaktiviert 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, Version 1809 (10.0, Build 17763) oder höher festgelegt ist.

4. Navigieren Sie nach dem Erstellen des Projekts zum Projektordner, öffnen Sie den Ressourcenordner[….\DataClassifier\Assets], und kopieren Sie die Network.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.

Während wir unsere Network.onnx Datei dem Ressourcenordner hinzugefügt haben, müssen wir sie diesem Projekt ordnungsgemäß hinzufügen.

1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Ordner "Assets", und wählen Sie " Add > Existing Item.
2. Navigieren Sie zum Ordner "Assets" in Iris Data Analysis [….\Iris Data Analysis \Assets], suchen Sie das Network.onnx model, das Sie zuvor dorthin kopiert haben, und wählen Sie Add aus.
3. Um sicherzustellen, dass das Modell beim Kompilieren der Anwendung erstellt wird, klicken Sie mit der rechten Maustaste auf die Network.onnx Datei, und wählen Sie Properties Legen Sie Build Action auf Content fest.

Außerdem müssen Sie eine neue Cs-Code-Klassendatei erstellen, um zusätzlichen Machine Learning-Code aufzunehmen, der Klassen und Methoden enthält, die Windows ML-APIs aufrufen.

4. Klicken Sie mit der rechten Maustaste auf den Projektmappennamen in Visual Studio und wählen Sie add und new item. Wählen Sie im geöffneten Fenster Class aus und geben Sie ihm einen Namen – hier verwenden wir IrisModel.cs. Unter Ihrem Projekt wird eine neue Klassendatei angezeigt.

.

Erstellen von Machine Learning-Code

In diesem Schritt erstellen wir alle Klassen und Methoden, die die Windows Machine Learning-APIs aufrufen. Auf diese Weise können Sie ein ONNX Machine Learning-Modell in Ihrem Projekt laden, binden und auswerten.

1. Doppelklicken Sie auf die IrisModel.cs Datei.

2. Ersetzen Sie die using-Anweisungen durch Folgendes, um Zugriff auf alle APIs zu erhalten, die Sie benötigen.

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

Initialisieren von Machine Learning-Kursen

Wir müssen IrisModel.cs mehrere Klassen hinzufügen, um Ihnen die Interaktion mit den Windows Machine Learning-APIs zu erleichtern.

Um Zugriff auf das trainierte Machine Learning-Modell zu erhalten, verwenden wir den LearningModel Kurs. Diese Klasse ist Teil des Windows.AI.MachineLearning Namespace und stellt ein trainiertes Machine Learning-Modell dar. Nach der Instanziierung ist das LearningModel Hauptobjekt, das Sie für die Interaktion mit Windows ML-APIs verwenden.

Um das Lernmodell auszuwerten, müssen Sie eine Auswertungssitzung erstellen. Dazu 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. Wenn Sie eine Sitzung mit dieser API erstellen, können Sie auch ein Gerät auswählen, das Ihr Modell ausführt (der Standardwert ist Ihre CPU).

Darüber hinaus müssen Sie die Bezeichnungen der Ausgabe Ihrer Machine Learning-Modelle angeben. Sie können diese Beschriftungen später mit der vorhergesagten Ausgabe des Modells verknüpfen.

3. Kopieren Sie den folgenden Code in die IrisModel.cs Datei.

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

Laden des Modells

Als Nächstes müssen Sie das Machine Learning-Modell laden und eine Sitzung erstellen, die Sie mit den gerade definierten Kursen ausführen. Zum Laden des Modells verwenden Sie mehrere statische Methoden der LearningModel-Klasse – in unserem Fall verwenden wir LoadFromStorageFileAsync, mit dem Sie ein ONNX-Modell asynchron aus einem ISorageFile laden können.

1. Kopieren Sie den folgenden Code in die IrisModel.cs Datei.

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

Definieren des Modelleingabe-Tensors

Jetzt definieren wir die richtigen Eingaben basierend auf Ihren Modellanforderungen. Das im vorherigen Teil integrierte Netzwerkmodell weist vier Eingabewerte auf. Jeder Eingabewert stellt die möglichen Größen von vier Merkmalen von Iris dar: Sepallänge in cm, Sepalbreite in cm, Petallänge in cm und Petalbreite in cm. Basierend auf dieser Eingabe gibt das Modell den Iristyp zurück, der am besten zu diesen Parametern passt. ** Sie müssen die Größe der Eingabewerte auf die gültigen logischen Werte beschränken; für dieses Tutorial verwenden wir Folgendes.

• Sepallänge - 1cm bis 100cm
• Sepalbreite – 1cm bis 8cm
• Petallänge – 0,5 cm bis 10cm
• Petalbreite – 0,1cm bis 5cm

1. Kopieren Sie den folgenden Code in die IrisModel.cs Datei.

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-APIs akzeptieren Eingabewerte der vier beschreibenden Klassen, die von ONNX-Modellen unterstützt werden: Tensoren, Sequenzen, Karten und Bilder. In diesem Fall erfordert das Modell ein 32-Bit-Tensor-Float-Objekt in einer Form von float32[batch_size,4]. Da die Batchgröße 1 ist, hat der Eingabe-Tensor die Form [1x4].

Um eine Tensoreingabe zu erstellen, verwenden Sie die TensorFloat-Klasse .

Die TensorFloat Klasse ist Teil des Windows.AI.MachineLearning Namespace und dient zum Definieren eines 32-Bit-Float-Tensorobjekts – einem Tensor von 32-Bit-Gleitkommawerten. Diese Klasse enthält mehrere nützliche Methoden zum Erstellen eines Tensors. In Ihrem Fall verwenden Sie die CreateFromArray-Methode , um eine Tensoreingabe in der genauen Größe zu erstellen, die Ihr Modell benötigt. Wir fügen diesen Aufruf innerhalb der Bewertungsmethode hinzu.

Binden und Auswerten des Modells

Nachdem Sie nun den Modelleingabe-Tensor definiert und das trainierte Modell und die Sitzung instanziiert haben, ist es an der Zeit, eine Methode zum Binden und Auswerten des trainierten maschinellen Lernmodells zu erstellen.

Diese Methode ist der wichtigste Teil einer Machine Learning-App. Sie enthält die Tensorisierung der Eingabewerte und die Bindung der Modelleingabe. Sie verwenden dieses Modell später im Anwendungscode, um Ihr Modell auszuwerten.

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 die erforderlichen Features von den Windows 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 LearningModelBinding Klasse verfügt über mehrere vordefinierte Methoden, mit denen Sie Werte an diese benannten Features binden können. Hier verwenden Sie die Bind Methode, um Werte an Ihr Modell zu binden.

Um Ihr Modell auszuwerten und Ergebnisse daraus zu erhalten, rufen Sie die vordefinierten Evauierungsmethoden LearningModelSession von relevent auf – in Ihrem Fall die Evaluate Methode. Diese Methode stellt die benötigten Funktionen bereit und bewertet das Machine Learning-Modell mithilfe der von der LearningModelBinding Klasse bereitgestellten Featurewerte.

Extrahieren und Anzeigen der Ergebnisse

Das Modell gibt die vorhergesagten Werte im Tensorformat als Tensor-Float-Ausgabe zurück. Sie müssen jetzt die Modellausgabe extrahieren und die richtigen Ergebnisse anzeigen. Dazu konvertieren Sie das Tensorformat in einen Vektor, indem Sie die GetAsVectorView() Funktion auf der prädizierten Ausgabe ausführen.

Das Modell gibt drei Wahrscheinlichkeitswerte zurück, die jeweils einen bestimmten Iristyp darstellen. Sie müssen die Bezeichnung mit der höchsten Wahrscheinlichkeit zurückgeben.

1. Kopieren Sie den folgenden Code in die IrisModel.cs Datei.

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

Sie haben nun den Machine Learning-Teil Ihres Codes abgeschlossen. Jetzt können Sie Ihr Modell ganz einfach in die Windows-Anwendung integrieren. Im letzten Teil dieses Lernprogramms haben wir einen einfachen Windows-GUI- und Steuerelementcode zum Testen des Modells bereitgestellt, wobei die methoden verwendet werden, die Sie bereits erstellt haben.

Erstellen der Anwendungs-GUI

1. Um einen GUI-App-Code für Ihre App zu erstellen, doppelklicken Sie auf die MainPage.xaml Codedatei, und öffnen Sie eine vordefinierte Vorlage für Ihre GUI.

2. Kopieren Sie den folgenden Code in MainPage.xaml, unter die “Background="{ThemeResource ApplicationPageBackgroundThemeBrush}" " Height="939"> Zeile.

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

Erstellen der Anwendungssteuerung

Der Anwendungssteuerungscode MainPage.xaml.cs enthält die Hauptmethode zum Ausführen der App sowie mehrere Schritte zum Ausführen Ihres Modells und zur Verarbeitung der Ausgabe.

1. Sie instanziieren ein neues Objekt der IrisModel Klasse, die Sie zuvor in diesem Lernprogramm erstellt haben.
2. Sie rufen die Evaluate() Methode auf, die Sie im vorherigen Teil auf dem Modell erstellt haben. Diese Methode wird viermal angewendet, je einmal auf jeden der Eingabeparameter: Kelchlänge, Kelchbreite, Blütenblattlänge und Blütenblattbreite.

Die App zeigt das Ergebnis basierend auf dem Algorithmus für maschinelles Lernen an.

1. Um einen Anwendungssteuerungscode zu erstellen, doppelklicken Sie auf die MainPage.xaml.cs Codedatei, und fügen Sie den folgenden Code hinzu.

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

Starten der Anwendung

Jetzt können Sie Ihre Anwendung starten und die Ergebnisse sehen.

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.

Die App-GUI enthält vier Schieberegler, um die Eingabe der erforderlichen Parameter zu ändern. Jede Änderung der Eingabe generiert eine neue Ausgabe basierend auf dem Vorhersagealgorithmus. Die Ausgabe wird unterhalb der Eingabeschieberegler angezeigt.

Sie können sehen, dass die App bei der Eingabe von Kelchblattlänge = 40 mm, Kelchblattbreite = 50, Blütenblattlänge = 75 und Blütenblattbreite = 15 die Eingabe des Typs „Iris-versicolor“ generiert hat!

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 über das Verwalten der App-Leistung mit Windows ML.
• Referenz zur Windows Machine Learning-API: Erfahren Sie mehr über drei Bereiche von Windows ML-APIs.