Bagikan melalui


Tutorial: Membuat, mengevaluasi, dan menilai model klasifikasi teks

Tutorial ini menyajikan contoh end-to-end dari alur kerja Synapse Data Science untuk model klasifikasi teks, di Microsoft Fabric. Skenario ini menggunakan pemrosesan bahasa alami Word2vec (NLP), dan regresi logistik, di Spark, untuk menentukan genre buku dari himpunan data buku British Library. Penentuan semata-mata didasarkan pada judul buku.

Tutorial ini mencakup langkah-langkah berikut:

  • Menginstal pustaka kustom
  • Memuat data
  • Memahami dan memproses data dengan analisis data eksploratif
  • Latih model pembelajaran mesin dengan NLP Word2vec dan regresi logistik, dan lacak eksperimen dengan MLflow dan fitur autologging Fabric
  • Muat model pembelajaran mesin untuk penilaian dan prediksi

Prasyarat

  • Dapatkan langganan Microsoft Fabric . Atau, daftar untuk uji coba Microsoft Fabric gratis.

  • Masuk ke Microsoft Fabric.

  • Gunakan pengalih pengalaman di sisi kiri bawah halaman beranda Anda untuk beralih ke Fabric.

    Cuplikan layar menu pengalih pengalaman, memperlihatkan tempat untuk memilih Ilmu Data.

Ikuti instruksi menggunakan buku catatan

Untuk mengikuti di buku catatan, Anda memiliki pilihan berikut:

  • Buka dan jalankan buku catatan bawaan.
  • Unggah buku catatan Anda dari GitHub.

Buka buku catatan bawaan

Contoh buku catatan klasifikasi genre Judul menyertai tutorial ini.

  1. Untuk membuka contoh buku catatan untuk tutorial ini, ikuti instruksi di Menyiapkan sistem Anda untuk tutorial ilmu data.

  2. Pastikan untuk melampirkan lakehouse pada notebook sebelum menjalankan kode.

Mengimpor notebook dari GitHub

AIsample - Title Genre Classification.ipynb adalah notebook yang menyertai tutorial ini.

Langkah 1: Menginstal pustaka kustom

Untuk pengembangan model pembelajaran mesin atau analisis data ad-hoc, Anda mungkin perlu menginstal pustaka kustom dengan cepat untuk sesi Apache Spark Anda. Anda memiliki dua opsi untuk menginstal pustaka.

  • Untuk menginstal pustaka, hanya di buku catatan Anda saat ini, gunakan kemampuan penginstalan sebaris (%pip atau %conda) buku catatan Anda.
  • Sebagai alternatif, Anda dapat membuat lingkungan Fabric, dan menginstal pustaka dari sumber publik atau mengunggah pustaka kustom ke dalamnya. Kemudian, admin ruang kerja Anda dapat melampirkan lingkungan sebagai default untuk ruang kerja. Pada saat itu, semua pustaka di lingkungan menjadi tersedia untuk digunakan di semua buku catatan dan semua definisi tugas Spark di ruang kerja tersebut. Untuk informasi selengkapnya tentang lingkungan, kunjungi membuat, mengonfigurasi, dan menggunakan lingkungan di sumber daya Microsoft Fabric .

Untuk model klasifikasi, gunakan wordcloud pustaka untuk mewakili frekuensi kata dalam teks. Dalam wordcloud sumber daya, ukuran kata mewakili frekuensinya. Untuk tutorial ini, gunakan %pip install untuk menginstal wordcloud di notebook Anda.

Nota

Kernel PySpark dimulai ulang setelah %pip install berjalan. Instal pustaka yang Anda butuhkan sebelum menjalankan sel lain.

# Install wordcloud for text visualization by using pip
%pip install wordcloud

Langkah 2: Muat data

Himpunan data buku British Library memiliki metadata tentang buku dari British Library. Kolaborasi antara pustaka dan Microsoft mendigitalkan sumber daya asli yang menjadi himpunan data. Metadata adalah informasi klasifikasi yang menunjukkan apakah buku adalah fiksi atau nonfiksi atau tidak. Diagram berikut menunjukkan sampel baris himpunan data.

