Menyebarkan model ML.NET Anda di aplikasi Windows dengan WINDOWS Pembelajaran Mesin API

Di bagian sebelumnya dari tutorial ini, Anda mempelajari cara membangun dan mengekspor model ML.NET dalam format ONNX. Sekarang setelah Anda memiliki model tersebut, Anda dapat menyematkannya ke dalam aplikasi Windows dan menjalankannya secara lokal di perangkat dengan memanggil API WinML.

Setelah selesai, Anda akan memiliki aplikasi WinML UWP pengklasifikasi gambar (C#).

Tentang aplikasi sampel

Dengan menggunakan model kami, kami akan membuat aplikasi yang dapat mengklasifikasikan gambar makanan. Ini memungkinkan Anda untuk memilih gambar dari perangkat lokal Anda dan memprosesnya dengan model ONNX klasifikasi yang disimpan secara lokal yang Anda buat dan latih di bagian sebelumnya. Tag yang dikembalikan ditampilkan di samping gambar, serta probabilitas keyakinan klasifikasi.

Jika Anda telah mengikuti tutorial ini sejauh ini, Anda harus sudah memiliki prasyarat yang diperlukan untuk pengembangan aplikasi. Jika Anda memerlukan penyegaran, lihat bagian pertama dari tutorial ini.

Membuat WinML UWP (C#)

Di bawah ini, kami akan menunjukkan kepada Anda cara membuat aplikasi dan kode WinML dari awal. Anda akan mempelajari cara:

• Muat model pembelajaran mesin.
• Muat gambar dalam format yang diperlukan.
• Ikat input dan output model.
• Mengevaluasi model dan menampilkan hasil yang bermakna.

Anda juga akan menggunakan XAML dasar untuk membuat GUI sederhana, sehingga Anda dapat menguji pengklasifikasi gambar.

Membuat aplikasi

1. Buka Visual Studio dan pilih create a new project.

2. Di bilah pencarian, ketik UWP lalu pilih Blank APP (Universal Windows). Ini membuka proyek C# baru untuk aplikasi Platform Windows Universal satu halaman (UWP) yang tidak memiliki kontrol atau tata letak yang telah ditentukan sebelumnya. Pilih Next untuk membuka jendela konfigurasi untuk proyek.

3. Di jendela konfigurasi:

• Masukkan nama untuk proyek Anda. Di sini, kami menggunakan pengklasifikasiMLNETModel.
• Pilih lokasi proyek Anda.
• Jika Anda menggunakan VS 2019, pastikan Place solution and project in the same directory tidak dicentang.
• Jika Anda menggunakan VS 2017, pastikan Create directory for solution dicentang.

Tekan create untuk membuat proyek Anda. Jendela versi target minimum dapat muncul. Pastikan versi minimum Anda diatur ke Windows 10 build 17763 atau yang lebih baru.

Untuk membuat aplikasi dan menyebarkan model dengan aplikasi WinML, Anda memerlukan hal berikut:

4. Setelah proyek dibuat, navigasikan ke folder proyek, buka folder aset [....\classifierMLNETModel\Assets], dan salin file Anda bestModel.onnx ke lokasi ini.

Menjelajahi solusi proyek

Mari kita jelajahi solusi proyek Anda.

Visual Studio secara otomatis membuat beberapa file kode cs di dalam Penjelajah Solusi. MainPage.xaml berisi kode XAML untuk GUI Anda, dan MainPage.xaml.cs berisi kode aplikasi Anda. Jika Anda telah membuat aplikasi UWP sebelumnya, file-file ini harus sangat akrab bagi Anda.

Membuat GUI Aplikasi

Pertama, mari kita buat GUI sederhana untuk aplikasi Anda.

1. Klik dua kali pada MainPage.xaml file. Di aplikasi kosong Anda, templat XAML untuk GUI aplikasi Anda kosong, jadi kita harus menambahkan beberapa fitur UI.

2. Ganti kode MainPage.xaml dengan yang berikut ini.

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

Menambahkan model ke proyek menggunakan Windows Pembelajaran Mesin Code Generator

Windows Pembelajaran Mesin Code Generator, atau mlgen, adalah ekstensi Visual Studio untuk membantu Anda mulai menggunakan API WinML di aplikasi UWP. Ini menghasilkan kode templat saat Anda menambahkan file ONNX terlatih ke dalam proyek UWP.

Mlgen generator kode Windows Pembelajaran Mesin membuat antarmuka (untuk C#, C++/WinRT, dan C++/CX) dengan kelas pembungkus yang memanggil Windows ML API untuk Anda. Ini memungkinkan Anda untuk dengan mudah memuat, mengikat, dan mengevaluasi model dalam proyek Anda. Kita akan menggunakannya dalam tutorial ini untuk menangani banyak fungsi tersebut bagi kita.

Generator kode tersedia untuk Visual Studio 2017 dan yang lebih baru. Perlu diketahui bahwa di Windows 10, versi 1903 dan yang lebih baru, mlgen tidak lagi disertakan dalam Windows 10 SDK, sehingga Anda harus mengunduh dan menginstal ekstensi. Jika Anda telah mengikuti tutorial ini dari pengantar, Anda akan telah menangani ini, tetapi jika tidak, Anda harus mengunduh untuk VS 2019 atau untuk VS 2017.

1. Jika Anda belum melakukannya, instal mlgen.

2. Klik kanan pada Assets folder di Penjelajah Solusi di Visual studio, dan pilih Add > Existing Item.

3. Navigasi ke folder aset di dalam ImageClassifierAppUWP [….\ImageClassifierAppUWP\Assets], temukan model ONNX yang sebelumnya Anda salin di sana, dan pilih add.

4. Setelah Anda menambahkan model ONNX (nama: "pengklasifikasi") ke folder aset di penjelajah solusi di VS, proyek sekarang harus memiliki dua file baru:

• bestModel.onnx - ini adalah model Anda dalam format ONNX.
• bestModel.cs – file kode WinML yang dihasilkan secara otomatis.

5. Untuk memastikan model dibuat saat Anda mengkompilasi aplikasi kami, pilih bestModel.onnx file dan pilih Properties. Untuk Build Action, pilih Content.

Sekarang, mari kita jelajahi kode yang baru dibuat dalam bestModel.cs file.

Kode yang dihasilkan mencakup tiga kelas:

• bestModelModel: Kelas ini mencakup dua metode untuk instansiasi model dan evaluasi model. Ini akan membantu kami membuat representasi model pembelajaran mesin, membuat sesi pada perangkat default sistem, mengikat input dan output tertentu ke model, dan mengevaluasi model secara asinkron.
• bestModelInput: Kelas ini menginisialisasi jenis input yang diharapkan model. Input model tergantung pada persyaratan model untuk data input.
• bestModelOutput: Kelas ini menginisialisasi jenis yang akan dihasilkan model. Output model tergantung pada bagaimana output didefinisikan oleh model.

Anda sekarang akan menggunakan kelas-kelas ini untuk memuat, mengikat, dan mengevaluasi model dalam proyek kami.

Konversi tensor

Untuk mempermudah berurusan dengan tensorisasi, ubah kelas input TensorFloat menjadi ImageFeatureValue.

1. Buat perubahan berikut dalam bestModel.cs file:

Kode:

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

Akan menjadi:

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

Memuat model & input

Memuat model

1. Klik dua kali pada MainPage.xaml.cs file kode untuk membuka kode aplikasi.

2. Ganti pernyataan "menggunakan" dengan yang berikut ini, untuk mendapatkan akses ke semua API yang akan Anda butuhkan.

// 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. Tambahkan deklarasi variabel berikut setelah pernyataan penggunaan di dalam kelas Anda MainPage , di bawah namespace 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,
		}

Sekarang, Anda akan menerapkan metode .LoadModel Metode ini akan mengakses model ONNX dan menyimpannya dalam memori. Kemudian, Anda akan menggunakan CreateFromStreamAsync metode untuk membuat instans model sebagai LearningModel objek. Kelas mewakili LearningModel model pembelajaran mesin terlatih. Setelah dibuat, LearningModel adalah objek awal yang Anda gunakan untuk berinteraksi dengan Windows ML.

Untuk memuat model, Anda dapat menggunakan beberapa metode statis di LearningModel kelas . Dalam hal ini, Anda akan menggunakan metode .CreateFromStreamAsync

Metode CreateFromStreamAsync ini secara otomatis dibuat dengan mlgen, sehingga Anda tidak perlu menerapkan metode ini. Anda dapat meninjau metode ini dengan mengklik dua kali pada bestModel.cs file yang dihasilkan oleh mlgen.

Untuk mempelajari lebih lanjut tentang LearningModel kelas, silakan tinjau dokumentasi Kelas Pembelajaran Model.

Untuk mempelajari selengkapnya tentang cara memuat model tambahan, silakan tinjau dokumentasi Muat model

4. Mari kita tentukan metode utama.

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

5. Tambahkan implementasi metode ke loadModel file kode Anda MainPage.xaml.cs di MainPage dalam kelas .

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

Muat Gambar

1. Kita perlu menentukan peristiwa klik untuk memulai urutan empat panggilan metode untuk eksekusi model - konversi, pengikatan dan evaluasi, ekstraksi output, dan menampilkan hasilnya. Tambahkan metode berikut ke file kode Anda MainPage.xaml.cs di MainPage dalam kelas .

        // 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. Sekarang, Anda akan menerapkan metode .getImage() Metode ini akan memilih file gambar input dan menyimpannya dalam memori. Tambahkan metode berikut ke file kode Anda MainPage.xaml.cs di MainPage dalam kelas .

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

Selanjutnya, Anda akan menerapkan metode gambar Bind() untuk mendapatkan representasi file dalam format bitmap BGRA8. Tetapi pertama-tama, Anda akan membuat kelas pembantu untuk mengubah ukuran gambar.

3. Untuk membuat file pembantu, klik kanan pada nama solusi (ClassifierPyTorch), lalu pilih Add a new item. Di jendela yang terbuka, pilih Class dan beri nama. Di sini, kami menyebutnya Helper.

4. File kelas baru akan muncul dalam proyek Anda. Buka kelas ini, dan tambahkan kode berikut:

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

Sekarang, mari kita konversi gambar ke format yang sesuai.

Kelas bestModelInput menginisialisasi jenis input yang diharapkan model. Dalam kasus kami, kami mengonfigurasi kode kami untuk mengharapkan ImageFeatureValue.

Kelas menjelaskan ImageFeatureValue properti gambar yang digunakan untuk meneruskan ke model. Untuk membuatImageFeatureValue, Anda menggunakan CreateFromVideoFrame metode . Untuk detail yang lebih spesifik tentang mengapa hal ini terjadi dan cara kerja kelas dan metode ini, lihat dokumentasi kelas ImageFeatureValue.

5. Tambahkan implementasi metode ke convert() file kode Anda MainPage.xaml.cs di dalam kelas MainPage. Metode konversi akan memberi kita representasi file input dalam format 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)
            {
            }
        }

