Wdrażanie modelu ML.NET w aplikacji systemu Windows przy użyciu interfejsów API usługi Windows Machine Learning

W poprzedniej części tego samouczka przedstawiono sposób kompilowania i eksportowania modelu ML.NET 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 klasyfikatoraMLNETModel.
• 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 [....\classifierMLNETModel\Assets] i skopiuj bestModel.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.

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. Zastąp kod MainPage.xaml poniższym kodem.

<Page
    x:Class="classifierMLNETModel.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:classifierMLNETModel"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">

       <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>
            <!--Dispaly the Result-->
            <TextBlock Name="displayOutput" 
                       FontWeight="Bold" 
                       TextWrapping="Wrap"
                       Margin="25,0,0,0"
                       Text="" Width="1471" />
            <TextBlock Name="space2" />
            <!--Image preview -->
            <Image Name="UIPreviewImage" Stretch="Uniform" MaxWidth="300" MaxHeight="300"/>
        </StackPanel>
    </Grid> 
</Page>

Dodawanie modelu do projektu przy użyciu generatora 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:

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

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

Teraz przyjrzyjmy się nowo wygenerowanemu kodzie w pliku bestModel.cs.

Wygenerowany kod zawiera trzy klasy:

• bestModelModel: 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.
• bestModelInput: ta klasa inicjuje typy danych wejściowych, których oczekuje model. Dane wejściowe modelu zależą od wymagań modelu na dane wejściowe.
• bestModelOutput: Ta klasa inicjuje typy, które będą zwracane przez model. Dane wyjściowe modelu zależą od sposobu jego definiowania przez model.

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

Konwersja tensora

Aby ułatwić obsługę tensoryzacji, zmień klasę danych wejściowych TensorFloat na ImageFeatureValue.

1. Wprowadź następujące zmiany w bestModel.cs pliku:

Kod:

public sealed class bestModelInput
    {
        public TensorFloat input; // shape(-1,3,32,32)
    }

Stanie się:

public sealed class bestModelInput
    {
        public ImageFeatureValue input; // shape(-1,3,32,32)
    }

Ł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 classifierMLNETModel.

		// All the required fields declaration
		private bestModelModel modelGen;
		private bestModelInput image = new bestModelInput();
		private bestModelOutput results;
		private StorageFile selectedStorageFile;
		private string label = "";
		private float probability = 0;
		private Helper helper = new Helper();

		public enum Labels
		{
			desert,
			soup,
			vegetable_fruit,
		}

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 bestModel.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. Zdefiniujmy główną metodę.

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

5. Dodaj implementację loadModel metody 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/bestModel.onnx"));
// Instantiate the model. 
	modelGen = await bestModelModel.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;
        }

Następnie zaimplementujesz metodę obrazu Bind() , aby uzyskać reprezentację pliku w formacie mapy bitowej BGRA8. Najpierw utworzysz klasę pomocnika, aby zmienić rozmiar obrazu.

3. Aby utworzyć plik pomocnika, kliknij prawym przyciskiem myszy nazwę rozwiązania (ClassifierPyTorch), a następnie wybierz pozycję Add a new item. W otwartym oknie wybierz Class i nadaj mu nazwę. W tym miejscu nazywamy go Helper.

4. W projekcie zostanie wyświetlony nowy plik klasy. Otwórz tę klasę i dodaj następujący kod:

using System; 
using System.Threading.Tasks; 
using Windows.Graphics.Imaging; 
using Windows.Media; 

namespace classifierPyTorch 
{ 
    public class Helper 
    { 
        private const int SIZE = 32;  
        VideoFrame cropped_vf = null; 
 
