Tarif: Döküm Araçları - Çok Değişkenli Anomali Algılama

Bu tarif, çok değişkenli anomali algılama için Apache Spark üzerinde SynapseML ve Foundry Araçları'nın nasıl kullanılacağını gösterir. Çok değişkenli anomali algılama, birçok değişken veya zaman serisi arasındaki anomalilerin algılanmasıyla birlikte, farklı değişkenler arasındaki tüm bağıntılar ve bağımlılıkların hesaplanmasıdır. Bu senaryoda, bir modeli çok değişkenli anomali algılama için eğitmek için SynapseML ve Foundry Araçları kullanılır. Ardından modeli kullanarak üç IoT algılayıcısından yapay ölçümler içeren bir veri kümesi içinde çok değişkenli anomaliler çıkarabilirsiniz.

Önemli

20 Eylül 2023'den itibaren yeni Anomali Algılayıcısı kaynakları oluşturamazsınız. Anomali Algılayıcısı hizmeti 1 Ekim 2026'da kullanımdan kaldırılacak.

Azure Yapay Zeka Anomali Algılayıcısı hakkında daha fazla bilgi için Anomaly Detector bilgi kaynağını ziyaret edin.

Önkoşullar

  • Azure aboneliği - Ücretsiz bir abonelik oluştur
  • Defterinizi bir lakehouse'a bağlayın. Sol tarafta Ekle'yi seçerek mevcut bir göl evi ekleyin veya bir göl evi oluşturun.

Ayarlama

Mevcut Anomaly Detector bir kaynakla başlayarak, çeşitli biçimlerdeki verileri işlemenin yollarını keşfedebilirsiniz.

Anomali Algılayıcısı kaynağı oluşturma

Uyarı

20 Eylül 2023'ten bu yana yeni Anomali Algılayıcısı kaynakları oluşturamazsınız. Aşağıdaki adımlar yalnızca mevcut bir Anomali Algılayıcısı kaynağınız varsa geçerlidir. Anomali Algılayıcısı hizmetini gerektirmeyen çok değişkenli bir anomali algılama yaklaşımı için bkz. Yalıtım Ormanı ile Çok Değişkenli Anomali Algılama.

  • Azure portalında kaynak grubunuzda Create öğesini seçin ve ardından Anomaly Detector yazın. Anomali Algılayıcısı kaynağını seçin.
  • Kaynağı adlandırın ve ideal olarak kaynak grubunuzun geri kalanıyla aynı bölgeyi kullanın. Geri kalanı için varsayılan seçenekleri kullanın ve ardından Gözden Geçir + Oluştur'u ve sonra Oluştur'u seçin.
  • Anomali Algılayıcısı kaynağını oluşturduktan sonra açın ve sol gezinti bölmesindeki paneli seçin Keys and Endpoints . Anomali Algılayıcısı kaynağının anahtarını ortam değişkenine ANOMALY_API_KEY kopyalayın veya değişkende anomalyKey depolayın.

Depolama Hesabı kaynağı oluştur

Ara verileri kaydetmek için bir Azure Blob Depolama Hesabı oluşturmanız gerekir. Bu depolama hesabında ara verileri depolamak için bir kapsayıcı oluşturun. Kapsayıcı adını not edin ve bağlantı dizesini kapsayıcıya kopyalayın. Daha sonra containerName değişkenini ve BLOB_CONNECTION_STRING ortam değişkenini doldurmak için buna ihtiyacınız vardır.

Hizmet anahtarlarınızı girin

İlk olarak, hizmet anahtarlarınız için ortam değişkenlerini ayarlayın. Sonraki hücre ANOMALY_API_KEY ve BLOB_CONNECTION_STRING ortam değişkenlerini Azure Key Vault depolanan değerlere göre ayarlar. Bu öğreticiyi kendi ortamınızda çalıştırırsanız, devam etmeden önce bu ortam değişkenlerini ayarladığınızdan emin olun:

import os
from pyspark.sql import SparkSession
from synapse.ml.core.platform import find_secret

# Bootstrap Spark Session
spark = SparkSession.builder.getOrCreate()

ANOMALY_API_KEY ve BLOB_CONNECTION_STRING ortam değişkenlerini okuyun ve ve containerName değişkenlerini ayarlayınlocation:

