Wdrażanie modelu analizy danych w aplikacji systemu Windows przy użyciu interfejsów API uczenia maszynowego systemu Windows

W poprzedniej części tego samouczka przedstawiono sposób kompilowania i eksportowania modelu w formacie ONNX. Teraz pokażemy, jak osadzić wyeksportowany model w aplikacji systemu Windows i uruchomić go lokalnie na urządzeniu, wywołując interfejsy API uczenia maszynowego systemu Windows.

Po zakończeniu będziesz mieć działającą aplikację do analizy danych.

Informacje o przykładowej aplikacji

W tym kroku samouczka utworzysz aplikację, która może analizować dane tabelaryczne o irysach. Aplikacja umożliwi dodanie pliku Excel zawierającego wymagane informacje wejściowe lub ręczne wprowadzenie parametrów wejściowych – długości i szerokości działek kielicha oraz płatków korony irysa w cm. Te cechy będą przetwarzane przez lokalnie przechowywany model ONNX sieci neuronowej, który utworzyłeś i wytrenowałeś w poprzedniej części. Na podstawie danych wyjściowych modelu aplikacja wyświetli prawidłowy typ irysa.

W tym miejscu przeprowadzimy Cię przez ten proces.

Poniżej przeprowadzimy Cię przez proces tworzenia aplikacji i dodawania kodu uczenia maszynowego systemu Windows.

