แชร์ผ่าน

บทช่วยสอน: สร้าง ประเมิน และให้คะแนนแบบจําลองการตรวจหาการฉ้อโกง

  • บทความ

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

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

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

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

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

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

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

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

ตัวอย่างการตรวจหา ฉ้อฉล สมุดบันทึกมาพร้อมกับบทช่วยสอนนี้

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

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

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

AIsample - Detection.ipynb notebook มาพร้อมกับบทช่วยสอนนี้

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

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

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

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

โน้ต

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

# Use pip to install imblearn
%pip install imblearn

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

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

รายละเอียดเหล่านี้อธิบายชุดข้อมูล:

  • คุณลักษณะ V1, V2, V3, ... V28 เป็นส่วนประกอบหลักที่ได้จาก PCA
  • คุณลักษณะ Time ประกอบด้วยวินาทีที่ผ่านไประหว่างธุรกรรมและธุรกรรมแรกในชุดข้อมูล
  • ลักษณะการทํางาน Amount คือยอดเงินธุรกรรม คุณสามารถใช้คุณลักษณะนี้สําหรับการเรียนรู้ที่ขึ้นอยู่กับตัวอย่าง และมีความไวต่อค่าใช้จ่าย
  • คอลัมน์ Class คือตัวแปรการตอบสนอง (เป้าหมาย) มี 1 ค่าสําหรับการฉ้อโกงและ 0 ถ้าเป็นอย่างอื่น

เพียง 492 รายการ จากธุรกรรมทั้งหมด 284,807 รายการ ชุดข้อมูลมีความไม่สมดุลอย่างมาก เนื่องจากบัญชีของชั้นน้อย (ฉ้อฉล) มีเพียงประมาณ 0.172% ของข้อมูลเท่านั้น

ตารางนี้แสดงตัวอย่างของข้อมูล creditcard.csv:

เวลา V1 V2 V3 V4 V5 V6 V7 V8 V9 V10 V11 V12 V13 V14 V15 V16 V17 V18 V19 V20 V21 V22 V23 V24 V25 V26 V27 V28 ปริมาณ ประเภท
0 -1.3598071336738 -0.0727811733098497 2.53634673796914 1.37815522427443 -0.338320769942518 0.462387777762292 0.239598554061257 0.0986979012610507 0.363786969611213 0.0907941719789316 -0.551599533260813 -0.617800855762348 -0.991389847235408 -0.311169353699879 1.46817697209427 -0.470400525259478 0.207971241929242 0.0257905801985591 0.403992960255733 0.251412098239705 -0.018306777944153 0.277837575558899 -0.110473910188767 0.0669280749146731 0.128539358273528 -0.189114843888824 0.133558376740387 -0.0210530534538215 149.62 "0"
0 1.19185711131486 0.26615071205963 0.16648011335321 0.448154078460911 0.0600176492822243 -0.0823608088155687 -0.0788029833323113 0.0851016549148104 -0.255425128109186 -0.166974414004614 1.61272666105479 1.06523531137287 0.48909501589608 -0.143772296441519 0.635558093258208 0.463917041022171 -0.114804663102346 -0.183361270123994 -0.145783041325259 -0.0690831352230203 -0.225775248033138 -0.638671952771851 0.101288021253234 -0.339846475529127 0.167170404418143 0.125894532368176 -0.00898309914322813 0.0147241691924927 2.69 "0"

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

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

IS_CUSTOM_DATA = False  # If True, the dataset has to be uploaded manually

TARGET_COL = "Class"  # Target column name
IS_SAMPLE = False  # If True, use only <SAMPLE_ROWS> rows of data for training; otherwise, use all data
SAMPLE_ROWS = 5000  # If IS_SAMPLE is True, use only this number of rows for training

DATA_FOLDER = "Files/fraud-detection/"  # Folder with data files
DATA_FILE = "creditcard.csv"  # Data file name

EXPERIMENT_NAME = "aisample-fraud"  # MLflow experiment name

รหัสนี้จะดาวน์โหลดเวอร์ชันสาธารณะของชุดข้อมูล และจากนั้นเก็บไว้ใน Fabric lakehouse

สําคัญ

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

if not IS_CUSTOM_DATA:
    # Download data files into the lakehouse if they're not already there
    import os, requests

    remote_url = "https://synapseaisolutionsa.blob.core.windows.net/public/Credit_Card_Fraud_Detection"
    fname = "creditcard.csv"
    download_path = f"/lakehouse/default/{DATA_FOLDER}/raw"

    if not os.path.exists("/lakehouse/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.")

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

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

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

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

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

