Tutorial: Melatih model klasifikasi ML.NET untuk mengategorikan gambar

Pelajari cara melatih model klasifikasi untuk mengategorikan gambar menggunakan model TensorFlow yang telah dilatih sebelumnya untuk pemrosesan gambar.

Model TensorFlow dilatih untuk mengklasifikasikan gambar ke dalam seribu kategori. Karena model TensorFlow tahu cara mengenali pola dalam gambar, model ML.NET dapat menggunakan bagian darinya dalam alurnya untuk mengonversi gambar mentah menjadi fitur atau input untuk melatih model klasifikasi.

Dalam tutorial ini, Anda akan belajar cara:

Memahami masalahnya
Menggabungkan model TensorFlow yang telah dilatih sebelumnya ke dalam alur ML.NET
Melatih dan mengevaluasi model ML.NET
Mengklasifikasikan gambar pengujian

Anda dapat menemukan kode sumber untuk tutorial ini di repositori dotnet/samples . Secara default, konfigurasi proyek .NET untuk tutorial ini menargetkan .NET core 2.2.

Prasyarat

Pilih tugas pembelajaran mesin yang tepat

Pembelajaran mendalam

Pembelajaran mendalam adalah subset Pembelajaran Mesin, yang merevolusi area seperti visi komputer dan pengenalan ucapan.

Model pembelajaran mendalam dilatih dengan menggunakan sekumpulan besar data berlabel dan jaringan neural yang berisi beberapa lapisan pembelajaran. Pembelajaran mendalam:

Berkinerja lebih baik pada beberapa tugas seperti visi komputer.
Membutuhkan data pelatihan dalam jumlah besar.

Klasifikasi gambar adalah tugas klasifikasi tertentu yang memungkinkan kami mengklasifikasikan gambar secara otomatis ke dalam kategori seperti:

Mendeteksi wajah manusia dalam gambar atau tidak.
Mendeteksi kucing vs. anjing.

Atau seperti pada gambar berikut, menentukan apakah gambar adalah makanan, mainan, atau appliance:

gambar pizza gambar teddy bear gambar pemanggang roti

Nota

Gambar sebelumnya milik Wikimedia Commons dan dikaitkan sebagai berikut:

"220px-Pepperoni_pizza.jpg" Domain Publik, , https://commons.wikimedia.org/w/index.php?curid=79505
"119px-Nalle_-_a_small_brown_teddy_bear.jpg" Oleh Jonik - Swafoto, CC BY-SA 2.0, https://commons.wikimedia.org/w/index.php?curid=48166.
"193px-Broodrooster.jpg" Oleh M.Minderhoud - Karya sendiri, CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=27403

Melatih model klasifikasi gambar dari awal memerlukan pengaturan jutaan parameter, banyak data pelatihan berlabel, dan sejumlah besar sumber daya komputasi (ratusan jam GPU). Meskipun tidak seefektif melatih model kustom dari awal, menggunakan model pralatih memungkinkan Anda untuk memangkas proses ini dengan bekerja dengan ribuan gambar dibandingkan dengan jutaan gambar berlabel dan menyesuaikan model dengan cukup cepat (dalam waktu satu jam pada mesin tanpa GPU). Tutorial ini menskalakan yang memproses lebih jauh, hanya menggunakan selusin gambar pelatihan.

Inception model dilatih untuk mengklasifikasikan gambar menjadi seribu kategori. Namun, untuk tutorial ini, Anda perlu mengklasifikasikan gambar hanya dalam set kategori yang lebih kecil. Anda dapat menggunakan Inception modelkemampuan untuk mengenali dan mengklasifikasikan gambar ke kategori terbatas baru pengklasifikasi gambar kustom Anda.

Makanan
Mainan
Peralatan

Tutorial ini menggunakan model pembelajaran mendalam TensorFlow Inception , model pengenalan gambar populer yang dilatih pada himpunan ImageNet data. Model TensorFlow mengklasifikasikan seluruh gambar ke dalam seribu kelas, seperti "Umbrella", "Jersey", dan "Dishwasher".

Karena Inception model telah dilatih sebelumnya pada ribuan gambar yang berbeda, secara internal ia mengandung fitur gambar yang diperlukan untuk identifikasi gambar. Kita dapat menggunakan fitur gambar internal ini dalam model untuk melatih model baru dengan kelas yang jauh lebih sedikit.

Seperti yang ditunjukkan dalam diagram berikut, Anda menambahkan referensi ke paket NuGet ML.NET di aplikasi .NET atau .NET Framework Anda. Di bawah sampul, ML.NET menyertakan dan mereferensikan pustaka asli TensorFlow yang memungkinkan Anda menulis kode yang memuat file model terlatih TensorFlow yang ada.

