แชร์ผ่าน

บทช่วยสอน: สร้าง ประเมิน และให้คะแนนแบบจําลองการจัดประเภทข้อความ

บทช่วยสอนนี้แสดงตัวอย่างแบบ end-to-end ของเวิร์กโฟลว์ Synapse Data Science สําหรับแบบจําลองการจัดประเภทข้อความใน Microsoft Fabric สถานการณ์นี้ใช้การประมวลผลภาษาธรรมชาติของ Word2vec (NLP) และการถดถอยโลจิสติกส์บน Spark เพื่อกําหนดประเภทของหนังสือจากชุดข้อมูลหนังสือบริติชไลบรารี การกําหนดจะขึ้นอยู่กับชื่อของหนังสือเท่านั้น

บทช่วยสอนนี้ครอบคลุมขั้นตอนเหล่านี้:

  • ติดตั้งไลบรารีแบบกําหนดเอง
  • โหลดข้อมูล
  • ทําความเข้าใจและประมวลผลข้อมูลด้วยการวิเคราะห์ข้อมูลเชิงสํารวจ
  • ฝึกแบบจําลองการเรียนรู้ของเครื่องด้วยทั้ง Word2vec NLP และการถดถอยโลจิสติกส์ และติดตามการทดลองด้วย MLflow และคุณลักษณะ Fabric autologging
  • โหลดแบบจําลองการเรียนรู้ของเครื่องสําหรับการให้คะแนนและการคาดการณ์

ข้อกําหนดเบื้องต้น

ติดตามในสมุดบันทึก

เมื่อต้องการทําตามในสมุดบันทึก คุณมีตัวเลือกเหล่านี้:

  • เปิดและเรียกใช้สมุดบันทึกที่มีอยู่ภายใน
  • อัปโหลดสมุดบันทึกของคุณจาก GitHub

เปิดสมุดบันทึกที่มีอยู่แล้วภายใน

ตัวอย่าง การจัดประเภทประเภทประเภทชื่อเรื่อง สมุดบันทึกมาพร้อมกับบทช่วยสอนนี้

  1. เมื่อต้องการเปิดสมุดบันทึกตัวอย่างสําหรับบทช่วยสอนนี้ ให้ทําตามคําแนะนําใน เตรียมระบบของคุณสําหรับบทช่วยสอนวิทยาศาสตร์ข้อมูล

  2. ตรวจสอบให้แน่ใจว่า แนบ lakehouse เข้ากับ สมุดบันทึกก่อนที่คุณจะเริ่มเรียกใช้โค้ด

นําเข้าสมุดบันทึกจาก GitHub

AIsample - เรื่อง Classification.ipynb ชื่อเรื่องคือสมุดบันทึกที่มาพร้อมกับบทช่วยสอนนี้

ขั้นตอนที่ 1: ติดตั้งไลบรารีแบบกําหนดเอง

สําหรับการพัฒนาแบบจําลองการเรียนรู้ของเครื่องหรือการวิเคราะห์ข้อมูลเฉพาะกิจ คุณอาจจําเป็นต้องติดตั้งไลบรารีแบบกําหนดเองสําหรับเซสชัน Apache Spark ของคุณได้อย่างรวดเร็ว คุณมีสองตัวเลือกในการติดตั้งไลบรารี

  • เมื่อต้องการติดตั้งไลบรารี ในสมุดบันทึกปัจจุบันของคุณเท่านั้น ให้ใช้ความสามารถในการติดตั้งแบบอินไลน์ (%pip หรือ %conda) ของสมุดบันทึกของคุณ
  • อีกทางเลือกหนึ่งคือ คุณสามารถสร้างสภาพแวดล้อม Fabric และติดตั้งไลบรารีจากแหล่งข้อมูลสาธารณะหรืออัปโหลดไลบรารีแบบกําหนดเองได้ จากนั้น ผู้ดูแลระบบพื้นที่ทํางานของคุณสามารถแนบสภาพแวดล้อมเป็นค่าเริ่มต้นสําหรับพื้นที่ทํางานได้ ณ จุดนั้น ไลบรารีทั้งหมดในสภาพแวดล้อมจะพร้อมใช้งานสําหรับใช้ในสมุดบันทึกทั้งหมด และข้อกําหนดงาน Spark ทั้งหมดในพื้นที่ทํางานนั้น สําหรับข้อมูลเพิ่มเติมเกี่ยวกับสภาพแวดล้อม โปรดเยี่ยมชมสร้าง กําหนดค่า และใช้สภาพแวดล้อมในทรัพยากร Microsoft Fabric