Mengikat dan Mengevaluasi model

Selanjutnya, Anda akan membuat sesi berdasarkan model, mengikat input dan output dari sesi, dan mengevaluasi model.

Buat sesi untuk mengikat model:

Untuk membuat sesi, Anda menggunakan LearningModelSession kelas . Kelas ini digunakan untuk mengevaluasi model pembelajaran mesin, dan mengikat model ke perangkat yang kemudian menjalankan dan mengevaluasi model. Anda dapat memilih perangkat saat membuat sesi untuk menjalankan model pada perangkat tertentu dari komputer Anda. Perangkat default adalah CPU.

Mengikat input dan output model:

Untuk mengikat input dan output, Anda menggunakan LearningModelBinding kelas . Model pembelajaran mesin memiliki fitur input dan output, yang meneruskan informasi ke dalam dan ke luar model. Ketahuilah bahwa fitur yang diperlukan harus didukung oleh API Window ML. Kelas LearningModelBinding diterapkan pada nilai yang LearningModelSession mengikat ke fitur input dan output bernama.

Implementasi pengikatan secara otomatis dihasilkan oleh mlgen, sehingga Anda tidak perlu mengurusnya. Pengikatan diimplementasikan dengan memanggil metode kelas yang LearningModelBinding telah ditentukan sebelumnya. Dalam kasus kami, metode ini menggunakan Bind metode untuk mengikat nilai ke jenis fitur bernama.

