Tutorial: Menganalisis sentimen ulasan film menggunakan model TensorFlow yang telah dilatih sebelumnya di ML.NET

2024-12-21

Tutorial ini menunjukkan kepada Anda cara menggunakan model TensorFlow yang telah dilatih sebelumnya untuk mengklasifikasikan sentimen dalam komentar situs web. Pengklasifikasi sentimen biner adalah aplikasi konsol C# yang dikembangkan menggunakan Visual Studio.

Model TensorFlow yang digunakan dalam tutorial ini dilatih menggunakan ulasan film dari database IMDB. Setelah selesai mengembangkan aplikasi, Anda akan dapat menyediakan teks ulasan film dan aplikasi akan memberi tahu Anda apakah ulasan memiliki sentimen positif atau negatif.

Dalam tutorial ini, Anda mempelajari cara:

Memuat model TensorFlow yang telah dilatih sebelumnya
Mengubah teks komentar situs web menjadi fitur yang cocok untuk model
Menggunakan model untuk membuat prediksi

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

Prasyarat

Visual Studio 2022 dengan paket pengembangan ".NET Desktop Development" terinstal.

Pengaturan

Membuat aplikasi

Buat Aplikasi Konsol C# yang disebut "TextClassificationTF". Klik tombol Berikutnya.
Pilih .NET 8 sebagai kerangka kerja yang akan digunakan. Klik tombol Buat.
Buat direktori bernama Data di proyek Anda untuk menyimpan file himpunan data Anda.
Pasang Paket NuGet Microsoft.ML :

Nota

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, lalu pilih tab Telusuri. Cari Microsoft.ML, pilih paket yang Anda inginkan, lalu pilih Instal. Lanjutkan dengan penginstalan dengan menyetujui persyaratan lisensi untuk paket yang Anda pilih. Ulangi langkah-langkah ini untuk Microsoft.ML.TensorFlow , Microsoft.ML.SampleUtils dan SciSharp.TensorFlow.Redist.

Menambahkan model TensorFlow ke proyek

Nota

Model untuk tutorial ini berasal dari dotnet/machinelearning-testdata repositori GitHub. Model ini dalam format TensorFlow SavedModel.

Unduh file zip sentiment_model, dan unzip.

File zip berisi:
- saved_model.pb: model TensorFlow itu sendiri. Model tersebut mengambil array bilangan bulat dengan panjang tetap (ukuran 600) yang mewakili teks dalam string ulasan IMDB, dan menghasilkan dua probabilitas yang jumlahnya 1: probabilitas bahwa ulasan tersebut bersentimen positif, dan probabilitas bahwa ulasan tersebut bersentimen negatif.
- imdb_word_index.csv: pemetaan dari kata individual ke nilai bilangan bulat. Pemetaan digunakan untuk menghasilkan fitur input untuk model TensorFlow.
Salin konten dari direktori terdalam ke dalam direktori proyek TextClassificationTF 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 dan subdirektori sentiment_model dan pilih Properti . Di bawah Tingkat Lanjut, ubah nilai Salin ke Direktori Output ke Salin jika lebih baru.

Menambahkan arahan `using` dan variabel global

Tambahkan arahan using tambahan berikut ke bagian atas file Program.cs:

using Microsoft.ML;
using Microsoft.ML.Data;
using Microsoft.ML.Transforms;

Buat variabel global tepat setelah arahan using untuk menyimpan jalur file model yang disimpan.
```
string _modelPath = Path.Combine(Environment.CurrentDirectory, "sentiment_model");
```
- _modelPath adalah jalur file dari model terlatih.

Memodelkan data

Ulasan film adalah teks bebas. Aplikasi Anda mengonversi teks menjadi format input yang diharapkan oleh model dalam sejumlah tahap diskrit.

Yang pertama adalah membagi teks menjadi kata terpisah dan menggunakan file pemetaan yang disediakan untuk memetakan setiap kata ke pengodean bilangan bulat. Hasil transformasi ini adalah array bilangan bulat panjang variabel dengan panjang yang sesuai dengan jumlah kata dalam kalimat.