สําหรับแบบจําลองการจัดประเภท ให้ใช้ wordcloud ไลบรารีเพื่อแสดงคําว่า ความถี่ในข้อความ ใน wordcloud ทรัพยากร ขนาดของคําแสดงถึงความถี่ สําหรับบทช่วยสอนนี้ ให้ใช้ %pip install เพื่อติดตั้ง wordcloud ในสมุดบันทึกของคุณ

โน้ต

เคอร์เนล PySpark รีสตาร์ทหลังจาก %pip install ทํางาน ติดตั้งไลบรารีที่คุณต้องการก่อนที่คุณจะเรียกใช้เซลล์อื่น

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

ขั้นตอนที่ 2: โหลดข้อมูล

ชุดข้อมูลหนังสือบริติชไลบรารีมีเมตาดาต้าเกี่ยวกับหนังสือจากห้องสมุดอังกฤษ การทํางานร่วมกันระหว่างไลบรารีและ Microsoft ทําให้ทรัพยากรดั้งเดิมกลายเป็นชุดข้อมูลเป็นตัวเลข เมตาดาต้าคือข้อมูลการจัดประเภทที่ระบุว่าหนังสือเป็นนิยายหรือไม่ ไดอะแกรมต่อไปนี้แสดงตัวอย่างแถวของชุดข้อมูล

รหัสเรกคอร์ด BL ชนิดของทรัพยากร ชื่อ วันที่ที่เชื่อมโยงกับชื่อ ชนิดของชื่อ บทบาท ชื่อทั้งหมด ชื่อเรื่อง ชื่อตัวแปร ชื่อชุดข้อมูล หมายเลขภายในชุดข้อมูล ประเทศที่เผยแพร่ สถานที่เผยแพร่ ผู้พิมพ์ วันที่เผยแพร่ ฉบับ คําอธิบายทางกายภาพ การจําแนกประเภท Dewey BL shelfmark หัว ข้อ ประเภท ภาษา หมาย เหตุ รหัสเรกคอร์ด BL สําหรับทรัพยากรจริง classification_id user_id created_at subject_ids annotator_date_pub annotator_normalised_date_pub annotator_edition_statement annotator_genre annotator_FAST_genre_terms annotator_FAST_subject_terms annotator_comments annotator_main_language annotator_other_languages_summaries annotator_summaries_language annotator_translation annotator_original_language annotator_publisher annotator_place_pub annotator_country annotator_title ลิงก์ไปยังหนังสือที่เป็นตัวเลข มีคําอธิบายประกอบ
014602826 Monograph Yearsley, Ann 1753-1806 คน เพิ่มเติม, ฮันนาห์, 1745-1833 [บุคคล]; Yearsley, Ann, 1753-1806 [person] บทกวีในหลายโอกาส [ด้วยตัวอักษรเตรียมการโดยฮันนาห์เพิ่มเติม] อังกฤษ ลอนดอน 1786 หมายเหตุ MANUSCRIPT รุ่นที่สี่ Digital Store 11644.d.32 อังกฤษ 003996603 ปลอม
014602830 Monograph A, T. คน Oldham, John, 1653-1683 [person]; A, T. [person] Satyr ต่อต้าน Vertue (บทกวี: ควรพูดโดย Town-Hector [โดย John Oldham) เครื่องหมายนําหน้า: T. A.]) อังกฤษ ลอนดอน 1679 15 หน้า (4°) Digital Store 11602.ee.10. (2.) อังกฤษ 000001143 ปลอม