# Set up MLflow for experiment tracking
import mlflow

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

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

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

df = (
    spark.read.format("csv")
    .option("header", "true")
    .option("inferSchema", True)
    .load(f"{DATA_FOLDER}/raw/{DATA_FILE}")
    .cache()
)

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

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

แสดงข้อมูลดิบ

  1. สํารวจข้อมูลดิบและดูสถิติระดับสูงด้วยคําสั่ง display สําหรับข้อมูลเพิ่มเติมเกี่ยวกับการแสดงภาพข้อมูล ดูการแสดงภาพของ Notebook ใน Microsoft Fabric

    display(df)

  2. พิมพ์ข้อมูลพื้นฐานบางอย่างเกี่ยวกับชุดข้อมูล:

    # Print dataset basic information
print("records read: " + str(df.count()))
print("Schema: ")
df.printSchema()

แปลงข้อมูล

  1. แคสต์คอลัมน์ชุดข้อมูลลงในประเภทที่ถูกต้อง:

    import pyspark.sql.functions as F

df_columns = df.columns
df_columns.remove(TARGET_COL)

# Ensure that TARGET_COL is the last column
df = df.select(df_columns + [TARGET_COL]).withColumn(TARGET_COL, F.col(TARGET_COL).cast("int"))

if IS_SAMPLE:
    df = df.limit(SAMPLE_ROWS)

  2. แปลง Spark DataFrame เป็น pandas DataFrame เพื่อให้ง่ายต่อการแสดงภาพและการประมวลผล:

    df_pd = df.toPandas()

สํารวจการแจกแจงคลาสในชุดข้อมูล

  1. แสดงการกระจายคลาสในชุดข้อมูล:

    # The distribution of classes in the dataset
print('No Frauds', round(df_pd['Class'].value_counts()[0]/len(df_pd) * 100,2), '% of the dataset')
print('Frauds', round(df_pd['Class'].value_counts()[1]/len(df_pd) * 100,2), '% of the dataset')

    รหัสจะส่งกลับการแจกแจงคลาสชุดข้อมูลนี้: 99.83% No Frauds และ 0.17% Frauds การแจกแจงคลาสนี้แสดงว่าธุรกรรมส่วนใหญ่ไม่มีการป้องกัน ดังนั้น จําเป็นต้องมีการประมวลผลข้อมูลล่วงหน้าก่อนการฝึกแบบจําลองเพื่อหลีกเลี่ยงการมากเกินไป

  2. ใช้การลงจุดเพื่อแสดงความไม่สมดุลของคลาสในชุดข้อมูล โดยการดูการกระจายของการฉ้อโกงเทียบกับธุรกรรมที่ไม่น่าเชื่อถือ:

    import seaborn as sns
import matplotlib.pyplot as plt

colors = ["#0101DF", "#DF0101"]
sns.countplot(x='Class', data=df_pd, palette=colors) 
plt.title('Class Distributions \n (0: No Fraud || 1: Fraud)', fontsize=10)

  3. แสดงข้อมูลสรุปแบบห้าตัวเลข (คะแนนต่ําสุด ควอร์ไทล์ แรก ค่ามัธยฐาน ควอร์ไทล์ที่สาม และคะแนนสูงสุด) สําหรับจํานวนธุรกรรม พร้อมกับการลงจุดกล่อง:

    fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(12,5))
s = sns.boxplot(ax = ax1, x="Class", y="Amount", hue="Class",data=df_pd, palette="PRGn", showfliers=True) # Remove outliers from the plot
s = sns.boxplot(ax = ax2, x="Class", y="Amount", hue="Class",data=df_pd, palette="PRGn", showfliers=False) # Keep outliers from the plot
plt.show()

    สําหรับข้อมูลที่ไม่สมดุลสูง แผนภูมิบ็อกซ์อาจไม่แสดงข้อมูลเชิงลึกที่ถูกต้อง อย่างไรก็ตาม คุณสามารถจัดการปัญหาความไม่สมดุลของ Class ก่อน จากนั้นสร้างพล็อตเดียวกันสําหรับข้อมูลเชิงลึกที่ถูกต้องยิ่งขึ้น

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

ที่นี่คุณฝึกแบบจําลอง LightGBM เพื่อจัดประเภทธุรกรรมการฉ้อโกง คุณฝึกแบบจําลอง LightGBM บนทั้งชุดข้อมูลที่ไม่สมดุลและชุดข้อมูลที่สมดุล จากนั้น คุณเปรียบเทียบประสิทธิภาพของทั้งสองแบบจําลอง

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