Rekaman BL ID Jenis sumber daya Nama Tanggal yang terkait dengan nama Jenis nama Peranan Semua nama Titel Judul varian Judul seri Angka dalam seri Negara publikasi Tempat publikasi Penerbit Tanggal publikasi Edisi Deskripsi fisik Klasifikasi Dewey Tanda rak Perpustakaan Britania Topik Genre Bahasa Catatan ID rekaman BL untuk sumber daya fisik id_klasifikasi ID_pengguna dibuat_pada subject_ids tanggal_pub_annotator penanda_tanggal_dipublikasi_dinormalisasi pernyataan_edisi_annotator annotator_genre penanda_kata_kunci_genre_cepat penanda_ISTILAH_subjek_cepat komentar_penilai bahasa_utama_pentanda ringkasan_annotator_bahasa_lain pengolah_ringkasan_bahasa penerjemah_catatan anotator_bahasa_asli penerbit_penanda penempatan_penanda_pub negara_annotator judul_penanda Tautan ke buku digital Dianotasi
014602826 Monografi Yearsley, Ann 1753-1806 orang Hannah More, 1745-1833 [tokoh]; Ann Yearsley, 1753-1806 [tokoh] Puisi pada beberapa kesempatan [Dengan surat pengantar oleh Hannah More.] Inggris London 1786 Catatan naskah edisi keempat Toko Digital 11644.d.32 Inggris 003996603 Palsu
014602830 Monografi A, T. orang Oldham, John, 1653-1683 [orang]; A, T. [orang] Satyr melawan Vertue. (Sebuah puisi: seharusnya dibacakan oleh Town-Hector [Oleh John Oldham. Pendahuluan ditandatangani: T. A.]) Inggris London 1679 15 halaman (4°) Toko Digital 11602.ee.10. (2.) Inggris 000001143 Palsu

Dengan himpunan data ini, tujuan kami adalah untuk melatih model klasifikasi yang menentukan genre buku, hanya berdasarkan judul buku.

Tentukan parameter berikut, untuk menerapkan buku catatan ini pada himpunan data yang berbeda:

IS_CUSTOM_DATA = False  # If True, the user must manually upload the dataset
DATA_FOLDER = "Files/title-genre-classification"
DATA_FILE = "blbooksgenre.csv"

# Data schema
TEXT_COL = "Title"
LABEL_COL = "annotator_genre"
LABELS = ["Fiction", "Non-fiction"]

EXPERIMENT_NAME = "sample-aisample-textclassification"  # MLflow experiment name

Mengunduh himpunan data dan mengunggah ke lakehouse

Cuplikan kode berikut mengunduh versi himpunan data yang tersedia untuk umum, lalu menyimpannya di Fabric lakehouse:

Penting

Tambahkan lakehouse ke buku catatan sebelum Anda menjalankannya. Kegagalan untuk melakukannya mengakibatkan kesalahan.

if not IS_CUSTOM_DATA:
    # Download demo data files into the lakehouse, if they don't exist
    import os, requests

    remote_url = "https://synapseaisolutionsa.z13.web.core.windows.net/data/Title_Genre_Classification"
    fname = "blbooksgenre.csv"
    download_path = f"/lakehouse/default/{DATA_FOLDER}/raw"

    if not os.path.exists("/lakehouse/default"):
        # Add a lakehouse, if no default lakehouse was added to the notebook
        # A new notebook won't link to any lakehouse by default
        raise FileNotFoundError(
            "Default lakehouse not found, please add a lakehouse and restart the session."
        )
    os.makedirs(download_path, exist_ok=True)
    if not os.path.exists(f"{download_path}/{fname}"):
        r = requests.get(f"{remote_url}/{fname}", timeout=30)
        with open(f"{download_path}/{fname}", "wb") as f:
            f.write(r.content)
    print("Downloaded demo data files into lakehouse.")

Mengimpor pustaka yang diperlukan

Sebelum pemrosesan apa pun, Anda harus mengimpor pustaka yang diperlukan, termasuk pustaka untuk Spark dan SynapseML:

import numpy as np
from itertools import chain

from wordcloud import WordCloud
import matplotlib.pyplot as plt
import seaborn as sns

import pyspark.sql.functions as F

from pyspark.ml import Pipeline
from pyspark.ml.feature import *
from pyspark.ml.tuning import CrossValidator, ParamGridBuilder
from pyspark.ml.classification import LogisticRegression
from pyspark.ml.evaluation import (
    BinaryClassificationEvaluator,
    MulticlassClassificationEvaluator,
)

from synapse.ml.stages import ClassBalancer
from synapse.ml.train import ComputeModelStatistics

import mlflow

Tentukan hiperparameter

Cuplikan kode berikut mendefinisikan hiperparameter yang diperlukan untuk pelatihan model:

Penting

Ubah hiperparameter ini hanya jika Anda memahami setiap parameter.

