การให้คะแนนแบบจําลองการเรียนรู้ของเครื่องด้วย PREDICT ใน Microsoft Fabric

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

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

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

• รับการสมัครใช้งาน Microsoft Fabric หรือลงทะเบียนเพื่อทดลองใช้งาน Microsoft Fabric ฟรี

• ลงชื่อเข้าใช้ Microsoft Fabric

• ใช้ตัวสลับประสบการณ์ทางด้านซ้ายของโฮมเพจของคุณเพื่อสลับไปยังประสบการณ์วิทยาศาสตร์ข้อมูล Synapse

  

ข้อจำกัด

• ในขณะนี้ฟังก์ชัน PREDICT ได้รับการสนับสนุนสําหรับชุดที่จํากัดของรสชาติแบบจําลอง ML นี้:
  • CatBoost
  • Keras
  • LightGBM
  • ONNX
  • ศาสดา
  • PyTorch
  • Sklearn
  • Spark
  • Statsmodels
  • TensorFlow
  • XGBoost
• PREDICT จําเป็นต้อง ให้คุณบันทึกแบบจําลอง ML ในรูปแบบ MLflow ด้วยลายเซ็นที่เติม
• PREDICT ไม่สนับสนุน แบบจําลอง ML ที่มีอินพุตหรือเอาต์พุตหลายเทนเนอร์

เรียกการคาดการณ์จากสมุดบันทึก

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

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

   import mlflow
   import numpy as np 
   from sklearn.linear_model import LogisticRegression 
   from sklearn.datasets import load_diabetes
   from mlflow.models.signature import infer_signature 
   
   mlflow.set_experiment("diabetes-demo")
   with mlflow.start_run() as run:
       lr = LogisticRegression()
       data = load_diabetes(as_frame=True)
       lr.fit(data.data, data.target) 
       signature = infer_signature(data.data, data.target) 
   
       mlflow.sklearn.log_model(
           lr,
           "diabetes-model",
           signature=signature,
           registered_model_name="diabetes-model"
       ) 
   

2. โหลดในข้อมูลทดสอบเป็น Spark DataFrame หากต้องการสร้างการคาดการณ์แบบกลุ่มด้วยรูปแบบ ML ที่ได้รับการฝึกในขั้นตอนก่อนหน้านี้ คุณจําเป็นต้องทดสอบข้อมูลในรูปแบบของ Spark DataFrame ในโค้ดต่อไปนี้ ให้ test แทนที่ค่าตัวแปรด้วยข้อมูลของคุณเอง

   # You can substitute "test" below with your own data
   test = spark.createDataFrame(data.frame.drop(['target'], axis=1))
   

3. MLFlowTransformerสร้างวัตถุเพื่อโหลดแบบจําลอง ML สําหรับการอนุมาน หากต้องการสร้าง MLFlowTransformer วัตถุเพื่อสร้างการคาดการณ์ชุดงาน คุณต้องดําเนินการเหล่านี้:

   • ระบุ test คอลัมน์ DataFrame ที่คุณต้องการเป็นข้อมูลป้อนเข้าแบบจําลอง (ในกรณีนี้ทั้งหมด)
   • เลือกชื่อสําหรับคอลัมน์ผลลัพธ์ใหม่ (ในกรณีนี้คือ predictions)
   • ระบุชื่อแบบจําลองที่ถูกต้องและรุ่นแบบจําลองสําหรับการสร้างการคาดการณ์เหล่านั้น

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

   from synapse.ml.predict import MLFlowTransformer
   
   # You can substitute values below for your own input columns,
   # output column name, model name, and model version
   model = MLFlowTransformer(
       inputCols=test.columns,
       outputCol='predictions',
       modelName='diabetes-model',
       modelVersion=1
   )
   