ก่อนการทดสอบการใช้งาน ให้แยกข้อมูลลงในชุดข้อมูลการฝึกอบรมและการทดสอบ:

# Split the dataset into training and testing sets
from sklearn.model_selection import train_test_split

train, test = train_test_split(df_pd, test_size=0.15)
feature_cols = [c for c in df_pd.columns.tolist() if c not in [TARGET_COL]]

นํา SMOTE ไปใช้กับชุดข้อมูลการฝึกอบรม

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

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

# Apply SMOTE to the training data
import pandas as pd
from collections import Counter
from imblearn.over_sampling import SMOTE

X = train[feature_cols]
y = train[TARGET_COL]
print("Original dataset shape %s" % Counter(y))

sm = SMOTE(random_state=42)
X_res, y_res = sm.fit_resample(X, y)
print("Resampled dataset shape %s" % Counter(y_res))

new_train = pd.concat([X_res, y_res], axis=1)

สําหรับข้อมูลเพิ่มเติมเกี่ยวกับ SMOTE ให้ดูหน้าการอ้างอิง scikit-learn สําหรับเมธอด SMOTE และคู่มือผู้ใช้ scikit-learn เกี่ยวกับการสุ่มตัวอย่างทรัพยากร มากเกินไป

ฝึกแบบจําลองการเรียนรู้ของเครื่องและเรียกใช้การทดลอง

Apache Spark ใน Microsoft Fabric ช่วยให้เครื่องสามารถเรียนรู้ด้วยข้อมูลขนาดใหญ่ได้ ด้วย Apache Spark คุณจะได้รับข้อมูลเชิงลึกที่มีประโยชน์จากข้อมูลที่มีโครงสร้าง ไม่มีโครงสร้าง และการเคลื่อนไหวที่รวดเร็วจํานวนมาก

คุณมีตัวเลือกมากมายในการฝึกแบบจําลองการเรียนรู้ของเครื่องด้วย Apache Spark ใน Microsoft Fabric: Apache Spark MLlib, SynapseML และไลบรารีแหล่งข้อมูลแบบเปิดอื่นๆ สําหรับข้อมูลเพิ่มเติม โปรดดู แบบจําลองการเรียนรู้ของเครื่อง Train ใน Microsoft Fabric

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

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

  1. เพื่อติดตามเมตริก พารามิเตอร์ และไฟล์เพิ่มเติม ตั้งค่า exclusive=False เพื่ออัปเดตการกําหนดค่าการบันทึกอัตโนมัติ MLflow:

    mlflow.autolog(exclusive=False)

  2. ฝึกแบบจําลองสองแบบด้วย LightGBM แบบจําลองหนึ่งจัดการชุดข้อมูลที่ไม่สมดุล และอีกแบบจําลองหนึ่งจัดการชุดข้อมูลที่สมดุล (ผ่าน SMOTE) จากนั้นเปรียบเทียบประสิทธิภาพของสองแบบจําลอง

    import lightgbm as lgb

model = lgb.LGBMClassifier(objective="binary") # Imbalanced dataset
smote_model = lgb.LGBMClassifier(objective="binary") # Balanced dataset

    # Train LightGBM for both imbalanced and balanced datasets and define the evaluation metrics
print("Start training with imbalanced data:\n")
with mlflow.start_run(run_name="raw_data") as raw_run:
    model = model.fit(
        train[feature_cols],
        train[TARGET_COL],
        eval_set=[(test[feature_cols], test[TARGET_COL])],
        eval_metric="auc",
        callbacks=[
            lgb.log_evaluation(10),
        ],
    )

print(f"\n\nStart training with balanced data:\n")
with mlflow.start_run(run_name="smote_data") as smote_run:
    smote_model = smote_model.fit(
        new_train[feature_cols],
        new_train[TARGET_COL],
        eval_set=[(test[feature_cols], test[TARGET_COL])],
        eval_metric="auc",
        callbacks=[
            lgb.log_evaluation(10),
        ],
    )

กําหนดความสําคัญของคุณลักษณะสําหรับการฝึกอบรม

  1. กําหนดความสําคัญของคุณลักษณะสําหรับแบบจําลองที่คุณฝึกบนชุดข้อมูลที่ไม่สมดุล:

    with mlflow.start_run(run_id=raw_run.info.run_id):
    importance = lgb.plot_importance(
        model, title="Feature importance for imbalanced data"
    )
    importance.figure.savefig("feauture_importance.png")
    mlflow.log_figure(importance.figure, "feature_importance.png")

  2. กําหนดความสําคัญของคุณลักษณะสําหรับแบบจําลองที่คุณฝึกฝนบนข้อมูลที่สมดุล SMOTE สร้างข้อมูลที่สมดุล:

    with mlflow.start_run(run_id=smote_run.info.run_id):
    smote_importance = lgb.plot_importance(
        smote_model, title="Feature importance for balanced (via SMOTE) data"
    )
    smote_importance.figure.savefig("feauture_importance_smote.png")
    mlflow.log_figure(smote_importance.figure, "feauture_importance_smote.png")

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

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