Diagram TensorFlow mengubah ML.NET Arch

Klasifikasi multikelas

Setelah menggunakan model awal TensorFlow untuk mengekstrak fitur yang cocok sebagai input untuk algoritma pembelajaran mesin klasik, Anda menambahkan pengklasifikasi multikelas ML.NET.

Pelatih khusus yang digunakan dalam hal ini adalah algoritma regresi logistik multinomial.

Algoritma yang diterapkan oleh pelatih ini berkinerja baik pada masalah dengan sejumlah besar fitur, yang merupakan kasus untuk model pembelajaran mendalam yang beroperasi pada data gambar.

Untuk informasi selengkapnya, lihat Pembelajaran mendalam vs. pembelajaran mesin.

Data Informasi

Ada dua sumber data: .tsv file, dan file gambar. File tags.tsv berisi dua kolom: yang pertama didefinisikan sebagai ImagePath dan yang kedua sesuai Label dengan gambar. Contoh file berikut tidak memiliki baris header, dan terlihat seperti ini:

broccoli.jpg	food
pizza.jpg	food
pizza2.jpg	food
teddy2.jpg	toy
teddy3.jpg	toy
teddy4.jpg	toy
toaster.jpg	appliance
toaster2.png	appliance

Gambar pelatihan dan pengujian terletak di folder aset yang akan Anda unduh dalam file zip. Gambar-gambar ini milik Wikimedia Commons.

Wikimedia Commons, repositori media gratis. Diakses tanggal 10:48, October 17, 2018 dari: https://commons.wikimedia.org/wiki/Pizza https://commons.wikimedia.org/wiki/Toaster https://commons.wikimedia.org/wiki/Teddy_bear

Pengaturan

Membuat proyek

Buat Aplikasi Konsol C# yang disebut "TransferLearningTF". Klik tombol Berikutnya.
Pilih .NET 8 sebagai kerangka kerja yang akan digunakan. Klik tombol Buat.
Instal Paket Microsoft.ML NuGet:

Nota

Sampel ini menggunakan versi stabil terbaru dari paket NuGet yang disebutkan kecuali dinyatakan lain.
- Di Penjelajah Solusi, klik kanan pada proyek Anda dan pilih Kelola Paket NuGet.
- Pilih "nuget.org" sebagai sumber Paket, pilih tab Telusuri, cari Microsoft.ML.
- Pilih tombol Instal.
- Pilih tombol OK pada dialog Pratinjau Perubahan .
- Pilih tombol Saya Terima pada dialog Penerimaan Lisensi jika Anda setuju dengan ketentuan lisensi untuk paket yang tercantum.
- Ulangi langkah-langkah ini untuk Microsoft.ML.ImageAnalytics, SciSharp.TensorFlow.Redist, dan Microsoft.ML.TensorFlow.

Mengunduh aset

Unduh file zip direktori aset proyek, dan unzip.
assets Salin direktori ke direktori proyek TransferLearningTF Anda. Direktori ini dan subdirektorinya berisi data dan file dukungan (kecuali untuk model Inception, yang akan Anda unduh dan tambahkan di langkah berikutnya) yang diperlukan untuk tutorial ini.
Unduh model Inception, dan unzip.
Salin konten inception5h direktori yang baru saja di-unzip ke direktori proyek assets/inception Anda. Direktori ini berisi model dan file dukungan tambahan yang diperlukan untuk tutorial ini, seperti yang ditunjukkan pada gambar berikut:
Di Penjelajah Solusi, klik kanan setiap file di direktori aset dan subdirektori dan pilih Properti. Di bawah Tingkat Lanjut, ubah nilai Salin ke Direktori Output menjadi Salin jika lebih baru.

Membuat kelas dan menentukan jalur

Tambahkan arahan tambahan using berikut ke bagian atas file Program.cs :
```
using Microsoft.ML;
using Microsoft.ML.Data;
```

Tambahkan kode berikut ke baris tepat di bawah using arahan untuk menentukan jalur aset:

string _assetsPath = Path.Combine(Environment.CurrentDirectory, "assets");
string _imagesFolder = Path.Combine(_assetsPath, "images");
string _trainTagsTsv = Path.Combine(_imagesFolder, "tags.tsv");
string _testTagsTsv = Path.Combine(_imagesFolder, "test-tags.tsv");
string _predictSingleImage = Path.Combine(_imagesFolder, "toaster3.jpg");
string _inceptionTensorFlowModel = Path.Combine(_assetsPath, "inception", "tensorflow_inception_graph.pb");