Mengevaluasi model:

Setelah Membuat sesi untuk mengikat model dan nilai terikat ke input dan output model, Anda dapat mengevaluasi input model dan mendapatkan prediksinya. Untuk menjalankan eksekusi model, Anda harus memanggil salah satu metode evaluasi yang telah ditentukan sebelumnya pada Pembelajaran ModelSession. Dalam kasus kami, kami akan menggunakan metode .EvaluateAsync

Mirip CreateFromStreamAsyncdengan , EvaluateAsync metode ini juga secara otomatis dihasilkan oleh WinML Code Generator, sehingga Anda tidak perlu menerapkan metode ini. Anda dapat meninjau metode ini dalam bestModel.cs file.

Metode ini EvaluateAsync akan mengevaluasi model pembelajaran mesin secara asinkron menggunakan nilai fitur yang sudah terikat dalam pengikatan. Ini akan membuat sesi dengan LearningModelSession, mengikat input dan output dengan LearningModelBinding, menjalankan evaluasi model, dan mendapatkan fitur output model menggunakan LearningModelEvaluationResult kelas .

1. Tambahkan metode berikut ke file kode Anda MainPage.xaml.cs di dalam kelas MainPage untuk membuat sesi, mengikat, dan mengevaluasi model.

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

Mengekstrak dan menampilkan hasilnya

