การตรวจหาความผิดปกติแบบหลากหลายรูปแบบ

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

สําหรับข้อมูลพื้นฐาน โปรดดู การตรวจหาความผิดปกติหลายตัวแปรใน Microsoft Fabric - ภาพรวม

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

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

ส่วนที่ 1: เปิดความพร้อมใช้งานของ OneLake

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

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

ส่วนที่ 2: เปิดปลั๊กอิน KQL Python

ในขั้นตอนนี้ คุณเปิดปลั๊กอิน Python ในอีเวนต์เฮาส์ของคุณ ขั้นตอนนี้จําเป็นในการเรียกใช้โค้ด Python ในชุดคิวรี KQL ในส่วนที่ 9: คาดการณ์ความผิดปกติในชุดคิวรี KQL เลือกอิมเมจ Python ที่มีแพ็คเกจตัวตรวจจับความผิดปกติของอนุกรมเวลา

ในอีเวนต์เฮาส์ ให้เลือก ปลั๊กอินอีเวนต์เฮาส์> บนริบบิ้น
ในบานหน้าต่างปลั๊กอิน ให้ตั้งค่าส่วนขยายภาษา Pythonเป็นเปิด
เลือก Python 3.11.7 DL
เลือก เสร็จสิ้น

ส่วนที่ 3: สร้างสภาพแวดล้อม Spark

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

จากพื้นที่ทํางานของคุณ ให้เลือก + รายการใหม่ แล้วเลือก สภาพแวดล้อม
ป้อนMVAD_ENVชื่อสภาพแวดล้อม แล้วเลือก สร้าง
ภายใต้ ไลบรารี เลือก ไลบรารีสาธารณะ
เลือกเพิ่มจาก PyPI
ในช่องค้นหา ให้ป้อนtime-series-anomaly-detector ในกล่อง รุ่น ให้ป้อน0.3.9
เลือก บันทึก
เลือก แท็บ หน้าแรก ในสภาพแวดล้อม
เลือก ไอคอน เผยแพร่ จากริบบอน
เลือก เผยแพร่ทั้งหมด ขั้นตอนนี้อาจใช้เวลาหลายนาทีในการดําเนินการให้เสร็จสมบูรณ์

ส่วนที่ 4: โหลดข้อมูลลงในอีเวนต์เฮาส์

ในอีเวนต์เฮาส์ ให้วางเมาส์เหนือฐานข้อมูล KQL ที่คุณต้องการจัดเก็บข้อมูล จากนั้นเลือกเมนูเพิ่มเติม [...]>รับข้อมูล>ไฟล์ในเครื่อง
เลือก + ตารางใหม่ และป้อน demo_stocks_change เป็นชื่อตาราง
ในกล่องโต้ตอบการอัปโหลด ให้เลือก เรียกดูไฟล์ และอัปโหลดไฟล์ข้อมูลตัวอย่างที่คุณดาวน์โหลดใน ข้อกําหนดเบื้องต้น
เลือก ถัดไป
ในส่วน ตรวจสอบ ข้อมูล ให้ตรวจสอบว่า แถว แรก เป็น ส่วนหัวของคอลัมน์ถูกตั้งค่าเป็น เมื่อ
เลือก เสร็จสิ้น
เมื่อข้อมูลถูกอัปโหลด เลือกปิด

ส่วนที่ 5: คัดลอกเส้นทาง OneLake

เลือก demo_stocks_change ตาราง ในบานหน้าต่างรายละเอียดตาราง ให้เลือกโฟลเดอร์ OneLake เพื่อคัดลอกเส้นทาง OneLake ไปยังคลิปบอร์ดของคุณ บันทึกเส้นทางในโปรแกรมแก้ไขข้อความเพื่อใช้ในภายหลัง

สกรีนช็อตของการคัดลอกเส้นทาง OneLake

ส่วนที่ 6: เตรียมสมุดบันทึก

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

ส่วนที่ 7: เรียกใช้สมุดบันทึก

นําเข้าแพคเกจมาตรฐาน
```
import numpy as np
import pandas as pd
```

Spark ต้องการ ABFSS URI เพื่อเชื่อมต่อกับที่เก็บข้อมูล OneLake อย่างปลอดภัย ดังนั้นให้กําหนดฟังก์ชันตัวช่วยที่แปลง OneLake URI เป็น ABFSS URI

def convert_onelake_to_abfss(onelake_uri):
    if not onelake_uri.startswith('https://'):
        raise ValueError("Invalid OneLake URI. It should start with 'https://'.")
    uri_without_scheme = onelake_uri[8:]
    parts = uri_without_scheme.split('/')
    if len(parts) < 3:
        raise ValueError("Invalid OneLake URI format.")
    container_name = parts[1]
    path = '/'.join(parts[2:])
    abfss_uri = f"abfss://{container_name}@{parts[0]}/{path}"
    return abfss_uri