Buat kelas untuk data input, dan prediksi Anda.
```
public class ImageData
{
    [LoadColumn(0)]
    public string? ImagePath;

    [LoadColumn(1)]
    public string? Label;
}
```
ImageData adalah kelas data gambar input dan memiliki bidang berikut String :
- ImagePath berisi nama file gambar.
- Label berisi nilai untuk label gambar.
Tambahkan kelas baru ke proyek Anda untuk ImagePrediction:
```
public class ImagePrediction : ImageData
{
    public float[]? Score;

    public string? PredictedLabelValue;
}
```
ImagePrediction adalah kelas prediksi gambar dan memiliki bidang berikut:
- Score berisi persentase keyakinan untuk klasifikasi gambar tertentu.
- PredictedLabelValue berisi nilai untuk label klasifikasi gambar yang diprediksi.
ImagePrediction adalah kelas yang digunakan untuk prediksi setelah model dilatih. Ini memiliki string (ImagePath) untuk jalur gambar. Label digunakan untuk menggunakan kembali dan melatih model. PredictedLabelValue digunakan selama prediksi dan evaluasi. Untuk evaluasi, digunakan input dengan data pelatihan, nilai yang diprediksi, dan model.

Menginisialisasi variabel

Inisialisasi mlContext variabel dengan instans MLContextbaru . Console.WriteLine("Hello World!") Ganti baris dengan kode berikut:
```
MLContext mlContext = new MLContext();
```
Kelas MLContext adalah titik awal untuk semua operasi ML.NET, dan menginisialisasi mlContext membuat lingkungan ML.NET baru yang dapat dibagikan di seluruh objek alur kerja pembuatan model. Ini mirip, secara konseptual, hingga DBContext di Entity Framework.

Membuat struktur untuk parameter model Inception

Model Inception memiliki beberapa parameter yang perlu Anda teruskan. Buat struktur untuk memetakan nilai parameter ke nama yang mudah diingat dengan kode berikut, tepat setelah menginisialisasi mlContext variabel:

struct InceptionSettings
{
    public const int ImageHeight = 224;
    public const int ImageWidth = 224;
    public const float Mean = 117;
    public const float Scale = 1;
    public const bool ChannelsLast = true;
}

Membuat metode utilitas tampilan

Karena Anda akan menampilkan data gambar dan prediksi terkait lebih dari sekali, buat metode utilitas tampilan untuk menangani menampilkan gambar dan hasil prediksi.

DisplayResults() Buat metode , tepat setelah InceptionSettings struktur, menggunakan kode berikut:
```
void DisplayResults(IEnumerable<ImagePrediction> imagePredictionData)
{

}
```

Isi isi DisplayResults metode :

foreach (ImagePrediction prediction in imagePredictionData)
{
    Console.WriteLine($"Image: {Path.GetFileName(prediction.ImagePath)} predicted as: {prediction.PredictedLabelValue} with score: {prediction.Score?.Max()} ");
}

Membuat metode untuk membuat prediksi

ClassifySingleImage() Buat metode , tepat sebelum DisplayResults() metode , menggunakan kode berikut:
```
void ClassifySingleImage(MLContext mlContext, ITransformer model)
{

}
```
Buat ImageData objek yang berisi jalur dan nama file gambar yang sepenuhnya memenuhi syarat untuk satu ImagePath. Tambahkan kode berikut sebagai baris berikutnya dalam ClassifySingleImage() metode :
```
var imageData = new ImageData()
{
    ImagePath = _predictSingleImage
};
```
Buat prediksi tunggal, dengan menambahkan kode berikut sebagai baris berikutnya dalam ClassifySingleImage metode :
```
// Make prediction function (input = ImageData, output = ImagePrediction)
var predictor = mlContext.Model.CreatePredictionEngine<ImageData, ImagePrediction>(model);
var prediction = predictor.Predict(imageData);
```
Untuk mendapatkan prediksi, gunakan metode Predict(). PredictionEngine adalah API kenyamanan, yang memungkinkan Anda melakukan prediksi pada satu instans data. PredictionEngine tidak aman untuk utas. Dapat diterima untuk digunakan di lingkungan utas tunggal atau prototipe. Untuk peningkatan performa dan keamanan utas di lingkungan produksi, gunakan PredictionEnginePool layanan , yang menciptakan ObjectPoolPredictionEngine objek untuk digunakan di seluruh aplikasi Anda. Lihat panduan ini tentang cara menggunakan PredictionEnginePool di ASP.NET Core Web API.

Nota

