Wdrażaj model w aplikacji systemu Windows za pomocą interfejsów API usługi Windows Machine Learning.

W poprzedniej części tego samouczka przedstawiono sposób kompilowania i eksportowania modelu w formacie ONNX. Teraz, gdy masz ten model, możesz go osadzić w aplikacji systemu Windows i uruchomić go lokalnie na urządzeniu, wywołując interfejsy API WinML.

Po zakończeniu będziesz mieć działającą aplikację klasyfikatora obrazów WinML UWP (C#).

Informacje o przykładowej aplikacji

Korzystając z naszego modelu, utworzymy aplikację, która może klasyfikować obrazy żywności. Umożliwia wybranie obrazu z urządzenia lokalnego i przetworzenie go za pomocą lokalnie przechowywanego modelu ONNX, który został utworzony i wytrenowany w poprzedniej części. Zwrócone tagi są wyświetlane obok obrazu, a także współczynnik pewności klasyfikacji.

Jeśli korzystasz z tego samouczka do tej pory, musisz mieć już wymagane wymagania wstępne dotyczące tworzenia aplikacji. Jeśli potrzebujesz odświeżenia, zapoznaj się z pierwszą częścią tego samouczka.

Stwórz projekt UWP z użyciem WinML (C#)

Poniżej pokażemy, jak utworzyć aplikację i kod WinML od podstaw. Dowiesz się, jak:

• Ładowanie modelu uczenia maszynowego.
• Załaduj obraz w wymaganym formacie.
• Powiąż dane wejściowe i wyjściowe modelu.
• Oceń model i wyświetl znaczące wyniki.

Użyjesz również podstawowego kodu XAML do utworzenia prostego graficznego interfejsu użytkownika, aby można było przetestować klasyfikator obrazu.

Tworzenie aplikacji

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

2. Na pasku wyszukiwania wpisz UWP , a następnie wybierz pozycję Blank APP (Universal Windows). Spowoduje to otwarcie nowego projektu języka C# dla jednostronicowej aplikacji platformy uniwersalnej systemu Windows (UWP), która nie ma wstępnie zdefiniowanych kontrolek ani układu. Wybierz Next , aby otworzyć okno konfiguracji dla projektu.

3. W oknie konfiguracji:

• Wybierz nazwę projektu. W tym miejscu używamy elementu ImageClassifierAppUWP.
• Wybierz lokalizację projektu.
• Jeśli używasz programu VS 2019, upewnij się, że Place solution and project in the same directory nie jest zaznaczona.
• Jeśli używasz programu VS 2017, upewnij się, że Create directory for solution jest zaznaczone.

Naciśnij create , aby utworzyć projekt. Może zostać wyświetlone okno minimalnej wersji docelowej. Upewnij się, że minimalna wersja jest ustawiona na kompilację 17763 lub nowszą w systemie Windows 10.

Aby utworzyć aplikację i wdrożyć model za pomocą aplikacji WinML, potrzebne są następujące elementy:

4. Po utworzeniu projektu przejdź do folderu projektu, otwórz folder assets [....\ImageClassifierAppUWP\Assets] i skopiuj model do tej lokalizacji.

5. Zmień nazwę modelu z model.onnx na classifier.onnx. Dzięki temu wszystko jest nieco jaśniejsze i dopasowuje je do formatu samouczka.

Eksplorowanie modelu

Zapoznajmy się ze strukturą pliku modelu.

1. classifier.onnx Otwórz plik modelu przy użyciu narzędzia Netron.

2. Naciśnij , Data aby otworzyć właściwości modelu.

Jak widać, model wymaga 32-bitowej tablicy zmiennoprzecinkowej Tensor (tablicy wielowymiarowej) jako obiektu wejściowego i zwraca dwa dane wyjściowe: pierwszy nazwa classLabel to tensor ciągów, a drugi nazwany loss jest sekwencją map ciąg-zmiennoprzecinkowych, które opisują prawdopodobieństwo każdej klasyfikacji oznaczonej etykietą. Te informacje będą potrzebne do pomyślnego wyświetlenia danych wyjściowych modelu w aplikacji systemu Windows.

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.

Tworzenie graficznego interfejsu użytkownika aplikacji

Najpierw utwórzmy prosty graficzny interfejs użytkownika dla aplikacji.

1. Kliknij dwukrotnie na plik MainPage.xaml. W pustej aplikacji szablon XAML dla graficznego interfejsu użytkownika aplikacji jest pusty, dlatego musimy dodać niektóre funkcje interfejsu użytkownika.

2. Dodaj poniższy kod do głównej treści pliku 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>

Generator kodu usługi Windows Machine Learning

Generator kodu usługi Windows Machine Learning lub mlgen to rozszerzenie programu Visual Studio, które ułatwia rozpoczęcie korzystania z interfejsów API WinML w aplikacjach platformy UWP. Generuje kod szablonu podczas dodawania przeszkolonego pliku ONNX do projektu UWP.

Generator kodu mlgen usługi Windows Machine Learning tworzy interfejs (dla języków C#, C++/WinRT i C++/CX) z klasami otoki, które wywołują interfejs API Windows ML za Ciebie. Dzięki temu można łatwo ładować, wiązać i oceniać model w projekcie. Użyjemy go w tym samouczku, aby obsłużyć wiele z tych funkcji.

Generator kodu jest dostępny dla programu Visual Studio 2017 lub nowszego. Należy pamiętać, że w systemie Windows 10 w wersji 1903 lub nowszej oprogramowanie mlgen nie jest już uwzględnione w zestawie SDK systemu Windows 10, dlatego należy pobrać i zainstalować rozszerzenie. Jeśli śledzisz ten samouczek od początku, powinieneś to już zrobić, ale jeśli nie, powinieneś pobrać VS 2019 lub VS 2017.

1. Jeśli jeszcze tego nie zrobiono, zainstaluj oprogramowanie mlgen.

2. Kliknij prawym przyciskiem myszy folder Assets w Eksploratorze rozwiązań w programie Visual Studio, a następnie wybierz Add > Existing Item.

3. Przejdź do folderu zasobów w folderze ImageClassifierAppUWP [….\ImageClassifierAppUWP\Assets], znajdź wcześniej skopiowany tam model ONNX i wybierz pozycję add.

4. Po dodaniu modelu ONNX (nazwa: "klasyfikator") do folderu zasobów w Eksploratorze rozwiązań w programie VS projekt powinien teraz mieć dwa nowe pliki:

• classifier.onnx — jest to model w formacie ONNX.
• classifier.cs — automatycznie wygenerowany plik kodu WinML.

5. Żeby upewnić się, że model jest budowany podczas kompilowania naszej aplikacji, oznacz plik classifier.onnx i wybierz pozycję Properties. Dla pozycji Build Action wybierz opcję Content.

Teraz przyjrzyjmy się nowo wygenerowanej kodzie w pliku classifier.cs.

Wygenerowany kod zawiera trzy klasy:

• classifierModel: Ta klasa zawiera dwie metody tworzenia wystąpienia modelu i oceny modelu. Pomoże nam to utworzyć reprezentację modelu uczenia maszynowego, utworzyć sesję na domyślnym urządzeniu systemowym, powiązać określone dane wejściowe i wyjściowe z modelem oraz ocenić model asynchronicznie.
• classifierInput: ta klasa inicjuje typy danych wejściowych, których oczekuje model. Dane wejściowe modelu zależą od wymagań modelu na dane wejściowe. W naszym przypadku dane wejściowe oczekują klasy ImageFeatureValue, która opisuje właściwości obrazu użytego do przekazania do modelu.
• classifierOutput: Ta klasa inicjuje typy, które będą zwracane przez model. Dane wyjściowe modelu zależą od sposobu jego definiowania przez model. W naszym przypadku dane wyjściowe będą sekwencją map (słowników) typu String i TensorFloat (Float32) o nazwie loss.

Teraz użyjesz tych klas, aby załadować, powiązać i ocenić model w naszym projekcie.

Ładowanie modelu i danych wejściowych

Ładowanie modelu

1. MainPage.xaml.cs Kliknij dwukrotnie plik kodu, aby otworzyć kod aplikacji.

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

// 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. Dodaj następujące deklaracje zmiennych po instrukcjach using wewnątrz swojej klasy MainPage, w przestrzeni nazw 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;

Wynik będzie wyglądać następująco.

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

Teraz zaimplementujesz metodę LoadModel . Metoda uzyska dostęp do modelu ONNX i zapisze go w pamięci. Następnie użyjesz CreateFromStreamAsync metody aby utworzyć wystąpienie modelu jako obiekt LearningModel. Klasa LearningModel reprezentuje wytrenowany model uczenia maszynowego. Po utworzeniu wystąpienia, LearningModel jest początkowym obiektem używanym do interakcji z Windows ML.

Aby załadować model, możesz użyć kilku metod statycznych w LearningModel klasie . W tym przypadku użyjesz metody CreateFromStreamAsync.

Metoda CreateFromStreamAsync została utworzona automatycznie za pomocą narzędzia mlgen, więc nie trzeba implementować tej metody. Tę metodę można przejrzeć, dwukrotnie klikając plik classifier.cs wygenerowany przez mlgen.

Aby dowiedzieć się więcej o LearningModel klasie, zapoznaj się z dokumentacją Klas LearningModel. Aby dowiedzieć się więcej na temat dodatkowych sposobów ładowania modelu, zapoznaj się z dokumentacją Load a model (Ładowanie modelu)

4. Dodaj metodę loadModel do MainPage.xaml.cs pliku kodu wewnątrz MainPage klasy.

        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. Teraz dodaj wywołanie nowej metody do konstruktora klasy.

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

Wynik będzie wyglądać następująco.

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

Ładowanie obrazu

1. Musimy zdefiniować zdarzenie kliknięcia, aby zainicjować sekwencję czterech wywołań metody na potrzeby wykonywania modelu — konwersji, powiązania i oceny, wyodrębniania danych wyjściowych i wyświetlania wyników. Dodaj następującą metodę do MainPage.xaml.cs pliku kodu wewnątrz MainPage klasy.

        // 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. Teraz zaimplementujesz metodę getImage() . Ta metoda wybierze plik obrazu wejściowego i zapisze go w pamięci. Dodaj następującą metodę do MainPage.xaml.cs pliku kodu wewnątrz MainPage klasy.

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

Teraz zaimplementujesz metodę obrazu Bind() , aby uzyskać reprezentację pliku w formacie mapy bitowej BGRA8.

3. Dodaj implementację metody convert() do pliku kodu MainPage.xaml.cs w klasie MainPage. Metoda convert pobierze nam reprezentację pliku wejściowego w formacie BGRA8.

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

Wynik pracy wykonanej w tej sekcji będzie wyglądać następująco.

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

Powiązanie i ocena modelu

Następnie utworzysz sesję na podstawie modelu, powiąż dane wejściowe i wyjściowe z sesji i ocenisz model.

Utwórz sesję, aby powiązać model:

Aby utworzyć sesję, 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. Urządzenie można wybrać podczas tworzenia sesji w celu wykonania modelu na określonym urządzeniu maszyny. Domyślnym urządzeniem jest procesor CPU.

Powiązywanie danych wejściowych i wyjściowych modelu:

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.

Implementacja powiązania jest generowana automatycznie przez narzędzie mlgen, więc nie musisz się tym zajmować. Powiązanie jest implementowane przez wywołanie wstępnie zdefiniowanych LearningModelBinding metod klasy. W naszym przypadku używa metody Bind do powiązania wartości z nazwanym typem cechy.

Obecnie usługa Windows ML obsługuje wszystkie typy funkcji ONNX, takie jak Tensors (tablice wielowymiarowe), Sekwencje (wektory wartości), Mapa (pary wartości informacji) i Obrazy (określone formaty). Wszystkie obrazy będą reprezentowane w Windows ML w formacie tensora. Tensoryzacja to proces konwertowania obrazu na tensor i odbywa się podczas wiązania.

Na szczęście nie trzeba zajmować się konwersją na tensoryzację. Metoda użyta ImageFeatureValue w poprzedniej części zajmuje się zarówno konwersją, jak i tensoryzacją, więc obrazy są zgodne z wymaganym przez model formatem obrazu.

Oceń model:

Po utworzeniu sesji w celu powiązania modelu i powiązanych wartości z danymi wejściowymi i wyjściowymi modelu można ocenić dane wejściowe modelu i uzyskać jego przewidywania. Aby uruchomić wykonywanie modelu, należy wywołać dowolną ze wstępnie zdefiniowanych metod oceny w modelu LearningModelSession. W naszym przypadku użyjemy EvaluateAsync metody .

Podobnie jak metoda CreateFromStreamAsync, metoda EvaluateAsync została również automatycznie wygenerowana przez WinML Code Generator, więc nie musisz jej implementować. Tę metodę można przejrzeć w classifier.cs pliku.

Metoda EvaluateAsync będzie asynchronicznie oceniać model uczenia maszynowego przy użyciu wartości funkcji już powiązanych w powiązaniach. Spowoduje to utworzenie sesji z elementem LearningModelSession, powiązanie danych wejściowych i wyjściowych za pomocą LearningModelBinding, wykonanie oceny modelu i pobranie funkcji wyjściowych modelu przy użyciu klasy LearningModelEvaluationResult.

1. Dodaj następującą metodę do MainPage.xaml.cs pliku kodu wewnątrz klasy MainPage, aby utworzyć sesję, powiązać i ocenić model.

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

Wyodrębnianie i wyświetlanie wyników

Teraz musisz wyodrębnić dane wyjściowe modelu i wyświetlić odpowiednie wyniki. Będziesz to robić, implementując metodę extractResult i metodę displayResult.

Jak pokazano wcześniej, model zwraca dwa dane wyjściowe: pierwszy, o nazwie classLabel, to tensor ciągów, a druga, nazwana 'utrata', to sekwencja map od ciągów do wartości zmiennoprzecinkowych, opisująca prawdopodobieństwo dla każdej oznaczonej etykietą klasyfikacji. Aby pomyślnie wyświetlić wynik i prawdopodobieństwo, wystarczy wyodrębnić dane wyjściowe z danych wyjściowych utraty. Aby zwrócić prawidłowy wynik, musimy znaleźć najwyższe prawdopodobieństwo.

1. Dodaj metodę extractResult do MainPage.xaml.cs pliku kodu wewnątrz MainPage klasy.

        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. Dodaj metodę displayResult do MainPage.xaml.cs pliku kodu wewnątrz MainPage klasy.

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

Wynik części Powiązywania i Oceniania oraz Wyodrębniania i Wyświetlania wyników kodu WinML naszej aplikacji będzie wyglądać następująco.

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

I już! Pomyślnie utworzono aplikację uczenia maszynowego systemu Windows z podstawowym graficznym interfejsem użytkownika do przetestowania naszego modelu klasyfikacji. Następnym krokiem jest uruchomienie aplikacji i uruchomienie jej lokalnie na urządzeniu z systemem Windows.

Uruchamianie aplikacji

Po ukończeniu interfejsu aplikacji, dodaniu modelu i wygenerowaniu kodu WinML możesz przetestować aplikację. Upewnij się, że menu rozwijane na górnym pasku narzędzi są ustawione na Debug. Zmień Solution Platform na x64, aby uruchomić projekt na komputerze lokalnym, jeśli twoje urządzenie jest 64-bitowe, lub na x86, jeśli jest 32-bitowe.

Aby przetestować naszą aplikację, użyjesz poniższego obrazu owoców. Zobaczmy, jak nasza aplikacja klasyfikuje zawartość obrazu.

1. Zapisz ten obraz na urządzeniu lokalnym, aby przetestować aplikację. W razie potrzeby zmień format obrazu na jpg. Możesz również dodać dowolny inny odpowiedni obraz z urządzenia lokalnego w odpowiednim formacie — .jpg, .png, .bmplub .gif formatach.

2. Aby uruchomić projekt, naciśnij Start Debugging przycisk na pasku narzędzi lub naciśnij F5.

3. Po uruchomieniu aplikacji naciśnij Pick Image i wybierz obraz z urządzenia lokalnego.

Wynik pojawi się na ekranie od razu. Jak widać, nasza aplikacja WinML pomyślnie sklasyfikowała obraz jako owoce lub warzywa, z oceną ufności 99,9%.

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 systemu Windows.
• Dokumentacja interfejsu API usługi Windows Machine Learning: dowiedz się więcej o trzech obszarach interfejsów API uczenia maszynowego systemu Windows.