# Hyperparameters 
word2vec_size = 128  # The length of the vector for each word
min_word_count = 3  # The minimum number of times that a word must appear to be considered
max_iter = 10  # The maximum number of training iterations
k_folds = 3  # The number of folds for cross-validation

Mulai rekam waktu yang diperlukan untuk menjalankan buku catatan ini:

# Record the notebook running time
import time

ts = time.time()

Menyiapkan pelacakan eksperimen MLflow

Autologging memperluas kemampuan pengelogan MLflow. Autologging secara otomatis menangkap nilai parameter input dan metrik output model pembelajaran mesin saat Anda melatihnya. Anda kemudian mencatat informasi ini ke ruang kerja. Di ruang kerja, Anda dapat mengakses dan memvisualisasikan informasi dengan API MLflow, atau eksperimen yang sesuai, di ruang kerja. Untuk informasi selengkapnya tentang autologging, kunjungi Autologging di sumber daya Microsoft Fabric .

Untuk menonaktifkan autologging Microsoft Fabric dalam sesi notebook, panggil mlflow.autolog() dan atur disable=True:

# Set up Mlflow for experiment tracking

mlflow.set_experiment(EXPERIMENT_NAME)
mlflow.autolog(disable=True)  # Disable Mlflow autologging

Membaca data tanggal mentah dari lakehouse

raw_df = spark.read.csv(f"{DATA_FOLDER}/raw/{DATA_FILE}", header=True, inferSchema=True)

Langkah 3: Lakukan analisis data eksploratif

Jelajahi himpunan data dengan perintah display, untuk melihat statistik tingkat tinggi untuk himpunan data dan untuk menampilkan tampilan bagan:

display(raw_df.limit(20))

Menyiapkan data

Untuk membersihkan data, hapus duplikat:

df = (
    raw_df.select([TEXT_COL, LABEL_COL])
    .where(F.col(LABEL_COL).isin(LABELS))
    .dropDuplicates([TEXT_COL])
    .cache()
)

display(df.limit(20))

Terapkan penyeimbangan kelas untuk mengatasi bias apa pun:

# Create a ClassBalancer instance, and set the input column to LABEL_COL
cb = ClassBalancer().setInputCol(LABEL_COL)

# Fit the ClassBalancer instance to the input DataFrame, and transform the DataFrame
df = cb.fit(df).transform(df)

# Display the first 20 rows of the transformed DataFrame
display(df.limit(20))

Untuk tokenisasi himpunan data, pisahkan paragraf dan kalimat menjadi unit yang lebih kecil. Dengan cara ini, menjadi lebih mudah untuk menetapkan makna. Selanjutnya, hapus stopword untuk meningkatkan performa. Penghapusan kata hentian melibatkan penghapusan kata-kata yang umumnya muncul di semua dokumen dalam korpus. Penghapusan stopword adalah salah satu langkah praproses yang paling umum digunakan dalam aplikasi pemrosesan bahasa alami (NLP). Cuplikan kode berikut mencakup langkah-langkah berikut:

# Text transformer
tokenizer = Tokenizer(inputCol=TEXT_COL, outputCol="tokens")
stopwords_remover = StopWordsRemover(inputCol="tokens", outputCol="filtered_tokens")

# Build the pipeline
pipeline = Pipeline(stages=[tokenizer, stopwords_remover])

token_df = pipeline.fit(df).transform(df)

display(token_df.limit(20))

Tampilkan pustaka wordcloud untuk setiap kelas. Pustaka wordcloud menyajikan kata kunci yang sering muncul dalam data teks, adalah presentasi yang menonjol secara visual. Pustaka wordcloud efektif karena penyajian kata kunci membentuk gambar warna seperti cloud, untuk menangkap data teks utama dengan lebih baik secara sekilas. Kunjungi sumber daya ini untuk informasi selengkapnya tentang wordcloud.

Cuplikan kode berikut mencakup langkah-langkah berikut:

# WordCloud
for label in LABELS:
    tokens = (
        token_df.where(F.col(LABEL_COL) == label)
        .select(F.explode("filtered_tokens").alias("token"))
        .where(F.col("token").rlike(r"^\w+$"))
    )

    top50_tokens = (
        tokens.groupBy("token").count().orderBy(F.desc("count")).limit(50).collect()
    )

    # Generate a wordcloud image
    wordcloud = WordCloud(
        scale=10,
        background_color="white",
        random_state=42,  # Make sure the output is always the same for the same input
    ).generate_from_frequencies(dict(top50_tokens))

    # Display the generated image by using matplotlib
    plt.figure(figsize=(10, 10))
    plt.title(label, fontsize=20)
    plt.axis("off")
    plt.imshow(wordcloud, interpolation="bilinear")