4. สร้างการคาดการณ์โดยใช้ฟังก์ชัน PREDICT หากต้องการเรียกใช้ฟังก์ชัน PREDICT ให้ใช้ Transformer API, Spark SQL API หรือฟังก์ชันที่ผู้ใช้กําหนดเองแบบ PySpark (UDF) ส่วนต่อไปนี้แสดงวิธีการสร้างการคาดการณ์ชุดงานด้วยข้อมูลทดสอบและแบบจําลอง ML ที่กําหนดไว้ในขั้นตอนก่อนหน้านี้โดยใช้วิธีการที่แตกต่างกันเพื่อเรียกใช้ฟังก์ชัน PREDICT

คาดการณ์ด้วย API ตัวแปลง

โค้ดนี้เรียกใช้ฟังก์ชัน PREDICT ด้วย Transformer API ถ้าคุณใช้แบบจําลอง ML ของคุณเอง ให้แทนที่ค่าสําหรับแบบจําลองและทดสอบข้อมูล

# You can substitute "model" and "test" below with values  
# for your own model and test data 
model.transform(test).show()

คาดการณ์ด้วย Spark SQL API

โค้ดนี้จะเรียกใช้ฟังก์ชัน PREDICT ด้วย Spark SQL API ถ้าคุณใช้แบบจําลอง ML ของคุณเอง ให้แทนที่ค่าสําหรับ model_namemodel_version, และ features ด้วยชื่อแบบจําลอง รุ่นแบบจําลอง และคอลัมน์คุณลักษณะของคุณ

หมายเหตุ

การใช้ Spark SQL API สําหรับการสร้างการคาดการณ์ยังต้องสร้าง MLFlowTransformer ออบเจ็กต์ (ดังที่แสดงในขั้นตอนที่ 3)

from pyspark.ml.feature import SQLTransformer 

# You can substitute "model_name," "model_version," and "features" 
# with values for your own model name, model version, and feature columns
model_name = 'diabetes-model'
model_version = 1
features = test.columns

sqlt = SQLTransformer().setStatement( 
    f"SELECT PREDICT('{model_name}/{model_version}', {','.join(features)}) as predictions FROM __THIS__")

# You can substitute "test" below with your own test data
sqlt.transform(test).show()

ทํานายด้วยฟังก์ชันที่ผู้ใช้กําหนดเอง

โค้ดนี้จะเรียกใช้ฟังก์ชัน PREDICT ด้วย PySpark UDF ถ้าคุณใช้แบบจําลอง ML ของคุณเอง ให้แทนที่ค่าสําหรับแบบจําลองและคุณลักษณะ

from pyspark.sql.functions import col, pandas_udf, udf, lit

# You can substitute "model" and "features" below with your own values
my_udf = model.to_udf()
features = test.columns

test.withColumn("PREDICT", my_udf(*[col(f) for f in features])).show()

สร้างรหัสคาดการณ์จากหน้ารายการของแบบจําลอง ML

จากหน้าหน่วยข้อมูลของแบบจําลอง ML ใด ๆ คุณสามารถเลือกหนึ่งในตัวเลือกเหล่านี้เพื่อเริ่มการสร้างการคาดการณ์ชุดงานสําหรับเวอร์ชันแบบจําลองเฉพาะด้วยฟังก์ชัน PREDICT:

• คัดลอกเทมเพลตโค้ดลงในสมุดบันทึก และกําหนดค่าพารามิเตอร์ด้วยตนเอง
• ใช้ประสบการณ์ UI ที่แนะนําเพื่อสร้างรหัสการคาดการณ์

ใช้ประสบการณ์ UI ที่แนะนํา

ประสบการณ์ UI ที่แนะนําจะแนะนําคุณผ่านขั้นตอนเหล่านี้:

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

เพื่อใช้ประสบการณ์ที่มีผู้แนะแนวทาง

1. นําทางไปยังหน้ารายการสําหรับเวอร์ชันแบบจําลอง ML ที่กําหนด

2. จากรายการดรอปดาวน์ ใช้เวอร์ชันนี้ ให้เลือก ใช้แบบจําลองนี้ในตัวช่วยสร้าง

   

   ในขั้นตอน "เลือกตารางอินพุต" หน้าต่าง "ใช้การคาดการณ์แบบจําลอง ML" จะเปิดขึ้น