Harta benda	Nilai	Jenis
Teks Ulasan	film ini benar-benar bagus	tali
FiturPanjangVariabel	14,22,9,66,78,...	int[]

Array fitur panjang variabel kemudian diubah ukurannya menjadi panjang tetap 600. Ini adalah panjang yang diharapkan model TensorFlow.

Harta benda	Nilai	Jenis
Teks Ulasan	film ini benar-benar bagus	tali
FiturPanjangVariabel	14,22,9,66,78,...	int[]
Fitur	14,22,9,66,78,...	int[600]

Buat kelas untuk data input Anda di bagian bawah file Program.cs:

/// <summary>
/// Class to hold original sentiment data.
/// </summary>
public class MovieReview
{
    public string? ReviewText { get; set; }
}

Kelas data input, MovieReview, memiliki string untuk komentar pengguna (ReviewText).

Buat kelas untuk fitur panjang variabel setelah kelas MovieReview:
```
/// <summary>
/// Class to hold the variable length feature vector. Used to define the
/// column names used as input to the custom mapping action.
/// </summary>
public class VariableLength
{
    /// <summary>
    /// This is a variable length vector designated by VectorType attribute.
    /// Variable length vectors are produced by applying operations such as 'TokenizeWords' on strings
    /// resulting in vectors of tokens of variable lengths.
    /// </summary>
    [VectorType]
    public int[]? VariableLengthFeatures { get; set; }
}
```
Properti VariableLengthFeatures memiliki atribut VectorType untuk menunjuknya sebagai vektor. Semua elemen vektor harus berjenis yang sama. Dalam himpunan data dengan sejumlah besar kolom, memuat beberapa kolom sebagai vektor tunggal mengurangi jumlah data yang lolos saat Anda menerapkan transformasi data.

Kelas ini digunakan dalam tindakan ResizeFeatures. Nama propertinya (dalam hal ini hanya satu) yang digunakan untuk menunjukkan kolom mana di DataView yang dapat digunakan sebagai input ke tindakan pemetaan kustom.
Buat kelas untuk fitur panjang tetap, setelah kelas VariableLength:
```
/// <summary>
/// Class to hold the fixed length feature vector. Used to define the
/// column names used as output from the custom mapping action,
/// </summary>
public class FixedLength
{
    /// <summary>
    /// This is a fixed length vector designated by VectorType attribute.
    /// </summary>
    [VectorType(Config.FeatureLength)]
    public int[]? Features { get; set; }
}
```
Kelas ini digunakan dalam tindakan ResizeFeatures. Nama propertinya (dalam hal ini hanya satu) yang digunakan untuk menunjukkan kolom mana di DataView yang dapat digunakan sebagai output tindakan pemetaan kustom.

Perhatikan bahwa nama properti Features ditentukan oleh model TensorFlow. Anda tidak dapat mengubah nama properti ini.
Buat kelas untuk prediksi setelah kelas FixedLength:
```
/// <summary>
/// Class to contain the output values from the transformation.
/// </summary>
public class MovieReviewSentimentPrediction
{
    [VectorType(2)]
    public float[]? Prediction { get; set; }
}
```
MovieReviewSentimentPrediction adalah kelas prediksi yang digunakan setelah pelatihan model. MovieReviewSentimentPrediction memiliki array tunggal float (Prediction) dan atribut VectorType.
Buat kelas lain untuk menyimpan nilai konfigurasi, seperti panjang vektor fitur:
```
static class Config
{
    public const int FeatureLength = 600;
}
```

Buat MLContext, kamus pencarian data, dan tindakan untuk mengubah dimensi fitur

kelas MLContext adalah titik awal untuk semua operasi ML.NET. Menginisialisasi mlContext membuat lingkungan ML.NET baru yang dapat dibagikan di seluruh objek alur kerja pembuatan model. Ini mirip, secara konseptual, untuk DBContext dalam Entity Framework.

Ganti baris Console.WriteLine("Hello World!") dengan kode berikut untuk mendeklarasikan dan menginisialisasi variabel mlContext:
```
MLContext mlContext = new MLContext();
```