Terakhir, gunakan Word2vec NLP untuk memvektorisasi teks. Teknik NLP Word2vec membuat representasi vektor dari setiap kata dalam teks. Kata-kata yang digunakan dalam konteks serupa, atau yang memiliki hubungan semantik, ditangkap secara efektif melalui kedekatannya di ruang vektor. Kedekatan ini menunjukkan bahwa kata serupa memiliki vektor kata yang sama. Cuplikan kode berikut mencakup langkah-langkah berikut:

# Label transformer
label_indexer = StringIndexer(inputCol=LABEL_COL, outputCol="labelIdx")
vectorizer = Word2Vec(
    vectorSize=word2vec_size,
    minCount=min_word_count,
    inputCol="filtered_tokens",
    outputCol="features",
)

# Build the pipeline
pipeline = Pipeline(stages=[label_indexer, vectorizer])
vec_df = (
    pipeline.fit(token_df)
    .transform(token_df)
    .select([TEXT_COL, LABEL_COL, "features", "labelIdx", "weight"])
)

display(vec_df.limit(20))

Langkah 4: Melatih dan mengevaluasi model

Dengan data di tempat, tentukan model. Di bagian ini, Anda melatih model regresi logistik untuk mengklasifikasikan teks vektorisasi.

Menyiapkan himpunan data pelatihan dan pengujian

Cuplikan kode berikut membagi himpunan data:

# Split the dataset into training and testing
(train_df, test_df) = vec_df.randomSplit((0.8, 0.2), seed=42)

Melacak eksperimen pembelajaran mesin

Pelacakan eksperimen pembelajaran mesin mengelola semua eksperimen dan komponennya - misalnya, parameter, metrik, model, dan artefak lainnya. Pelacakan memungkinkan organisasi dan manajemen semua komponen yang diperlukan eksperimen pembelajaran mesin tertentu. Ini juga memungkinkan reproduksi hasil sebelumnya yang mudah dengan eksperimen yang disimpan. Kunjungi Eksperimen pembelajaran mesin di Microsoft Fabric untuk informasi selengkapnya.

Eksperimen pembelajaran mesin adalah unit utama organisasi dan kontrol untuk semua eksekusi pembelajaran mesin terkait. Sebuah run merujuk pada satu kali eksekusi kode untuk model. Cuplikan kode berikut mencakup langkah-langkah berikut:

# Build the logistic regression classifier
lr = (
    LogisticRegression()
    .setMaxIter(max_iter)
    .setFeaturesCol("features")
    .setLabelCol("labelIdx")
    .setWeightCol("weight")
)

Mengoptimalkan hiperparameter

Buat pola parameter untuk mencari melalui hiperparameter tersebut. Kemudian, seperti yang ditunjukkan dalam cuplikan kode berikut, buat estimator lintas penilaian untuk menghasilkan model CrossValidator.

# Build a grid search to select the best values for the training parameters
param_grid = (
    ParamGridBuilder()
    .addGrid(lr.regParam, [0.03, 0.1])
    .addGrid(lr.elasticNetParam, [0.0, 0.1])
    .build()
)

if len(LABELS) > 2:
    evaluator_cls = MulticlassClassificationEvaluator
    evaluator_metrics = ["f1", "accuracy"]
else:
    evaluator_cls = BinaryClassificationEvaluator
    evaluator_metrics = ["areaUnderROC", "areaUnderPR"]
evaluator = evaluator_cls(labelCol="labelIdx", weightCol="weight")

# Build a cross-evaluator estimator
crossval = CrossValidator(
    estimator=lr,
    estimatorParamMaps=param_grid,
    evaluator=evaluator,
    numFolds=k_folds,
    collectSubModels=True,
)

Evaluasi model

Kita dapat mengevaluasi model pada himpunan data pengujian, untuk membandingkannya. Model yang terlatih harus menunjukkan performa tinggi, pada metrik yang relevan, saat dijalankan terhadap validasi dan himpunan data pengujian. Cuplikan kode berikut mencakup langkah-langkah berikut:

def evaluate(model, df):
    log_metric = {}
    prediction = model.transform(df)
    for metric in evaluator_metrics:
        value = evaluator.evaluate(prediction, {evaluator.metricName: metric})
        log_metric[metric] = value
        print(f"{metric}: {value:.4f}")
    return prediction, log_metric

