Schnellstart: Verwenden der Clientbibliothek für die multivariate Anomalieerkennung

Artikel
01/18/2024

Wichtig

Ab dem 20. September 2023 können Sie keine neuen Ressourcen für die Anomalieerkennung mehr erstellen. Der Anomalieerkennungsdienst wird am 1. Oktober 2026 eingestellt.

Bibliotheksreferenzdokumentation |Quellcode der Bibliothek | Paket (NuGet) |Beispielcode auf GitHub finden

Erfahren Sie etwas über die ersten Schritte mit der Clientbibliothek für Anomalieerkennung für C#. Führen Sie diese Schritte aus, um das Paket zu installieren und mit der Verwendung der vom Dienst zur Verfügung gestellten Algorithmen zu beginnen. Mit dem Anomalieerkennungsdienst können Sie Anomalien in Zeitreihendaten ermitteln, da unabhängig von der Branche, dem Szenario oder der Datenmenge automatisch die am besten geeigneten Modelle für Ihre Daten angewandt werden.

Mit der Clientbibliothek für Anomalieerkennung für C# ist Folgendes möglich:

Erkennen von Anomalien in Ihrem gesamten Zeitreihendataset als Batchanforderung
Erkennen des Anomaliestatus des letzten Datenpunkts in Ihrer Zeitreihe
Erkennen von Trendänderungspunkten in Ihrem Dataset

Voraussetzungen

Azure-Abonnement: Kostenloses Azure-Konto
Aktuelle Version von .NET Core
Sobald Sie über Ihr Azure-Abonnement verfügen, können Sie im Azure-Portal eine Anomalieerkennungsressource erstellen , um Ihren Schlüssel und Endpunkt zu erhalten. Warten Sie die Bereitstellung ab, und wählen Sie dann die Schaltfläche Zu Ressource wechseln aus. Sie können den kostenlosen Tarif (F0) verwenden, um den Dienst zu testen, und später für die Produktion auf einen kostenpflichtigen Tarif upgraden.

Einrichten

Erstellen einer neuen .NET Core-Anwendung

Verwenden Sie in einem Konsolenfenster (z. B. cmd, PowerShell oder Bash) den Befehl dotnet new zum Erstellen einer neuen Konsolen-App mit dem Namen anomaly-detector-quickstart. Dieser Befehl erstellt ein einfaches „Hallo Welt“-Projekt mit einer einzigen C#-Quelldatei: Program.cs.

dotnet new console -n anomaly-detector-quickstart

Wechseln Sie zum Ordner der neu erstellten App. Sie können die Anwendung mit folgendem Befehl erstellen:

dotnet build

Die Buildausgabe sollte keine Warnungen oder Fehler enthalten.

...
Build succeeded.
 0 Warning(s)
 0 Error(s)
...

Installieren der Clientbibliothek

Installieren Sie im Anwendungsverzeichnis mit dem folgenden Befehl die Anomalieerkennungs-Clientbibliothek für .NET:

dotnet add package Azure.AI.AnomalyDetector --prerelease

Abrufen von Schlüssel und Endpunkt

Für einen erfolgreichen Aufruf des Anomalieerkennungsdiensts benötigen Sie die folgenden Werte:

Variablenname	Wert
`ANOMALY_DETECTOR_ENDPOINT`	Diesen Wert finden Sie im Abschnitt Schlüssel und Endpunkt, wenn Sie die Ressource über das Azure-Portal untersuchen. Beispiel für einen Endpunkt: `https://YOUR_RESOURCE_NAME.cognitiveservices.azure.com/`
`ANOMALY_DETECTOR_API_KEY`	Den Wert des API-Schlüssels finden Sie im Abschnitt Schlüssel und Endpunkt, wenn Sie die Ressource über das Azure-Portal untersuchen. Sie können `KEY1` oder `KEY2` verwenden.
`DATA_PATH`	In diesem Schnellstart wird die Datei `request-data.csv` verwendet, die aus unseren GitHub-Beispieldaten heruntergeladen werden kann. Beispiel-Pfad: `c:\\test\\request-data.csv`

Wechseln Sie zu Ihrer Ressource im Azure-Portal. Die Werte für Endpunkt und Schlüssel finden Sie im Abschnitt Ressourcenverwaltung. Kopieren Sie die Werte für Endpunkt und Zugriffsschlüssel, da Sie beide für die Authentifizierung Ihrer API-Aufrufe benötigen. Sie können KEY1 oder KEY2 verwenden. Wenn Sie jederzeit zwei Schlüssel zur Verfügung haben, können Sie die Schlüssel auf sichere Weise rotieren und neu generieren, ohne Dienstunterbrechungen zu verursachen.

Erstellen von Umgebungsvariablen

Erstellen und Zuweisen von beständigen Umgebungsvariablen für Ihren Schlüssel und Endpunkt.