Anda sekarang perlu mengekstrak output model dan menampilkan hasil yang tepat, yang akan Anda lakukan dengan menerapkan extractResult metode dan displayResult . Anda harus menemukan probabilitas tertinggi untuk mengembalikan label yang benar.

1. Tambahkan metode ke extractResult file kode Anda MainPage.xaml.cs di MainPage dalam kelas .

        // 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. Tambahkan metode ke displayResult file kode Anda MainPage.xaml.cs di MainPage dalam kelas .

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

Itu saja! Anda telah berhasil membuat aplikasi pembelajaran mesin Windows dengan GUI dasar untuk menguji model klasifikasi kami. Langkah selanjutnya adalah meluncurkan aplikasi dan menjalankannya secara lokal di perangkat Windows Anda.

Luncurkan aplikasi tersebut

Setelah Anda menyelesaikan antarmuka aplikasi, menambahkan model, dan menghasilkan kode Windows ML, Anda dapat menguji aplikasi!

Aktifkan mode pengembang dan uji aplikasi Anda dari Visual Studio. Pastikan menu dropdown di toolbar atas diatur ke Debug. Ubah Platform Solusi ke x64 untuk menjalankan proyek di komputer lokal Anda jika perangkat Anda 64-bit, atau x86 jika 32-bit.

Untuk menguji aplikasi kami, mari kita gunakan gambar sup di bawah ini. Mari kita lihat bagaimana aplikasi kita mengklasifikasikan konten gambar.

1. Simpan gambar ini di perangkat lokal Anda untuk menguji aplikasi. Ubah format gambar menjadi .jpg jika diperlukan. Anda juga dapat menambahkan gambar lain yang .jpg relevan dari perangkat lokal Anda dalam format atau .png .

2. Untuk menjalankan proyek, pilih tombol Start Debugging pada toolbar, atau tekan F5.

3. Saat aplikasi dimulai, tekan Pick Image dan pilih gambar dari perangkat lokal Anda.

Hasilnya akan langsung muncul di layar. Seperti yang Anda lihat, aplikasi Windows ML kami berhasil mengklasifikasikan gambar sebagai sup.

Ringkasan

Anda baru saja membuat aplikasi Windows Pembelajaran Mesin pertama Anda, dari pembuatan model hingga keberhasilan eksekusi.

Sumber Tambahan

Untuk mempelajari selengkapnya tentang topik yang disebutkan dalam tutorial ini, kunjungi sumber daya berikut:

• Alat Windows ML: Pelajari lebih lanjut alat seperti Dasbor Windows ML, WinMLRunner, dan generator kode ML Windows mglen .
• Model ONNX: Pelajari selengkapnya tentang format ONNX.
• Performa dan memori Windows ML: Pelajari selengkapnya cara mengelola performa aplikasi dengan Windows ML.
• Referensi WINDOWS Pembelajaran Mesin API: Pelajari selengkapnya tentang tiga area API Windows ML.