Tworzenie aplikacji windows ML Desktop (C#)

Aby utworzyć działającą aplikację uczenia maszynowego systemu Windows, należy wykonać następujące czynności:

• Ładowanie modelu uczenia maszynowego.
• Powiąż dane wejściowe i wyjściowe modelu.
• Oceń model i wyświetl znaczące wyniki.

Musisz również utworzyć podstawowy interfejs użytkownika, aby zapewnić lepsze środowisko użytkownika.

Otwieranie nowego projektu w programie Visual Studio

1. Zacznijmy. Otwórz program Visual Studio i wybierz pozycję Create a new project.

2. Na pasku wyszukiwania wybierz C# jako język jako Windows platformę docelową i Dektop jako typ projektu. Wybierz NUnit Test Project (.NET Core) jako typ projektu i wybierz next , aby otworzyć okno konfiguracji dla projektu.

3. W oknie konfiguracji wykonaj następujące czynności:

• Nadaj projektowi nazwę. W tym miejscu nazywamy to Iris Data Analysis.
• Wybierz lokalizację projektu.
• Jeśli używasz programu VS2019, upewnij się, że Create directory for solution jest zaznaczone.
• Jeśli używasz programu VS2017, upewnij się, że Place solution and project in the same directory nie jest zaznaczona.

Naciśnij create , aby utworzyć projekt. Może zostać wyświetlone okno minimalnej wersji docelowej. Upewnij się, że minimalna wersja jest ustawiona na Windows 10, wersja 1809 (10.0; kompilacja 17763) lub nowsza.

4. Po utworzeniu projektu przejdź do folderu projektu, otwórz folder [….\DataClassifier\Assets] i skopiuj Network.onnx plik do tej lokalizacji.

Eksplorowanie rozwiązania projektu

Przyjrzyjmy się rozwiązaniu projektu.

Program Visual Studio automatycznie utworzył kilka plików cs-code w Eksploratorze rozwiązań. MainPage.xaml zawiera kod XAML dla graficznego interfejsu użytkownika i MainPage.xaml.cs zawiera kod aplikacji. Jeśli wcześniej utworzono aplikację platformy UWP, te pliki powinny być dla Ciebie bardzo znane.

Chociaż dodaliśmy plik Network.onnx do folderu assets, musimy go prawidłowo dodać do tego projektu.

1. Kliknij prawym przyciskiem myszy folder Assets w Eksploratorze rozwiązań, a następnie wybierz pozycję Add > Existing Item.
2. Przejdź do folderu Assets w folderze Iris Data Analysis [….\Iris Data Analysis \Assets], znajdź Network.onnx model wcześniej skopiowane tam, a następnie wybierz pozycję Add.
3. Aby upewnić się, że model jest budowany podczas kompilowania aplikacji, kliknij prawym przyciskiem myszy plik Network.onnx i wybierz Properties. Ustaw opcję Build Action na Content.

Należy również utworzyć nowy plik klasy cs-code, aby pomieścić dodatkowy kod uczenia maszynowego, który zawiera klasy i metody, które będą wywoływać interfejsy API uczenia maszynowego systemu Windows.

4. Kliknij prawym przyciskiem myszy nazwę rozwiązania w programie Visual Studio, a następnie wybierz polecenie add i new item. W otwartym oknie wybierz Class i nadaj mu nazwę — w tym miejscu użyjemy polecenia IrisModel.cs. Nowy plik klasy pojawi się w projekcie.

.

Tworzenie kodu usługi Machine Learning

W tym kroku utworzymy wszystkie klasy i metody, które będą wywoływać interfejsy API usługi Windows Machine Learning. Pozwoli to załadować, powiązać i ocenić model uczenia maszynowego ONNX w projekcie.

1. Kliknij dwukrotnie na plik IrisModel.cs.

2. Zastąp instrukcje using następującymi instrukcjami, aby uzyskać dostęp do wszystkich potrzebnych interfejsów API.

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

Inicjowanie klas uczenia maszynowego

Musimy dodać kilka klas do IrisModel.cs, aby pomóc Ci w interakcji z interfejsami API Windows Machine Learning.

Aby uzyskać dostęp do wytrenowanego modelu uczenia maszynowego, użyjemy LearningModel klasy . Ta klasa jest częścią Windows.AI.MachineLearning przestrzeni nazw i reprezentuje wytrenowany model uczenia maszynowego. Po utworzeniu wystąpienia, LearningModel jest głównym obiektem używanym do interakcji z interfejsami API Windows ML.

Aby ocenić model uczenia, musisz utworzyć sesję ewaluaną. W tym celu należy użyć LearningModelSession klasy . Ta klasa służy do oceny modeli uczenia maszynowego i wiąże model z urządzeniem, które następnie uruchamia i ocenia model. Podczas tworzenia sesji przy użyciu tego interfejsu API możesz również wybrać urządzenie do wykonania swojego modelu (wartość domyślna to CPU).

Ponadto należy określić etykiety danych wyjściowych modeli uczenia maszynowego. Te etykiety można połączyć z przewidywanymi danymi wyjściowymi modelu później.

3. Skopiuj następujący kod do IrisModel.cs pliku.

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

Ładowanie modelu

Następnie należy załadować model uczenia maszynowego i utworzyć sesję, którą wykonasz przy użyciu właśnie zdefiniowanych klas. Aby załadować model, użyjesz kilku statycznych metod LearningModel klasy — w naszym przypadku użyjemy metody LoadFromStorageFileAsync, która umożliwia ładowanie modelu ONNX z ISorageFile asynchronicznie.

1. Skopiuj następujący kod do IrisModel.cs pliku.

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

Definiowanie tensoru wejściowego modelu

Teraz zdefiniujemy poprawne dane wejściowe na podstawie wymagań dotyczących modelu. Model sieci utworzony w poprzedniej części ma cztery wartości wejściowe. Każda wartość wejściowa reprezentuje możliwe rozmiary czterech cech irysów: długość sepa w cm, szerokość sepa w cm, długość płatka w cm i szerokość płatka w cm. Na podstawie tych danych wejściowych model zwróci typ irysu, który najlepiej pasuje do tych parametrów. Musisz ograniczyć rozmiar wartości wejściowych do prawidłowych wartości logicznych — w tym samouczku użyjemy następujących elementów:

• długość sepa - od 1 cm do 100 cm
• szerokość sepa – od 1 cm do 8 cm
• długość płatka – od 0,5 cm do 10 cm
• szerokość płatka – od 0,1 cm do 5 cm

1. Skopiuj następujący kod do IrisModel.cs pliku.

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

Interfejsy API uczenia maszynowego systemu Windows akceptują wartości wejściowe czterech klas opisowych obsługiwanych przez modele ONNX: tensor, sekwencje, mapy i obrazy. W tym przypadku model wymaga 32-bitowego obiektu zmiennoprzecinkowego w kształcie float32[batch_size,4]. Ponieważ rozmiar partii wynosi 1, kształt tensora wejściowego to [1x4].

Aby utworzyć dane wejściowe tensor, użyjesz klasy TensorFloat .

Klasa TensorFloat jest częścią przestrzeni nazw Windows.AI.MachineLearning i służy do definiowania obiektu tensora zmiennoprzecinkowego 32-bitowego — tensora 32-bitowych wartości zmiennoprzecinkowych. Ta klasa zawiera kilka przydatnych metod tworzenia tensoru. W twoim przypadku użyjesz metody CreateFromArray , aby utworzyć dane wejściowe tensor w dokładnym rozmiarze wymaganym przez model. Dodamy to wywołanie w metodzie oceny.

Powiązanie i ocena modelu

Teraz, gdy zdefiniowano tensor wejściowy modelu i utworzono wystąpienie wytrenowanego modelu i sesji, nadszedł czas, aby utworzyć metodę powiązania i oceny wytrenowanego modelu uczenia maszynowego.

Ta metoda jest kluczową częścią aplikacji uczenia maszynowego. Obejmuje on tensoryzację wartości wejściowych oraz wiązanie danych wejściowych modelu. Użyjesz tego modelu w dalszej części kodu aplikacji, aby ocenić model.

Aby powiązać dane wejściowe i wyjściowe, należy użyć LearningModelBinding klasy . Model uczenia maszynowego ma funkcje danych wejściowych i wyjściowych, które przekazują informacje do i z modelu. Należy pamiętać, że wymagane funkcje muszą być obsługiwane przez interfejsy API uczenia maszynowego systemu Windows. Klasa LearningModelBinding jest stosowana na obiekcie LearningModelSession , aby powiązać wartości z nazwanymi funkcjami wejściowymi i wyjściowymi.

Klasa LearningModelBinding ma kilka wstępnie zdefiniowanych metod, których można użyć do powiązania wartości z tymi nazwanymi funkcjami. W tym miejscu użyjesz Bind metody , aby powiązać wartości z modelem.

Aby ocenić swój model i uzyskać z niego wyniki, wywołaj odpowiednie, wstępnie zdefiniowane metody ewaluacji z LearningModelSession — w twoim przypadku metoda Evaluate. Ta metoda zapewni potrzebne funkcje, oceniając model uczenia maszynowego przy użyciu wartości funkcji dostarczonych przez klasę LearningModelBinding .

Wyodrębnianie i wyświetlanie wyników

Model zwraca przewidywane wartości w formacie tensor jako dane wyjściowe zmiennoprzecinkowe Tensor. Teraz musisz wyodrębnić dane wyjściowe modelu i wyświetlić odpowiednie wyniki. W tym celu przekonwertujesz format tensor na wektor, wykonując GetAsVectorView() funkcję na prognozowanych danych wyjściowych.

Model zwraca trzy wartości prawdopodobieństwa, z których każdy reprezentuje jeden konkretny typ irysów. Należy zwrócić etykietę z najwyższym prawdopodobieństwem.

1. Skopiuj następujący kod do IrisModel.cs pliku.

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

Ukończono część kodu uczenia maszynowego. Teraz możesz łatwo zintegrować model z aplikacją systemu Windows. W ostatniej części tego samouczka udostępniliśmy podstawowy graficzny interfejs użytkownika systemu Windows i kod sterujący do przetestowania modelu przy użyciu już utworzonych metod.

Tworzenie graficznego interfejsu użytkownika aplikacji

1. Aby utworzyć kod aplikacji GUI, kliknij dwa razy na plik MainPage.xaml i otwórz wstępnie zdefiniowany szablon dla swojego interfejsu graficznego.

2. Skopiuj poniższy kod do MainPage.xaml, pod linią “Background="{ThemeResource ApplicationPageBackgroundThemeBrush}" " Height="939">.

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

Tworzenie kontrolki aplikacji

Kod sterowania aplikacji, MainPage.xaml.cs, zawiera główną metodę uruchamiania aplikacji oraz kilka kroków, aby uruchomić model i wykonać dane wyjściowe:

1. Utworzysz wystąpienie nowego obiektu klasy, którą utworzyłeś wcześniej w tym samouczku.
2. Wywołasz metodę Evaluate() utworzoną w poprzedniej części modelu. Ta metoda zostanie zastosowana cztery razy, jeden raz dla każdego z parametrów wejściowych: długość działki kielicha, szerokość działki kielicha, długość płatka i szerokość płatka.

Aplikacja wyświetli wynik na podstawie algorytmu przewidywania uczenia maszynowego.

1. Aby utworzyć kod kontroli aplikacji, kliknij MainPage.xaml.cs dwukrotnie plik kodu i dodaj następujący kod.

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

Uruchamianie aplikacji

Teraz możesz uruchomić aplikację i zobaczyć wyniki.

Włącz tryb dewelopera i przetestuj aplikację z poziomu programu Visual Studio. Upewnij się, że menu rozwijane na górnym pasku narzędzi są ustawione na Debug. Zmień platformę rozwiązania na x64, aby uruchomić projekt na komputerze lokalnym, jeśli urządzenie jest 64-bitowe lub x86, jeśli jest 32-bitowe.

Graficzny interfejs użytkownika aplikacji zawiera cztery suwaki, aby zmienić dane wejściowe wymaganych parametrów. Każda zmiana danych wejściowych spowoduje wygenerowanie nowych danych wyjściowych na podstawie algorytmu przewidywania. Dane wyjściowe są wyświetlane poniżej suwaków wejściowych.

Widać, że dla podanych wartości: długość działki kielicha = 40 mm, szerokość działki kielicha = 50 mm, długość płatka = 75 mm oraz szerokość płatka = 15 mm, aplikacja wygenerowała dane wejściowe typu Iris-versicolor!

Podsumowanie

Właśnie udało Ci się utworzyć pierwszą aplikację windows Machine Learning, od utworzenia modelu do pomyślnego wykonania.

Dodatkowe zasoby

Aby dowiedzieć się więcej o tematach wymienionych w tym samouczku, odwiedź następujące zasoby:

• Narzędzia Windows ML: Poznaj więcej narzędzi, takich jak Windows ML Dashboard, WinMLRunner i generator kodu Windows ML mglen.
• Model ONNX: dowiedz się więcej o formacie ONNX.
• Wydajność i pamięć uczenia maszynowego systemu Windows: dowiedz się więcej na temat zarządzania wydajnością aplikacji za pomocą uczenia maszynowego z systemem Windows.
• Dokumentacja interfejsu API usługi Windows Machine Learning: dowiedz się więcej o trzech obszarach interfejsów API uczenia maszynowego systemu Windows.