Membuat prediksi dengan model AutoML ONNX di .NET

Artikel
09/21/2023

Dalam artikel ini, Anda mempelajari cara menggunakan model Automated ML (AutoML) Open Neural Network Exchange (ONNX) untuk membuat prediksi dalam aplikasi konsol C# .NET Core dengan ML.NET.

ML.NET adalah kerangka kerja pembelajaran mesin sumber terbuka lintas platform untuk ekosistem .NET yang memungkinkan Anda melatih dan memakai model pembelajaran mesin kustom menggunakan pendekatan code first di C # atau F # serta melalui peralatan low-code seperti Penyusun Model dan ML.NET CLI. Kerangka kerja ini juga dapat diperluas dan memungkinkan Anda memanfaatkan kerangka kerja pembelajaran mesin populer lainnya seperti TensorFlow dan ONNX.

ONNX adalah format sumber terbuka untuk model AI. ONNX mendukung interoperabilitas antarkerangka kerja. Ini berarti Anda dapat melatih model di salah satu dari banyak kerangka kerja pembelajaran mesin populer seperti PyTorch, mengonversinya menjadi format ONNX, dan menggunakan model ONNX dalam kerangka kerja yang berbeda seperti ML.NET. Untuk mempelajari lebih lanjut, kunjungi situs web ONNX.

Prasyarat

.NET Core SDK 3.1 atau lebih tinggi
Editor Teks atau IDE (seperti Visual Studio atau Visual Studio Code)
Model ONNX. Untuk mempelajari cara melatih model AutoML ONNX, lihat buku catatan klasifikasi pemasaran bank berikut.
Netron (opsional)

Membuat aplikasi konsol C#

Dalam sampel ini, Anda menggunakan .NET Core CLI untuk membangun aplikasi tetapi Anda dapat melakukan tugas yang sama menggunakan Visual Studio. Pelajari lebih lanjut tentang .NET Core CLI.

Buka terminal dan buat aplikasi konsol C# .NET Core baru. Dalam contoh ini, nama aplikasinya adalah AutoMLONNXConsoleApp. Direktori dibuat dengan nama yang sama dengan isi aplikasi Anda.
```
dotnet new console -o AutoMLONNXConsoleApp
```
Di terminal, navigasikan ke direktori AutoMLONNXConsoleApp.
```
cd AutoMLONNXConsoleApp
```

Menambahkan paket perangkat lunak

Instal paket NuGet Microsoft.ML, Microsoft.ML.OnnxRuntime, dan Microsoft.ML.OnnxTransformer menggunakan .NET Core CLI.
```
dotnet add package Microsoft.ML
dotnet add package Microsoft.ML.OnnxRuntime
dotnet add package Microsoft.ML.OnnxTransformer
```
Paket-paket ini berisi dependensi yang diperlukan untuk menggunakan model ONNX dalam aplikasi .NET. ML.NET menyediakan API yang menggunakan runtime ONNX untuk prediksi.
Buka file Program.cs dan tambahkan pernyataan using berikut di bagian atas untuk mereferensikan paket yang sesuai.
```
using System.Linq;
using Microsoft.ML;
using Microsoft.ML.Data;
using Microsoft.ML.Transforms.Onnx;
```

Menambahkan referensi ke model ONNX

Cara untuk aplikasi konsol mengakses model ONNX adalah dengan menambahkannya ke direktori output build. Untuk mempelajari selengkapnya tentang item umum MSBuild, lihat panduan MSBuild. Jika Anda belum memiliki model, ikuti buku catatan ini untuk membuat model contoh.

Menambahkan referensi ke file model ONNX Anda di aplikasi Anda

Salin model ONNX Anda ke direktori akar AutoMLONNXConsoleApp aplikasi Anda.

Buka file AutoMLONNXConsoleApp.csproj dan tambahkan konten berikut di dalam node Project.

<ItemGroup>
    <None Include="automl-model.onnx">
        <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </None>
</ItemGroup>

Dalam hal ini, nama file model ONNX adalah automl-model.onnx.

Buka file Program.cs dan tambahkan baris berikut di dalam kelas Program.
```
static string ONNX_MODEL_PATH = "automl-model.onnx";
```

Menginisialisasi MLContext

Di dalam metode Main kelas Program Anda, buat instans baru MLContext.

MLContext mlContext = new MLContext();