Buat kamus untuk mengodekan kata sebagai bilangan bulat dengan menggunakan metode LoadFromTextFile untuk memuat data pemetaan dari file, seperti yang terlihat dalam tabel berikut:

Kata	Indeks
Anak	362
ingin	181
salah	355
Efek	302
perasaan	547

Tambahkan kode di bawah ini untuk membuat peta pencarian:

var lookupMap = mlContext.Data.LoadFromTextFile(Path.Combine(_modelPath, "imdb_word_index.csv"),
    columns: new[]
        {
            new TextLoader.Column("Words", DataKind.String, 0),
            new TextLoader.Column("Ids", DataKind.Int32, 1),
        },
    separatorChar: ','
    );

Tambahkan Action untuk mengubah ukuran array integer dengan panjang variabel menjadi array integer dengan ukuran tetap, dengan baris kode berikut ini:

Action<VariableLength, FixedLength> ResizeFeaturesAction = (s, f) =>
{
    var features = s.VariableLengthFeatures;
    Array.Resize(ref features, Config.FeatureLength);
    f.Features = features;
};

Memuat model TensorFlow yang telah dilatih sebelumnya

Tambahkan kode untuk memuat model TensorFlow:

TensorFlowModel tensorFlowModel = mlContext.Model.LoadTensorFlowModel(_modelPath);

Setelah model dimuat, Anda dapat mengekstrak skema input dan outputnya. Skema ditampilkan hanya untuk minat dan pembelajaran. Anda tidak memerlukan kode ini agar aplikasi akhir berfungsi:

DataViewSchema schema = tensorFlowModel.GetModelSchema();
Console.WriteLine(" =============== TensorFlow Model Schema =============== ");
var featuresType = (VectorDataViewType)schema["Features"].Type;
Console.WriteLine($"Name: Features, Type: {featuresType.ItemType.RawType}, Size: ({featuresType.Dimensions[0]})");
var predictionType = (VectorDataViewType)schema["Prediction/Softmax"].Type;
Console.WriteLine($"Name: Prediction/Softmax, Type: {predictionType.ItemType.RawType}, Size: ({predictionType.Dimensions[0]})");

Skema input adalah array panjang tetap dari kata yang dikodekan bilangan bulat. Skema output adalah array float probabilitas yang menunjukkan apakah sentimen ulasan negatif atau positif. Nilai-nilai ini berjumlah 1, karena probabilitas menjadi positif adalah pelengkap probabilitas sentimen menjadi negatif.

Membuat alur ML.NET

Buatlah alur, lalu bagi teks input menjadi kata-kata dengan menggunakan TokenizeIntoWords untuk memecah teks tersebut menjadi kata-kata, seperti dalam baris kode berikut ini:
```
IEstimator<ITransformer> pipeline =
    // Split the text into individual words
    mlContext.Transforms.Text.TokenizeIntoWords("TokenizedWords", "ReviewText")
```
Transformasi TokenizeIntoWords menggunakan spasi untuk mengurai teks/string menjadi kata-kata. Ini membuat kolom baru dan membagi setiap string input ke vektor substring berdasarkan pemisah yang ditentukan pengguna.

Petakan kata-kata ke pengodean bilangan bulatnya menggunakan tabel pencarian yang Anda deklarasikan di atas:

// Map each word to an integer value. The array of integer makes up the input features.
.Append(mlContext.Transforms.Conversion.MapValue("VariableLengthFeatures", lookupMap,
    lookupMap.Schema["Words"], lookupMap.Schema["Ids"], "TokenizedWords"))

Mengubah ukuran pengodean bilangan bulat panjang variabel ke panjang tetap yang diperlukan oleh model:

// Resize variable length vector to fixed length vector.
.Append(mlContext.Transforms.CustomMapping(ResizeFeaturesAction, "Resize"))

