แชร์ผ่าน

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

  • บทความ

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

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

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

ข้อจำกัด

  • ในขณะนี้ฟังก์ชัน PREDICT ได้รับการสนับสนุนสําหรับชุดที่จํากัดของรสชาติแบบจําลอง ML รวมถึง:
    • PyTorch
    • Sklearn
    • Spark
    • TensorFlow
    • ONNX
    • XGBoost
    • LightGBM
    • CatBoost
    • Statsmodels
    • ศาสดาพยากรณ์
    • Keras
  • 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 ที่กําหนดไว้ในขั้นตอนก่อนหน้านี้โดยใช้วิธีการที่แตกต่างกันสําหรับการเรียกใช้การคาดการณ์

คาดการณ์ด้วย 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 คุณสามารถเลือกหนึ่งในตัวเลือกต่อไปนี้เพื่อเริ่มสร้างการคาดการณ์ชุดงานสําหรับเวอร์ชันแบบจําลองเฉพาะด้วยการคาดการณ์

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

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

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

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

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

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

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

    Screenshot of the prompt to apply an ML model from its item page.

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

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

    Screenshot of the step to select an input table for ML model predictions.

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

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

    เคล็ดลับ

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

    Screenshot of the step to map input columns for ML model predictions.

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

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

    Screenshot of the step to create an output table for ML model predictions.

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

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

    Screenshot of the step to map output columns for ML model predictions.

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

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

    Screenshot of the step to configure a notebook for ML model predictions.

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

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

    Screenshot of the review-and-finish step for ML model predictions.

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

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

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

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

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

Screenshot of the copy-code template for ML model predictions. 

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
)

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