Kelas MLContext ini adalah titik awal untuk semua operasi ML.NET, dan menginisialisasi mlContext membuat lingkungan ML.NET baru yang dapat dibagikan di seluruh siklus hidup model. Ini mirip, secara konseptual, dengan DbContext dalam Kerangka Kerja Entitas.

Menentukan skema data model

Model Anda mengharapkan data input dan output Anda dalam format tertentu. ML.NET memungkinkan Anda menentukan format data melalui kelas. Terkadang Anda mungkin sudah tahu seperti apa format tersebut. Jika Anda tidak mengetahui format datanya, Anda dapat menggunakan alat seperti Netron untuk memeriksa model ONNX Anda.

Model yang digunakan dalam sampel ini menggunakan data dari himpunan data NYC TLC Taxi Trip. Sampel data dapat dilihat di bawah ini:

vendor_id	rate_code	passenger_count	trip_time_in_secs	trip_distance	payment_type	fare_amount
VTS	1	1	1140	3.75	CRD	15,5
VTS	1	1	480	2.72	CRD	10.0
VTS	1	1	1680	7.8	CSH	26,5

Memeriksa model ONNX (opsional)

Gunakan alat seperti Netron untuk memeriksa input dan output model Anda.

Buka Netron.
Di bilah menu atas, pilih File > Buka dan gunakan browser file untuk memilih model Anda.
Model Anda akan terbuka. Misalnya, struktur model automl-model.onnx terlihat seperti berikut ini:
Pilih node terakhir di bagian bawah grafik (variable_out1 dalam hal ini) untuk menampilkan metadata model. Input dan output pada bilah sisi menunjukkan input, output, dan jenis data yang diharapkan dari model. Gunakan informasi ini untuk menentukan skema input dan output model Anda.

Menentukan skema input model

Buat kelas baru bernama OnnxInput dengan properti berikut ini di dalam file Program.cs.

public class OnnxInput
{
    [ColumnName("vendor_id")]
    public string VendorId { get; set; }

    [ColumnName("rate_code"),OnnxMapType(typeof(Int64),typeof(Single))]
    public Int64 RateCode { get; set; }

    [ColumnName("passenger_count"), OnnxMapType(typeof(Int64), typeof(Single))]
    public Int64 PassengerCount { get; set; }

    [ColumnName("trip_time_in_secs"), OnnxMapType(typeof(Int64), typeof(Single))]
    public Int64 TripTimeInSecs { get; set; }

    [ColumnName("trip_distance")]
    public float TripDistance { get; set; }

    [ColumnName("payment_type")]
    public string PaymentType { get; set; }
}

Setiap properti memetakan ke kolom di dalam himpunan data. Properti selanjutnya dianotasikan dengan atribut.

Atribut ColumnName ini memungkinkan Anda menentukan bagaimana ML.NET harus mereferensikan kolom saat beroperasi pada data. Misalnya, meskipun properti TripDistance mengikuti konvensi penamaan .NET standar, model hanya mengetahui kolom atau fitur yang dikenal sebagai trip_distance. Untuk mengatasi perbedaan penamaan ini, atribut ColumnName memetakan properti TripDistance ke sebuah kolom atau fitur dengan nama trip_distance.

Untuk nilai numerik, ML.NET hanya beroperasi pada jenis nilai Single. Namun, jenis data asli dari beberapa kolom adalah bilangan bulat. Atribut OnnxMapType memetakan jenis-jenis antara ONNX dan ML.NET.

Untuk mempelajari selengkapnya tentang atribut data, lihat panduan memuat data ML.NET.

Menentukan skema output model

Setelah data diproses, data menghasilkan output format tertentu. Tentukan skema output data Anda. Buat kelas baru bernama OnnxOutput dengan properti berikut ini di dalam file Program.cs.

public class OnnxOutput
{
    [ColumnName("variable_out1")]
    public float[] PredictedFare { get; set; }
}

Mirip dengan OnnxInput, gunakan atribut ColumnName untuk memetakan output variable_out1 ke nama yang lebih deskriptif PredictedFare.

Menentukan alur prediksi

Alur di ML.NET biasanya merupakan serangkaian transformasi berantai yang beroperasi pada data input untuk menghasilkan output. Untuk mempelajari selengkapnya tentang transformasi data, lihat panduan transformasi data ML.NET.

