Catatan
Akses ke halaman ini memerlukan otorisasi. Anda dapat mencoba masuk atau mengubah direktori.
Akses ke halaman ini memerlukan otorisasi. Anda dapat mencoba mengubah direktori.
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.
- Jika Anda tidak memiliki Microsoft Fabric lakehouse, ikuti langkah-langkah di Membuat lakehouse di sumber daya Microsoft Fabric untuk membuatnya.
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.
Untuk membuka contoh buku catatan untuk tutorial ini, ikuti instruksi di Menyiapkan sistem Anda untuk tutorial ilmu data.
Pastikan untuk melampirkan lakehouse pada notebook sebelum menjalankan kode.
Mengimpor notebook dari GitHub
AIsample - Title Genre Classification.ipynb adalah notebook yang menyertai tutorial ini.
Untuk membuka buku catatan yang menyertai tutorial ini, ikuti instruksi di Menyiapkan sistem Anda untuk tutorial ilmu data mengimpor buku catatan ke ruang kerja Anda.
Jika Anda lebih suka menyalin dan menempelkan kode dari halaman ini, Anda bisa membuat buku catatan baru.
Pastikan melampirkan lakehouse ke notebook sebelum Anda mulai menjalankan kode.
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:
- Pilih ruang kerja Anda di navigasi kiri
- Temukan dan pilih nama eksperimen - dalam hal ini, sample_aisample-textclassification
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.")