PredictionEnginePool ekstensi layanan saat ini dalam pratinjau.

Tampilkan hasil prediksi sebagai baris kode berikutnya dalam ClassifySingleImage() metode :

Console.WriteLine($"Image: {Path.GetFileName(imageData.ImagePath)} predicted as: {prediction.PredictedLabelValue} with score: {prediction.Score?.Max()} ");

Membuat alur model ML.NET

Alur model ML.NET adalah rantai estimator. Tidak ada eksekusi yang terjadi selama konstruksi alur. Objek estimator dibuat tetapi tidak dijalankan.

Menambahkan metode untuk menghasilkan model

Metode ini adalah inti dari tutorial. Ini membuat pipeline untuk model, dan melatih pipeline tersebut untuk menghasilkan model ML.NET. Ini juga mengevaluasi model terhadap beberapa data pengujian yang sebelumnya tidak terlihat.

Buat metode GenerateModel(), tepat setelah struct InceptionSettings dan tepat sebelum method DisplayResults(), menggunakan kode berikut:
```
ITransformer GenerateModel(MLContext mlContext)
{

}
```

Tambahkan estimator untuk memuat, mengubah ukuran, dan mengekstrak piksel dari data gambar:

IEstimator<ITransformer> pipeline = mlContext.Transforms.LoadImages(outputColumnName: "input", imageFolder: _imagesFolder, inputColumnName: nameof(ImageData.ImagePath))
                // The image transforms transform the images into the model's expected format.
                .Append(mlContext.Transforms.ResizeImages(outputColumnName: "input", imageWidth: InceptionSettings.ImageWidth, imageHeight: InceptionSettings.ImageHeight, inputColumnName: "input"))
                .Append(mlContext.Transforms.ExtractPixels(outputColumnName: "input", interleavePixelColors: InceptionSettings.ChannelsLast, offsetImage: InceptionSettings.Mean))

Data gambar perlu diproses ke dalam format yang diharapkan model TensorFlow. Dalam hal ini, gambar dimuat ke dalam memori, diubah ukurannya menjadi ukuran yang konsisten, dan piksel diekstrak menjadi vektor numerik.

Tambahkan estimator untuk memuat model TensorFlow, dan menilainya:
```
.Append(mlContext.Model.LoadTensorFlowModel(_inceptionTensorFlowModel).
    ScoreTensorFlowModel(outputColumnNames: new[] { "softmax2_pre_activation" }, inputColumnNames: new[] { "input" }, addBatchDimensionInput: true))
```
Tahap ini dalam alur memuat model TensorFlow ke dalam memori, lalu memproses vektor nilai piksel melalui jaringan model TensorFlow. Menerapkan input ke model pembelajaran mendalam, dan menghasilkan output menggunakan model, disebut sebagai Penilaian. Saat menggunakan model secara keseluruhan, penilaian membuat inferensi, atau prediksi.

Dalam hal ini, Anda menggunakan semua model TensorFlow kecuali lapisan terakhir, yaitu lapisan yang membuat inferensi. Output dari lapisan penultimat diberi label softmax_2_preactivation. Output dari lapisan ini secara efektif adalah vektor fitur yang menggambarkan gambar input asli.

Vektor fitur yang dihasilkan oleh model TensorFlow ini akan digunakan sebagai input ke algoritma pelatihan ML.NET.
Tambahkan estimator untuk memetakan label string dalam data pelatihan ke nilai kunci bilangan bulat:
```
.Append(mlContext.Transforms.Conversion.MapValueToKey(outputColumnName: "LabelKey", inputColumnName: "Label"))
```
Pelatih ML.NET yang ditambahkan selanjutnya mengharuskan labelnya berformat key alih-alih string sembarang. Kunci adalah angka yang memiliki pemetaan satu ke satu ke nilai string.

Tambahkan algoritma pelatihan ML.NET:

.Append(mlContext.MulticlassClassification.Trainers.LbfgsMaximumEntropy(labelColumnName: "LabelKey", featureColumnName: "softmax2_pre_activation"))

Tambahkan estimator untuk memetakan nilai kunci yang diprediksi kembali ke dalam string:

.Append(mlContext.Transforms.Conversion.MapKeyToValue("PredictedLabelValue", "PredictedLabel"))
.AppendCacheCheckpoint(mlContext);

Melatih model