setx ANOMALY_DETECTOR_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE"

setx ANOMALY_DETECTOR_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

[System.Environment]::SetEnvironmentVariable('ANOMALY_DETECTOR_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')

[System.Environment]::SetEnvironmentVariable('ANOMALY_DETECTOR_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

echo export ANOMALY_DETECTOR_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE" >> /etc/environment && source /etc/environment

echo export ANOMALY_DETECTOR_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE" >> /etc/environment && source /etc/environment

Herunterladen von Beispieldaten

In diesem Schnellstart wird die Datei request-data.csv verwendet, die aus unseren GitHub-Beispieldaten heruntergeladen werden kann

Sie können die Beispieldaten auch herunterladen, indem Sie folgenden Befehl ausführen:

curl "https://raw.githubusercontent.com/Azure/azure-sdk-for-python/main/sdk/anomalydetector/azure-ai-anomalydetector/samples/sample_data/request-data.csv" --output request-data.csv

Erkennen von Anomalien

Öffnen Sie im Projektverzeichnis die Datei program.cs, und ersetzen Sie den Inhalt durch den folgenden Code:

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using Azure;
using Azure.AI.AnomalyDetector;
using static System.Environment;

namespace anomaly_detector_quickstart
{
    internal class Program
    {
        static void Main(string[] args)
        {
            string endpoint = GetEnvironmentVariable("ANOMALY_DETECTOR_ENDPOINT");
            string apiKey = GetEnvironmentVariable("ANOMALY_DETECTOR_API_KEY");

            var endpointUri = new Uri(endpoint);
            var credential = new AzureKeyCredential(apiKey);

            //create client
            AnomalyDetectorClient client = new AnomalyDetectorClient(endpointUri, credential);

            //read data
            //example: string datapath = @"c:\test\request-data.csv";
            string datapath = @"REPLACE_WITH_YOUR_LOCAL_SAMPLE_REQUEST_DATA_PATH";

            List<TimeSeriesPoint> list = File.ReadAllLines(datapath, Encoding.UTF8)
                .Where(e => e.Trim().Length != 0)
                .Select(e => e.Split(','))
                .Where(e => e.Length == 2)
                .Select(e => new TimeSeriesPoint(float.Parse(e[1])) { Timestamp = DateTime.Parse(e[0]) }).ToList();

              //create request
            UnivariateDetectionOptions request = new UnivariateDetectionOptions(list)
            {
                Granularity = TimeGranularity.Daily
            };

            UnivariateEntireDetectionResult result = client.DetectUnivariateEntireSeries(request);

            bool hasAnomaly = false;
            for (int i = 0; i < request.Series.Count; ++i)
            {
                if (result.IsAnomaly[i])
                {
                    Console.WriteLine("Anomaly detected at index: {0}.", i);
                    hasAnomaly = true;
                }
            }
            if (!hasAnomaly)
            {
                Console.WriteLine("No anomalies detected in the series.");
            }
        }
    }
}

Wichtig

Verwenden Sie für die Produktion eine sichere Art der Speicherung und des Zugriffs auf Ihre Anmeldeinformationen wie Azure Key Vault. Weitere Informationen zur Sicherheit von Anmeldeinformationen finden Sie im Azure KI Services-Artikel Sicherheit.

dotnet run program.cs

Ausgabe

Anomaly detected at index:      3
Anomaly detected at index:      18
Anomaly detected at index:      21
Anomaly detected at index:      22
Anomaly detected at index:      23
Anomaly detected at index:      24
Anomaly detected at index:      25
Anomaly detected at index:      28
Anomaly detected at index:      29
Anomaly detected at index:      30
Anomaly detected at index:      31
Anomaly detected at index:      32
Anomaly detected at index:      35
Anomaly detected at index:      44

Codedetails

Verstehen der Ergebnisse

Im Code oben werden die Beispieldaten gelesen und in ein DetectRequest-Objekt konvertiert. Rufen Sie File.ReadAllLines mit dem Dateipfad auf, erstellen Sie eine Liste der TimeSeriesPoint-Objekte, und entfernen Sie alle Zeilenvorschubzeichen. Extrahieren Sie die Werte, trennen Sie den Zeitstempel von seinem numerischen Wert, und fügen Sie diese einem neuen TimeSeriesPoint-Objekt hinzu. Das DetectRequest-Objekt besteht aus einer Reihe von Datenpunkten mit TimeGranularity.Daily als Wert für die Granularität (oder Periodizität) der Datenpunkte. Als Nächstes rufen wir die DetectEntireSeriesAsync-Methode des Clients mit dem DetectRequest-Objekt auf und warten die Antwort in Form eines EntireDetectResponse-Objekts ab. Anschließend durchlaufen wir die IsAnomaly-Werte der Antwort und geben alle Werte aus, die „true“ sind. Diese Werte stimmen mit dem Index der anomalen Datenpunkte überein, sofern welche gefunden wurden.

Bereinigen von Ressourcen

Wenn Sie eine Ressource der Anomalieerkennung bereinigen und entfernen möchten, können Sie die eigentliche Ressource oder die Ressourcengruppe löschen. Wenn Sie die Ressourcengruppe löschen, werden auch alle anderen Ressourcen gelöscht, die ihr zugeordnet sind. Möglicherweise sollten Sie auch die von Ihnen erstellten Umgebungsvariablen löschen, wenn Sie diese nicht mehr verwenden möchten.

Bibliotheksreferenzdokumentation |Quellcode der Bibliothek | Paket (npm) |Codebeispiele auf GitHub

Hier erfahren Sie etwas über die ersten Schritte mit der Anomalieerkennungs-Clientbibliothek für JavaScript. Führen Sie die hier angegebenen Schritte aus, um das Paket zu installieren und mit der Verwendung der bereitgestellten Algorithmen zu beginnen. Mit dem Anomalieerkennungsdienst können Sie Anomalien in Zeitreihendaten ermitteln, da unabhängig von der Branche, dem Szenario oder der Datenmenge automatisch das am besten geeignete Modell für Ihre Daten angewandt wird.

Mit der Anomalieerkennungs-Clientbibliothek für JavaScript ist Folgendes möglich:

Erkennen von Anomalien in Ihrem gesamten Zeitreihendataset als Batchanforderung
Erkennen des Anomaliestatus des letzten Datenpunkts in Ihrer Zeitreihe
Erkennen von Trendänderungspunkten in Ihrem Dataset

Voraussetzungen

Azure-Abonnement: Kostenloses Azure-Konto
Die aktuelle Version von Node.js
Sobald Sie über Ihr Azure-Abonnement verfügen, können Sie im Azure-Portal eine Anomalieerkennungsressource erstellen , um Ihren Schlüssel und Endpunkt zu erhalten. Warten Sie die Bereitstellung ab, und wählen Sie dann die Schaltfläche Zu Ressource wechseln aus.
- Sie benötigen den Schlüssel und Endpunkt der von Ihnen erstellten Ressource, um Ihre Anwendung mit der Anomalieerkennungs-API zu verbinden. Sie verwenden den Schlüssel und Endpunkt zum Erstellen von Umgebungsvariablen. Sie können den kostenlosen Tarif (F0) verwenden, um den Dienst zu testen, und später für die Produktion auf einen kostenpflichtigen Tarif upgraden.

Einrichten

Erstellen einer neuen Node.js-Anwendung

Erstellen Sie in einem Konsolenfenster (etwa cmd, PowerShell oder Bash) ein neues Verzeichnis für Ihre App, und rufen Sie es auf.

mkdir myapp && cd myapp

Erstellen Sie eine Datei package.json mit folgendem Inhalt:

{
  "dependencies": {
    "@azure/ai-anomaly-detector": "next",
    "@azure-rest/ai-anomaly-detector": "next",
    "@azure/core-auth": "^1.3.0",
    "csv-parse": "^5.3.0"
  }
}

Installieren der Clientbibliothek

Installieren Sie die erforderlichen npm-Pakete, indem Sie den folgenden Befehl in demselben Verzeichnis ausführen, in dem sich Ihre Datei „package.json“ befindet:

npm install

Abrufen von Schlüssel und Endpunkt

Für einen erfolgreichen Aufruf des Anomalieerkennungsdiensts benötigen Sie die folgenden Werte:

Variablenname	Wert
`ANOMALY_DETECTOR_ENDPOINT`	Diesen Wert finden Sie im Abschnitt Schlüssel und Endpunkt, wenn Sie die Ressource über das Azure-Portal untersuchen. Beispiel für einen Endpunkt: `https://YOUR_RESOURCE_NAME.cognitiveservices.azure.com/`
`ANOMALY_DETECTOR_API_KEY`	Den Wert des API-Schlüssels finden Sie im Abschnitt Schlüssel und Endpunkt, wenn Sie die Ressource über das Azure-Portal untersuchen. Sie können `KEY1` oder `KEY2` verwenden.
`datapath`	In diesem Schnellstart wird die Datei `request-data.csv` verwendet, die aus unseren GitHub-Beispieldaten heruntergeladen werden kann.

Erstellen von Umgebungsvariablen

Erstellen und Zuweisen von beständigen Umgebungsvariablen für Ihren Schlüssel und Endpunkt.

setx ANOMALY_DETECTOR_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE"

setx ANOMALY_DETECTOR_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

[System.Environment]::SetEnvironmentVariable('ANOMALY_DETECTOR_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')

[System.Environment]::SetEnvironmentVariable('ANOMALY_DETECTOR_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

echo export ANOMALY_DETECTOR_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE" >> /etc/environment && source /etc/environment

echo export ANOMALY_DETECTOR_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE" >> /etc/environment && source /etc/environment

Herunterladen von Beispieldaten

In diesem Schnellstart wird die Datei request-data.csv verwendet, die aus unseren GitHub-Beispieldaten heruntergeladen werden kann

Sie können die Beispieldaten auch herunterladen, indem Sie folgenden Befehl ausführen:

curl "https://raw.githubusercontent.com/Azure/azure-sdk-for-python/main/sdk/anomalydetector/azure-ai-anomalydetector/samples/sample_data/request-data.csv" --output request-data.csv

Erkennen von Anomalien

Erstellen Sie eine Datei namens index.js, und ersetzen Sie sie durch den folgenden Code:

const AnomalyDetector = require("@azure-rest/ai-anomaly-detector").default,
  { isUnexpected } = require("@azure-rest/ai-anomaly-detector");
const { AzureKeyCredential } = require("@azure/core-auth");

const { parse } = require("csv-parse/sync");
const fs = require("fs");

// You will need to set this environment variables or edit the following values
const apiKey = process.env["ANOMALY_DETECTOR_API_KEY"] || "";
const endpoint = process.env["ANOMALY_DETECTOR_ENDPOINT"] || "";
const timeSeriesDataPath = "./request-data.csv";

function read_series_from_file(path) {
  let result = Array();
  let input = fs.readFileSync(path).toString();
  let parsed = parse(input, { skip_empty_lines: true });
  parsed.forEach(function (e) {
    result.push({ timestamp: new Date(e[0]), value: Number(e[1]) });
  });
  return result;
}

async function main() {
  // create client
  const credential = new AzureKeyCredential(apiKey);
  const client = AnomalyDetector(endpoint, credential);

  // construct request
  const options = {
    body: {
      granularity: "daily",
      imputeMode: "auto",
      maxAnomalyRatio: 0.25,
      sensitivity: 95,
      series: read_series_from_file(timeSeriesDataPath),
    },
    headers: { "Content-Type": "application/json" },
  };

  // get last detect result
  const result = await client.path("/timeseries/entire/detect").post(options);
  if (isUnexpected(result)) {
    throw result;
  }

  if (result.body.isAnomaly) {
    result.body.isAnomaly.forEach(function (anomaly, index) {
      if (anomaly === true) {
        console.log(index);
      }
    });
  } else {
    console.log("There is no anomaly detected from the series.");
  }

}

main().catch((err) => {
  console.error("The sample encountered an error:", err);
});

module.exports = { main };

Ausführen der Anwendung

Führen Sie die Anwendung mit dem Befehl node für die Schnellstartdatei aus.

node index.js

Output

Anomalies were detected from the series at index:
3
18
21
22
23
24
25
28
29
30
31
32
35
44

Verstehen der Ergebnisse

Im Code oben rufen wir die Anomalieerkennungs-API auf, um Anomalien mit der Methode detectEntireSeries() über die gesamte Zeitreihe als Batch zu erkennen. Wir speichern das zurückgegebene Objekt AnomalyDetectorDetectEntireSeriesResponse. Anschließend durchlaufen wir die isAnomaly-Liste der Antwort und geben den Index aller true-Werte aus. Diese Werte stimmen mit dem Index der anomalen Datenpunkte überein, sofern welche gefunden wurden.

Bereinigen von Ressourcen

Bibliotheksreferenzdokumentation |Quellcode der Bibliothek | Paket (PyPi) |Codebeispiele auf GitHub

Hier erfahren Sie etwas über die ersten Schritte mit der Anomalieerkennungs-Clientbibliothek für Python. Führen Sie die hier angegebenen Schritte aus, um das Paket zu installieren und mit der Verwendung der bereitgestellten Algorithmen zu beginnen. Mit dem Anomalieerkennungsdienst können Sie Anomalien in Zeitreihendaten ermitteln, da unabhängig von der Branche, dem Szenario oder der Datenmenge automatisch die am besten geeigneten Modelle für Ihre Daten angewandt werden.

Mit der Anomalieerkennungs-Clientbibliothek für Python ist Folgendes möglich:

Erkennen von Anomalien in Ihrem gesamten Zeitreihendataset als Batchanforderung
Erkennen des Anomaliestatus des letzten Datenpunkts in Ihrer Zeitreihe
Erkennen von Trendänderungspunkten in Ihrem Dataset

Voraussetzungen

Azure-Abonnement: Kostenloses Azure-Konto
Python 3.x
Pandas-Bibliothek für Datenanalyse
Sobald Sie über Ihr Azure-Abonnement verfügen, können Sie im Azure-Portal eine Anomalieerkennungsressource erstellen , um Ihren Schlüssel und Endpunkt zu erhalten. Warten Sie die Bereitstellung ab, und wählen Sie dann die Schaltfläche Zu Ressource wechseln aus. Sie können den kostenlosen Tarif (F0) verwenden, um den Dienst zu testen, und später für die Produktion auf einen kostenpflichtigen Tarif upgraden.

Einrichten

Installieren der Clientbibliothek Sie können die Clientbibliothek wie folgt installieren:

pip install --upgrade azure.ai.anomalydetector

Abrufen von Schlüssel und Endpunkt

Für einen erfolgreichen Aufruf des Anomalieerkennungsdiensts benötigen Sie die folgenden Werte:

Variablenname	Wert
`ANOMALY_DETECTOR_ENDPOINT`	Diesen Wert finden Sie im Abschnitt Schlüssel und Endpunkt, wenn Sie die Ressource über das Azure-Portal untersuchen. Beispiel für einen Endpunkt: `https://YOUR_RESOURCE_NAME.cognitiveservices.azure.com/`
`ANOMALY_DETECTOR_API_KEY`	Den Wert des API-Schlüssels finden Sie im Abschnitt Schlüssel und Endpunkt, wenn Sie die Ressource über das Azure-Portal untersuchen. Sie können `KEY1` oder `KEY2` verwenden.
`DATA_PATH`	In diesem Schnellstart wird die Datei `request-data.csv` verwendet, die aus unseren GitHub-Beispieldaten heruntergeladen werden kann. Beispiel-Pfad: `c:\\test\\request-data.csv`

Erstellen von Umgebungsvariablen

Erstellen und Zuweisen von beständigen Umgebungsvariablen für Ihren Schlüssel und Endpunkt.

setx ANOMALY_DETECTOR_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE"

setx ANOMALY_DETECTOR_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

[System.Environment]::SetEnvironmentVariable('ANOMALY_DETECTOR_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')

[System.Environment]::SetEnvironmentVariable('ANOMALY_DETECTOR_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

echo export ANOMALY_DETECTOR_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE" >> /etc/environment && source /etc/environment

echo export ANOMALY_DETECTOR_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE" >> /etc/environment && source /etc/environment

Herunterladen von Beispieldaten

In diesem Schnellstart wird die Datei request-data.csv verwendet, die aus unseren GitHub-Beispieldaten heruntergeladen werden kann

Sie können die Beispieldaten auch herunterladen, indem Sie folgenden Befehl ausführen:

curl "https://raw.githubusercontent.com/Azure/azure-sdk-for-python/main/sdk/anomalydetector/azure-ai-anomalydetector/samples/sample_data/request-data.csv" --output request-data.csv

Erkennen von Anomalien

Erstellen Sie eine neue Python-Datei namens „quickstart.py“. Öffnen Sie diese anschließend in Ihrem bevorzugten Editor oder Ihrer bevorzugten IDE.

Ersetzen Sie den Inhalt von „quickstart.py“ durch den folgenden Code. Ändern Sie den Code, um die Namen der Umgebungsvariablen für Ihren Schlüssel, den Endpunkt und den Pfad der Zeitreihendaten hinzuzufügen:

from azure.ai.anomalydetector import AnomalyDetectorClient
from azure.ai.anomalydetector.models import *
from azure.core.credentials import AzureKeyCredential
import pandas as pd
import os

API_KEY = os.environ['ANOMALY_DETECTOR_API_KEY']
ENDPOINT = os.environ['ANOMALY_DETECTOR_ENDPOINT']
DATA_PATH = "REPLACE_WITH_YOUR_LOCAL_SAMPLE_REQUEST_DATA_PATH" #example: c:\\test\\request-data.csv

client = AnomalyDetectorClient(ENDPOINT, AzureKeyCredential(API_KEY))

series = []
data_file = pd.read_csv(DATA_PATH, header=None, encoding='utf-8', date_parser=[0])
for index, row in data_file.iterrows():
    series.append(TimeSeriesPoint(timestamp=row[0], value=row[1]))

request = UnivariateDetectionOptions(series=series, granularity=TimeGranularity.DAILY)

change_point_response = client.detect_univariate_change_point(request)
anomaly_response = client.detect_univariate_entire_series(request)

for i in range(len(data_file.values)):
    if (change_point_response.is_change_point[i]):
        print("Change point detected at index: "+ str(i))
    elif (anomaly_response.is_anomaly[i]):
        print("Anomaly detected at index:      "+ str(i))

Wichtig

Führen Sie die Anwendung mit dem Befehl python für die quickstart-Datei aus.
```
python quickstart.py
```

Output

Anomaly detected at index:      3
Anomaly detected at index:      18
Change point detected at index: 20
Anomaly detected at index:      21
Anomaly detected at index:      22
Anomaly detected at index:      23
Anomaly detected at index:      24
Anomaly detected at index:      25
Change point detected at index: 27
Anomaly detected at index:      28
Anomaly detected at index:      29
Anomaly detected at index:      30
Anomaly detected at index:      31
Anomaly detected at index:      32
Anomaly detected at index:      35
Anomaly detected at index:      44

Verstehen der Ergebnisse

In unserem vorstehenden Code rufen wir die Anomalieerkennungs-API zweimal auf. Der erste Aufruf sucht in unserer Beispieldatenreihe mithilfe der Methode detect_change_point nach Trendumkehrpunkten. Dieser Aufruf gibt einen ChangePointDetectResponse-Wert zurück, den wir in einer Variablen gespeichert haben, der wir den Namen change_point_request gegeben haben. Anschließend durchlaufen wir die is_change_point-Liste der Antwort und geben den Index aller Werte mit dem booleschen Wert true aus.

Mit dem zweiten Aufruf wird die gesamte Beispieldatenreihe mithilfe der Methode detect_entire_series auf Anomalien überprüft. Dieser Aufruf gibt einen EntireDetectResponse-Wert zurück, den wir in einer Variablen gespeichert haben, der wir den Namen anomaly_response gegeben haben. Wir durchlaufen die is_anomaly-Liste der Antwort und geben den Index aller Werte mit dem booleschen Wert true aus. Alternativ hätten wir die Methode detect_last_point verwenden können, die für die Erkennung von Anomalien in Echtzeitdaten besser geeignet ist. Weitere Informationen finden Sie im Leitfaden zu bewährten Methoden.

Visualisieren der Ergebnisse

Zum Visualisieren der Anomalien und Umkehrpunkte in Bezug auf die Beispieldatenreihe verwenden wir die beliebte Open-Source-Bibliothek matplotlib.

Bibliothek Installieren.
```
pip install matplotlib
```

Ändern Sie Ihre quickstart.py-Datei mit dem folgenden Code:

from azure.ai.anomalydetector import AnomalyDetectorClient
from azure.ai.anomalydetector.models import *
from azure.core.credentials import AzureKeyCredential
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
import os

API_KEY = os.environ['ANOMALY_DETECTOR_API_KEY']
ENDPOINT = os.environ['ANOMALY_DETECTOR_ENDPOINT']
DATA_PATH = "REPLACE_WITH_YOUR_LOCAL_SAMPLE_REQUEST_DATA_PATH" #example: c:\\test\\request-data.csv

client = AnomalyDetectorClient(ENDPOINT, AzureKeyCredential(API_KEY))

series = []
data_file = pd.read_csv(DATA_PATH, header=None, encoding='utf-8', date_parser=[0])
for index, row in data_file.iterrows():
    series.append(TimeSeriesPoint(timestamp=row[0], value=row[1]))

request = UnivariateDetectionOptions(series=series, granularity=TimeGranularity.DAILY)

change_point_response = client.detect_univariate_change_point(request)
anomaly_response = client.detect_univariate_entire_series(request)

for i in range(len(data_file.values)):
    temp_date_to_num = mdates.date2num(data_file.values[i])
    date= temp_date_to_num[0]
    if (change_point_response.is_change_point[i]):
        plt.plot(date,data_file.values[i][1], 's', color ='blue')
        print("Change point detected at index: "+ str(i))
    elif (anomaly_response.is_anomaly[i]):
        plt.plot(date,data_file.values[i][1], '^', color="red")
        print("Anomaly detected at index:      "+ str(i))
    else:
        plt.plot(date,data_file.values[i][1], 'o', color ='green')
plt.show()

Wichtig

Verwenden Sie für die Produktion eine sichere Art der Speicherung und des Zugriffs auf Ihre Anmeldeinformationen wie Azure Key Vault. weitere Informationen zur Sicherheit von Anmeldeinformationen finden Sie im Azure KI Services-Artikel Sicherheit.

Führen Sie die Anwendung mit dem Befehl python für die quickstart-Datei aus.
```
python quickstart.py
```

Output

In diesem Codebeispiel haben wir die matplotlib-Bibliothek hinzugefügt, damit wir normale Datenpunkte leicht von Umkehrpunkten und Anomalien unterscheiden und sie visualisieren können. Umkehrpunkte werden durch blaue Quadrate dargestellt, Anomalien sind rote Dreiecke, und normale Datenpunkte sind grüne Kreise. Datumsangaben werden mithilfe der matplotlib-Methode date2num in Zahlen konvertiert, um diagrammfreundliche Werte für die y-Achse von Diagrammen bereitzustellen.

Bereinigen von Ressourcen

In dieser Schnellstartanleitung wird beschrieben, wie Sie Anomalien in Zeitreihendaten erkennen, indem Sie den Anomalieerkennungsdienst und cURL verwenden.

Allgemeine Informationen zu den Konzepten der Anomalieerkennung finden Sie im Übersichtsartikel.

Voraussetzungen

Azure-Abonnement: Kostenloses Azure-Konto
Sobald Sie über Ihr Azure-Abonnement verfügen, können Sie im Azure-Portal eine Anomalieerkennungsressource erstellen , um Ihren Schlüssel und Endpunkt zu erhalten. Warten Sie die Bereitstellung ab, und wählen Sie dann die Schaltfläche Zu Ressource wechseln aus. Sie können den kostenlosen Tarif (F0) verwenden, um den Dienst zu testen, und später für die Produktion auf einen kostenpflichtigen Tarif upgraden.
Eine gültige JSON-Datei mit Zeitreihendaten für Anomalietests Falls Sie nicht über eine eigene Datei verfügen, können Sie aus dem Anforderungstextbeispiel eine „sample.json“-Beispieldatei erstellen.

Abrufen von Schlüssel und Endpunkt

Für einen erfolgreichen Aufruf des Anomalieerkennungsdiensts benötigen Sie die folgenden Werte:

Variablenname	Wert
`ANOMALY_DETECTOR_ENDPOINT`	Diesen Wert finden Sie im Abschnitt Schlüssel und Endpunkt, wenn Sie die Ressource über das Azure-Portal untersuchen. Beispiel für einen Endpunkt: `https://YOUR_RESOURCE_NAME.cognitiveservices.azure.com/`
`ANOMALY_DETECTOR_API_KEY`	Den Wert des API-Schlüssels finden Sie im Abschnitt Schlüssel und Endpunkt, wenn Sie die Ressource über das Azure-Portal untersuchen. Sie können `KEY1` oder `KEY2` verwenden.

Erstellen von Umgebungsvariablen

Erstellen und Zuweisen von beständigen Umgebungsvariablen für Ihren Schlüssel und Endpunkt.

setx ANOMALY_DETECTOR_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE"

setx ANOMALY_DETECTOR_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

[System.Environment]::SetEnvironmentVariable('ANOMALY_DETECTOR_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')

[System.Environment]::SetEnvironmentVariable('ANOMALY_DETECTOR_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

echo export ANOMALY_DETECTOR_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE" >> /etc/environment && source /etc/environment

echo export ANOMALY_DETECTOR_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE" >> /etc/environment && source /etc/environment

Erkennen von Anomalien

Führen Sie an der Eingabeaufforderung den folgenden Befehl aus. Sie müssen die folgenden Werte in den Befehl einfügen.

Ihren Abonnementschlüssel des Anomalieerkennungsdiensts
Ihre Endpunktadresse der Anomalieerkennung
Eine gültige JSON-Datei mit Zeitreihendaten für Anomalietests Falls Sie nicht über eine eigene Datei verfügen, können Sie über das Anforderungstextbeispiel die Datei „sample.json“ erstellen.

curl -v POST "%ANOMALY_DETECTOR_ENDPOINT%/anomalydetector/v1.0/timeseries/entire/detect"
-H "Content-Type: application/json"
-H "Ocp-Apim-Subscription-Key: %ANOMALY_DETECTOR_API_KEY%"
-d "@path_to_sample_file.json"

Ein Beispiel für den vollständigen Befehl als einzelne Zeile:

curl -v POST "%ANOMALY_DETECTOR_ENDPOINT%/anomalydetector/v1.0/timeseries/entire/detect" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key: %ANOMALY_DETECTOR_API_KEY%" -d "@c:\test\rest.json"

Alternativ, falls Sie den cURL-Befehl an einer Bash-Shell ausführen, würde Ihr Befehl etwas anders lauten:

curl -v POST "$ANOMALY_DETECTOR_ENDPOINT/anomalydetector/v1.0/timeseries/entire/detect" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key: $ANOMALY_DETECTOR_API_KEY" -d "@c:\test\rest.json"

Wenn Sie die Beispieldaten aus den Voraussetzungen verwendet haben, sollten Sie eine Antwort vom Typ „200“ mit den folgenden Ergebnissen erhalten:

{
  "expectedValues": [
    827.7940908243968,
    798.9133774671927,
    888.6058431807189,
    900.5606407986661,
    962.8389426378304,
    933.2591606306954,
    891.0784104799666,
    856.1781601363697,
    809.8987227908941,
    807.375129007505,
    764.3196682448518,
    803.933498594564,
    823.5900620883058,
    794.0905641334288,
    883.164245249282,
    894.8419000690953,
    956.8430591101258,
    927.6285055190114,
    885.812983784303,
    851.6424797402517,
    806.0927886943216,
    804.6826815312029,
    762.74070738882,
    804.0251702513732,
    825.3523662579559,
    798.0404188724976,
    889.3016505577698,
    902.4226124345937,
    965.867078532635,
    937.3200495736695,
    896.1720524711102,
    862.0087368413656,
    816.4662342097423,
    814.4297745524709,
    771.8614479159354,
    811.859271346729,
    831.8998279215521,
    802.947544797165,
    892.5684407435083,
    904.5488214533809,
    966.8527063844707,
    937.3168391003043,
    895.180003672544,
    860.3649596356635,
    814.1707285969043,
    811.9054862686213,
    769.1083769610742,
    809.2328084659704
  ],
  "upperMargins": [
    41.389704541219835,
    39.94566887335964,
    44.43029215903594,
    45.02803203993331,
    48.14194713189152,
    46.66295803153477,
    44.55392052399833,
    42.808908006818484,
    40.494936139544706,
    40.36875645037525,
    38.215983412242586,
    40.196674929728196,
    41.17950310441529,
    39.70452820667144,
    44.1582122624641,
    44.74209500345477,
    47.84215295550629,
    46.38142527595057,
    44.290649189215145,
    42.58212398701258,
    40.30463943471608,
    40.234134076560146,
    38.137035369441,
    40.201258512568664,
    41.267618312897795,
    39.90202094362488,
    44.46508252788849,
    45.121130621729684,
    48.29335392663175,
    46.86600247868348,
    44.80860262355551,
    43.100436842068284,
    40.82331171048711,
    40.721488727623544,
    38.593072395796774,
    40.59296356733645,
    41.5949913960776,
    40.14737723985825,
    44.62842203717541,
    45.227441072669045,
    48.34263531922354,
    46.86584195501521,
    44.759000183627194,
    43.01824798178317,
    40.70853642984521,
    40.59527431343106,
    38.45541884805371,
    40.46164042329852
  ],
  "lowerMargins": [
    41.389704541219835,
    39.94566887335964,
    44.43029215903594,
    45.02803203993331,
    48.14194713189152,
    46.66295803153477,
    44.55392052399833,
    42.808908006818484,
    40.494936139544706,
    40.36875645037525,
    38.215983412242586,
    40.196674929728196,
    41.17950310441529,
    39.70452820667144,
    44.1582122624641,
    44.74209500345477,
    47.84215295550629,
    46.38142527595057,
    44.290649189215145,
    42.58212398701258,
    40.30463943471608,
    40.234134076560146,
    38.137035369441,
    40.201258512568664,
    41.267618312897795,
    39.90202094362488,
    44.46508252788849,
    45.121130621729684,
    48.29335392663175,
    46.86600247868348,
    44.80860262355551,
    43.100436842068284,
    40.82331171048711,
    40.721488727623544,
    38.593072395796774,
    40.59296356733645,
    41.5949913960776,
    40.14737723985825,
    44.62842203717541,
    45.227441072669045,
    48.34263531922354,
    46.86584195501521,
    44.759000183627194,
    43.01824798178317,
    40.70853642984521,
    40.59527431343106,
    38.45541884805371,
    40.46164042329852
  ],
  "isAnomaly": [
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    true,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false
  ],
  "isPositiveAnomaly": [
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    true,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false
  ],
  "isNegativeAnomaly": [
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false,
    false
  ],
  "period": 12
}

Weitere Informationen finden Sie in der REST-Referenz zur Anomalieerkennung.

Bereinigen von Ressourcen

Wenn Sie ein Azure KI Services-Abonnement bereinigen und entfernen möchten, können Sie die Ressource oder die Ressourcengruppe löschen. Wenn Sie die Ressourcengruppe löschen, werden auch alle anderen Ressourcen gelöscht, die der Ressourcengruppe zugeordnet sind.

Nächste Schritte

Konzepte:

Tutorials:

Schnellstart: Verwenden der Clientbibliothek für die multivariate Anomalieerkennung

Voraussetzungen

Einrichten

Erstellen einer neuen .NET Core-Anwendung

Installieren der Clientbibliothek

Abrufen von Schlüssel und Endpunkt

Erstellen von Umgebungsvariablen

Herunterladen von Beispieldaten

Erkennen von Anomalien

Ausgabe

Codedetails

Verstehen der Ergebnisse

Bereinigen von Ressourcen

Voraussetzungen

Einrichten

Erstellen einer neuen Node.js-Anwendung

Installieren der Clientbibliothek

Abrufen von Schlüssel und Endpunkt

Erstellen von Umgebungsvariablen

Herunterladen von Beispieldaten

Erkennen von Anomalien

Ausführen der Anwendung

Output

Verstehen der Ergebnisse

Bereinigen von Ressourcen

Voraussetzungen

Einrichten

Abrufen von Schlüssel und Endpunkt

Erstellen von Umgebungsvariablen

Herunterladen von Beispieldaten

Erkennen von Anomalien

Output

Verstehen der Ergebnisse

Visualisieren der Ergebnisse

Output

Bereinigen von Ressourcen

Voraussetzungen

Abrufen von Schlüssel und Endpunkt

Erstellen von Umgebungsvariablen

Erkennen von Anomalien

Bereinigen von Ressourcen

Nächste Schritte

Zusätzliche Ressourcen