# An Anomaly Detector subscription key
anomalyKey = find_secret("anomaly-api-key") # use your own anomaly api key
# Your storage account name
storageName = "anomalydetectiontest" # use your own storage account name
# A connection string to your blob storage account
storageKey = find_secret("madtest-storage-key") # use your own storage key
# A place to save intermediate MVAD results
intermediateSaveDir = (
    "wasbs://madtest@anomalydetectiontest.blob.core.windows.net/intermediateData"
)
# The location of the anomaly detector resource that you created
location = "westus2"

Anomali algılayıcısının bu depolama hesabına ara sonuçları kaydedebilmesi için depolama hesabına bağlanın:

spark.sparkContext._jsc.hadoopConfiguration().set(
    f"fs.azure.account.key.{storageName}.blob.core.windows.net", storageKey
)

Tüm gerekli modülleri içeri aktarın:

import numpy as np
import pandas as pd

import pyspark
from pyspark.sql.functions import col
from pyspark.sql.functions import lit
from pyspark.sql.types import DoubleType
import matplotlib.pyplot as plt

import synapse.ml
from synapse.ml.services import *

Spark DataFrame'de örnek verileri okuyun:

df = (
    spark.read.format("csv")
    .option("header", "true")
    .load("wasbs://publicwasb@mmlspark.blob.core.windows.net/MVAD/sample.csv")
)

df = (
    df.withColumn("sensor_1", col("sensor_1").cast(DoubleType()))
    .withColumn("sensor_2", col("sensor_2").cast(DoubleType()))
    .withColumn("sensor_3", col("sensor_3").cast(DoubleType()))
)

# Let's inspect the dataframe:
df.show(5)

Artık modelinizi eğitmek için kullandığınız bir estimator nesne oluşturabilirsiniz. Eğitim verileri için başlangıç ve bitiş saatlerini belirtin. Ayrıca kullanılacak giriş sütunlarını ve zaman damgalarını içeren sütunun adını belirtin. Son olarak, anomali algılama kayan penceresinde kullanılacak veri noktalarının sayısını belirtin ve Azure Blob Depolama Hesabı için bağlantı dizesi'i ayarlayın.

trainingStartTime = "2020-06-01T12:00:00Z"
trainingEndTime = "2020-07-02T17:55:00Z"
timestampColumn = "timestamp"
inputColumns = ["sensor_1", "sensor_2", "sensor_3"]

estimator = (
    FitMultivariateAnomaly()
    .setSubscriptionKey(anomalyKey)
    .setLocation(location)
    .setStartTime(trainingStartTime)
    .setEndTime(trainingEndTime)
    .setIntermediateSaveDir(intermediateSaveDir)
    .setTimestampCol(timestampColumn)
    .setInputCols(inputColumns)
    .setSlidingWindow(200)
)

Verilere estimator’i sığdırın.

model = estimator.fit(df)

Eğitim tamamlandıktan sonra çıkarım için modeli kullanın. Sonraki hücredeki kod, anomalileri algılamak istediğiniz verilerin başlangıç ve bitiş saatlerini belirtir:

inferenceStartTime = "2020-07-02T18:00:00Z"
inferenceEndTime = "2020-07-06T05:15:00Z"

result = (
    model.setStartTime(inferenceStartTime)
    .setEndTime(inferenceEndTime)
    .setOutputCol("results")
    .setErrorCol("errors")
    .setInputCols(inputColumns)
    .setTimestampCol(timestampColumn)
    .transform(df)
)

result.show(5)

Önceki hücrede .show(5) ilk beş veri çerçevesi satırını gösterir. Sonuçların tümü, çıkarım penceresinin dışında kaldığından null.

Yalnızca çıkarsanan verilerin sonuçlarını göstermek için gerekli sütunları seçin. Ardından veri çerçevesindeki satırları artan düzende sıralayabilir ve sonucu yalnızca çıkarım penceresi aralığındaki satırları gösterecek şekilde filtreleyebilirsiniz. Burada, inferenceEndTime veri çerçevesinin son satırıyla eşleştiği için onu göz ardı edebilirsiniz.

Son olarak, sonuçları daha iyi çizmek için Spark veri çerçevesini Pandas veri çerçevesine dönüştürün:

rdf = (
    result.select(
        "timestamp",
        *inputColumns,
        "results.contributors",
        "results.isAnomaly",
        "results.severity"
    )
    .orderBy("timestamp", ascending=True)
    .filter(col("timestamp") >= lit(inferenceStartTime))
    .toPandas()
)

