บทช่วยสอน: สร้าง ประเมิน และให้คะแนนแบบจําลองการตรวจหาการฉ้อโกง
บทช่วยสอนนี้แสดงตัวอย่างแบบ end-to-end ของเวิร์กโฟลว์ Synapse Data Science ใน Microsoft Fabric สถานการณ์ดังกล่าวสร้างแบบจําลองการตรวจจับการฉ้อฉลด้วยอัลกอริทึมการเรียนรู้ของเครื่องที่ได้รับการฝึกฝนเกี่ยวกับข้อมูลในอดีต จากนั้นใช้แบบจําลองเพื่อตรวจหาธุรกรรมการฉ้อโกงในอนาคต
บทช่วยสอนนี้ครอบคลุมขั้นตอนเหล่านี้:
- ติดตั้งไลบรารีแบบกําหนดเอง
- โหลดข้อมูล
- ทําความเข้าใจและประมวลผลข้อมูลผ่านการวิเคราะห์ข้อมูลเชิงสํารวจ
- ใช้ scikit-learn เพื่อฝึกแบบจําลองการเรียนรู้ของเครื่องและติดตามการทดลองด้วยฟีเจอร์ MLflow และ Fabric Autologging
- บันทึกและลงทะเบียนแบบจําลองการเรียนรู้ของเครื่องที่มีประสิทธิภาพสูงสุด
- โหลดแบบจําลองการเรียนรู้ของเครื่องสําหรับการให้คะแนนและทําการคาดการณ์
ข้อกำหนดเบื้องต้น
รับการสมัครใช้งาน Microsoft Fabric หรือลงทะเบียนเพื่อทดลองใช้งาน Microsoft Fabric ฟรี
ลงชื่อเข้าใช้ Microsoft Fabric
ใช้ตัวสลับประสบการณ์ทางด้านซ้ายของโฮมเพจของคุณเพื่อสลับไปยังประสบการณ์วิทยาศาสตร์ข้อมูล Synapse
- หากจําเป็น ให้สร้าง Microsoft Fabric lakehouse ตามที่อธิบายไว้ใน สร้างเลคเฮ้าส์ใน Microsoft Fabric
ติดตามในสมุดบันทึก
คุณสามารถเลือกหนึ่งในตัวเลือกเหล่านี้เพื่อติดตามในสมุดบันทึกได้:
- เปิดและเรียกใช้สมุดบันทึกที่มีอยู่ภายในในประสบการณ์วิทยาศาสตร์ข้อมูล
- อัปโหลดสมุดบันทึกของคุณจาก GitHub ไปยังประสบการณ์ด้านวิทยาศาสตร์ข้อมูล
เปิดสมุดบันทึกที่มีอยู่แล้วภายใน
สมุดบันทึกการตรวจจับการฉ้อฉลตัวอย่างจะมาพร้อมกับบทช่วยสอนนี้
เมื่อต้องการเปิดสมุดบันทึกตัวอย่างที่มีอยู่แล้วภายในของบทช่วยสอนในประสบการณ์ Synapse Data Science:
ไปที่หน้าแรกของ Synapse Data Science
เลือก ใช้ตัวอย่าง
เลือกตัวอย่างที่สอดคล้องกัน:
- จากแท็บ เวิร์กโฟลว์แบบ End-to-end (Python) ตามค่าเริ่มต้น ถ้าตัวอย่างมีไว้สําหรับบทช่วยสอน Python
- จากแท็บ เวิร์กโฟลว์แบบครอบคลุม (R) ถ้าตัวอย่างมีไว้สําหรับบทช่วยสอน R
- จากแท็บ บทช่วยสอน ด่วน ถ้าตัวอย่างมีไว้สําหรับบทช่วยสอนด่วน
แนบเลคเฮ้าส์ลงในสมุดบันทึก ก่อนที่คุณจะเริ่มเรียกใช้โค้ด
นําเข้าสมุดบันทึกจาก GitHub
AIsample - การตรวจหาการฉ้อโกง สมุดบันทึก ipynb มาพร้อมกับบทช่วยสอนนี้
เมื่อต้องการเปิดสมุดบันทึกที่มาพร้อมกับบทช่วยสอนนี้ ให้ทําตามคําแนะนําใน เตรียมระบบของคุณสําหรับบทช่วยสอนวิทยาศาสตร์ข้อมูล เพื่อนําเข้าสมุดบันทึกไปยังพื้นที่ทํางานของคุณ
ถ้าคุณต้องการคัดลอกและวางรหัสจากหน้านี้แทน คุณสามารถสร้าง สมุดบันทึกใหม่ได้
ตรวจสอบให้แน่ใจว่าแนบ lakehouse เข้ากับสมุดบันทึก ก่อนที่คุณจะเริ่มเรียกใช้รหัส
ขั้นตอนที่ 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 แปลงคุณลักษณะทั้งหมดยกเว้นและTimeAmount เพื่อปกป้องความลับ เราไม่สามารถให้คุณลักษณะดั้งเดิมหรือข้อมูลเบื้องหลังเพิ่มเติมเกี่ยวกับชุดข้อมูลได้
รายละเอียดเหล่านี้อธิบายชุดข้อมูล:
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 เพื่อให้ง่ายต่อการแสดงภาพ สุดท้าย คุณสํารวจและแสดงภาพการกระจายคลาสในข้อมูล
แสดงข้อมูลดิบ
สํารวจข้อมูลดิบและดูสถิติระดับสูงด้วย
displayคําสั่ง สําหรับข้อมูลเพิ่มเติมเกี่ยวกับการแสดงภาพข้อมูล ดูการแสดงภาพของสมุดบันทึกใน Microsoft Fabricdisplay(df)พิมพ์ข้อมูลพื้นฐานบางอย่างเกี่ยวกับชุดข้อมูล:
# Print dataset basic information print("records read: " + str(df.count())) print("Schema: ") df.printSchema()
แปลงข้อมูล
แคสต์คอลัมน์ชุดข้อมูลลงในประเภทที่ถูกต้อง:
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)แปลง Spark DataFrame เป็น pandas DataFrame เพื่อให้ง่ายต่อการแสดงภาพและการประมวลผล:
df_pd = df.toPandas()
สํารวจการแจกแจงคลาสในชุดข้อมูล
แสดงการกระจายคลาสในชุดข้อมูล:
# 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การแจกแจงคลาสนี้แสดงว่าธุรกรรมส่วนใหญ่ไม่มีการป้องกัน ดังนั้น จําเป็นต้องมีการประมวลผลข้อมูลล่วงหน้าก่อนการฝึกแบบจําลองเพื่อหลีกเลี่ยงการมากเกินไปใช้การลงจุดเพื่อแสดงความไม่สมดุลของคลาสในชุดข้อมูล โดยการดูการกระจายของการฉ้อโกงเทียบกับธุรกรรมที่ไม่น่าเชื่อถือ:
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)แสดงข้อมูลสรุปแบบห้าตัวเลข (คะแนนต่ําสุด ควอร์ไทล์ แรก ค่ามัธยฐาน ควอร์ไทล์ที่สาม และคะแนนสูงสุด) สําหรับจํานวนธุรกรรม พร้อมกับการลงจุดกล่อง:
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 และไลบรารีแหล่งข้อมูลแบบเปิดอื่นๆ สําหรับข้อมูลเพิ่มเติม โปรดดูแบบจําลองการเรียนรู้ของเครื่องใน Microsoft Fabric
การ ทดลอง การเรียนรู้ของเครื่องทําหน้าที่เป็นหน่วยหลักขององค์กรและควบคุมการเรียกใช้การเรียนรู้ของเครื่องที่เกี่ยวข้องทั้งหมด การ เรียกใช้ สอดคล้องกับการดําเนินการเดียวของรหัสแบบจําลอง การติดตามการทดลองการเรียนรู้ของเครื่องเกี่ยวข้องกับการจัดการการทดลองและส่วนประกอบทั้งหมด เช่น พารามิเตอร์ เมตริก แบบจําลอง และวัตถุอื่น ๆ
สําหรับการติดตามการทดลอง คุณสามารถจัดระเบียบคอมโพเนนต์ที่จําเป็นทั้งหมดของการทดสอบการเรียนรู้ของเครื่องเฉพาะได้ นอกจากนี้ คุณสามารถสร้างผลลัพธ์ในอดีตซ้ําได้อย่างง่ายดายด้วยการทดสอบที่บันทึกไว้ สําหรับข้อมูลเพิ่มเติมเกี่ยวกับการทดสอบการเรียนรู้ของเครื่อง โปรดดูการทดลองการเรียนรู้ของเครื่องใน Microsoft Fabric
เพื่อติดตามเมตริก พารามิเตอร์ และไฟล์เพิ่มเติม ตั้งค่า
exclusive=Falseเพื่ออัปเดตการกําหนดค่าการล็อกโดยอัตโนมัติของ MLflow:mlflow.autolog(exclusive=False)ฝึกแบบจําลองสองแบบด้วย 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), ], )
กําหนดความสําคัญของคุณลักษณะสําหรับการฝึกอบรม
กําหนดความสําคัญของคุณลักษณะสําหรับแบบจําลองที่คุณฝึกบนชุดข้อมูลที่ไม่สมดุล:
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")กําหนดความสําคัญของคุณลักษณะสําหรับแบบจําลองที่คุณฝึกฝนบนข้อมูลที่สมดุล 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ได้รับการฝึกฝนบนข้อมูลที่สมดุล
คํานวณเมตริกแบบจําลอง
prediction_to_sparkกําหนดฟังก์ชันที่ทํานายและแปลงผลลัพธ์การคาดการณ์เป็น Spark DataFrame จากนั้นคุณสามารถคํานวณสถิติแบบจําลองบนผลลัพธ์การคาดการณ์ด้วย SynapseMLfrom 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 predictionsprediction_to_sparkใช้ฟังก์ชัน เพื่อทําการคาดการณ์ด้วยสองแบบจําลอง และmodelsmote_model:predictions = prediction_to_spark(model, test) smote_predictions = prediction_to_spark(smote_model, test) predictions.limit(10).toPandas()คํานวณเมตริกสําหรับสองแบบจําลอง:
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 คือจํานวนคลาส
ใช้เมทริกซ์ความสับสนเพื่อสรุปประสิทธิภาพของแบบจําลองการเรียนรู้ของเครื่องที่ได้รับการฝึกบนข้อมูลทดสอบ:
# 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)ลงจุดเมทริกซ์ความสับสนสําหรับการทํานายของ
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")ลงจุดเมทริกซ์ความสับสนสําหรับการทํานายของ
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)
ในบางกรณี มีความเหมาะสมในการประเมินตัวจําแนกประเภทของคุณตามพื้นที่ภายใต้หน่วยวัดเส้นโค้งการเรียกคืนความแม่นยํา (AUPRC) เส้นโค้ง AUPRC จะรวมอัตราเหล่านี้:
- ความแม่นยําหรือค่าการคาดการณ์เชิงบวก (PPV)
- ค่าความระลึกหรือ TPR
เพื่อประเมินประสิทธิภาพด้วยหน่วยวัด AUC-ROC และ AUPRC:
กําหนดฟังก์ชันที่ส่งกลับหน่วยวัด 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บันทึกเมตริก 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})บันทึกเมตริก 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
โหลดแบบจําลองที่มีประสิทธิภาพดีขึ้น (เวอร์ชัน 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)บันทึกการคาดการณ์ไปยังเลคเฮ้าส์:
# Save the predictions to the lakehouse batch_predictions.write.format("delta").mode("overwrite").save(f"{DATA_FOLDER}/predictions/batch_predictions")
เนื้อหาที่เกี่ยวข้อง
คำติชม
เร็วๆ นี้: ตลอดปี 2024 เราจะขจัดปัญหา GitHub เพื่อเป็นกลไกคำติชมสำหรับเนื้อหา และแทนที่ด้วยระบบคำติชมใหม่ สำหรับข้อมูลเพิ่มเติม ให้ดู: https://aka.ms/ContentUserFeedback
ส่งและดูข้อคิดเห็นสำหรับ