Melacak eksperimen dengan menggunakan MLflow

Mulai proses pelatihan dan evaluasi. Gunakan MLflow untuk melacak semua eksperimen, dan mencatat parameter, metrik, dan model. Di ruang kerja, semua informasi ini dicatat dengan nama eksperimen. Cuplikan kode berikut mencakup langkah-langkah berikut:

with mlflow.start_run(run_name="lr"):
    models = crossval.fit(train_df)
    best_metrics = {k: 0 for k in evaluator_metrics}
    best_index = 0
    for idx, model in enumerate(models.subModels[0]):
        with mlflow.start_run(nested=True, run_name=f"lr_{idx}") as run:
            print("\nEvaluating on test data:")
            print(f"subModel No. {idx + 1}")
            prediction, log_metric = evaluate(model, test_df)

            if log_metric[evaluator_metrics[0]] > best_metrics[evaluator_metrics[0]]:
                best_metrics = log_metric
                best_index = idx

            print("log model")
            mlflow.spark.log_model(
                model,
                f"{EXPERIMENT_NAME}-lrmodel",
                registered_model_name=f"{EXPERIMENT_NAME}-lrmodel",
                dfs_tmpdir="Files/spark",
            )

            print("log metrics")
            mlflow.log_metrics(log_metric)

            print("log parameters")
            mlflow.log_params(
                {
                    "word2vec_size": word2vec_size,
                    "min_word_count": min_word_count,
                    "max_iter": max_iter,
                    "k_folds": k_folds,
                    "DATA_FILE": DATA_FILE,
                }
            )

    # Log the best model and its relevant metrics and parameters to the parent run
    mlflow.spark.log_model(
        models.subModels[0][best_index],
        f"{EXPERIMENT_NAME}-lrmodel",
        registered_model_name=f"{EXPERIMENT_NAME}-lrmodel",
        dfs_tmpdir="Files/spark",
    )
    mlflow.log_metrics(best_metrics)
    mlflow.log_params(
        {
            "word2vec_size": word2vec_size,
            "min_word_count": min_word_count,
            "max_iter": max_iter,
            "k_folds": k_folds,
            "DATA_FILE": DATA_FILE,
        }
    )

Untuk melihat eksperimen Anda:

  1. Pilih ruang kerja Anda di navigasi kiri
  2. Temukan dan pilih nama eksperimen - dalam hal ini, sample_aisample-textclassification

Cuplikan layar eksperimen.

Langkah 5: Menilai dan menyimpan hasil prediksi

Microsoft Fabric memungkinkan pengguna untuk mengoprasikan model pembelajaran mesin dengan fungsi yang dapat diskalakan PREDICT . Fungsi ini mendukung penilaian batch (atau inferensi batch) di mesin komputasi apa pun. Anda dapat membuat prediksi batch langsung dari buku catatan atau dari halaman item untuk model tertentu. Untuk informasi selengkapnya tentang PREDICT fungsi, dan cara menggunakannya di Fabric, kunjungi Penilaian model pembelajaran mesin dengan PREDICT di Microsoft Fabric.

Dari hasil evaluasi kami, model 1 memiliki metrik terbesar untuk Area Di Bawah Kurva Precision-Recall (AUPRC) dan untuk Area Di Bawah Karakteristik Operasi Penerima Kurva (AUC-ROC). Oleh karena itu, Anda harus menggunakan model 1 untuk prediksi.

Ukuran AUC-ROC banyak digunakan untuk mengukur performa pengklasifikasi biner. Namun, terkadang lebih tepat untuk mengevaluasi klasifikator berdasarkan pengukuran AUPRC. Bagan AUC-ROC menggambarkan pertukaran antara true positive rate (TPR) dan false positive rate (FPR). Kurva AUPRC menggabungkan presisi (nilai prediktif positif atau PPV) dan pengenalan (tingkat positif sejati atau TPR) dalam satu visualisasi. Cuplikan kode berikut mencakup langkah-langkah berikut:

# Load the best model
model_uri = f"models:/{EXPERIMENT_NAME}-lrmodel/1"
loaded_model = mlflow.spark.load_model(model_uri, dfs_tmpdir="Files/spark")

# Verify the loaded model
batch_predictions = loaded_model.transform(test_df)
batch_predictions.show(5)
# Code to save userRecs in the lakehouse
batch_predictions.write.format("delta").mode("overwrite").save(
    f"{DATA_FOLDER}/predictions/batch_predictions"
)
# Determine the entire runtime
print(f"Full run cost {int(time.time() - ts)} seconds.")