Bagikan melalui

Menyebarkan model Anda di aplikasi Windows dengan API Windows Machine Learning

Di bagian sebelumnya dari tutorial ini, Anda mempelajari cara membangun dan mengekspor model 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 memilih gambar dari perangkat lokal Anda dan memprosesnya dengan model klasifikasi ONNX yang tersimpan secara lokal, yang telah 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.

Nota

Jika Anda lebih suka mengunduh kode sampel lengkap, Anda dapat mengkloning file solusi. Klon repositori, buka sampel ini, lalu buka file ImageClassifierAppUWP.sln dengan Visual Studio. Kemudian, Anda dapat melompat ke langkah [Luncurkan aplikasi](#Launch aplikasi).

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.

Membuat proyek Visual Studio baru

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

Membuat aplikasi UWP baru

  1. Di jendela konfigurasi:
  • Pilih nama untuk proyek Anda. Di sini, kami menggunakan ImageClassifierAppUWP.
  • 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:

  1. Setelah proyek dibuat, navigasikan ke folder proyek, buka folder aset [....\ImageClassifierAppUWP\Assets], dan salin model Anda ke lokasi ini.

  2. Ubah nama model dari model.onnx ke classifier.onnx. Ini membuat hal-hal sedikit lebih jelas, dan menyelaraskannya dengan format tutorial.

Menjelajahi model Anda

Mari kita terbiasa dengan struktur file Model Anda.

  1. Buka file model Anda classifier.onnx , menggunakan Netron.

  2. Tekan Data untuk membuka properti model.

Properti model

Seperti yang Anda lihat, model memerlukan objek float Tensor (array multidimensi) 32-bit sebagai input dan mengembalikan dua output: yang pertama bernama classLabel tensor string dan yang kedua bernama loss adalah urutan peta string-ke-float yang menjelaskan probabilitas untuk setiap klasifikasi berlabel. Anda akan memerlukan informasi ini agar berhasil menampilkan output model di aplikasi Windows Anda.

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. Tambahkan kode di bawah ini ke bagian utama MainPage.xaml.

<Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">

        <StackPanel Margin="1,0,-1,0">
            <TextBlock x:Name="Menu" 
                       FontWeight="Bold" 
                       TextWrapping="Wrap"
                       Margin="10,0,0,0"
                       Text="Image Classification"/>
            <TextBlock Name="space" />
            <Button Name="recognizeButton"
                    Content="Pick Image"
                    Click="OpenFileButton_Click" 
                    Width="110"
                    Height="40"
                    IsEnabled="True" 
                    HorizontalAlignment="Left"/>
            <TextBlock Name="space3" />
            <Button Name="Output"
                    Content="Result is:"
                    Width="110"
                    Height="40"
                    IsEnabled="True" 
                    HorizontalAlignment="Left" 
                    VerticalAlignment="Top">
            </Button>
            <!--Display the Result-->
            <TextBlock Name="displayOutput" 
                       FontWeight="Bold" 
                       TextWrapping="Wrap"
                       Margin="30,0,0,0"
                       Text="" Width="1471" />
            <Button Name="ProbabilityResult"
                    Content="Probability is:"
                    Width="110"
                    Height="40"
                    IsEnabled="True" 
                    HorizontalAlignment="Left"/>
            <!--Display the Result-->
            <TextBlock Name="displayProbability" 
                       FontWeight="Bold" 
                       TextWrapping="Wrap"
                       Margin="30,0,0,0"
                       Text="" Width="1471" />
            <TextBlock Name="space2" />
            <!--Image preview -->
            <Image Name="UIPreviewImage" Stretch="Uniform" MaxWidth="300" MaxHeight="300"/>
        </StackPanel>
    </Grid>

Generator Kode Pembelajaran Mesin Windows

Windows Machine Learning 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 pengantarnya, Anda seharusnya sudah menangani ini, tetapi jika tidak, Anda harus mengunduhnya untuk VS 2019 atau untuk VS 2017.

Nota

Untuk mempelajari lebih lanjut tentang mlgen, silakan lihat dokumentasi mlgen

  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:

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

Struktur proyek dengan model ONNX ditambahkan

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

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

Kode yang dihasilkan mencakup tiga kelas:

  • classifierModel: 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.
  • classifierInput: Kelas ini menginisialisasi jenis input yang diharapkan model. Input model tergantung pada persyaratan model untuk data input. Dalam kasus kami, input mengharapkan ImageFeatureValue, sebuah kelas yang menjelaskan properti gambar yang digunakan untuk dimasukkan ke dalam model.
  • classifierOutput: Kelas ini menginisialisasi jenis yang akan dihasilkan model. Output model tergantung pada bagaimana output didefinisikan oleh model. Dalam kasus kami, output akan menjadi urutan peta (kamus) jenis String dan TensorFloat (Float32) yang disebut loss.

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

Memuat model dan masukan

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;
  1. Tambahkan deklarasi variabel berikut setelah pernyataan penggunaan di dalam kelas Anda MainPage , di bawah namespace ImageClassifierAppUWP.
        // All the required variable declaration
        private classifierModel modelGen;
        private classifierInput input = new classifierModelInput();
        private classifierOutput output;
        private StorageFile selectedStorageFile;
        private string result = "";
        private float resultProbability = 0;

Hasilnya akan terlihat sebagai berikut.

// Specify all the using statements which give us the access to all the APIs that we'll need
using System;
using System.Threading.Tasks;
using Windows.AI.MachineLearning;
using Windows.Graphics.Imaging;
using Windows.Media;
using Windows.Storage;
using Windows.Storage.Pickers;
using Windows.Storage.Streams;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Media.Imaging;

namespace ImageClassifierAppUWP
{
    public sealed partial class MainPage : Page
    {
        // All the required fields declaration
        private classifierModel modelGen;
        private classifierInput input = new classifierInput();
        private classifierOutput output;
        private StorageFile selectedStorageFile;
        private string result = "";
        private float resultProbability = 0;

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 classifier.cs file yang dihasilkan oleh mlgen.

Untuk mempelajari lebih lanjut tentang LearningModel kelas, silakan tinjau dokumentasi Kelas LearningModel. Untuk mempelajari selengkapnya tentang cara memuat model tambahan, silakan tinjau dokumentasi Muat model

  1. Tambahkan metode loadModel ke file kode MainPage.xaml.cs di dalam kelas MainPage.
        private async Task loadModel()
        {
            // Get an access the ONNX model and save it in memory.
            StorageFile modelFile = await StorageFile.GetFileFromApplicationUriAsync(new Uri($"ms-appx:///Assets/classifier.onnx"));
            // Instantiate the model. 
            modelGen = await classifierModel.CreateFromStreamAsync(modelFile);
        }
  1. Sekarang, tambahkan pemanggilan metode baru ke dalam konstruktor kelas.
        // The main page to initialize and execute the model.
        public MainPage()
        {
            this.InitializeComponent();
            loadModel();
        }

Hasilnya akan terlihat sebagai berikut.

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

        // A method to load a machine learning model.
        private async Task loadModel()
        {
            // Get an access the ONNX model and save it in memory.  
            StorageFile modelFile = await StorageFile.GetFileFromApplicationUriAsync(new Uri($"ms-appx:///Assets/classifier.onnx"));
            // Instantiate the model. 
            modelGen = await classifierModel.CreateFromStreamAsync(modelFile);
        }

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

Sekarang, Anda akan menerapkan metode gambar Bind() untuk mendapatkan representasi file dalam format bitmap BGRA8.

  1. 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);
                // bind the input image
                ImageFeatureValue imageTensor = ImageFeatureValue.CreateFromVideoFrame(inputImage);
                input.data = imageTensor;
            }
            catch (Exception e)
            {
            }
        }

