Wdrażanie modelu w aplikacji systemu Windows przy użyciu interfejsu 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 WinML.

Po zakończeniu będziesz mieć działającą aplikację klasyfikacji obrazów.

Informacje o przykładowej aplikacji

W tym kroku samouczka utworzysz aplikację, która może klasyfikować obrazy przy użyciu modelu uczenia maszynowego. Jego podstawowy interfejs użytkownika umożliwia wybranie obrazu z urządzenia lokalnego i użycie modelu klasyfikacji ONNX utworzonego i wytrenowanego w poprzedniej części w celu sklasyfikowania go. Tagi zwrócone przez model są następnie wyświetlane obok obrazu.

W tym miejscu przeprowadzimy Cię przez ten proces.

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

Utwórz Windows ML UWP (C#)

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

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

Musisz również utworzyć podstawowy interfejs użytkownika, ponieważ trudno jest utworzyć zadowalającą aplikację opartą na obrazie w wierszu polecenia.

Otwieranie nowego projektu w programie Visual Studio

1. Zacznijmy. Otwórz program Visual Studio i wybierz pozycję Utwórz nowy projekt.

2. Na pasku wyszukiwania wpisz UWP, a następnie wybierz pozycję Blank APP (Universal Windows). Spowoduje to otwarcie projektu języka C# dla jednostronicowej aplikacji platformy uniwersalnej systemu Windows (UWP) ze wstępnie zdefiniowanymi kontrolkami lub układem. 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 go klasyfikatoremPyTorch.
• 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 [….\classifierPyTorch \Assets] i skopiuj ImageClassifier.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, a MainPage.xaml.cs zawiera kod aplikacji, znany również jako kod zaplecza. 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 kodu 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 MainPage.xaml, zastępując tagi <Grid> oraz </Grid>.

    <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="25,0,0,0" 
                       Text="" Width="1471" /> 
            <TextBlock Name="space2" /> 
            <!--Image preview --> 
            <Image Name="UIPreviewImage" Stretch="Uniform" MaxWidth="300" MaxHeight="300"/> 
        </StackPanel> 
    </Grid> 

Dodawanie modelu do projektu przy użyciu generatora kodu ML systemu Windows (mlgen)

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. Zalecamy korzystanie z programu Visual Studio. 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 classifierPyTorch [….\classifierPyTorch \Assets], znajdź wcześniej skopiowany tam model ONNX i wybierz pozycję add.

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

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

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

Kod pliku ONNX

Teraz przyjrzyjmy się nowo wygenerowanemu kodowi w pliku ImageClassifier.cs.

Wygenerowany kod zawiera trzy klasy:

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

W tym samouczku nie chcemy zajmować się tensoryzacją. Wprowadzimy niewielką zmianę w ImageClassifierInput klasie, aby zmienić typ danych wejściowych i ułatwić nam życie.

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

Zmień zmienną input z a TensorFloat na .ImageFeatureValue

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

Ładowanie modelu

1. Kliknij dwukrotnie plik, MainPage.xaml.cs 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 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; 

3. Dodaj następujące deklaracje zmiennych do klasy MainPage, powyżej funkcji public MainPage().

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

        public enum Labels 
        {             
            plane,
            car,
            bird,
            cat,
            deer,
            dog,
            frog,
            horse,
            ship,
            truck
        } 

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.

4. Dodaj wywołanie metody loadModel w konstruktorze klasy głównej.

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

5. Dodaj implementację loadModel metody wewnątrz tej 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/ImageClassifier.onnx"));
            // Instantiate the model. 
            modelGen = await ImageClassifierModel.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 ImageClassifierInput 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ć metodę ImageFeatureValue, należy użyć CreateFromVideoFrame metody . Aby uzyskać bardziej szczegółowe informacje o tym, dlaczego tak jest 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 bide 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 32x32  
        inputImage=await helper.CropAndDisplayInputImageAsync(inputImage); 
        // Bind the model input with image 
        ImageFeatureValue imageTensor = ImageFeatureValue.CreateFromVideoFrame(inputImage); 
        image.modelInput = 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 ImageClassifier.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.

Nasz model został przeszkolony do klasyfikowania następujących obrazów: samolot, samochód, ptak, kot, jelenie, pies, żaba, koń, statek, ciężarówka. Aby przetestować naszą aplikację, użyjesz obrazu samochodu Lego utworzonego dla tego projektu. 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ż użyć dowolnego innego odpowiedniego obrazu 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 pozycję Wybierz obraz 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 samochód.

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.