Tutorial: Melatih model klasifikasi ML.NET untuk mengategorikan gambar

2023-04-08

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

Melakukan lebih baik pada beberapa tugas seperti visi komputer.
Membutuhkan sejumlah besar data pelatihan.

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 teddy gambar beruang pemanggang toaster gambar

Catatan

Gambar sebelumnya milik Wikimedia Commons dan dikaitkan sebagai berikut:

Domain Publik "220px-Pepperoni_pizza.jpg", https://commons.wikimedia.org/w/index.php?curid=79505,
"119px-Nalle_-_a_small_brown_teddy_bear.jpg" Oleh Jonik - Self-photographed, 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 yang telah dilatih sebelumnya memungkinkan Anda untuk pintasan proses ini dengan bekerja dengan ribuan gambar vs. jutaan gambar berlabel dan membangun model yang disesuaikan dengan cukup cepat (dalam waktu satu jam pada mesin tanpa GPU). Tutorial ini menskalakan proses yang turun lebih jauh, hanya menggunakan selusin gambar pelatihan.

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

Makanan
Mainan
Appliance

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

Inception model Karena telah dilatih sebelumnya pada ribuan gambar yang berbeda, secara internal berisi 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 Core 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.

Transformasi TensorFlow ML.NET diagram Arch

Klasifikasi multikelas

Setelah menggunakan model inception TensorFlow untuk mengekstrak fitur yang cocok sebagai input untuk algoritma pembelajaran mesin klasik, kami menambahkan pengklasifikasi multi-kelas 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.

Lihat Pembelajaran mendalam vs. pembelajaran mesin untuk informasi selengkapnya.

Data

Ada dua sumber data: .tsv file, dan file gambar. File tags.tsv berisi dua kolom: yang pertama didefinisikan sebagai ImagePath dan yang Label kedua sesuai 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, Oktober 17, 2018 dari: https://commons.wikimedia.org/wiki/Pizza https://commons.wikimedia.org/wiki/Toaster https://commons.wikimedia.org/wiki/Teddy_bear

Siapkan

Membuat proyek

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

Catatan

Sampel ini menggunakan versi stabil terbaru dari paket NuGet yang disebutkan kecuali dinyatakan lain.
- Di Penjelajah Solusi, klik kanan 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 persyaratan 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.
Salin direktori ke assets 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 direktori yang inception5h baru saja di-unzip ke direktori proyek assets/inceptionTransferLearningTF 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 pernyataan tambahan using berikut ke bagian atas file Program.cs :
```
using Microsoft.ML;
using Microsoft.ML.Data;
```

Tambahkan kode berikut ke baris tepat di bawah pernyataan penggunaan 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 Anda, dan prediksi.
```
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, input dengan data pelatihan, nilai yang diprediksi, dan model digunakan.

Inisialisasi 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 dalam Kerangka Kerja Entitas.

Membuat struktur untuk parameter model Inception

Model Inception memiliki beberapa parameter yang perlu Anda lewati. 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)
{

}
```
ImageData Buat objek yang berisi jalur yang sepenuhnya memenuhi syarat dan nama file gambar untuk tunggal ImagePath. Tambahkan kode berikut sebagai baris berikutnya dalam ClassifySingleImage() metode :
```
var imageData = new ImageData()
{
    ImagePath = _predictSingleImage
};
```
Buat satu prediksi, 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. Penggunaan di lingkungan utas tunggal atau prototipe dapat diterima. Untuk meningkatkan 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 dalam ASP.NET Core Web API.

Catatan

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 alur untuk model, dan melatih alur untuk menghasilkan model ML.NET. Ini juga mengevaluasi model terhadap beberapa data pengujian yang sebelumnya tidak terlihat.

GenerateModel() Buat metode , tepat setelah InceptionSettings struct dan tepat sebelum DisplayResults() metode , 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 dalam alur ini 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, yang merupakan lapisan yang membuat inferensi. Output lapisan penultimate diberi softmax_2_preactivationlabel . Output lapisan ini secara efektif merupakan vektor fitur yang mencirikan 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 dalam key format daripada string arbitrer. Kunci adalah angka yang memiliki pemetaan satu hingga 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);

Latih 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 GenerateModel metode berikutnya:

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 .

Di tutorial ini, Anda akan mempelajari 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

Bagikan melalui