ที่นี่ คุณประเมินแบบจําลองที่ได้รับการฝึกสองแบบ:

  • model ได้รับการฝึกฝนเกี่ยวกับข้อมูลดิบ ที่ไม่สมดุล
  • smote_model ได้รับการฝึกฝนบนข้อมูลที่สมดุล

คํานวณเมตริกแบบจําลอง

  1. กําหนดฟังก์ชัน prediction_to_spark ที่ทําการคาดการณ์ และแปลงผลลัพธ์การคาดการณ์เป็น Spark DataFrame จากนั้นคุณสามารถคํานวณสถิติแบบจําลองบนผลลัพธ์การคาดการณ์ด้วย SynapseMLได้

    from pyspark.sql.functions import col
from pyspark.sql.types import IntegerType, DoubleType

def prediction_to_spark(model, test):
    predictions = model.predict(test[feature_cols], num_iteration=model.best_iteration_)
    predictions = tuple(zip(test[TARGET_COL].tolist(), predictions.tolist()))
    dataColumns = [TARGET_COL, "prediction"]
    predictions = (
        spark.createDataFrame(data=predictions, schema=dataColumns)
        .withColumn(TARGET_COL, col(TARGET_COL).cast(IntegerType()))
        .withColumn("prediction", col("prediction").cast(DoubleType()))
    )

    return predictions

  2. ใช้ฟังก์ชัน prediction_to_spark เพื่อทําการคาดการณ์ด้วยสองแบบจําลอง ได้แก่ model และ smote_model:

    predictions = prediction_to_spark(model, test)
smote_predictions = prediction_to_spark(smote_model, test)
predictions.limit(10).toPandas()

  3. คํานวณเมตริกสําหรับสองแบบจําลอง:

    from synapse.ml.train import ComputeModelStatistics

metrics = ComputeModelStatistics(
    evaluationMetric="classification", labelCol=TARGET_COL, scoredLabelsCol="prediction"
).transform(predictions)

smote_metrics = ComputeModelStatistics(
    evaluationMetric="classification", labelCol=TARGET_COL, scoredLabelsCol="prediction"
).transform(smote_predictions)
display(metrics)

ประเมินประสิทธิภาพของแบบจําลองด้วยเมทริกซ์ความสับสน

เมทริกซ์ความสับสน แสดงจํานวนของ

  • ผลบวกจริง (TP)
  • ผลลบจริง (TN)
  • ผลบวกเท็จ (FP)
  • ผลลบเท็จ (FN)

ที่สร้างแบบจําลองขึ้นเมื่อให้คะแนนด้วยข้อมูลทดสอบ สําหรับการจัดประเภทไบนารี แบบจําลองส่งกลับเมทริกซ์ความสับสน 2x2 สําหรับการจัดประเภทแบบหลายคลาส แบบจําลองจะแสดงเมทริกซ์ความสับสน nxn โดยที่ n คือจํานวนคลาส

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

    # Collect confusion matrix values
cm = metrics.select("confusion_matrix").collect()[0][0].toArray()
smote_cm = smote_metrics.select("confusion_matrix").collect()[0][0].toArray()
print(cm)

  2. ลงจุดเมทริกซ์ความสับสนสําหรับการคาดการณ์ smote_model (ได้รับการฝึกฝนบนข้อมูลที่สมดุล):

    # Plot the confusion matrix
import seaborn as sns

def plot(cm):
    """
    Plot the confusion matrix.
    """
    sns.set(rc={"figure.figsize": (5, 3.5)})
    ax = sns.heatmap(cm, annot=True, fmt=".20g")
    ax.set_title("Confusion Matrix")
    ax.set_xlabel("Predicted label")
    ax.set_ylabel("True label")
    return ax

with mlflow.start_run(run_id=smote_run.info.run_id):
    ax = plot(smote_cm)
    mlflow.log_figure(ax.figure, "ConfusionMatrix.png")

  3. ลงจุดเมทริกซ์ความสับสนสําหรับการคาดการณ์ model (ได้รับการฝึกฝนบนข้อมูลดิบ ที่ไม่สมดุล):

    with mlflow.start_run(run_id=raw_run.info.run_id):
    ax = plot(cm)
    mlflow.log_figure(ax.figure, "ConfusionMatrix.png")