rdf

contributors Her bir sensörden saptanan anomalilere katkı puanını depolayan sütunu biçimlendirin. Sonraki hücre bunu işler ve her algılayıcının katkı puanını kendi sütununa böler:

def parse(x):
    if type(x) is list:
        return dict([item[::-1] for item in x])
    else:
        return {"series_0": 0, "series_1": 0, "series_2": 0}

rdf["contributors"] = rdf["contributors"].apply(parse)
rdf = pd.concat(
    [rdf.drop(["contributors"], axis=1), pd.json_normalize(rdf["contributors"])], axis=1
)
rdf

Artık sırasıyla , series_0ve series_1 sütunlarında 1, 2 ve 3 algılayıcılarının series_2katkı puanlarına sahipsiniz.

Sonuçları çizmek için sonraki hücreyi çalıştırın. parametresi, minSeverity çizecek anomalilerin en düşük önem derecesini belirtir:

minSeverity = 0.1

####### Main Figure #######
plt.figure(figsize=(23, 8))
plt.plot(
    rdf["timestamp"],
    rdf["sensor_1"],
    color="tab:orange",
    linestyle="solid",
    linewidth=2,
    label="sensor_1",
)
plt.plot(
    rdf["timestamp"],
    rdf["sensor_2"],
    color="tab:green",
    linestyle="solid",
    linewidth=2,
    label="sensor_2",
)
plt.plot(
    rdf["timestamp"],
    rdf["sensor_3"],
    color="tab:blue",
    linestyle="solid",
    linewidth=2,
    label="sensor_3",
)
plt.grid(axis="y")
plt.tick_params(axis="x", which="both", bottom=False, labelbottom=False)
plt.legend()

anoms = list(rdf["severity"] >= minSeverity)
_, _, ymin, ymax = plt.axis()
plt.vlines(np.where(anoms), ymin=ymin, ymax=ymax, color="r", alpha=0.8)

plt.legend()
plt.title(
    "A plot of the values from the three sensors with the detected anomalies highlighted in red."
)
plt.show()

####### Severity Figure #######
plt.figure(figsize=(23, 1))
plt.tick_params(axis="x", which="both", bottom=False, labelbottom=False)
plt.plot(
    rdf["timestamp"],
    rdf["severity"],
    color="black",
    linestyle="solid",
    linewidth=2,
    label="Severity score",
)
plt.plot(
    rdf["timestamp"],
    [minSeverity] * len(rdf["severity"]),
    color="red",
    linestyle="dotted",
    linewidth=1,
    label="minSeverity",
)
plt.grid(axis="y")
plt.legend()
plt.ylim([0, 1])
plt.title("Severity of the detected anomalies")
plt.show()

####### Contributors Figure #######
plt.figure(figsize=(23, 1))
plt.tick_params(axis="x", which="both", bottom=False, labelbottom=False)
plt.bar(
    rdf["timestamp"], rdf["series_0"], width=2, color="tab:orange", label="sensor_1"
)
plt.bar(
    rdf["timestamp"],
    rdf["series_1"],
    width=2,
    color="tab:green",
    label="sensor_2",
    bottom=rdf["series_0"],
)
plt.bar(
    rdf["timestamp"],
    rdf["series_2"],
    width=2,
    color="tab:blue",
    label="sensor_3",
    bottom=rdf["series_0"] + rdf["series_1"],
)
plt.grid(axis="y")
plt.legend()
plt.ylim([0, 1])
plt.title("The contribution of each sensor to the detected anomaly")
plt.show()

Çok değişkenli anomali algılama sonuçları çiziminin ekran görüntüsü.

Çizimler, algılayıcılardan alınan ham verileri (çıkarım penceresinin içinde) turuncu, yeşil ve mavi olarak gösterir. İlk şekildeki kırmızı dikey çizgiler, önem derecesi değerinden büyük veya eşit minSeverityolan algılanan anomalileri gösterir.

İkinci çizimde, algılanan tüm anomalilerin önem derecesi puanı gösterilir ve minSeverity eşik noktalı kırmızı çizgide gösterilir.

Son olarak, son çizimde her algılayıcıdan alınan verilerin algılanan anomalilere katkısı gösterilir. Her anomalinin en olası nedenini tanılamaya ve anlamaya yardımcı olur.

İlgili içerik

  • Last updated on