แชร์ผ่าน

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

  • บทความ

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

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

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

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

  1. เรียกดูโฮมเพจของพื้นที่ทํางานของคุณในตัวแสดงเวลาจริง

  2. เลือกอีเวนต์เฮ้าส์ที่คุณสร้างขึ้นในข้อกําหนดเบื้องต้น เลือกฐานข้อมูลที่คุณต้องการจัดเก็บข้อมูลของคุณ

  3. ใน ไทล์รายละเอียด ฐานข้อมูล เลือกไอคอนดินสอถัดจาก ความพร้อมใช้งาน OneLake

  4. ในบานหน้าต่างด้านขวา ให้สลับปุ่มเป็น ใช้งานอยู่

  5. เลือก เสร็จสิ้น

    สกรีนช็อตของการเปิดใช้งานความพร้อมใช้งาน OneLake ใน Eventhouse ของคุณ

ส่วนที่ 2- เปิดใช้งานปลั๊กอิน KQL Python

ในขั้นตอนนี้ คุณเปิดใช้งานปลั๊กอิน python ใน Eventhouse ของคุณ ขั้นตอนนี้จําเป็นสําหรับการ เรียกใช้รหัส Python ทํานายความผิดปกติ ในชุดคิวรี KQL สิ่งสําคัญคือการเลือกแพ็คเกจที่ถูกต้องที่มีแพคเกจ time-series-anomaly-detector

  1. ในหน้าจอ Eventhouse เลือกฐานข้อมูลของคุณ จากนั้นเลือกจัดการ>ปลั๊กอินจาก ribbon

  2. ในบานหน้าต่าง ปลั๊กอิน ให้สลับส่วนขยายภาษา Python เป็น เปิด

  3. เลือก Python 3.11.7 DL (ตัวอย่าง)

  4. เลือก เสร็จสิ้น

    สกรีนช็อตสําหรับวิธีการเปิดใช้งานแพคเกจ python 3.11.7 DL ใน Eventhouse

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

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

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

  2. จาก รายการที่แนะนํา เพื่อสร้าง เลือก สภาพแวดล้อม และใส่ชื่อ MVAD_ENV สําหรับสภาพแวดล้อม

    สกรีนช็อตของการสร้างสภาพแวดล้อมในการวิศวกรข้อมูล

  3. ภายใต้ ไลบรารี เลือก ไลบรารีสาธารณะ

  4. เลือกเพิ่มจาก PyPI

  5. ในกล่องค้นหา ให้ป้อน time-series-anomaly-detector เวอร์ชันจะเติมด้วยเวอร์ชันล่าสุดโดยอัตโนมัติ บทช่วยสอนนี้ถูกสร้างขึ้นโดยใช้เวอร์ชัน 0.2.7 ซึ่งเป็นเวอร์ชันที่รวมอยู่ใน Kusto Python 3.11.7 DL

  6. เลือก บันทึก

    สกรีนช็อตของการเพิ่มแพคเกจ PyPI ไปยังสภาพแวดล้อม Spark

  7. เลือก แท็บ หน้าแรก ในสภาพแวดล้อม

  8. เลือก ไอคอน เผยแพร่ จากริบบอน

  9. เลือก เผยแพร่ทั้งหมด ขั้นตอนนี้อาจใช้เวลาหลายนาทีในการดําเนินการให้เสร็จสมบูรณ์

    สกรีนช็อตของการเผยแพร่สภาพแวดล้อม

ส่วนที่ 4- รับข้อมูลลงในอีเวนต์เฮ้าส์

  1. วางเมาส์เหนือฐานข้อมูล KQL ที่คุณต้องการจัดเก็บข้อมูลของคุณ เลือก เมนูเพิ่มเติม [...]>รับข้อมูล>ไฟล์ภายในเครื่อง

    ภาพหน้าจอของรับข้อมูลจากไฟล์ภายในเครื่อง

  2. เลือก + ตาราง ใหม่ และใส่ demo_stocks_change เป็นชื่อตาราง

  3. ในกล่องโต้ตอบการอัปโหลดข้อมูล เลือก เรียกดูไฟล์ และอัปโหลดไฟล์ข้อมูลตัวอย่างที่ดาวน์โหลดใน ข้อกําหนดเบื้องต้น

  4. เลือก ถัดไป

  5. ในส่วน ตรวจสอบข้อมูล ให้สลับ แถวแรก เป็นส่วนหัวของคอลัมน์เป็น เปิด

  6. เลือก เสร็จสิ้น

  7. เมื่อข้อมูลถูกอัปโหลด เลือกปิด