ด้วยชุดข้อมูลนี้เป้าหมายของเราคือการฝึกแบบจําลองการจําแนกประเภทที่กําหนดประเภทของหนังสือโดยยึดตามชื่อหนังสือเท่านั้น

กําหนดพารามิเตอร์ต่อไปนี้เพื่อนําสมุดบันทึกนี้ไปใช้กับชุดข้อมูลต่างๆ:

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

ดาวน์โหลดชุดข้อมูลและอัปโหลดไปยัง lakehouse

ส่วนย่อยของโค้ดต่อไปนี้จะดาวน์โหลดชุดข้อมูลเวอร์ชันที่เผยแพร่ต่อสาธารณะแล้วจัดเก็บไว้ใน Fabric lakehouse:

สําคัญ

เพิ่มเลคเฮ้าส์ ลงในสมุดบันทึกก่อนที่คุณจะเรียกใช้ ความล้มเหลวในการดําเนินการดังกล่าวจะส่งผลให้เกิดข้อผิดพลาด

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.")

นําเข้าไลบรารีที่จําเป็น

ก่อนการประมวลผลใด ๆ คุณต้องนําเข้าไลบรารีที่จําเป็น รวมถึงไลบรารีสําหรับ Spark และ 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

กําหนด hyperparameters

ส่วนย่อยของโค้ดต่อไปนี้จะกําหนด hyperparameters ที่จําเป็นสําหรับการฝึกแบบจําลอง:

สําคัญ

แก้ไข hyperparameters เหล่านี้เฉพาะเมื่อคุณทําความเข้าใจแต่ละพารามิเตอร์เท่านั้น

# 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

เริ่มการบันทึกเวลาที่จําเป็นในการเรียกใช้สมุดบันทึกนี้:

# Record the notebook running time
import time

ts = time.time()

ตั้งค่าการติดตามการทดลอง MLflow

การล็อกอัตโนมัติจะขยายความสามารถในการบันทึกกระแส ML การล็อกอัตโนมัติจะจับค่าพารามิเตอร์อินพุตและเมตริกเอาต์พุตของแบบจําลองการเรียนรู้ของเครื่องตามที่คุณฝึกโดยอัตโนมัติ จากนั้นคุณจะบันทึกข้อมูลนี้ไปยังพื้นที่ทํางาน ในพื้นที่ทํางาน คุณสามารถเข้าถึงและแสดงข้อมูลด้วย MLflow API หรือการทดลองที่สอดคล้องกันในพื้นที่ทํางานได้ สําหรับข้อมูลเพิ่มเติมเกี่ยวกับ autologging ไปที่การล็อกอัตโนมัติในทรัพยากร Microsoft Fabric

เพื่อปิดการใช้งาน Microsoft Fabric autologging ในเซสชันสมุดบันทึก เรียก mlflow.autolog() และตั้งค่า disable=True:

# Set up Mlflow for experiment tracking

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

อ่านข้อมูลวันที่ดิบจากเลคเฮ้าส์

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

ขั้นตอนที่ 3: ดําเนินการวิเคราะห์ข้อมูลเชิงสํารวจ

สํารวจชุดข้อมูลด้วยคําสั่ง display เพื่อดูสถิติระดับสูงสําหรับชุดข้อมูลและเพื่อแสดงมุมมองแผนภูมิ:

display(raw_df.limit(20))

เตรียมข้อมูล

หากต้องการทําความสะอาดข้อมูล ให้ลบรายการที่ซ้ํากันออก:

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

display(df.limit(20))

ปรับใช้การปรับสมดุลระดับชั้นกับอคติใด ๆ:

# 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))

เมื่อต้องการโทเค็นชุดข้อมูล ให้แยกย่อหน้าและประโยคเป็นหน่วยขนาดเล็กลง ด้วยวิธีนี้ จึงเป็นเรื่องง่ายที่จะกําหนดความหมาย ถัดไป ลบคําหยุดเพื่อปรับปรุงประสิทธิภาพการทํางาน การลบ Stopword เกี่ยวข้องกับการลบคําที่เกิดขึ้นโดยทั่วไปในเอกสารทั้งหมดใน corpus การลบ Stopword คือหนึ่งในขั้นตอนการประมวลผลล่วงหน้าที่ใช้บ่อยที่สุดในแอปพลิเคชันการประมวลผลภาษาธรรมชาติ (NLP) ส่วนย่อยของโค้ดต่อไปนี้ครอบคลุมขั้นตอนเหล่านี้:

