A ML.NET modell üzembe helyezése Windows-alkalmazásban a Windows Machine Learning API-kkal

Az oktatóanyag előző részében megtanulta, hogyan hozhat létre és exportálhat ML.NET modellt ONNX formátumban. Most, hogy már rendelkezik ezzel a modellel, beágyazhatja egy Windows-alkalmazásba, és helyileg futtathatja egy eszközön a WinML API-k meghívásával.

Ha végzett, egy működő Képosztályozó WinML UWP-alkalmazással (C#) fog rendelkezni.

Tudnivalók a mintaalkalmazásról

A modell segítségével létrehozunk egy alkalmazást, amely képes osztályozni az élelmiszerek képeit. Lehetővé teszi, hogy egy képet válasszon a helyi eszközről, és a helyben tárolt, az előző részben létrehozott és betanított ONNX-modellel feldolgozza. A visszaadott címkék a kép mellett jelennek meg, valamint a besorolás megbízhatósági valószínűsége.

Ha eddig követte ezt az oktatóanyagot, már rendelkeznie kell az alkalmazásfejlesztéshez szükséges előfeltételekkel. Ha frissítésre van szüksége, tekintse meg az oktatóanyag első részét.

Megjegyzés:

Ha inkább a teljes mintakódot szeretné letölteni, klónozhatja a megoldásfájlt. Klónozza a tárházat, navigáljon a mintafájlhoz, majd nyissa meg a classifierMLNETModel.sln fájlt a Visual Studio programmal. Ezután ugorjon az [Alkalmazás indítása](#Alkalmazás indítása) lépésre.

WinML UWP létrehozása (C#)

Az alábbiakban bemutatjuk, hogyan hozhatja létre az alkalmazást és a WinML-kódot az alapoktól. Megtudhatja, hogyan:

• Gépi tanulási modell betöltése.
• Töltsön be egy képet a kívánt formátumban.
• Kösse össze a modell bemeneteit és kimeneteit.
• Értékelje ki a modellt, és jelenítsen meg hasznos eredményeket.

Az egyszerű grafikus felhasználói felület létrehozásához alapszintű XAML-t is használhat, így tesztelheti a képosztályozót.

Az alkalmazás létrehozása

1. Nyissa meg a Visual Studiót, és válassza a lehetőséget create a new project.

2. Írja be UWP a keresősávba, majd válassza a Blank APP (Universal Windowslehetőséget. Ezzel megnyílik egy új C#-projekt egy egyoldalas univerzális Windows-platform (UWP) alkalmazáshoz, amely nem rendelkezik előre definiált vezérlőkkel vagy elrendezéssel. Válassza ki Next a projekt konfigurációs ablakának megnyitásához.

3. A konfigurációs ablakban:

• Válasszon nevet a projektnek. Itt a classifierMLNETModel osztályozót használjuk.
• Válassza ki a projekt helyét.
• Ha VS 2019-et használ, győződjön meg arról, hogy Place solution and project in the same directory nincs bejelölve.
• Ha VS 2017-et használ, győződjön meg róla, hogy Create directory for solution be van jelölve.

Nyomja le create a projekt létrehozásához. Előfordulhat, hogy a célverzió minimális ablaka megjelenik. Győződjön meg arról, hogy a minimális verzió a Windows 10 17763-as vagy újabb buildre van állítva.

Az alkalmazás létrehozásához és a modell WinML-alkalmazással való üzembe helyezéséhez a következőkre lesz szüksége:

4. A projekt létrehozása után keresse meg a projektmappát, nyissa meg az [....\classifierMLNETModel\Assets] objektummappát, és másolja a fájlt erre a bestModel.onnx helyre.

A projektmegoldás felfedezése

Vizsgáljuk meg a projektmegoldást.

A Visual Studio automatikusan létrehozott több cs-code fájlt a Megoldáskezelőben. MainPage.xaml tartalmazza a grafikus felhasználói felület XAML-kódját, és MainPage.xaml.cs tartalmazza az alkalmazáskódot. Ha korábban már létrehozott egy UWP-alkalmazást, ezeknek a fájloknak nagyon ismerősnek kell lenniük.

Az alkalmazás grafikus felhasználói felületének létrehozása

Először hozzunk létre egy egyszerű grafikus felhasználói felületet az alkalmazáshoz.

1. Kattintson duplán a MainPage.xaml fájlra. Az üres alkalmazásban az alkalmazás grafikus felhasználói felületének XAML-sablonja üres, ezért hozzá kell adnunk néhány felhasználói felületi funkciót.

2. Cserélje le a kódját MainPage.xaml a következőre.

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

A modell hozzáadása a projekthez a Windows Machine Learning Code Generator használatával

A Windows Machine Learning Code Generator vagy mlgen egy Visual Studio-bővítmény, amellyel megkezdheti a WinML API-k használatát UWP-alkalmazásokban. Sablonkódot hoz létre, amikor betanított ONNX-fájlt ad hozzá az UWP-projekthez.

A Windows Machine Learning kódgenerátora, az Mlgen létrehoz egy felületet (C#, C++/WinRT és C++/CX) a Windows ML API-t meghívó burkolóosztályokkal. Ez lehetővé teszi egy modell egyszerű betöltését, kötését és kiértékelését a projektben. Ebben az oktatóanyagban sok ilyen függvény kezelésére fogjuk használni.

A kódgenerátor a Visual Studio 2017-hez és újabb verziókhoz érhető el. Vegye figyelembe, hogy a Windows 10 1903-es és újabb verzióiban az mlgen már nem szerepel a Windows 10 SDK-ban, ezért le kell töltenie és telepítenie kell a bővítményt. Ha követte ezt az oktatóanyagot a bevezetésből, akkor már elvégezte ezt, de ha nem, le kell töltenie és telepítenie a VS 2019-et vagy a VS 2017-et.

Megjegyzés:

Az mlgenről további információt a mlgen dokumentációjában talál.

1. Ha még nem tette meg, telepítse a mlgent.

2. Kattintson a jobb gombbal a Visual Studio Megoldáskezelőjében lévő Assets mappára, és válassza a Add > Existing Item lehetőséget.

3. Keresse meg a benne lévő ImageClassifierAppUWP [….\ImageClassifierAppUWP\Assets]eszközök mappát, keresse meg a korábban oda másolt ONNX-modellt, és válassza a lehetőséget add.

4. Miután hozzáadott egy ONNX-modellt (név: "osztályozó") a VS megoldáskezelő eszközmappájába, a projektnek most két új fájllal kell rendelkeznie:

• bestModel.onnx - ez a modell ONNX formátumban van.
• bestModel.cs – automatikusan létrehozott WinML-kódfájl.

5. Annak érdekében, hogy a modell létrejöjjön az alkalmazás fordításakor, válassza a bestModel.onnx fájlt, és kattintson a Properties lehetőségre. Build Action céljából válassza a Content lehetőséget.

Most vizsgáljuk meg az újonnan létrehozott kódot a bestModel.cs fájlban.

A létrehozott kód három osztályt tartalmaz:

• bestModelModel: Ez az osztály két módszert tartalmaz a modell példányosításához és a modell kiértékeléshez. Segít létrehozni a gépi tanulási modell reprezentációját, létrehozni egy munkamenetet a rendszer alapértelmezett eszközén, a megadott bemeneteket és kimeneteket a modellhez kötni, és a modell aszinkron módon kiértékelni.
• bestModelInput: Ez az osztály inicializálja a modell által várt bemeneti típusokat. A modell bemenete a bemeneti adatok modellkövetelményeitől függ.
• bestModelOutput: Ez az osztály inicializálja a modell által előállított típusokat. A modell kimenete attól függ, hogy a modell hogyan határozza meg.

Most ezeket az osztályokat fogja használni a modell betöltésére, kötésére és kiértékelésére a projektben.

Tenszor-átalakítás

A tenzorizálás kezelésének megkönnyítése érdekében módosítsa a bemeneti TensorFloat osztályt a következőre ImageFeatureValue: .

1. Végezze el a következő módosításokat a bestModel.cs fájlban:

A kód:

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

A következő lesz:

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

Modell és a bemenetek betöltése

A modell betöltése

1. Kattintson duplán a MainPage.xaml.cs kódfájlra az alkalmazáskód megnyitásához.

2. Cserélje le a "using" utasítást a következőre, hogy hozzáférést kapjon az összes szükséges API-hoz.

// 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. Adja hozzá a következő változódeklarációkat a MainPage utasítások után az osztályon belül, a classifierMLNETModel névtér alatt.

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

Most a LoadModel metódust fogja implementálni. A metódus hozzáfér az ONNX-modellhez, és a memóriában tárolja. Ezután a CreateFromStreamAsync módszerrel példányosíthatja a modellt objektumként LearningModel . Az LearningModel osztály egy betanított gépi tanulási modellt jelöl. A példányosítás után az LearningModel a kezdeti objektum, amelyet a Windows ML-vel való interakcióhoz használ.

A modell betöltéséhez több statikus metódust is használhat az LearningModel osztályban. Ebben az esetben a CreateFromStreamAsync módszert fogja használni.

A CreateFromStreamAsync metódus automatikusan létre lett hozva mlgennel, így nem kell implementálnia ezt a metódust. Ezt a módszert az mlgen által létrehozott fájlra bestModel.cs duplán kattintva tekintheti át.

Az osztályról LearningModel további információt a LearningModel Osztály dokumentációjában talál.

A modell betöltésének további módjairól további információt a Modell betöltése dokumentációban talál.

4. Határozzuk meg a fő metódust.

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

5. Adja hozzá a loadModel metódus implementációját a MainPage.xaml.cs kódfájljához az MainPage osztályon belül.

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

A kép betöltése

1. Meg kell határoznunk egy kattintásos eseményt, amely négy metódushívás sorozatát indítja el a modell végrehajtásához – átalakítás, kötés és értékelés, kimeneti kinyerés és az eredmények megjelenítése. Adja hozzá a következő metódust a MainPage.xaml.cs kódfájlhoz az MainPage osztályon belül.

        // 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. Most a getImage() metódust fogja implementálni. Ez a metódus kiválaszt egy bemeneti képfájlt, és menti a memóriába. Adja hozzá a következő metódust a MainPage.xaml.cs kódfájlhoz az MainPage osztályon belül.

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

Ezután implementál egy képmetódust Bind() , amely bitkép BGRA8 formátumban jeleníti meg a fájlt. Először azonban létrehoz egy segédosztályt a kép átméretezéséhez.

3. Segédfájl létrehozásához kattintson a jobb gombbal a megoldás nevére (ClassifierPyTorch), majd válassza a lehetőséget Add a new item. A megnyitott ablakban válassza ki Class és adja meg a nevét. Itt így nevezzük: Helper.

4. Megjelenik egy új osztályfájl a projektben. Nyissa meg ezt az osztályt, és adja hozzá a következő kódot:

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

Most konvertáljuk a képet a megfelelő formátumra.

Az bestModelInput osztály inicializálja a modell által várt bemeneti típusokat. Esetünkben úgy konfiguráltuk a kódot, hogy egy ImageFeatureValue-et várjon.

Az ImageFeatureValue osztály a modellbe való továbbításhoz használt kép tulajdonságait írja le. A ImageFeatureValue létrehozásához a CreateFromVideoFrame metódust használja. Ennek okairól és az osztályok és metódusok működéséről az ImageFeatureValue osztály dokumentációjában olvashat bővebben.

Megjegyzés:

Ebben az oktatóanyagban az osztályt ImageFeatureValue használjuk tenzor helyett. Ha a Windows ML nem támogatja a modell színformátumát, ez nem lesz lehetőség. A képkonvertálások és a tenszorizációk használatával kapcsolatos példákért tekintse meg az egyéni tenzorizálási mintát.

5. Adja hozzá a convert() metódus implementálását a MainPage.xaml.cs MainPage osztály kódfájljához. A konvertálási metódus BGRA8 formátumban jeleníti meg a bemeneti fájlt.

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

A modell előkészítése és kiértékelése

Ezután létre fog hozni egy munkamenetet a modell alapján, megköti a bemenetet és a kimenetet a munkamenetből, és kiértékeli a modellt.

Hozzon létre egy munkamenetet a modell kötéséhez:

Munkamenet létrehozásához használja az osztályt LearningModelSession . Ez az osztály a gépi tanulási modellek kiértékelésére szolgál, és egy olyan eszközhöz köti a modellt, amely ezután futtatja és kiértékeli a modellt. Amikor létrehoz egy munkamenetet, kiválaszthat egy eszközt, amellyel végrehajthatja a modellt a gép egy adott eszközén. Az alapértelmezett eszköz a PROCESSZOR.

Megjegyzés:

Ha többet szeretne megtudni az eszköz kiválasztásáról, tekintse át a munkamenet-dokumentáció létrehozását .

Kötésmodell bemenetei és kimenetei:

A bemenet és a kimenet kötéséhez használja az osztályt LearningModelBinding . A gépi tanulási modell bemeneti és kimeneti funkciókkal rendelkezik, amelyek információkat adnak át a modellbe és kifelé. Vegye figyelembe, hogy a Windows ML API-knak támogatniuk kell a szükséges szolgáltatásokat. A LearningModelBinding osztály LearningModelSession-re van alkalmazva, hogy értékeket kössön névvel ellátott bemeneti és kimeneti tulajdonságokhoz.

A kötés implementálását a mlgen automatikusan létrehozza, így nem kell gondoskodnia róla. A kötés az osztály előre definiált metódusainak LearningModelBinding meghívásával implementálható. Esetünkben a metódussal Bind köt egy értéket a nevesített funkciótípushoz.

A modell kiértékelése:

Miután létrehozott egy munkamenetet, amely a modell és a határolókeret értékeit egy modell bemeneteihez és kimeneteihez köti, kiértékelheti a modell bemeneteit, és lekérheti az előrejelzéseit. A modell végrehajtásának futtatásához hívja meg a LearningModelSession előre definiált kiértékelési módszereit. A mi esetünkben a EvaluateAsync módszert fogjuk használni.

CreateFromStreamAsyncEhhez hasonlóan a EvaluateAsync metódust a WinML Code Generator is automatikusan generálta, így nem kell implementálnia ezt a metódust. Ezt a módszert a fájlban bestModel.cs tekintheti át.

A EvaluateAsync metódus aszinkron módon kiértékeli a gépi tanulási modellt a kötésekben már kötött funkcióértékek használatával. Létrehoz egy munkamenetet LearningModelSession, összeköti a bemenetet és a kimenetet LearningModelBinding, végrehajtja a modell kiértékelését, és lekéri a modell kimeneti funkcióit az LearningModelEvaluationResult osztály használatával.

Megjegyzés:

A modell futtatására szolgáló egyéb kiértékelési módszerekről a LearningModelSession osztály dokumentációjának áttekintésével ellenőrizheti, hogy mely módszerek implementálhatók a LearningModelSession osztályban.

1. Adja hozzá a következő metódust a MainPage.xaml.cs kódfájlhoz a MainPage osztályban egy munkamenet létrehozásához, a kötéshez és a modell kiértékeléséhez.

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

Az eredmények kinyerése és megjelenítése

Ki kell nyernie a modell kimenetét, és meg kell jelenítenie az eredményét, amit a extractResult és displayResult módszerek implementálásával fog elvégezni. Meg kell találnia azt a legnagyobb valószínűséget, amely a megfelelő címkéhez vezet.

1. Adja hozzá a extractResult metódust a MainPage.xaml.cs kódfájlhoz az MainPage osztályon belül.

        // 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. Adja hozzá a displayResult metódust a MainPage.xaml.cs kódfájlhoz az MainPage osztályon belül.

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

Ennyi az egész! Sikeresen létrehozta a Windows gépi tanulási alkalmazást egy alapszintű grafikus felhasználói felülettel a besorolási modell teszteléséhez. A következő lépés az alkalmazás elindítása és helyi futtatása a Windows-eszközön.

Az alkalmazás indítása

Miután elvégezte az alkalmazás felületét, hozzáadta a modellt, és létrehozta a Windows ML-kódot, tesztelheti az alkalmazást!

Engedélyezze a fejlesztői módot, és tesztelje az alkalmazást a Visual Studióban. Győződjön meg arról, hogy a felső eszköztár legördülő menüi a következőre Debugvannak állítva: . Módosítsa a megoldásplatformot x64-re a projekt helyi gépen való futtatásához, ha az eszköz 64 bites, vagy x86, ha az 32 bites.

Az alkalmazás teszteléséhez használjuk az alábbi leves képét. Lássuk, hogyan osztályozza az alkalmazás a kép tartalmát.

1. Mentse ezt a lemezképet a helyi eszközön az alkalmazás teszteléséhez. Szükség esetén módosítsa a képformátumot .jpg . Releváns képet is hozzáadhat a helyi eszközről .jpg vagy .png formátumban.

2. A projekt futtatásához kattintson az Start Debugging eszköztár gombra, vagy nyomja le a gombot F5.

3. Az alkalmazás indításakor nyomja le Pick Image és válassza ki a képet a helyi eszközről.

Az eredmény azonnal megjelenik a képernyőn. Amint láthatja, a Windows ML-alkalmazás sikeresen osztályozta a képet levesként.

Összefoglalás

Most hozta létre az első Windows Machine Learning-alkalmazást a modelllétrehozástól a sikeres végrehajtásig.

További források

Az oktatóanyagban említett témakörökről az alábbi forrásokból tudhat meg többet:

• Windows ML-eszközök: További eszközök, például a Windows ML irányítópultja, a WinMLRunner és a mglen Windows ML-kódgenerátor.
• ONNX-modell: További információ az ONNX formátumról.
• Windows ML teljesítménye és memóriája: További információ az alkalmazások teljesítményének a Windows ML-vel való kezeléséről.
• Windows Machine Learning API-referencia: További információ a Windows ML API-k három területéről.