ประเมินประสิทธิภาพของแบบจําลองด้วยหน่วยวัด AUC-ROC และ AUPRC

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

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

  • ความแม่นยําหรือค่าการคาดการณ์เชิงบวก (PPV)
  • ค่าความระลึกหรือ TPR

เพื่อประเมินประสิทธิภาพด้วยหน่วยวัด AUC-ROC และ AUPRC:

  1. กําหนดฟังก์ชันที่ส่งกลับหน่วยวัด AUC-ROC และ AUPRC:

    from pyspark.ml.evaluation import BinaryClassificationEvaluator

def evaluate(predictions):
    """
    Evaluate the model by computing AUROC and AUPRC with the predictions.
    """

    # Initialize the binary evaluator
    evaluator = BinaryClassificationEvaluator(rawPredictionCol="prediction", labelCol=TARGET_COL)

    _evaluator = lambda metric: evaluator.setMetricName(metric).evaluate(predictions)

    # Calculate AUROC, baseline 0.5
    auroc = _evaluator("areaUnderROC")
    print(f"The AUROC is: {auroc:.4f}")

    # Calculate AUPRC, baseline positive rate (0.172% in the data)
    auprc = _evaluator("areaUnderPR")
    print(f"The AUPRC is: {auprc:.4f}")

    return auroc, auprc

  2. บันทึกเมตริก AUC-ROC และ AUPRC สําหรับแบบจําลองที่คุณฝึกบนข้อมูลที่ไม่สมดุล:

    with mlflow.start_run(run_id=raw_run.info.run_id):
    auroc, auprc = evaluate(predictions)
    mlflow.log_metrics({"AUPRC": auprc, "AUROC": auroc})
    mlflow.log_params({"Data_Enhancement": "None", "DATA_FILE": DATA_FILE})

  3. บันทึกเมตริก AUC-ROC และ AUPRC สําหรับแบบจําลองที่คุณฝึกฝนบนข้อมูลที่สมดุล:

    with mlflow.start_run(run_id=smote_run.info.run_id):
    auroc, auprc = evaluate(smote_predictions)
    mlflow.log_metrics({"AUPRC": auprc, "AUROC": auroc})
    mlflow.log_params({"Data_Enhancement": "SMOTE", "DATA_FILE": DATA_FILE})

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

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

สกรีนช็อตของการทดลองที่ถูกติดตาม

รูปภาพนี้แสดงเมตริกประสิทธิภาพการทํางานสําหรับแบบจําลองที่ได้รับการฝึกบนชุดข้อมูลที่สมดุล (ใน เวอร์ชัน 2):

สกรีนช็อตของเมตริกประสิทธิภาพแบบจําลองที่บันทึกไว้และพารามิเตอร์แบบจําลอง

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

ขั้นตอนที่ 5: ลงทะเบียนแบบจําลอง

ใช้ MLflow เพื่อลงทะเบียนทั้งสองแบบจําลอง:

# Register the model
registered_model_name = f"{EXPERIMENT_NAME}-lightgbm"

raw_model_uri = "runs:/{}/model".format(raw_run.info.run_id)
mlflow.register_model(raw_model_uri, registered_model_name)

smote_model_uri = "runs:/{}/model".format(smote_run.info.run_id)
mlflow.register_model(smote_model_uri, registered_model_name)

ขั้นตอนที่ 6: บันทึกผลลัพธ์การคาดการณ์

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

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

  1. โหลดแบบจําลองที่มีประสิทธิภาพดีกว่า (เวอร์ชัน 2) สําหรับการให้คะแนนชุดงานและสร้างผลลัพธ์การคาดการณ์:

    from synapse.ml.predict import MLFlowTransformer

spark.conf.set("spark.synapse.ml.predict.enabled", "true")

model = MLFlowTransformer(
    inputCols=feature_cols,
    outputCol="prediction",
    modelName=f"{EXPERIMENT_NAME}-lightgbm",
    modelVersion=2,
)

test_spark = spark.createDataFrame(data=test, schema=test.columns.to_list())

batch_predictions = model.transform(test_spark)

  2. บันทึกการคาดการณ์ไปยังเลคเฮ้าส์:

    # Save the predictions to the lakehouse
batch_predictions.write.format("delta").mode("overwrite").save(f"{DATA_FOLDER}/predictions/batch_predictions")

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