# 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))

แสดงคลัง wordcloud สําหรับแต่ละชั้นเรียน ไลบรารี wordcloud แสดงคําหลักที่ปรากฏขึ้นบ่อยในข้อมูลข้อความ เป็นงานนําเสนอที่โดดเด่นด้วยภาพ ไลบรารี wordcloud มีประสิทธิภาพเนื่องจากการแสดงผลคําสําคัญจะสร้างรูปภาพสีที่ cloudlike เพื่อให้จับภาพข้อมูลข้อความหลักได้อย่างรวดเร็ว เยี่ยมชม แหล่งข้อมูลนี้ สําหรับข้อมูลเพิ่มเติมเกี่ยวกับ wordcloud

ส่วนย่อยของโค้ดต่อไปนี้ครอบคลุมขั้นตอนเหล่านี้:

# 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")

สุดท้ายให้ใช้ Word2vec NLP เพื่อทําให้ข้อความเป็นเวกเตอร์ เทคนิค Word2vec NLP จะสร้างการแสดงเวกเตอร์ของแต่ละคําในข้อความ คําที่ใช้ในบริบทที่คล้ายกันหรือที่มีความสัมพันธ์เชิงความหมายถูกจับภาพได้อย่างมีประสิทธิภาพผ่านความใกล้ชิดในพื้นที่เวกเตอร์ ความใกล้ชิดนี้แสดงให้เห็นว่าคําที่คล้ายกันมีเวกเตอร์คําที่คล้ายกัน ส่วนย่อยของโค้ดต่อไปนี้ครอบคลุมขั้นตอนเหล่านี้:

# 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))

ขั้นตอนที่ 4: ฝึกและประเมินแบบจําลอง

ด้วยข้อมูลที่มีอยู่ ให้กําหนดแบบจําลอง ในส่วนนี้ คุณฝึกแบบจําลองการถดถอยโลจิสติกส์เพื่อจัดประเภทข้อความที่เป็นแบบเวกเตอร์

เตรียมการฝึกอบรมและทดสอบชุดข้อมูล

ส่วนย่อยของโค้ดต่อไปนี้แยกชุดข้อมูล:

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

ติดตามการทดลองการเรียนรู้ของเครื่อง

การติดตามการทดสอบการเรียนรู้ของเครื่องจะจัดการการทดลองและคอมโพเนนต์ทั้งหมด เช่น พารามิเตอร์ เมตริก แบบจําลอง และวัตถุอื่น ๆ การติดตามช่วยให้องค์กรและการจัดการคอมโพเนนต์ทั้งหมดที่การทดสอบการเรียนรู้ของเครื่องเฉพาะต้องการได้ นอกจากนี้ยังช่วยให้สามารถทําซ้ําผลลัพธ์ในอดีตได้ง่ายด้วยการทดลองที่บันทึกไว้ เยี่ยมชม การทดลองการเรียนรู้ของเครื่องใน Microsoft Fabric สําหรับข้อมูลเพิ่มเติม

การทดลองการเรียนรู้ของเครื่องเป็นหน่วยหลักขององค์กรและควบคุมการเรียกใช้การเรียนรู้ของเครื่องที่เกี่ยวข้องทั้งหมด การเรียกใช้สอดคล้องกับการดําเนินการเดียวของรหัสแบบจําลอง ส่วนย่อยของโค้ดต่อไปนี้ครอบคลุมขั้นตอนเหล่านี้:

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

ปรับแต่ง hyperparameters

สร้างเส้นตารางของพารามิเตอร์เพื่อค้นหามากกว่า hyperparameters จากนั้นสร้างตัวประมาณค่าข้าม เพื่อสร้าง 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,
)

ประเมินแบบจําลอง