        public async Task<VideoFrame> CropAndDisplayInputImageAsync(VideoFrame inputVideoFrame) 
        { 
            bool useDX = inputVideoFrame.SoftwareBitmap == null; 

            BitmapBounds cropBounds = new BitmapBounds(); 
            uint h = SIZE; 
            uint w = SIZE; 
            var frameHeight = useDX ? inputVideoFrame.Direct3DSurface.Description.Height : inputVideoFrame.SoftwareBitmap.PixelHeight; 
            var frameWidth = useDX ? inputVideoFrame.Direct3DSurface.Description.Width : inputVideoFrame.SoftwareBitmap.PixelWidth; 
 
            var requiredAR = ((float)SIZE / SIZE); 
            w = Math.Min((uint)(requiredAR * frameHeight), (uint)frameWidth); 
            h = Math.Min((uint)(frameWidth / requiredAR), (uint)frameHeight); 
            cropBounds.X = (uint)((frameWidth - w) / 2); 
            cropBounds.Y = 0; 
            cropBounds.Width = w; 
            cropBounds.Height = h; 
 
            cropped_vf = new VideoFrame(BitmapPixelFormat.Bgra8, SIZE, SIZE, BitmapAlphaMode.Ignore); 
 
            await inputVideoFrame.CopyToAsync(cropped_vf, cropBounds, null); 
            return cropped_vf; 
        } 
    } 
} 

Teraz przekonwertujmy obraz na odpowiedni format.

Klasa bestModelInput inicjuje typy danych wejściowych, których oczekuje model. W naszym przypadku skonfigurowaliśmy nasz kod, aby oczekiwał wartości ImageFeatureValue.

Klasa ImageFeatureValue opisuje właściwości obrazu użytego do przekazania do modelu. Aby utworzyć obiektImageFeatureValue , należy użyć CreateFromVideoFrame metody . Aby uzyskać bardziej szczegółowe informacje o tym, dlaczego tak się dzieje i jak działają te klasy i metody, zobacz dokumentację klasy ImageFeatureValue.

5. 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);
              	// Resize the image size to 224x224 
              	inputImage=await helper.CropAndDisplayInputImageAsync(inputImage);
              	// Bind the model input with image
              	ImageFeatureValue imageTensor = ImageFeatureValue.CreateFromVideoFrame(inputImage);
				image.input1 = imageTensor;

				// 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);
				image.modelInput = 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.

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 bestModel.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()
        {
            results = await modelGen.EvaluateAsync(image);
        }

Wyodrębnianie i wyświetlanie wyników

Teraz musisz wyodrębnić dane wyjściowe modelu i wyświetlić odpowiedni wynik, co zrobisz, implementując metodę extractResult i metodę displayResult. Aby zwrócić poprawną etykietę, musisz znaleźć najwyższe prawdopodobieństwo.

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

        // A method to extract output from the model 
        private void extractResult()
        {
            // Retrieve the results of evaluation
            var mResult = results.modelOutput as TensorFloat;
            // convert the result to vector format
            var resultVector = mResult.GetAsVectorView();
            
            probability = 0;
            int index = 0;
            // find the maximum probability
            for(int i=0; i<resultVector.Count; i++)
            {
                var elementProbability=resultVector[i];
                if (elementProbability > probability)
                {
                    index = i;
                }
            }
            label = ((Labels)index).ToString();
        }

2. Dodaj metodę displayResult do MainPage.xaml.cs pliku kodu wewnątrz MainPage klasy.

        private async Task displayResult() 
        {
            displayOutput.Text = label; 
        }

I już! Pomyślnie utworzyłeś aplikację systemu Windows do uczenia maszynowego z podstawowym graficznym interfejsem użytkownika, aby przetestować nasz model 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 uczenia maszynowego systemu Windows możesz przetestować aplikację.

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.

Aby przetestować naszą aplikację, użyjmy poniższego obrazu zupy. Zobaczmy, jak nasza aplikacja klasyfikuje zawartość obrazu.

1. Zapisz ten obraz na urządzeniu lokalnym, aby przetestować aplikację. Zmień format obrazu na .jpg , jeśli jest to wymagane. Możesz również dodać dowolny inny odpowiedni obraz z urządzenia lokalnego w formacie .jpg lub .png .

2. Aby uruchomić projekt, wybierz 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 windows ML pomyślnie sklasyfikowała obraz jako zupę.

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.