Nasazení modelu v aplikaci pro Windows pomocí rozhraní API služby Windows Machine Learning

V předchozí části tohoto kurzu jste se naučili, jak sestavit a exportovat model ve formátu ONNX. Teď, když máte tento model, můžete ho vložit do aplikace pro Windows a spustit ho místně na zařízení zavoláním rozhraní API WinML.

Až to dokončíme, budete mít funkční aplikaci WinML UWP (C#) pro klasifikaci obrázků.

Informace o ukázkové aplikaci

Pomocí našeho modelu vytvoříme aplikaci, která dokáže klasifikovat obrázky potravin. Umožňuje vybrat obrázek z místního zařízení a zpracovat ho místně uloženým modelem ONNX klasifikace, který jste vytvořili a vytrénovali v předchozí části. Vrácené značky se zobrazí vedle obrázku a také pravděpodobnost klasifikace.

Pokud jste zatím postupovali podle tohoto kurzu, měli byste už mít potřebné předpoklady pro vývoj aplikací. Pokud si potřebujete osvěžit paměť, podívejte se na první část tohoto kurzu.

Vytvořte WinML aplikaci UWP (C#)

Níže vám ukážeme, jak vytvořit aplikaci a kód WinML od začátku. Naučíte se:

• Načtěte model strojového učení.
• Načtěte prosím obrázek v požadovaném formátu.
• Spojte vstupy a výstupy modelu.
• Vyhodnoťte model a zobrazte smysluplné výsledky.

K vytvoření jednoduchého grafického uživatelského rozhraní použijete také základní XAML, abyste mohli klasifikátor obrázků otestovat.

Vytvoření aplikace

1. Otevřete Visual Studio a zvolte create a new project.

2. Na panelu hledání zadejte UWP a pak vyberte Blank APP (Universal Windows). Tím se otevře nový projekt jazyka C# pro jednostráňovou aplikaci univerzální platformy Windows (UPW), která nemá žádné předdefinované ovládací prvky ani rozložení. Výběrem Next otevřete okno konfigurace projektu.

3. V okně konfigurace:

• Zvolte název projektu. Tady používáme ImageClassifierAppUWP.
• Zvolte umístění projektu.
• Pokud používáte VS 2019, ujistěte se, že Place solution and project in the same directory není zaškrtnuto.
• Pokud používáte VS 2017, zkontrolujte, jestli Create directory for solution je zaškrtnuté.

Stisknutím create vytvoříte projekt. Může se objevit okno minimální cílové verze. Ujistěte se, že je minimální verze nastavená na Build 17763 nebo novější.

Pokud chcete vytvořit aplikaci a nasadit model s aplikací WinML, budete potřebovat následující:

4. Po vytvoření projektu přejděte do složky projektu, otevřete složku assets [....\ImageClassifierAppUWP\Assets] a zkopírujte model do tohoto umístění.

5. Změňte název modelu z model.onnx na classifier.onnx. Díky tomu je to trochu jasnější a sladí se s formátem návodu.

Prozkoumání modelu

Pojďme se seznámit se strukturou souboru Modelu.

1. classifier.onnx Otevřete soubor modelu pomocí Netronu.

2. Stisknutím Data otevřete vlastnosti modelu.

Jak vidíte, model vyžaduje 32bitový objekt Tensor (multidimenzionální pole) float jako vstup a vrací dva výstupy: první pojmenovaný classLabel je tensor řetězců a druhý pojmenovaný loss je posloupnost map typu string-to-float, která popisuje pravděpodobnost každé popisované klasifikace. Tyto informace budete potřebovat k úspěšnému zobrazení výstupu modelu v aplikaci pro Windows.

Prozkoumání projektového řešení

Pojďme prozkoumat řešení projektu.

Visual Studio automaticky vytvořilo několik souborů cs-code v Průzkumníku řešení. MainPage.xaml obsahuje kód XAML pro vaše grafické uživatelské rozhraní a MainPage.xaml.cs obsahuje kód vaší aplikace. Pokud jste předtím vytvořili aplikaci pro UPW, měly by vám tyto soubory být velmi známé.

Vytvoření grafického uživatelského rozhraní aplikace

Nejprve vytvoříme pro vaši aplikaci jednoduché grafické uživatelské rozhraní.

1. Poklepejte na soubor MainPage.xaml. V prázdné aplikaci je šablona XAML pro grafické uživatelské rozhraní prázdná, takže budeme muset přidat některé funkce uživatelského rozhraní.

2. Přidejte následující kód do hlavního textu souboru 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>

Generátor kódu služby Windows Machine Learning

Windows Machine Learning Code Generator nebo mlgen je rozšíření sady Visual Studio, které vám pomůže začít používat rozhraní API WinML v aplikacích pro UPW. Generuje kód šablony při přidání trénovaného souboru ONNX do projektu UPW.

Generátor kódu služby Windows Machine Learning mlgen vytvoří rozhraní (pro C#, C++/WinRT a C++/CX) s obálkovými třídami, které za vás volají rozhraní WINDOWS ML API. To vám umožní snadno načíst, svázat a vyhodnotit model v projektu. V tomto kurzu ji použijeme ke zpracování mnoha těchto funkcí.

Generátor kódu je k dispozici pro Visual Studio 2017 a novější. Mějte na paměti, že ve Windows 10 verze 1903 a novějším už není mlgen součástí sady Windows 10 SDK, takže je nutné stáhnout a nainstalovat rozšíření. Pokud jste postupovali podle tohoto kurzu z úvodu, už to zvládnete, ale pokud ne, měli byste si stáhnout verzi VS 2019 nebo VS 2017.

1. Pokud jste to ještě neudělali, nainstalujte mlgen.

2. Klikněte pravým tlačítkem myši na Assets složku v Průzkumníku řešení v sadě Visual Studio a vyberte Add > Existing Item.

3. Přejděte do složky assets uvnitř ImageClassifierAppUWP [….\ImageClassifierAppUWP\Assets], vyhledejte model ONNX, který jste tam dříve zkopírovali, a vyberte add.

4. Po přidání modelu ONNX (název: "klasifikátor") do složky assets v Průzkumníku řešení ve VS by teď měl mít projekt dva nové soubory:

• classifier.onnx - toto je váš model ve formátu ONNX.
• classifier.cs – automaticky vygenerovaný soubor kódu WinML.

5. Pokud chcete mít jistotu, že se model sestaví při kompilaci naší aplikace, vyberte classifier.onnx soubor a zvolte Properties. Pro Build Action vyberte Content.

Teď pojďme prozkoumat nově vygenerovaný kód v souboru classifier.cs.

Vygenerovaný kód obsahuje tři třídy:

• classifierModel: Tato třída obsahuje dvě metody pro vytvoření instance modelu a vyhodnocení modelu. Pomůže nám vytvořit reprezentaci modelu strojového učení, vytvořit relaci na výchozím systémovém zařízení, svázat konkrétní vstupy a výstupy s modelem a asynchronně vyhodnotit model.
• classifierInput: Tato třída inicializuje vstupní typy, které model očekává. Vstup modelu závisí na požadavcích modelu pro vstupní data. V našem případě vstup očekává ImageFeatureValue, třída, která popisuje vlastnosti obrázku použitého k předání do modelu.
• classifierOutput: Tato třída inicializuje typy, které bude model generovat. Výstup modelu závisí na tom, jak ho model definuje. V našem případě bude výstup posloupnost map (slovníků) typu String a TensorFloat (Float32) s názvem ztráta.

Tyto třídy teď použijete k načtení, vytvoření vazby a vyhodnocení modelu v našem projektu.

Načtěte model a vstupy

Načtení modelu

1. Dvojitým kliknutím na soubor MainPage.xaml.cs otevřete kód aplikace.

2. Nahraďte příkazy using následujícím kódem, abyste získali přístup ke všem rozhraním API, která budete potřebovat.

// 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. Přidejte následující deklarace proměnných po příkazech using uvnitř třídy MainPage v oboru názvů 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;

Výsledek bude vypadat následovně.

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

Teď implementujete metodu LoadModel . Metoda získá přístup k modelu ONNX a uloží ho do paměti. Pak použijete metodu CreateFromStreamAsync k vytvoření instance modelu jako objektu LearningModel . Třída LearningModel představuje trénovaný model strojového učení. Po vytvoření instance je počátečním objektem, LearningModel který používáte k interakci s Windows ML.

K načtení modelu můžete ve LearningModel třídě použít několik statických metod. V tomto případě použijete metodu CreateFromStreamAsync .

Metoda CreateFromStreamAsync byla automaticky vytvořena pomocí mlgen, takže tuto metodu nemusíte implementovat. Tuto metodu můžete zkontrolovat dvojitým kliknutím na soubor classifier.cs vygenerovaný nástrojem mlgen.

Další informace o LearningModel třídě najdete v dokumentaci k třídě LearningModel. Chcete-li se dozvědět více o dalších způsobech načítání modelu, podívejte se na dokumentaci "Načtení modelu."

4. Přidejte metodu loadModel do souboru kódu MainPage.xaml.cs uvnitř třídy MainPage.

        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. Nyní přidejte volání nové metody do konstruktoru třídy.

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

Výsledek bude vypadat následovně.

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

Načtení obrázku

1. Potřebujeme definovat událost kliknutí, abychom zahájili posloupnost čtyř volání metod pro provádění modelu – převod, vazbu a vyhodnocení, extrakci výstupu a zobrazení výsledků. Do souboru kódu MainPage.xaml.cs uvnitř třídy MainPage přidejte následující metodu.

        // 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. Teď implementujete metodu getImage() . Tato metoda vybere vstupní soubor obrázku a uloží ho do paměti. Do souboru kódu MainPage.xaml.cs uvnitř třídy MainPage přidejte následující metodu.

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

Nyní implementujete metodu obrázku Bind() , která získá reprezentaci souboru ve formátu rastrového obrázku BGRA8.

3. Přidejte implementaci convert() metody do MainPage.xaml.cs souboru kódu uvnitř Třídy MainPage. Metoda convert nám získá reprezentaci vstupního souboru ve formátu 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)
            {
            }
        }

Výsledek práce provedené v této části bude vypadat následovně.

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

Vytvoření vazby a vyhodnocení modelu

Dále vytvoříte relaci založenou na modelu, vytvoříte vazbu vstupu a výstupu z relace a vyhodnotíte model.

Vytvořte relaci pro svázání modelu.

K vytvoření relace použijete LearningModelSession třídu. Tato třída se používá k vyhodnocení modelů strojového učení a vytvoří vazbu modelu na zařízení, které pak model spustí a vyhodnotí. Můžete vybrat zařízení, když vytvoříte relaci pro spuštění svého modelu na konkrétním zařízení vašeho počítače. Výchozím zařízením je procesor.

Vytvoření vazby vstupů a výstupů modelu:

Pro vázání vstupu a výstupu použijte třídu LearningModelBinding. Model strojového učení má vstupní a výstupní funkce, které předávají informace do a z modelu. Mějte na paměti, že rozhraní API služby Windows ML musí podporovat požadované funkce. Třída LearningModelBinding se aplikuje na LearningModelSession k přiřazení hodnot pojmenovaným vstupním a výstupním vlastnostem.

Implementace vazby se automaticky vygeneruje nástrojem mlgen, takže se o ni nemusíte starat. Vazba je implementována voláním předdefinovaných metod LearningModelBinding třídy. V našem případě používá metodu Bind k vytvoření vazby hodnoty na pojmenovaný typ funkce.

Windows ML v současné době podporuje všechny typy funkcí ONNX, jako jsou Tensors (multidimenzionální pole), sekvence (vektory hodnot), mapa (dvojice hodnot informací) a obrázky (specifické formáty). Všechny obrázky budou reprezentovány ve Windows ML ve formátu tensoru. Tensorizace je proces převodu obrázku na tenzor a probíhá během vazby.

Naštěstí se nemusíte starat o převod procesu tensorizace. Metoda ImageFeatureValue , kterou jste použili v předchozí části, se postará o převod i tensorizaci, takže obrázky odpovídají požadovanému formátu obrázku modelu.

Vyhodnocení modelu:

Po vytvoření relace, která vytvoří vazbu modelu a ohraničovaných hodnot na vstupy a výstupy modelu, můžete vyhodnotit vstupy modelu a získat jeho předpovědi. Pokud chcete spustit provádění modelu, měli byste volat některou z předdefinovaných metod vyhodnocení v LearningModelSession. V našem případě použijeme metodu EvaluateAsync .

CreateFromStreamAsyncPodobně jako , EvaluateAsync metoda byla také automaticky generována WinML Code Generator, takže nemusíte implementovat tuto metodu. Tuto metodu classifier.cs můžete zkontrolovat v souboru.

Metoda EvaluateAsync asynchronně vyhodnotí model strojového učení pomocí hodnot funkcí, které jsou již vázány ve vazbách. Vytvoří relaci s LearningModelSession, sváže vstup a výstup s LearningModelBinding, spustí vyhodnocení modelu a získá výstupní funkce modelu pomocí třídy LearningModelEvaluationResult.

1. Do souboru kódu uvnitř třídy MainPage přidejte následující metodu MainPage.xaml.cs pro vytvoření relace, vytvoření vazby a vyhodnocení modelu.

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

Extrahování a zobrazení výsledků

Teď budete muset extrahovat výstup modelu a zobrazit správné výsledky. Provedete to implementací extractResult a displayResult metod.

Jak jste prozkoumali dříve, model vrátí dva výstupy: první pojmenovaný classLabel je tensor řetězců a druhá pojmenovaná ztráta je posloupnost map typu string-to-float, která popisuje pravděpodobnost pro každou klasifikaci označenou popiskem. Abychom tedy úspěšně zobrazili výsledek a pravděpodobnost, stačí extrahovat výstup z výstupu ztráty. Abychom vrátili správný výsledek, musíme najít nejvyšší pravděpodobnost.

1. Přidejte metodu extractResult do MainPage.xaml.cs souboru kódu uvnitř MainPage třídy.

        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. Přidejte metodu displayResult do MainPage.xaml.cs souboru kódu uvnitř MainPage třídy.

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

Výsledek vazby a vyhodnocení a extrakce a zobrazení částí výsledků kódu WinML naší aplikace bude vypadat následovně.

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

A je to. Úspěšně jste vytvořili aplikaci strojového učení pro Windows se základním grafickým uživatelským rozhraním pro testování našeho klasifikačního modelu. Dalším krokem je spuštění aplikace a jeho místní spuštění na zařízení s Windows.

Spuštění aplikace

Jakmile dokončíte rozhraní aplikace, přidáte model a vygenerujete kód WinML, můžete aplikaci otestovat. Ujistěte se, že jsou rozevírací nabídky v horním panelu nástrojů nastaveny na Debug. Změňte Solution Platform na x64 pro spuštění projektu na vašem místním počítači, pokud je vaše zařízení 64bitové, nebo na x86, pokud je 32bitové.

K otestování naší aplikace použijete následující obrázek ovoce. Pojďme se podívat, jak naše aplikace klasifikuje obsah obrázku.

1. Uložte tento obrázek na místní zařízení a otestujte aplikaci. V případě potřeby změňte formát obrázku na jpg. Můžete také přidat jakýkoliv další relevantní obrázek z místního zařízení v vhodném formátu – .jpg, .png, .bmpnebo .gif formáty.

2. Pokud chcete projekt spustit, stiskněte Start Debugging tlačítko na panelu nástrojů nebo stiskněte F5.

3. Po spuštění aplikace stiskněte Pick Image a vyberte obrázek z místního zařízení.

Výsledek se hned zobrazí na obrazovce. Jak vidíte, naše aplikace WinML úspěšně klasifikuje obrázek jako ovoce nebo zeleninu s hodnocením 99,9% spolehlivosti.

Shrnutí

Právě jste vytvořili svou první aplikaci Windows Machine Learning od vytvoření modelu po úspěšné spuštění.

Další zdroje

Další informace o tématech uvedených v tomto kurzu najdete v následujících zdrojích informací:

• Nástroje Windows ML: Přečtěte si další nástroje, jako je Řídicí panel Windows ML, WinMLRunner a generátor kódu mglen Windows ML.
• Model ONNX: Přečtěte si další informace o formátu ONNX.
• Výkon a paměť Windows ML: Přečtěte si další informace o správě výkonu aplikací pomocí Windows ML.
• Referenční informace k rozhraní API služby Windows Machine Learning: Přečtěte si další informace o třech oblastech rozhraní API služby Windows ML.