แชร์ผ่าน

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

  • บทความ

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

สําหรับแบบจําลองการจัดประเภท ให้ใช้ไลบรารี 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.blob.core.windows.net/public/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 ดู Autologging ใน Microsoft Fabric

# Set up Mlflow for experiment tracking

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

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

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

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

แยกย่อหน้าและประโยคออกเป็นหน่วยขนาดเล็กลงเพื่อทําโทเค็นชุดข้อมูล ด้วยวิธีนี้ จึงเป็นเรื่องง่ายที่จะกําหนดความหมาย จากนั้นลบ stopwords เพื่อปรับปรุงประสิทธิภาพการทํางาน การลบ 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 เพื่อทําให้ข้อความเป็นเวกเตอร์ เทคนิค word2vec สร้างการแสดงเวกเตอร์ของแต่ละคําในข้อความ คําที่ใช้ในบริบทที่คล้ายกันหรือที่มีความสัมพันธ์เชิงความหมายถูกจับภาพได้อย่างมีประสิทธิภาพผ่านความใกล้ชิดในพื้นที่เวกเตอร์ ความใกล้ชิดนี้แสดงให้เห็นว่าคําที่คล้ายกันมีเวกเตอร์คําที่คล้ายกัน

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