Membuat metode baru yang disebut GetPredictionPipeline di dalam kelas Program
```
static ITransformer GetPredictionPipeline(MLContext mlContext)
{

}
```

Tentukan nama kolom input dan output. Tambahkan kode berikut di dalam metode GetPredictionPipeline.

var inputColumns = new string []
{
    "vendor_id", "rate_code", "passenger_count", "trip_time_in_secs", "trip_distance", "payment_type"
};

var outputColumns = new string [] { "variable_out1" };

Tentukan alur Anda. IEstimator menyediakan cetak biru operasi, input, dan skema output pipeline Anda.
```
var onnxPredictionPipeline =
    mlContext
        .Transforms
        .ApplyOnnxModel(
            outputColumnNames: outputColumns,
            inputColumnNames: inputColumns,
            ONNX_MODEL_PATH);
```
Dalam hal ini, ApplyOnnxModel adalah satu-satunya transformasi di dalam alur, yang menyertakan nama kolom input dan output serta jalur ke file model ONNX.
IEstimator hanya menentukan set operasi untuk diterapkan ke data Anda. Apa yang beroperasi pada data Anda dikenal sebagai ITransformer. Gunakan metode Fit untuk membuat satu dari onnxPredictionPipeline Anda.
```
var emptyDv = mlContext.Data.LoadFromEnumerable(new OnnxInput[] {});

return onnxPredictionPipeline.Fit(emptyDv);
```
Metode Fit ini mengharapkan IDataView sebagai input untuk pelaksanaan operasi. IDataView adalah cara untuk mewakili data dalam ML.NET menggunakan format tabular. Karena dalam hal ini alur hanya digunakan untuk prediksi, Anda dapat menyediakan IDataView kosong untuk memberi ITransformer informasi skema input dan output yang diperlukan. ITransformer yang telah disesuaikan kemudian dikembalikan untuk digunakan lebih lanjut di aplikasi Anda.

Tip

Dalam sampel ini, alur ditentukan dan digunakan di aplikasi yang sama. Namun, disarankan agar Anda menggunakan aplikasi terpisah untuk menentukan dan menggunakan alur Anda untuk membuat prediksi. Di ML.NET, alur Anda dapat diserialisasikan dan disimpan untuk digunakan lebih lanjut dalam aplikasi pengguna akhir .NET lainnya. ML.NET mendukung berbagai target penyebaran seperti aplikasi desktop, layanan web, aplikasi WebAssembly*, dan banyak lagi. Untuk mempelajari selengkapnya tentang cara menyimpan alur, lihat panduan ML.NET menyimpan dan memuat model terlatih.

*WebAssembly hanya didukung di .NET Core 5 atau yang lebih tinggi
Di dalam metode Main, panggil metode GetPredictionPipeline dengan parameter yang diperlukan.
```
var onnxPredictionPipeline = GetPredictionPipeline(mlContext);
```

Menggunakan model untuk membuat prediksi

Setelah Anda memiliki alur, sekarang saatnya menggunakannya untuk membuat prediksi. ML.NET menyediakan API praktis untuk membuat prediksi pada satu instans data yang disebut PredictionEngine.

Di dalam metode Main, buat PredictionEngine dengan menggunakan metode CreatePredictionEngine.

var onnxPredictionEngine = mlContext.Model.CreatePredictionEngine<OnnxInput, OnnxOutput>(onnxPredictionPipeline);

Buat input data pengujian.

var testInput = new OnnxInput
{
    VendorId = "CMT",
    RateCode = 1,
    PassengerCount = 1,
    TripTimeInSecs = 1271,
    TripDistance = 3.8f,
    PaymentType = "CRD"
};

Gunakan predictionEngine untuk membuat prediksi berdasarkan data testInput yang baru menggunakan metode Predict ini.
```
var prediction = onnxPredictionEngine.Predict(testInput);
```

Keluarkan hasil prediksi Anda ke konsol.

Console.WriteLine($"Predicted Fare: {prediction.PredictedFare.First()}");

Gunakan .NET Core CLI untuk menjalankan aplikasi Anda.
```
dotnet run
```
Hasilnya akan terlihat mirip dengan output berikut:
```
Predicted Fare: 15.621523
```

Untuk mempelajari selengkapnya tentang pembuatan prediksi di ML.NET, lihat panduan menggunakan model untuk membuat prediksi.