Muat data pelatihan menggunakan pembungkus LoadFromTextFile . Tambahkan kode berikut sebagai baris berikutnya dalam GenerateModel() metode :
```
IDataView trainingData = mlContext.Data.LoadFromTextFile<ImageData>(path:  _trainTagsTsv, hasHeader: false);
```
Data dalam ML.NET direpresentasikan sebagai antarmuka IDataView. IDataView adalah cara yang fleksibel dan efisien untuk menjelaskan data tabular (numerik dan teks). Data dapat dimuat dari file teks atau secara real time (misalnya, database SQL atau file log) ke IDataView objek.
Latih model dengan data yang dimuat di atas:
```
ITransformer model = pipeline.Fit(trainingData);
```
Metode ini Fit() melatih model Anda dengan menerapkan himpunan data pelatihan ke alur.

Mengevaluasi akurasi model

Muat dan ubah data pengujian, dengan menambahkan kode berikut ke baris berikutnya dari GenerateModel metode:

IDataView testData = mlContext.Data.LoadFromTextFile<ImageData>(path: _testTagsTsv, hasHeader: false);
IDataView predictions = model.Transform(testData);

// Create an IEnumerable for the predictions for displaying results
IEnumerable<ImagePrediction> imagePredictionData = mlContext.Data.CreateEnumerable<ImagePrediction>(predictions, true);
DisplayResults(imagePredictionData);

Ada beberapa gambar sampel yang dapat Anda gunakan untuk mengevaluasi model. Seperti data pelatihan, ini perlu dimuat ke dalam IDataView, sehingga dapat diubah oleh model.

Tambahkan kode berikut ke GenerateModel() metode untuk mengevaluasi model:
```
MulticlassClassificationMetrics metrics =
    mlContext.MulticlassClassification.Evaluate(predictions,
        labelColumnName: "LabelKey",
        predictedLabelColumnName: "PredictedLabel");
```
Setelah Anda memiliki set prediksi, metode Evaluate():
- Menilai model (membandingkan nilai yang diprediksi dengan himpunan labelsdata pengujian ).
- Mengembalikan metrik performa model.
Menampilkan metrik akurasi model

Gunakan kode berikut untuk menampilkan metrik, membagikan hasilnya, lalu menindaklanjutinya:
```
Console.WriteLine($"LogLoss is: {metrics.LogLoss}");
Console.WriteLine($"PerClassLogLoss is: {String.Join(" , ", metrics.PerClassLogLoss.Select(c => c.ToString()))}");
```
Metrik berikut dievaluasi untuk klasifikasi gambar:
- Log-loss - lihat Log Loss. Anda ingin Log-loss sedekat mungkin dengan nol.
- Per class Log-loss. Anda ingin log-loss per kelas sedekat mungkin dengan nol.
Tambahkan kode berikut untuk mengembalikan model terlatih sebagai baris berikutnya:
```
return model;
```

Jalankan aplikasi

Tambahkan panggilan ke GenerateModel setelah pembuatan MLContext kelas:
```
ITransformer model = GenerateModel(mlContext);
```
Tambahkan panggilan ke ClassifySingleImage() metode setelah panggilan ke GenerateModel() metode :
```
ClassifySingleImage(mlContext, model);
```

Jalankan aplikasi konsol Anda (Ctrl + F5). Hasil Anda harus mirip dengan output berikut. (Anda mungkin melihat peringatan atau memproses pesan, tetapi pesan ini telah dihapus dari hasil berikut untuk kejelasan.)

=============== Training classification model ===============
Image: broccoli2.jpg predicted as: food with score: 0.8955513
Image: pizza3.jpg predicted as: food with score: 0.9667718
Image: teddy6.jpg predicted as: toy with score: 0.9797683
=============== Classification metrics ===============
LogLoss is: 0.0653774699265059
PerClassLogLoss is: 0.110315812569315 , 0.0204391272836966 , 0
=============== Making single image classification ===============
Image: toaster3.jpg predicted as: appliance with score: 0.9646884

Selamat! Anda sekarang telah berhasil membangun model klasifikasi di ML.NET untuk mengategorikan gambar dengan menggunakan TensorFlow yang telah dilatih sebelumnya untuk pemrosesan gambar.

Anda dapat menemukan kode sumber untuk tutorial ini di repositori dotnet/samples .

Dalam tutorial ini, Anda belajar cara:

Memahami masalahnya
Menggabungkan model TensorFlow yang telah dilatih sebelumnya ke dalam alur ML.NET
Melatih dan mengevaluasi model ML.NET
Mengklasifikasikan gambar pengujian

Lihat repositori GitHub sampel Pembelajaran Mesin untuk menjelajahi sampel klasifikasi gambar yang diperluas.

repositori GitHub dotnet/machinelearning-samples

Saran dan Komentar

Apakah halaman ini membantu?

Last updated on 2025-12-06