แทนที่ OneLakeTableURI ด้วย URI OneLake ที่คุณคัดลอกในส่วน ที่ 5: คัดลอกเส้นทาง OneLake แล้วโหลด demo_stocks_change ตารางลงในกรอบข้อมูลแพนด้า

onelake_uri = "OneLakeTableURI"  # Replace with your OneLake table URI.
abfss_uri = convert_onelake_to_abfss(onelake_uri)
print(abfss_uri)

df = spark.read.format('delta').load(abfss_uri)
df = df.toPandas()
df['Date'] = pd.to_datetime(df['Date'])
df = df.set_index('Date').sort_index()
print(df.shape)
df.head(3)

เรียกใช้เซลล์ต่อไปนี้เพื่อเตรียมกรอบข้อมูลการฝึกและการคาดเดา

หมายเหตุ

การคาดการณ์จริงทํางานในบ้านเหตุการณ์ในส่วนที่ 9: คาดการณ์ความผิดปกติในชุดคิวรี KQL ในสถานการณ์การผลิต โดยทั่วไป คุณจะให้คะแนนข้อมูลการสตรีมใหม่ ในบทช่วยสอนนี้ ชุดข้อมูลจะถูกแบ่งตามวันที่ออกเป็นช่วงการฝึกอบรมและการคาดการณ์เพื่อจําลองข้อมูลในอดีตและข้อมูลขาเข้า
```
features_cols = ['AAPL', 'AMZN', 'GOOG', 'MSFT', 'SPY']
cutoff_date = pd.Timestamp('2023-01-01')
```
```
train_df = df.loc[df.index < cutoff_date, features_cols]
print(train_df.shape)
train_df.head(3)
```
```
train_len = len(train_df)
predict_len = len(df) - train_len
print(f'Total samples: {len(df)}. Split to {train_len} for training, {predict_len} for testing')
```

เรียกใช้เซลล์เพื่อฝึกโมเดลและบันทึกในรีจิสทรีแบบจําลอง Fabric MLflow

from anomaly_detector import MultivariateAnomalyDetector
model = MultivariateAnomalyDetector()

sliding_window = 200
params = {"sliding_window": sliding_window}

model.fit(train_df, params=params)

model_name = "mvad_5_stocks_model"

import mlflow

with mlflow.start_run():
    mlflow.log_params(params)
    mlflow.set_tag("Training Info", "MVAD on 5 Stocks Dataset")

    model_info = mlflow.pyfunc.log_model(
        python_model=model,
        artifact_path="mvad_artifacts",
        registered_model_name=model_name,
    )

เรียกใช้เซลล์ต่อไปนี้เพื่อรับเส้นทางแบบจําลองที่ลงทะเบียนซึ่งคุณใช้ในภายหลังสําหรับการคาดคะเนในแซนด์บ็อกซ์ KQL Python
```
from mlflow.tracking import MlflowClient

client = MlflowClient()
mvs = client.search_model_versions(f"name='{model_name}'")
latest = max(mvs, key=lambda v: v.creation_timestamp)
model_abfss = latest.source
print(model_abfss)
```
คัดลอก URI แบบจําลองจากเอาต์พุตของเซลล์สุดท้าย คุณใช้มันในส่วนที่ 9

ส่วนที่ 8: สร้างชุดคิวรี KQL

สําหรับข้อมูลทั่วไป ดู สร้างคิวรี KQL

ในพื้นที่ทํางานของคุณ ให้เลือก + ชุดคิวรี KQL รายการ>ใหม่
ป้อน MultivariateAnomalyDetectionTutorialแล้วเลือก สร้าง
ในหน้าต่าง แค็ตตาล็อก OneLake ให้เลือกฐานข้อมูล KQL ที่คุณเก็บข้อมูล
เลือก เชื่อมต่อ

ส่วนที่ 9: คาดการณ์ความผิดปกติในชุดคิวรี KQL

เรียกใช้คิวรีต่อไปนี้ .create-or-alter function เพื่อกําหนดฟังก์ชันที่ predict_fabric_mvad_fl() เก็บไว้:

.create-or-alter function with (folder = "Packages\\ML", docstring = "Predict MVAD model in Microsoft Fabric")
predict_fabric_mvad_fl(samples:(*), features_cols:dynamic, artifacts_uri:string, trim_result:bool=false)
{
    let s = artifacts_uri;
    let artifacts = bag_pack('MLmodel', strcat(s, '/MLmodel;impersonate'), 'conda.yaml', strcat(s, '/conda.yaml;impersonate'),
                             'requirements.txt', strcat(s, '/requirements.txt;impersonate'), 'python_env.yaml', strcat(s, '/python_env.yaml;impersonate'),
                             'python_model.pkl', strcat(s, '/python_model.pkl;impersonate'));
    let kwargs = bag_pack('features_cols', features_cols, 'trim_result', trim_result);
    let code = ```if 1:
        import os
        import shutil
        import mlflow
        work_dir = os.environ.get("UPLOAD_PATH")
        model_dir = work_dir + '/mvad_model'
        model_data_dir = model_dir + '/data'
        os.mkdir(model_dir)
        shutil.move(work_dir + '/MLmodel', model_dir)
        shutil.move(work_dir + '/conda.yaml', model_dir)
        shutil.move(work_dir + '/requirements.txt', model_dir)
        shutil.move(work_dir + '/python_env.yaml', model_dir)
        shutil.move(work_dir + '/python_model.pkl', model_dir)
        features_cols = kargs["features_cols"]
        trim_result = kargs["trim_result"]
        test_data = df[features_cols]
        model = mlflow.pyfunc.load_model(model_dir)
        predictions = model.predict(test_data)
        predict_result = pd.DataFrame(predictions)
        samples_offset = len(df) - len(predict_result)        # this model doesn't output predictions for the first sliding_window-1 samples
        if trim_result:                                       # trim the prefix samples
            result = df[samples_offset:]
            result.iloc[:,-4:] = predict_result.iloc[:, 1:]   # no need to copy 1st column which is the timestamp index
        else:
            result = df                                       # output all samples
            result.iloc[samples_offset:,-4:] = predict_result.iloc[:, 1:]
        ```;
    samples
    | evaluate python(typeof(*), code, kwargs, external_artifacts=artifacts)
}

เรียกใช้แบบสอบถามการคาดคะเนต่อไปนี้ แทนที่enter your model URI hereด้วย URI ที่คุณคัดลอกไว้ที่ส่วนท้ายของส่วนที่ 7: เรียกใช้สมุดบันทึก

แบบสอบถามตรวจพบความผิดปกติหลายตัวแปรในหุ้นทั้งห้าโดยใช้แบบจําลองที่ผ่านการฝึกอบรม แล้วแสดงผลลัพธ์เป็นanomalychart จุดผิดปกติจะแสดงในหุ้นตัวแรก (AAPL) แต่แสดงถึงความผิดปกติในพฤติกรรมร่วมกันของหุ้นทั้งห้าตัวในวันที่กําหนด

let cutoff_date=datetime(2023-01-01);
let num_predictions=toscalar(demo_stocks_change | where Date >= cutoff_date | count);   //  number of latest points to predict
let sliding_window=200;                                                                 //  should match the window that was set for model training
let prefix_score_len = sliding_window/2+min_of(sliding_window/2, 200)-1;
let num_samples = prefix_score_len + num_predictions;
demo_stocks_change
| top num_samples by Date desc
| order by Date asc
| extend is_anomaly=bool(false), score=real(null), severity=real(null), interpretation=dynamic(null)
| invoke predict_fabric_mvad_fl(pack_array('AAPL', 'AMZN', 'GOOG', 'MSFT', 'SPY'),
            // NOTE: Update artifacts_uri to model path
            artifacts_uri='enter your model URI here',
            trim_result=true)
| summarize Date=make_list(Date), AAPL=make_list(AAPL), AMZN=make_list(AMZN), GOOG=make_list(GOOG), MSFT=make_list(MSFT), SPY=make_list(SPY), anomaly=make_list(toint(is_anomaly))
| render anomalychart with(anomalycolumns=anomaly, title='Stock price changes in % with anomalies')

แผนภูมิความผิดปกติที่ได้จะมีลักษณะคล้ายกับภาพต่อไปนี้:

ล้างแหล่งข้อมูล

เมื่อคุณเสร็จสิ้นบทช่วยสอน ให้ลบทรัพยากรที่คุณสร้างขึ้นเพื่อหลีกเลี่ยงค่าใช้จ่ายที่ไม่จําเป็น:

เรียกดูโฮมเพจพื้นที่ทํางานของคุณ
ลบสภาพแวดล้อมที่สร้างขึ้นในบทช่วยสอนนี้
ลบสมุดบันทึกที่สร้างขึ้นในบทช่วยสอนนี้
ลบบ้านเหตุการณ์หรือ ฐานข้อมูล ที่ใช้ในบทช่วยสอนนี้
ลบคิวรี KQL ที่สร้างขึ้นในบทช่วยสอนนี้

คำติชม

หน้านี้มีประโยชน์หรือไม่

Last updated on 2026-06-18