Hasil pekerjaan yang dilakukan di bagian ini akan terlihat sebagai berikut.

        // Waiting for a click event to select a file 
        private async void OpenFileButton_Click(object sender, RoutedEventArgs e)
        {
            if (!await getImage())
            {
                return;
            }
            // After the click event happened and an input selected, we begin the model execution. 
            // Bind the model input
            await imageBind();
            // Model evaluation
            await evaluate();
            // Extract the results
            extractResult();
            // Display the results  
            await displayResult();
        }

        // A method to select an input image file
        private async Task<bool> getImage()
        {
            try
            {
                // Trigger file picker to select an image file
                FileOpenPicker fileOpenPicker = new FileOpenPicker();
                fileOpenPicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
                fileOpenPicker.FileTypeFilter.Add(".jpg");
                fileOpenPicker.FileTypeFilter.Add(".png");
                fileOpenPicker.ViewMode = PickerViewMode.Thumbnail;
                selectedStorageFile = await fileOpenPicker.PickSingleFileAsync();
                if (selectedStorageFile == null)
                {
                    return false;
                }
            }
            catch (Exception)
            {
                return false;
            }
            return true;
        }

        // A method to convert and bind the input image.  
        private async Task imageBind()
        {
            UIPreviewImage.Source = null;

            try
            {
                SoftwareBitmap softwareBitmap;
                using (IRandomAccessStream stream = await selectedStorageFile.OpenAsync(FileAccessMode.Read))
                {
                    // Create the decoder from the stream 
                    BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);

                    // Get the SoftwareBitmap representation of the file in BGRA8 format
                    softwareBitmap = await decoder.GetSoftwareBitmapAsync();
                    softwareBitmap = SoftwareBitmap.Convert(softwareBitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
                }
                // Display the image
                SoftwareBitmapSource imageSource = new SoftwareBitmapSource();
                await imageSource.SetBitmapAsync(softwareBitmap);
                UIPreviewImage.Source = imageSource;

                // Encapsulate the image within a VideoFrame to be bound and evaluated
                VideoFrame inputImage = VideoFrame.CreateWithSoftwareBitmap(softwareBitmap);

                // bind the input image
                ImageFeatureValue imageTensor = ImageFeatureValue.CreateFromVideoFrame(inputImage);
                input.data = imageTensor;
            }
            catch (Exception e)
            {
            }
        }

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.