ส่วนที่ 5- คัดลอกเส้นทาง OneLake ไปยังตาราง

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

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

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

  1. ในตัวสลับประสบการณ์ เลือก พัฒนา และเลือกพื้นที่ทํางานของคุณ

  2. เลือก นําเข้า, สมุดบันทึก แล้วเลือก จากคอมพิวเตอร์เครื่องนี้

  3. เลือก อัปโหลด และเลือกสมุดบันทึกที่คุณดาวน์โหลดใน ข้อกําหนดเบื้องต้น

  4. หลังจากอัปโหลดสมุดบันทึกแล้ว คุณสามารถค้นหาและเปิดสมุดบันทึกของคุณได้จากพื้นที่ทํางานของคุณ

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

    สกรีนช็อตของการเลือกสภาพแวดล้อมในสมุดบันทึก

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

  1. นําเข้าแพคเกจมาตรฐาน

    import numpy as np
import pandas as pd

  2. 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.")
account_name = parts[0].split('.')[0]
container_name = parts[1]
path = '/'.join(parts[2:])
abfss_uri = f"abfss://{container_name}@{parts[0]}/{path}"
return abfss_uri

  3. ป้อนข้อมูล OneLake URI ของคุณที่คัดลอกจาก ส่วนที่ 5- คัดลอกเส้นทาง OneLake ไปยังตาราง เพื่อโหลด ตาราง demo_stocks_change ลงในดาต้าเฟรมของ pandas

    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().set_index('Date')
print(df.shape)
df[:3]

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

    หมายเหตุ

    การคาดการณ์จริงจะเรียกใช้ข้อมูลโดย Eventhouse ในส่วน ที่ 9- ทํานายความผิดปกติในชุดคิวรี kql ในสถานการณ์การผลิต ถ้าคุณกําลังสตรีมข้อมูลไปยัง eventhouse การคาดการณ์จะทําบนข้อมูลการสตรีมใหม่ สําหรับวัตถุประสงค์ของบทช่วยสอน ชุดข้อมูลถูกแยกตามวันที่เป็นสองส่วนสําหรับการฝึกอบรมและการคาดการณ์ นี่คือการจําลองข้อมูลในอดีตและข้อมูลการสตรีมใหม่

    features_cols = ['AAPL', 'AMZN', 'GOOG', 'MSFT', 'SPY']
cutoff_date = pd.to_datetime('2023-01-01')

    train_df = df[df.Date < cutoff_date]
print(train_df.shape)
train_df[: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')

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

    import mlflow
from anomaly_detector import MultivariateAnomalyDetector
model = MultivariateAnomalyDetector()

    sliding_window = 200
param   s = {"sliding_window": sliding_window}

    model.fit(train_df, params=params)

    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="mvad_5_stocks_model",
    )

    # Extract the registered model path to be used for prediction using Kusto Python sandbox

mi = mlflow.search_registered_models(filter_string="name='mvad_5_stocks_model'")[0]
model_abfss = mi.latest_versions[0].source
print(model_abfss)

  6. คัดลอก URI ของแบบจําลองจากผลลัพธ์เซลล์สุดท้าย คุณจะใช้ขั้นตอนนี้ในขั้นตอนถัดไป

ส่วนที่ 8- ตั้งค่าคิวรี KQL ของคุณ

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

  1. ในตัวสลับประสบการณ์ ให้เลือก ตัวแสดงเวลาจริง
  2. เลือกพื้นที่ทํางานของคุณ
  3. เลือก +รายการ>ใหม่ คิวรี KQL ใส่ชื่อ MultivariateAnomalyDetectionTutorial
  4. เลือก สร้าง
  5. ในหน้าต่างฮับข้อมูล OneLake ให้เลือกฐานข้อมูล KQL ที่คุณจัดเก็บข้อมูล
  6. เลือก เชื่อมต่อ

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

  1. คัดลอก/วาง และเรียกใช้คิวรี '.create-or-alter' ต่อไปนี้เพื่อกําหนดฟังก์ชันที่ 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
        model_dir = 'C:/Temp/mvad_model'
        model_data_dir = model_dir + '/data'
        os.mkdir(model_dir)
        shutil.move('C:/Temp/MLmodel', model_dir)
        shutil.move('C:/Temp/conda.yaml', model_dir)
        shutil.move('C:/Temp/requirements.txt', model_dir)
        shutil.move('C:/Temp/python_env.yaml', model_dir)
        shutil.move('C:/Temp/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)
}

  2. คัดลอก/วางคิวรีการคาดการณ์ต่อไปนี้

    1. แทนที่ URI แบบจําลองผลลัพธ์ที่คัดลอกในตอนท้ายของขั้นตอนที่ 7
    2. เรียกใช้ การสอบถาม ซึ่งจะตรวจหาความผิดปกติที่หลากหลายในหุ้นห้าตัว ตามแบบจําลองที่ได้รับการฝึกและแสดงผลลัพธ์เป็น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 Changest in % with Anomalies')

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

สกรีนช็อตของเอาต์พุตความผิดปกติแบบหลากหลาย

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

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

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