เราสามารถประเมินแบบจําลองบนชุดข้อมูลทดสอบเพื่อเปรียบเทียบได้ แบบจําลองที่ได้รับการฝึกฝนมาอย่างดีควรแสดงให้เห็นถึงประสิทธิภาพการทํางานสูงในเมตริกที่เกี่ยวข้องเมื่อเรียกใช้กับการตรวจสอบความถูกต้องและทดสอบชุดข้อมูล ส่วนย่อยของโค้ดต่อไปนี้ครอบคลุมขั้นตอนเหล่านี้:

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

ติดตามการทดลองโดยใช้ MLflow

เริ่มต้นกระบวนการฝึกอบรมและการประเมินผล ใช้ MLflow เพื่อติดตามการทดลองทั้งหมด และบันทึกพารามิเตอร์ เมตริก และแบบจําลอง ในพื้นที่ทํางาน ข้อมูลทั้งหมดนี้จะถูกบันทึกไว้ภายใต้ชื่อการทดลอง ส่วนย่อยของโค้ดต่อไปนี้ครอบคลุมขั้นตอนเหล่านี้:

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,
        }
    )

วิธีดูการทดลองของคุณ:

  1. เลือกพื้นที่ทํางานของคุณในการนําทางด้านซ้าย
  2. ค้นหาและเลือกชื่อการทดสอบ - ในกรณีนี้ sample_aisample-textclassification

ภาพหน้าจอ ของการทดลอง

ขั้นตอนที่ 5: ให้คะแนนและบันทึกผลลัพธ์การคาดการณ์

Microsoft Fabric ช่วยให้ผู้ใช้สามารถดําเนินการแบบจําลองการเรียนรู้ของเครื่องด้วยฟังก์ชันที่ปรับขนาดได้PREDICT ฟังก์ชันนี้สนับสนุนการให้คะแนนแบบกลุ่ม (หรือการอนุมานชุด) ในกลไกการคํานวณใดก็ตาม คุณสามารถสร้างการคาดการณ์ชุดงานได้โดยตรงจากสมุดบันทึกหรือจากหน้ารายการสําหรับแบบจําลองเฉพาะ สําหรับข้อมูลเพิ่มเติมเกี่ยวกับฟังก์ชันและวิธีการใช้งานใน Fabric โปรดไปที่การให้คะแนนแบบจําลองการเรียนรู้ของPREDICTเครื่องด้วย PREDICT ใน Microsoft Fabric

จากผลการประเมินของเรา แบบจําลอง 1 มีเมตริกที่ใหญ่ที่สุดสําหรับทั้งพื้นที่ภายใต้เส้นโค้ง Precision-Recall (AUPRC) และสําหรับพื้นที่ภายใต้ลักษณะการใช้งานของตัวรับเส้นโค้ง (AUC-ROC) ดังนั้น คุณควรใช้แบบจําลอง 1 สําหรับการคาดการณ์

หน่วยวัด AUC-ROC มีการใช้กันอย่างแพร่หลายในการวัดประสิทธิภาพของตัวจัดประเภทไบนารี อย่างไรก็ตาม บางครั้งมีความเหมาะสมมากขึ้นในการประเมินตัวจําแนกประเภทตามการวัด AUPRC แผนภูมิ AUC-ROC แสดงภาพการแลกเปลี่ยนระหว่างอัตราบวกจริง (TPR) และอัตราบวกเท็จ (FPR) เส้นโค้ง AUPRC จะรวมทั้งความแม่นยํา (ค่าการคาดการณ์เชิงบวกหรือ PPV) และการเรียกใช้ (อัตราบวกจริงหรือ TPR) ในการแสดงผลข้อมูลด้วยภาพเดียว ส่วนย่อยของโค้ดต่อไปนี้ครอบคลุมขั้นตอนเหล่านี้:

# 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.")

เนื้อหาที่เกี่ยวข้อง

  • แบบจําลองการเรียนรู้ของเครื่อง ใน Microsoft Fabric
  • แบบจําลองการเรียนรู้ของเครื่อง Train
  • การทดลองการเรียนรู้ของเครื่อง ใน Microsoft Fabric