Nota

Untuk mempelajari selengkapnya tentang cara memilih perangkat, tinjau dokumentasi Buat sesi .

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.

Saat ini, Windows ML mendukung semua jenis fitur ONNX seperti Tensor (array multi-dimensi), Urutan (vektor nilai), Peta (pasangan nilai informasi) dan Gambar (format tertentu). Semua gambar akan diwakili dalam Windows ML dalam format tensor. Tensorisasi adalah proses mengonversi gambar menjadi tensor dan terjadi selama pengikatan.

Untungnya, Anda tidak perlu repot mengurus konversi tensorisasi. Metode ImageFeatureValue yang Anda gunakan di bagian sebelumnya mengurus konversi dan tensorisasi, sehingga gambar cocok dengan format gambar model yang diperlukan.

Nota

Untuk mempelajari selengkapnya tentang cara mengikat LearningModel dan tentang jenis fitur yang didukung oleh WinML, silakan tinjau dokumentasi Ikat model.

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 LearningModelSession. 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 classifier.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 .

Nota

Untuk mempelajari tentang metode evaluasi lain untuk menjalankan model, silakan periksa metode mana yang dapat diimplementasikan pada LearningModelSession dengan meninjau dokumentasi Kelas LearningModelSession.

  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()
        {
            output = await modelGen.EvaluateAsync(input);
        }

Mengekstrak dan menampilkan hasilnya

Anda sekarang perlu mengekstrak output model dan menampilkan hasil yang tepat. Anda akan melakukannya dengan menerapkan metode extractResult dan displayResult.

Seperti yang Anda jelajahi sebelumnya, model mengembalikan dua output: yang pertama bernama classLabel adalah tensor berisi string, dan yang kedua bernama loss adalah urutan peta dari string ke float yang menjelaskan probabilitas untuk setiap klasifikasi berlabel. Jadi, untuk berhasil menampilkan hasil dan probabilitas, yang kita butuhkan adalah mengekstrak output dari output kerugian. Kita harus menemukan probabilitas tertinggi untuk mengembalikan hasil yang benar.

  1. Tambahkan metode ke extractResult file kode Anda MainPage.xaml.cs di MainPage dalam kelas .
        private void extractResult()
        {
        // A method to extract output (result and a probability) from the "loss" output of the model 
            var collection = output.loss;
            float maxProbability = 0;
            string keyOfMax = "";

            foreach (var dictionary in collection)
            {
                foreach (var key in dictionary.Keys)
                {
                    if (dictionary[key] > maxProbability)
                    {
                        maxProbability = dictionary[key];
                        keyOfMax = key;
                    }
                }
            }
            result = keyOfMax;
            resultProbability = maxProbability;
        }
  1. Tambahkan metode ke displayResult file kode Anda MainPage.xaml.cs di MainPage dalam kelas .
        // A method to display the results
        private async Task displayResult()
        {
            displayOutput.Text = result.ToString();
            displayProbability.Text = resultProbability.ToString();
        }

Hasil dari Mengikat dan Evaluasi dan Ekstrak dan tampilkan hasilnya dari kode WinML aplikasi kami akan terlihat sebagai berikut.

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

        // A method to extract output (string and a probability) from the "loss" output of the model 
        private void extractResult()
        {
            var collection = output.loss;
            float maxProbability = 0;
            string keyOfMax = "";

            foreach (var dictionary in collection)
            {
                foreach (var key in dictionary.Keys)
                {
                    if (dictionary[key] > maxProbability)
                    {
                        maxProbability = dictionary[key];
                        keyOfMax = key;
                    }
                }
            }
            result = keyOfMax;
            resultProbability = maxProbability;
        }

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

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 WinML, Anda dapat menguji aplikasi. Pastikan menu dropdown di toolbar atas diatur ke Debug. Solution Platform Ubah ke x64 untuk menjalankan proyek di komputer lokal Anda jika perangkat Anda 64-bit, atau x86 jika 32-bit.

Untuk menguji aplikasi kami, Anda akan menggunakan gambar buah di bawah ini. Mari kita lihat bagaimana aplikasi kita mengklasifikasikan konten gambar.

Contoh gambar buah

  1. Simpan gambar ini di perangkat lokal Anda untuk menguji aplikasi. Ubah format gambar menjadi jpg jika diperlukan. Anda juga dapat menambahkan gambar relevan lainnya dari perangkat lokal Anda dalam format yang sesuai - format .jpg, .png, .bmp, atau .gif.

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

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

Pilih dialog gambar

Hasilnya akan langsung muncul di layar. Seperti yang Anda lihat, aplikasi WinML kami berhasil mengklasifikasikan gambar sebagai buah atau sayuran, dengan peringkat keyakinan 99,9%.

Klasifikasi gambar berhasil

Ringkasan

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

Sumber Daya Tambahan

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

  • Last updated on