Klasifikasikan input dengan model TensorFlow yang dimuat:
```
// Passes the data to TensorFlow for scoring
.Append(tensorFlowModel.ScoreTensorFlowModel("Prediction/Softmax", "Features"))
```
Output model TensorFlow disebut Prediction/Softmax. Perhatikan bahwa nama Prediction/Softmax ditentukan oleh model TensorFlow. Anda tidak dapat mengubah nama ini.
Buat kolom baru untuk prediksi output:
```
// Retrieves the 'Prediction' from TensorFlow and copies to a column
.Append(mlContext.Transforms.CopyColumns("Prediction", "Prediction/Softmax"));
```
Anda perlu menyalin kolom Prediction/Softmax ke dalam kolom dengan nama yang dapat digunakan sebagai properti di kelas C#: Prediction. Karakter / tidak diperbolehkan dalam nama properti C#.

Buat model ML.NET dari jalur pemrosesan

Tambahkan kode untuk membuat model dari alur:
```
// Create an executable model from the estimator pipeline
IDataView dataView = mlContext.Data.LoadFromEnumerable(new List<MovieReview>());
ITransformer model = pipeline.Fit(dataView);
```
Model ML.NET dibuat dari rantai estimator dalam alur dengan memanggil metode Fit. Dalam hal ini, Anda tidak perlu menyesuaikan data apa pun untuk membuat model, karena model TensorFlow sudah dilatih sebelumnya. Anda menyediakan objek tampilan data kosong untuk memenuhi persyaratan metode Fit.

Menggunakan model untuk membuat prediksi

Tambahkan metode PredictSentiment di atas kelas MovieReview:

void PredictSentiment(MLContext mlContext, ITransformer model)
{

}

Tambahkan kode berikut untuk membuat PredictionEngine sebagai baris pertama dalam metode PredictSentiment():
```
var engine = mlContext.Model.CreatePredictionEngine<MovieReview, MovieReviewSentimentPrediction>(model);
```
PredictionEngine adalah API yang memudahkan, yang memungkinkan Anda melakukan prediksi pada satu contoh data. PredictionEngine tidak aman untuk utas. Dapat diterima untuk digunakan di lingkungan utas tunggal atau prototipe. Untuk meningkatkan performa dan keamanan thread di lingkungan produksi, gunakan layanan PredictionEnginePool, yang menciptakan ObjectPool objek PredictionEngine yang dapat digunakan di seluruh aplikasi Anda. Lihat panduan ini tentang cara menggunakan PredictionEnginePool diASP.NET Core Web API .

Nota

ekstensi layanan PredictionEnginePool saat ini sedang dalam tahap pratinjau.
Tambahkan komentar untuk menguji prediksi model terlatih dalam metode Predict() dengan membuat instans MovieReview:
```
var review = new MovieReview()
{
    ReviewText = "this film is really good"
};
```
Teruskan data komentar pengujian ke Prediction Engine dengan menambahkan baris kode berikutnya dalam metode PredictSentiment():
```
var sentimentPrediction = engine.Predict(review);
```
Fungsi Predict() membuat prediksi pada satu baris data:

Harta benda Nilai Jenis

Prediksi [0.5459937, 0.454006255] float[]

Harta benda	Nilai	Jenis
Prediksi	[0.5459937, 0.454006255]	float[]

Tampilkan prediksi sentimen menggunakan kode berikut:

Console.WriteLine($"Number of classes: {sentimentPrediction.Prediction?.Length}");
Console.WriteLine($"Is sentiment/review positive? {(sentimentPrediction.Prediction?[1] > 0.5 ? "Yes." : "No.")}");

Tambahkan panggilan ke PredictSentiment setelah memanggil metode Fit():
```
PredictSentiment(mlContext, model);
```

Hasil

Buat dan jalankan aplikasi Anda.

Hasil Anda harus mirip dengan yang berikut ini. Selama pemrosesan, pesan ditampilkan. Anda mungkin melihat peringatan, atau memproses pesan. Pesan ini telah dihapus dari hasil berikut untuk kejelasan.

Number of classes: 2
Is sentiment/review positive ? Yes

Selamat! Anda sekarang telah berhasil membangun model pembelajaran mesin untuk mengklasifikasikan dan memprediksi sentimen pesan dengan menggunakan kembali model TensorFlow yang telah dilatih sebelumnya di ML.NET.