3. เลือกตารางอินพุตจากเลคเฮ้าส์ในพื้นที่ทํางานปัจจุบันของคุณ

   

4. เลือก ถัดไป เพื่อไปที่ขั้นตอน "แมปคอลัมน์อินพุต"

5. แมปชื่อคอลัมน์จากตารางต้นทางไปยังเขตข้อมูลอินพุตของแบบจําลอง ML ซึ่งดึงมาจากลายเซ็นของแบบจําลอง คุณต้องระบุคอลัมน์อินพุตสําหรับเขตข้อมูลที่จําเป็นทั้งหมดของแบบจําลอง นอกจากนี้ ชนิดข้อมูลของคอลัมน์ต้นทางจะต้องตรงกับชนิดข้อมูลที่คาดหวังไว้ของแบบจําลอง

   เคล็ดลับ

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

   

6. เลือก ถัดไป เพื่อไปที่ขั้นตอน "สร้างตารางผลลัพธ์"

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

   

8. เลือก ถัดไป เพื่อไปที่ขั้นตอน "แมปคอลัมน์ผลลัพธ์"

9. ใช้เขตข้อมูลข้อความที่ระบุเพื่อตั้งชื่อคอลัมน์ของตารางผลลัพธ์ที่จัดเก็บการคาดการณ์แบบจําลอง ML

   

10. เลือก ถัดไป เพื่อไปขั้นตอน "กําหนดค่าสมุดบันทึก"

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

    

12. เลือก ถัดไป เพื่อไปที่ขั้นตอน "ตรวจสอบและเสร็จสิ้น"

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

    

ใช้เทมเพลตโค้ดที่สามารถกําหนดเองได้

หากต้องการใช้เทมเพลตโค้ดสําหรับการสร้างการคาดการณ์ชุดงาน:

1. ไปที่หน้ารายการสําหรับเวอร์ชันแบบจําลอง ML ที่กําหนด
2. เลือก คัดลอกรหัสที่จะใช้ จาก ดรอปดาวน์ใช้เวอร์ชัน นี้ การเลือกจะช่วยให้คุณสามารถคัดลอกเทมเพลตโค้ดที่ปรับแต่งได้

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

• <INPUT_TABLE>: เส้นทางไฟล์สําหรับตารางที่มีการป้อนข้อมูลเข้าไปยังแบบจําลอง ML
• <INPUT_COLS>: อาร์เรย์ของชื่อคอลัมน์จากตารางอินพุตเพื่อป้อนค่าไปยังแบบจําลอง ML
• <OUTPUT_COLS>: ชื่อสําหรับคอลัมน์ใหม่ในตารางผลลัพธ์ที่จัดเก็บการคาดการณ์
• <MODEL_NAME>: ชื่อของแบบจําลอง ML ที่จะใช้สําหรับการสร้างการคาดการณ์
• <MODEL_VERSION>: เวอร์ชันของแบบจําลอง ML ที่จะใช้สําหรับการสร้างการคาดการณ์
• <OUTPUT_TABLE>: เส้นทางไฟล์สําหรับตารางที่จัดเก็บการคาดการณ์

import mlflow 
from synapse.ml.predict import MLFlowTransformer 
 
df = spark.read.format("delta").load( 
    <INPUT_TABLE> # Your input table filepath here
) 
 
model = MLFlowTransformer( 
    inputCols=<INPUT_COLS>, # Your input columns here
    outputCol=<OUTPUT_COLS>, # Your new column name here
    modelName=<MODEL_NAME>, # Your ML model name here
    modelVersion=<MODEL_VERSION> # Your ML model version here
) 
df = model.transform(df) 
 
df.write.format('delta').mode("overwrite").save( 
    <OUTPUT_TABLE> # Your output table filepath here
)  

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

• ตัวอย่างการคาดการณ์แบบครบวงจรโดยใช้แบบจําลองการตรวจจับการฉ้อโกง
• วิธีการฝึกแบบจําลอง ML ด้วย scikit-learn ใน Microsoft Fabric