Rychlý Start: použití klientské knihovny lineární detektoru anomálií

Článek
11/24/2021
24 min ke čtení

Začínáme s klientskou knihovnou Detektor anomálií multivariate pro jazyk C#. Postupujte podle těchto kroků a nainstalujte balíček a začněte používat algoritmy poskytované službou. Nová rozhraní API pro detekci anomálií s více odchylkami umožňují vývojářům snadno integrovat pokročilou AI pro detekci anomálií ze skupin metrik, aniž by potřebovali znalosti strojového učení nebo označená data. Závislosti a vzájemné korelace mezi různými signály se automaticky počítají jako klíčové faktory. To vám pomůže proaktivně chránit složité systémy před selháním.

Pomocí Detektor anomálií multivariate klientské knihovny jazyka C# můžete:

Detekce anomálií na úrovni systému ze skupiny časových řad
Pokud vám žádná jednotlivá časová řada toho moc nepoví a musíte se podívat na všechny signály, abyste problém detekovat.
Predikativní údržba nákladných fyzických prostředků s desítkami až stovkami různých typů senzorů, které měří různé aspekty stavu systému.

Referenční dokumentace ke knihovně | Zdrojový kód knihovny | Package (NuGet)

Požadavky

Předplatné Azure – Vytvořte si ho zdarma.
Aktuální verze .NET Core
Jakmile máte předplatné Azure, vytvořte prostředek Detektor anomálií prostředků Detektor anomálií ve službě Azure Portal a získejte svůj klíč a koncový bod. Počkejte, až se nasadí, a vyberte tlačítko Přejít k prostředku.
- Klíč a koncový bod z prostředku, který vytvoříte, budete potřebovat pro připojení aplikace k Detektor anomálií API. Vložte svůj klíč a koncový bod do kódu níže v pozdější části tohoto rychlého startu. K vyzkoušejí služby můžete použít bezplatnou cenovou úroveň ( ) a později upgradovat F0 na placenou úroveň pro produkční prostředí.

Nastavení

Vytvoření nové aplikace .NET Core

V okně konzoly (například cmd, PowerShell nebo Bash) pomocí příkazu vytvořte novou konzolovou aplikaci s dotnet new názvem anomaly-detector-quickstart-multivariate . Tento příkaz vytvoří jednoduchý projekt "Hello World" s jedním zdrojovým souborem jazyka C#: Program.cs.

dotnet new console -n anomaly-detector-quickstart-multivariate

Změňte adresář na nově vytvořenou složku aplikace. Aplikaci můžete sestavit pomocí:

dotnet build

Výstup sestavení by neměl obsahovat žádná upozornění ani chyby.

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

Instalace klientské knihovny

V adresáři aplikace nainstalujte klientskou Detektor anomálií pro .NET pomocí následujícího příkazu:

dotnet add package Azure.AI.AnomalyDetector --version 3.0.0-preview.3

Z adresáře projektu otevřete soubor program.cs a pomocí přidejte následující directives kód:

using System;
using System.Collections.Generic;
using System.Drawing.Text;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Net.NetworkInformation;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using Azure.AI.AnomalyDetector.Models;
using Azure.Core.TestFramework;
using Microsoft.Identity.Client;
using NUnit.Framework;

V metodě aplikace vytvořte proměnné pro koncový bod Azure vašeho prostředku, klíč rozhraní main() API a vlastní zdroj dat.

Poznámka

Vždy budete mít možnost použít jeden ze dvou klíčů. To umožňuje bezpečnou rotaci klíčů. Pro účely tohoto rychlého startu použijte první klíč.

string endpoint = "YOUR_API_KEY";
string apiKey =  "YOUR_ENDPOINT";
string datasource = "YOUR_SAMPLE_ZIP_FILE_LOCATED_IN_AZURE_BLOB_STORAGE_WITH_SAS";

Pokud chcete Detektor anomálií rozhraní API s více variantami, musíte nejprve vytrénovat vlastní modely. Trénovací data jsou sada několika časových řad, které splňují následující požadavky:

Každá časová řada by měla být soubor CSV se dvěma (a jenom dvěma) sloupci, "timestamp" a "value" (vše malými písmeny) jako řádkem záhlaví. Hodnoty "časového razítka" by měly odpovídat standardu ISO 8601. "hodnota" může být celá čísla nebo desetinná čísla s libovolným počtem desetinných míst. Například:

časové razítko	hodnota
2019-04-01T00:00:00Z	5
2019-04-01T00:01:00Z	3,6
2019-04-01T00:02:00Z	4
`...`	`...`

Každý soubor CSV by měl mít název podle jiné proměnné, která se použije pro trénování modelu. Například "temperature.csv" a "humidity.csv". Všechny soubory CSV by měly být zazipované do jednoho souboru ZIP bez podsložek. Soubor zip může mít název, který chcete. Soubor zip by se měl nahrát do úložiště objektů blob v Azure. Jakmile vygenerujete adresu URL SAS objektu blob (sdílené přístupové podpisy) pro soubor zip, můžete ji použít k trénování. Informace o vygenerování adres URL SAS ze služby Azure Blob Storage najdete v tomto Storage.

Příklady kódu

Tyto fragmenty kódu ukazují, jak pomocí knihovny multivariate Detektor anomálií pro .NET provést následující akce:

Ověření klienta
Trénování modelu
Detekce anomálií
Export modelu
Odstranění modelu

Ověření klienta

Vytvořte instanci klienta Detektor anomálií koncovým bodem a klíčem.

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

AnomalyDetectorClient client = new AnomalyDetectorClient(endpointUri, credential);

Trénování modelu

Vytvořte novou privátní asynchronní úlohu, jak je uvedeno níže pro zpracování trénování modelu. Použijete k TrainMultivariateModel trénování modelu GetMultivariateModelAysnc a ke kontrole dokončení trénování.

private async Task<Guid?> trainAsync(AnomalyDetectorClient client, string datasource, DateTimeOffset start_time, DateTimeOffset end_time)
{
    try
    {
        Console.WriteLine("Training new model...");

        int model_number = await getModelNumberAsync(client, false).ConfigureAwait(false);
        Console.WriteLine(String.Format("{0} available models before training.", model_number));

        ModelInfo data_feed = new ModelInfo(datasource, start_time, end_time);
        Response response_header = client.TrainMultivariateModel(data_feed);
        response_header.Headers.TryGetValue("Location", out string trained_model_id_path);
        Guid trained_model_id = Guid.Parse(trained_model_id_path.Split('/').LastOrDefault());
        Console.WriteLine(trained_model_id);

        // Wait until the model is ready. It usually takes several minutes
        Response<Model> get_response = await client.GetMultivariateModelAsync(trained_model_id).ConfigureAwait(false);
        while (get_response.Value.ModelInfo.Status != ModelStatus.Ready & get_response.Value.ModelInfo.Status != ModelStatus.Failed)
        {
            System.Threading.Thread.Sleep(10000);
            get_response = await client.GetMultivariateModelAsync(trained_model_id).ConfigureAwait(false);
            Console.WriteLine(String.Format("model_id: {0}, createdTime: {1}, lastUpdateTime: {2}, status: {3}.", get_response.Value.ModelId, get_response.Value.CreatedTime, get_response.Value.LastUpdatedTime, get_response.Value.ModelInfo.Status));
        }

        if (get_response.Value.ModelInfo.Status != ModelStatus.Ready)
        {
            Console.WriteLine(String.Format("Trainig failed."));
            IReadOnlyList<ErrorResponse> errors = get_response.Value.ModelInfo.Errors;
            foreach (ErrorResponse error in errors)
            {
                Console.WriteLine(String.Format("Error code: {0}.", error.Code));
                Console.WriteLine(String.Format("Error message: {0}.", error.Message));
            }
            throw new Exception("Training failed.");
        }

        model_number = await getModelNumberAsync(client).ConfigureAwait(false);
        Console.WriteLine(String.Format("{0} available models after training.", model_number));
        return trained_model_id;
    }
    catch (Exception e)
    {
        Console.WriteLine(String.Format("Train error. {0}", e.Message));
        throw new Exception(e.Message);
    }
}

Detekce anomálií

Pokud chcete detekovat anomálie pomocí nově natrénovaného modelu, vytvořte private async Task s názvem detectAsync . Vytvoříte nový objekt a DetectionRequest předáte ho jako parametr do DetectAnomalyAsync .

private async Task<DetectionResult> detectAsync(AnomalyDetectorClient client, string datasource, Guid model_id,DateTimeOffset start_time, DateTimeOffset end_time)
{
    try
    {
        Console.WriteLine("Start detect...");
        Response<Model> get_response = await client.GetMultivariateModelAsync(model_id).ConfigureAwait(false);

        DetectionRequest detectionRequest = new DetectionRequest(datasource, start_time, end_time);
        Response result_response = await client.DetectAnomalyAsync(model_id, detectionRequest).ConfigureAwait(false);
        var ok = result_response.Headers.TryGetValue("Location", out string result_id_path);
        Guid result_id = Guid.Parse(result_id_path.Split('/').LastOrDefault());
        // get detection result
        Response<DetectionResult> result = await client.GetDetectionResultAsync(result_id).ConfigureAwait(false);
        while (result.Value.Summary.Status != DetectionStatus.Ready & result.Value.Summary.Status != DetectionStatus.Failed)
        {
            System.Threading.Thread.Sleep(2000);
            result = await client.GetDetectionResultAsync(result_id).ConfigureAwait(false);
        }

        if (result.Value.Summary.Status != DetectionStatus.Ready)
        {
            Console.WriteLine(String.Format("Inference failed."));
            IReadOnlyList<ErrorResponse> errors = result.Value.Summary.Errors;
            foreach (ErrorResponse error in errors)
            {
                Console.WriteLine(String.Format("Error code: {0}.", error.Code));
                Console.WriteLine(String.Format("Error message: {0}.", error.Message));
            }
            return null;
        }

        return result.Value;
    }
    catch (Exception e)
    {
        Console.WriteLine(String.Format("Detection error. {0}", e.Message));
        throw new Exception(e.Message);
    }
}

Export modelu

Poznámka

Příkaz pro export slouží k povolení spouštění Detektor anomálií více variant v kontejnerizovaném prostředí. U multivariate se to v současné době nepodporuje, ale podpora bude přidána v budoucnu.

Pokud chcete vytrénovaný model exportovat, vytvořte private async Task pojmenovaný exportAysnc . Použijete a ExportModelAsync předáte ID modelu, který chcete exportovat.

private async Task exportAsync(AnomalyDetectorClient client, Guid model_id, string model_path = "model.zip")
{
    try
    {
        Stream model = await client.ExportModelAsync(model_id).ConfigureAwait(false);
        if (model != null)
        {
            var fileStream = File.Create(model_path);
            model.Seek(0, SeekOrigin.Begin);
            model.CopyTo(fileStream);
            fileStream.Close();
        }
    }
    catch (Exception e)
    {
        Console.WriteLine(String.Format("Export error. {0}", e.Message));
        throw new Exception(e.Message);
    }
}

Odstranění modelu

Pokud chcete odstranit model, který jste vytvořili dříve, a předat DeleteMultivariateModelAsync ID modelu, který chcete odstranit. Pokud chcete načíst ID modelu, můžete getModelNumberAsync nám:

private async Task deleteAsync(AnomalyDetectorClient client, Guid model_id)
{
    await client.DeleteMultivariateModelAsync(model_id).ConfigureAwait(false);
    int model_number = await getModelNumberAsync(client).ConfigureAwait(false);
    Console.WriteLine(String.Format("{0} available models after deletion.", model_number));
}
private async Task<int> getModelNumberAsync(AnomalyDetectorClient client, bool delete = false)
{
    int count = 0;
    AsyncPageable<ModelSnapshot> model_list = client.ListMultivariateModelAsync(0, 10000);
    await foreach (ModelSnapshot x in model_list)
    {
        count += 1;
        Console.WriteLine(String.Format("model_id: {0}, createdTime: {1}, lastUpdateTime: {2}.", x.ModelId, x.CreatedTime, x.LastUpdatedTime));
        if (delete & count < 4)
        {
            await client.DeleteMultivariateModelAsync(x.ModelId).ConfigureAwait(false);
        }
    }
    return count;
}

Metoda Main

Teď, když máte všechny součásti, musíte do hlavní metody přidat další kód pro volání nově vytvořených úloh.


{
    //read endpoint and apiKey
     string endpoint = "YOUR_API_KEY";
    string apiKey =  "YOUR_ENDPOINT";
    string datasource = "YOUR_SAMPLE_ZIP_FILE_LOCATED_IN_AZURE_BLOB_STORAGE_WITH_SAS";
    Console.WriteLine(endpoint);
    var endpointUri = new Uri(endpoint);
    var credential = new AzureKeyCredential(apiKey);

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

    // train
    TimeSpan offset = new TimeSpan(0);
    DateTimeOffset start_time = new DateTimeOffset(2021, 1, 1, 0, 0, 0, offset);
    DateTimeOffset end_time = new DateTimeOffset(2021, 1, 2, 12, 0, 0, offset);
    Guid? model_id_raw = null;
    try
    {
        model_id_raw = await trainAsync(client, datasource, start_time, end_time).ConfigureAwait(false);
        Console.WriteLine(model_id_raw);
        Guid model_id = model_id_raw.GetValueOrDefault();

        // detect
        start_time = end_time;
        end_time = new DateTimeOffset(2021, 1, 3, 0, 0, 0, offset);
        DetectionResult result = await detectAsync(client, datasource, model_id, start_time, end_time).ConfigureAwait(false);
        if (result != null)
        {
            Console.WriteLine(String.Format("Result ID: {0}", result.ResultId));
            Console.WriteLine(String.Format("Result summary: {0}", result.Summary));
            Console.WriteLine(String.Format("Result length: {0}", result.Results.Count));
        }

        // export model
        await exportAsync(client, model_id).ConfigureAwait(false);

        // delete
        await deleteAsync(client, model_id).ConfigureAwait(false);
    }
    catch (Exception e)
    {
        String msg = String.Format("Multivariate error. {0}", e.Message);
        if (model_id_raw != null)
        {
            await deleteAsync(client, model_id_raw.GetValueOrDefault()).ConfigureAwait(false);
        }
        Console.WriteLine(msg);
        throw new Exception(msg);
    }
}

Spuštění aplikace

Spusťte aplikaci pomocí dotnet run příkazu z adresáře vaší aplikace.

dotnet run

Vyčištění prostředků

Pokud chcete vyčistit a odebrat předplatné Cognitive Services, můžete odstranit prostředek nebo skupinu prostředků. Odstraněním skupiny prostředků se odstraní také všechny ostatní prostředky přidružené ke skupině prostředků.

Další kroky

Začínáme s klientskou knihovnou Detektor anomálií multivariate pro JavaScript. Postupujte podle těchto kroků a nainstalujte balíček a začněte používat algoritmy poskytované službou. Nová rozhraní API pro detekci anomálií s více odchylkami umožňují vývojářům snadno integrovat pokročilou AI pro detekci anomálií ze skupin metrik, aniž by potřebovali znalosti strojového učení nebo označená data. Závislosti a vzájemné korelace mezi různými signály se automaticky počítají jako klíčové faktory. To vám pomůže proaktivně chránit složité systémy před selháním.

Pomocí Detektor anomálií multivariate klientské knihovny pro JavaScript můžete:

Detekce anomálií na úrovni systému ze skupiny časových řad
Pokud vám žádná jednotlivá časová řada toho moc nepoví a musíte se podívat na všechny signály, abyste problém detekovat.
Predikativní údržba nákladných fyzických prostředků s desítkami až stovkami různých typů senzorů, které měří různé aspekty stavu systému.

Referenční dokumentace ke knihovně | Zdrojový kód knihovny | Balíček (npm) | Ukázkový kód

Požadavky

Předplatné Azure – Vytvořte si ho zdarma.
Aktuální verze Node.js
Jakmile máte předplatné Azure, vytvořte prostředek Detektor anomálií prostředků Detektor anomálií ve službě Azure Portal a získejte svůj klíč a koncový bod. Počkejte, až se nasadí, a klikněte na tlačítko Přejít k prostředku.
- Klíč a koncový bod z prostředku, který vytvoříte, budete potřebovat pro připojení aplikace k rozhraní DETEKTOR ANOMÁLIÍ API. Svůj klíč a koncový bod vložíte do kódu níže v pozdější části tohoto rychlého startu. K vyzkoušejí služby můžete použít bezplatnou cenovou úroveň ( ) a později upgradovat F0 na placenou úroveň pro produkční prostředí.

Nastavení

Vytvoření nové aplikace Node.js

V okně konzoly (například cmd, PowerShell nebo Bash) vytvořte nový adresář pro vaši aplikaci a přejděte do něj.

mkdir myapp && cd myapp

Spuštěním příkazu npm init vytvořte aplikaci Node se package.json souborem.

npm init

Vytvořte soubor s názvem a index.js importujte následující knihovny: '

'use strict'

const fs = require('fs');
const parse = require("csv-parse/lib/sync");
const { AnomalyDetectorClient } = require('@azure/ai-anomaly-detector');
const { AzureKeyCredential } = require('@azure/core-auth');

Vytvořte proměnné pro koncový bod a klíč Azure vašeho prostředku. Vytvořte další proměnnou pro příklad datového souboru.

Poznámka

Vždy budete mít možnost použít jeden ze dvou klíčů. To umožňuje bezpečnou rotaci klíčů. Pro účely tohoto rychlého startu použijte první klíč.

const apiKey = "YOUR_API_KEY";
const endpoint = "YOUR_ENDPOINT";
const data_source = "YOUR_SAMPLE_ZIP_FILE_LOCATED_IN_AZURE_BLOB_STORAGE_WITH_SAS";

časové razítko	hodnota
2019-04-01T00:00:00Z	5
2019-04-01T00:01:00Z	3,6
2019-04-01T00:02:00Z	4
`...`	`...`

Instalace klientské knihovny

Nainstalujte ms-rest-azure azure-ai-anomalydetector balíčky NPM a . Knihovna csv-parse se také používá v tomto rychlém startu:

npm install @azure/ai-anomaly-detector csv-parse

Soubor vaší package.json aplikace se aktualizuje o závislosti.

Příklady kódu

Tyto fragmenty kódu ukazují, jak pomocí klientské knihovny Detektor anomálií pro Node.js:

Ověření klienta
Učení modelu
Detekce anomálií
Export modelu
Odstranění modelu

Ověření klienta

Vytvořte instanci objektu s koncovým bodem a AnomalyDetectorClient přihlašovacími údaji.

const client = new AnomalyDetectorClient(endpoint, new AzureKeyCredential(apiKey));

Učení modelu

Vytvoření výsledku modelu

Nejprve musíme vytvořit požadavek modelu. Ujistěte se, že počáteční a koncový čas jsou v souladu se zdrojem dat.

const Modelrequest = {
  source: data_source,
  startTime: new Date(2021,0,1,0,0,0),
  endTime: new Date(2021,0,2,12,0,0),
  slidingWindow:200
};

Trénovat nový model

Požadavek modelu budete muset předat metodě klienta Detektor anomálií trainMultivariateModel klienta.

console.log("Training a new model...")
const train_response = await client.trainMultivariateModel(Modelrequest)
const model_id = train_response.location?.split("/").pop() ?? ""
console.log("New model ID: " + model_id)

Pokud chcete zkontrolovat, jestli je trénování modelu dokončené, můžete sledovat jeho stav:

let model_response = await client.getMultivariateModel(model_id);
let model_status = model_response.modelInfo.status;

while (model_status != 'READY' && model_status != 'FAILED'){
  await sleep(10000).then(() => {});
  model_response = await client.getMultivariateModel(model_id);
  model_status = model_response.modelInfo.status;
}

if (model_status == 'FAILED') {
  console.log("Training failed.\nErrors:");
  for (let error of model_response.modelInfo?.errors ?? []) {
    console.log("Error code: " + error.code + ". Message: " + error.message);
  }
}

console.log("TRAINING FINISHED.");

Detekce anomálií

Pomocí funkcí a určete, jestli ve vašem zdroji dat existují detectAnomaly getDectectionResult nějaké anomálie.

console.log("Start detecting...");
const detect_request = {
  source: data_source,
  startTime: new Date(2021,0,2,12,0,0),
  endTime: new Date(2021,0,3,0,0,0)
};
const result_header = await client.detectAnomaly(model_id, detect_request);
const result_id = result_header.location?.split("/").pop() ?? "";
let result = await client.getDetectionResult(result_id);
let result_status = result.summary.status;

while (result_status != 'READY' && result_status != 'FAILED'){
  await sleep(2000).then(() => {});
  result = await client.getDetectionResult(result_id);
  result_status = result.summary.status;
}

if (result_status == 'FAILED') {
  console.log("Detection failed.\nErrors:");
  for (let error of result.summary.errors ?? []) {
    console.log("Error code: " + error.code + ". Message: " + error.message)
  }
}
console.log("Result status: " + result_status);
console.log("Result Id: " + result.resultId);

Export modelu

Poznámka

K exportu vytrénovaného modelu použijte exportModel funkci .

const export_result = await client.exportModel(model_id)
const model_path = "model.zip"
const destination = fs.createWriteStream(model_path)
export_result.readableStreamBody?.pipe(destination)
console.log("New model has been exported to "+model_path+".")

Odstranění modelu

Pokud chcete odstranit existující model, který je k dispozici pro aktuální prostředek, použijte deleteMultivariateModel funkci .

client.deleteMultivariateModel(model_id)
console.log("New model has been deleted.")

Spuštění aplikace

Před spuštěním aplikace může být užitečné zkontrolovat kód proti úplnému vzorového kódu.

Spusťte aplikaci pomocí node příkazu v souboru rychlého startu.

node index.js

Vyčištění prostředků

Další kroky

Začněte s klientskou knihovnou anomálií lineární pro Python. Pomocí těchto kroků nainstalujete balíček Start s použitím algoritmů poskytovaných službou. Nová rozhraní API pro detekci anomálií lineární umožňují vývojářům snadnou integraci pokročilého AI pro detekci anomálií ze skupin metrik, aniž by to mělo znalosti strojového učení nebo data s popisky. Závislosti a vzájemné korelace mezi různými signály se automaticky počítají jako klíčové faktory. To vám pomůže aktivně chránit komplexní systémy před chybami.

Použijte klientskou knihovnu anomálie lineární pro Python k těmto akcím:

Zjišťuje anomálie na úrovni systému ze skupiny časových řad.
Když kterákoli z jednotlivých časových řad neřekne hodně a musíte se podívat na všechny signály a zjistit problém.
Predicative údržbu drahých fyzických prostředků s desítkou až stovkami různých typů senzorů, které měří různé aspekty stavu systému.

Referenční dokumentace ke knihovně | Zdrojový kód knihovny | Balíček (PyPi) | Vzorový kód

Požadavky

Python 3.x
Knihovna analýzy dat PANDAS
Předplatné Azure – Vytvořte si ho zdarma .
Jakmile budete mít předplatné Azure, vytvořením prostředku detektoru anomálií v Azure Portal, abyste získali svůj klíč a koncový bod. Počkejte na nasazení a klikněte na tlačítko Přejít k prostředku .
- K připojení aplikace k rozhraní API detektoru anomálií budete potřebovat klíč a koncový bod z prostředku, který vytvoříte. Svůj klíč a koncový bod vložíte do níže uvedeného kódu později v rychlém startu. K vyzkoušení služby můžete použít bezplatnou cenovou úroveň ( F0 ) a upgradovat ji později na placenou úroveň pro produkční prostředí.

Nastavení

Instalace klientské knihovny

Po instalaci Pythonu můžete klientské knihovny nainstalovat pomocí nástroje:

pip install pandas
pip install --upgrade azure-ai-anomalydetector

Vytvoření nové aplikace v Pythonu

Vytvořte nový soubor Pythonu a importujte následující knihovny.

import os
import time
from datetime import datetime

from azure.ai.anomalydetector import AnomalyDetectorClient
from azure.ai.anomalydetector.models import DetectionRequest, ModelInfo
from azure.core.credentials import AzureKeyCredential
from azure.core.exceptions import HttpResponseError

Vytvořte proměnné pro klíč jako proměnnou prostředí, cestu k datovému souboru časové řady a umístění Azure vašeho předplatného.

Poznámka

Vždy budete mít možnost použít jeden ze dvou klíčů. To umožňuje zabezpečenou rotaci klíčů. Pro účely tohoto rychlého startu se používá první klíč.

subscription_key = "ANOMALY_DETECTOR_KEY"
anomaly_detector_endpoint = "ANOMALY_DETECTOR_ENDPOINT"

Příklady kódu

Tyto fragmenty kódu ukazují, jak provést následující akce pomocí klientské knihovny pro detekci anomálií pro Python:

Ověření klienta
Trénování modelu
Detekovat anomálie
Exportovat model
Odstranit model

Ověření klienta

K vytvoření instance nového klienta detektoru anomálií musíte předat klíč předplatného detektoru anomálií a přidružený koncový bod. Vytvoříme také zdroj dat.

Aby bylo možné používat rozhraní API pro detekci anomálií lineární, musíte nejprve naučit vlastní modely. Školicí data jsou sada několika časových řad, které splňují následující požadavky:

Každá časová řada by měla být souborem CSV, který má dva (a jenom dva) sloupce, "časové razítko a" hodnotu "(s malým písmenem) jako řádek záhlaví. Hodnoty časového razítka by měly odpovídat normě ISO 8601; hodnota může být celá čísla nebo desetinná čísla s libovolným počtem desetinných míst. Například:

časové razítko	hodnota
2019-04-01T00:00:00Z	5
2019-04-01T00:01:00Z	3,6
2019-04-01T00:02:00Z	4
`...`	`...`

Každý soubor CSV by měl být pojmenován za jinou proměnnou, která se bude používat pro školení modelů. Například "temperature.csv" a "humidity.csv". Všechny soubory CSV by měly být komprimované do jednoho souboru ZIP bez podsložek. Soubor ZIP může mít libovolný název, který chcete. Soubor zip by se měl nahrát do úložiště objektů BLOB v Azure. Jakmile vygenerujete adresu URL objektu BLOB SAS (Shared Access signaturs) pro soubor zip, můžete ho použít pro školení. V tomto dokumentu najdete informace o tom, jak vygenerovat adresy URL SAS z Azure Blob Storage.

class MultivariateSample():

def __init__(self, subscription_key, anomaly_detector_endpoint, data_source=None):
    self.sub_key = subscription_key
    self.end_point = anomaly_detector_endpoint

    # Create an Anomaly Detector client

    # <client>
    self.ad_client = AnomalyDetectorClient(AzureKeyCredential(self.sub_key), self.end_point)
    # </client>

    self.data_source = "YOUR_SAMPLE_ZIP_FILE_LOCATED_IN_AZURE_BLOB_STORAGE_WITH_SAS"

Trénování modelu

Nejprve provedeme model, provedeme kontrolu stavu modelu během školení, abyste zjistili, kdy se školení dokončilo, a potom načtete nejnovější ID modelu, které budeme potřebovat při přesunu do fáze zjišťování.

def train(self, start_time, end_time):
    # Number of models available now
    model_list = list(self.ad_client.list_multivariate_model(skip=0, top=10000))
    print("{:d} available models before training.".format(len(model_list)))
    
    # Use sample data to train the model
    print("Training new model...(it may take a few minutes)")
    data_feed = ModelInfo(start_time=start_time, end_time=end_time, source=self.data_source)
    response_header = \
    self.ad_client.train_multivariate_model(data_feed, cls=lambda *args: [args[i] for i in range(len(args))])[-1]
    trained_model_id = response_header['Location'].split("/")[-1]
    
    # Model list after training
    new_model_list = list(self.ad_client.list_multivariate_model(skip=0, top=10000))
    
    # Wait until the model is ready. It usually takes several minutes
    model_status = None
    while model_status != ModelStatus.READY and model_status != ModelStatus.FAILED:
        model_info = self.ad_client.get_multivariate_model(trained_model_id).model_info
        model_status = model_info.status
        time.sleep(10)

    if model_status == ModelStatus.FAILED:
        print("Creating model failed.")
        print("Errors:")
        if model_info.errors:
            for error in model_info.errors:
                print("Error code: {}. Message: {}".format(error.code, error.message))
        else:
            print("None")
        return None

    if model_status == ModelStatus.READY:
        # Model list after training
        new_model_list = list(self.ad_client.list_multivariate_model(skip=0, top=10000))
        print("Done.\n--------------------")
        print("{:d} available models after training.".format(len(new_model_list)))

    # Return the latest model id
    return trained_model_id

Detekovat anomálie

Pomocí detect_anomaly a get_dectection_result Určete, jestli ve zdroji dat nejsou nějaké anomálie. Pro model, který jste právě proučeni, budete muset předat ID modelu.

def detect(self, model_id, start_time, end_time):
    # Detect anomaly in the same data source (but a different interval)
    try:
        detection_req = DetectionRequest(source=self.data_source, start_time=start_time, end_time=end_time)
        response_header = self.ad_client.detect_anomaly(model_id, detection_req,
                                                        cls=lambda *args: [args[i] for i in range(len(args))])[-1]
        result_id = response_header['Location'].split("/")[-1]
    
        # Get results (may need a few seconds)
        r = self.ad_client.get_detection_result(result_id)
        while r.summary.status != DetectionStatus.READY and r.summary.status != DetectionStatus.FAILED:
            r = self.ad_client.get_detection_result(result_id)
            time.sleep(2)

        if r.summary.status == DetectionStatus.FAILED:
            print("Detection failed.")
            print("Errors:")
            if r.summary.errors:
                for error in r.summary.errors:
                    print("Error code: {}. Message: {}".format(error.code, error.message))
            else:
                print("None")
            return None
    except HttpResponseError as e:
        print('Error code: {}'.format(e.error.code), 'Error message: {}'.format(e.error.message))
    except Exception as e:
        raise e
    return r

Exportovat model

Poznámka

Příkaz pro export má sloužit k tomu, aby bylo možné v kontejnerovém prostředí spouštět modely lineární anomálie. Tato akce není v současné době pro lineární podporovaná, ale v budoucnu se přidá podpora.

Pokud chcete exportovat použití modelu export_model a předat ID modelu modelu, který chcete exportovat:

def export_model(self, model_id, model_path="model.zip"):

    # Export the model
    model_stream_generator = self.ad_client.export_model(model_id)
    with open(model_path, "wb") as f_obj:
        while True:
            try:
                f_obj.write(next(model_stream_generator))
            except StopIteration:
                break
            except Exception as e:
                raise e

Odstranit model

Chcete-li odstranit model použití delete_multivariate_model a předat ID modelu modelu, který chcete odstranit:

def delete_model(self, model_id):

    # Delete the mdoel
    self.ad_client.delete_multivariate_model(model_id)
    model_list_after_delete = list(self.ad_client.list_multivariate_model(skip=0, top=10000))
    print("{:d} available models after deletion.".format(len(model_list_after_delete)))

Spuštění aplikace

Před spuštěním aplikace potřebujeme přidat nějaký kód pro volání našich nově vytvořených funkcí.

if __name__ == '__main__':
    subscription_key = "ANOMALY_DETECTOR_KEY"
    anomaly_detector_endpoint = "ANOMALY_DETECTOR_ENDPOINT"

    # Create a new sample and client
    sample = MultivariateSample(subscription_key, anomaly_detector_endpoint, data_source=None)

    # Train a new model
    model_id = sample.train(datetime(2021, 1, 1, 0, 0, 0), datetime(2021, 1, 2, 12, 0, 0))

    # Reference
    result = sample.detect(model_id, datetime(2021, 1, 2, 12, 0, 0), datetime(2021, 1, 3, 0, 0, 0))
    print("Result ID:\t", result.result_id)
    print("Result summary:\t", result.summary)
    print("Result length:\t", len(result.results))

    # Export model
    sample.export_model(model_id, "model.zip")

    # Delete model
    sample.delete_model(model_id)

Před spuštěním aplikace může být užitečné kontrolovat projekt před úplným ukázkovým kódem , ze kterého je tento rychlý Start odvozen.

Máme také podrobný Jupyter notebook , které vám pomůžou začít.

Spusťte aplikaci pomocí python příkazu a názvu souboru.

Vyčištění prostředků

Pokud chcete vyčistit a odebrat předplatné Cognitive Services, můžete prostředek nebo skupinu prostředků odstranit. Odstraněním skupiny prostředků dojde také k odstranění všech dalších prostředků přidružených ke skupině prostředků.

Další kroky

Začněte s klientskou knihovnou anomálie lineární pro Java. Pomocí těchto kroků nainstalujete balíček Start s použitím algoritmů poskytovaných službou. Nová rozhraní API pro detekci anomálií lineární umožňují vývojářům snadnou integraci pokročilého AI pro detekci anomálií ze skupin metrik, aniž by to mělo znalosti strojového učení nebo data s popisky. Závislosti a vzájemné korelace mezi různými signály se automaticky počítají jako klíčové faktory. To vám pomůže aktivně chránit komplexní systémy před chybami.

Pomocí klientské knihovny lineární detektoru anomálií pro jazyk Java:

Zjišťuje anomálie na úrovni systému ze skupiny časových řad.
Když kterákoli z jednotlivých časových řad neřekne hodně a musíte se podívat na všechny signály a zjistit problém.
Predicative údržbu drahých fyzických prostředků s desítkou až stovkami různých typů senzorů, které měří různé aspekty stavu systému.

Referenční dokumentace ke knihovně | Zdrojový kód knihovny | Balíček (Maven) | Vzorový kód

Požadavky

Předplatné Azure – Vytvořte si ho zdarma .
Aktuální verze sady Java Development Kit (JDK)
Nástroj Gradle Buildnebo jiný správce závislostí.
Jakmile budete mít předplatné Azure, vytvořením prostředku detektoru anomálií v Azure Portal, abyste získali svůj klíč a koncový bod. Počkejte na nasazení a klikněte na tlačítko Přejít k prostředku .
- K připojení aplikace k rozhraní API detektoru anomálií budete potřebovat klíč a koncový bod z prostředku, který vytvoříte. Svůj klíč a koncový bod vložíte do níže uvedeného kódu později v rychlém startu. K vyzkoušení služby můžete použít bezplatnou cenovou úroveň ( F0 ) a upgradovat ji později na placenou úroveň pro produkční prostředí.

Nastavení

Vytvořit nový projekt Gradle

V tomto rychlém startu se používá správce závislostí Gradle. Další informace o klientské knihovně najdete v úložišti Maven Central.

V okně konzoly (například cmd, PowerShell nebo bash) vytvořte nový adresář pro vaši aplikaci a přejděte na něj.

mkdir myapp && cd myapp

Spusťte gradle init příkaz z pracovního adresáře. Tento příkaz vytvoří základní soubory sestavení pro Gradle, včetně Build. Gradle. kts , který se používá za běhu k vytvoření a konfiguraci vaší aplikace.

gradle init --type basic

Po zobrazení výzvy k výběru DSL vyberte Kotlin.

Instalace klientské knihovny

Vyhledejte Build. Gradle. kts a otevřete ho pomocí vašeho preferovaného integrovaného vývojového prostředí (IDE) nebo textového editoru. Pak zkopírujte do této konfigurace sestavení. Nezapomeňte zahrnout závislosti projektu.

dependencies {
    compile("com.azure:azure-ai-anomalydetector")
}

Vytvoření souboru Java

Vytvořte složku pro ukázkovou aplikaci. V pracovním adresáři spusťte následující příkaz:

mkdir -p src/main/java

Přejděte do nové složky a vytvořte soubor s názvem MetricsAdvisorQuickstarts. Java. Otevřete ho v preferovaném editoru nebo integrovaném vývojovém prostředí a přidejte následující import příkazy:

package com.azure.ai.anomalydetector;

import com.azure.ai.anomalydetector.models.*;
import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.http.*;
import com.azure.core.http.policy.*;
import com.azure.core.http.rest.PagedIterable;
import com.azure.core.http.rest.PagedResponse;
import com.azure.core.http.rest.Response;
import com.azure.core.http.rest.StreamResponse;
import com.azure.core.util.Context;
import reactor.core.publisher.Flux;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.nio.ByteBuffer;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.Iterator;
import java.util.List;
import java.util.UUID;
import java.util.stream.Collectors;

Vytvořte proměnné koncového bodu a klíče Azure prostředku. Vytvořte další proměnnou pro ukázkový datový soubor.

Poznámka

Vždy budete mít možnost použít jeden ze dvou klíčů. To umožňuje zabezpečenou rotaci klíčů. Pro účely tohoto rychlého startu se používá první klíč.

String key = "YOUR_API_KEY";
String endpoint = "YOUR_ENDPOINT";

časové razítko	hodnota
2019-04-01T00:00:00Z	5
2019-04-01T00:01:00Z	3,6
2019-04-01T00:02:00Z	4
`...`	`...`

Příklady kódu

Tyto fragmenty kódu ukazují, jak provést následující akce pomocí klientské knihovny pro detekci anomálií pro Node.js:

Ověření klienta
Učení modelu
Detekovat anomálie
Exportovat model
Odstranit model

Ověření klienta

Vytvořte instanci anomalyDetectorClient objektu s vaším koncovým bodem a přihlašovacími údaji.

HttpHeaders headers = new HttpHeaders()
    .put("Accept", ContentType.APPLICATION_JSON);

HttpPipelinePolicy authPolicy = new AzureKeyCredentialPolicy(key,
    new AzureKeyCredential(key));
AddHeadersPolicy addHeadersPolicy = new AddHeadersPolicy(headers);

HttpPipeline httpPipeline = new HttpPipelineBuilder().httpClient(HttpClient.createDefault())
    .policies(authPolicy, addHeadersPolicy).build();
// Instantiate a client that will be used to call the service.
HttpLogOptions httpLogOptions = new HttpLogOptions();
httpLogOptions.setLogLevel(HttpLogDetailLevel.BODY_AND_HEADERS);

AnomalyDetectorClient anomalyDetectorClient = new AnomalyDetectorClientBuilder()
    .pipeline(httpPipeline)
    .endpoint(endpoint)
    .httpLogOptions(httpLogOptions)
    .buildClient();

Učení modelu

Sestavit výsledek modelu a model výuky

Nejdřív musíme vytvořit požadavek na model. Ujistěte se, že počáteční a koncový čas se zarovnává se zdrojem dat.

Aby bylo možné používat rozhraní API pro detekci anomálií lineární, musíme před použitím detekce vyškolit náš vlastní model. Data použitá pro školení jsou dávkou časových řad, přičemž každá časová řada by měla být v souboru CSV se dvěma sloupci, "časovým razítkem" a "hodnotou"(názvy sloupců by měly být přesně stejné). Každý soubor CSV by měl být pojmenován za každou proměnnou pro časovou řadu. Všechny časové řady by měly být ve formátu ZIP do jednoho souboru zip a nahrály do Azure Blob Storagea pro název souboru zip není potřeba. Alternativně je možné do souboru ZIP zahrnout další meta.js, pokud chcete, aby se název proměnné lišil od názvu .zip souboru. Po vygenerování adresy URL (SAS) objektu BLOB (Shared Access signatury)můžeme pro školení použít adresu URL souboru ZIP.

Path path = Paths.get("test-data.csv");
List<String> requestData = Files.readAllLines(path);
List<TimeSeriesPoint> series = requestData.stream()
    .map(line -> line.trim())
    .filter(line -> line.length() > 0)
    .map(line -> line.split(",", 2))
    .filter(splits -> splits.length == 2)
    .map(splits -> {
        TimeSeriesPoint timeSeriesPoint = new TimeSeriesPoint();
        timeSeriesPoint.setTimestamp(OffsetDateTime.parse(splits[0]));
        timeSeriesPoint.setValue(Float.parseFloat(splits[1]));
        return timeSeriesPoint;
    })
    .collect(Collectors.toList());

Integer window = 28;
AlignMode alignMode = AlignMode.OUTER;
FillNAMethod fillNAMethod = FillNAMethod.LINEAR;
Integer paddingValue = 0;
AlignPolicy alignPolicy = new AlignPolicy()
                                .setAlignMode(alignMode)
                                .setFillNAMethod(fillNAMethod)
                                .setPaddingValue(paddingValue);
String source = "YOUR_SAMPLE_ZIP_FILE_LOCATED_IN_AZURE_BLOB_STORAGE_WITH_SAS";
OffsetDateTime startTime = OffsetDateTime.of(2021, 1, 2, 0, 0, 0, 0, ZoneOffset.UTC);
OffsetDateTime endTime = OffsetDateTime.of(2021, 1, 3, 0, 0, 0, 0, ZoneOffset.UTC);
String displayName = "Devops-MultiAD";

ModelInfo request = new ModelInfo()
                        .setSlidingWindow(window)
                        .setAlignPolicy(alignPolicy)
                        .setSource(source)
                        .setStartTime(startTime)
                        .setEndTime(endTime)
                        .setDisplayName(displayName);
TrainMultivariateModelResponse trainMultivariateModelResponse = anomalyDetectorClient.trainMultivariateModelWithResponse(request, Context.NONE);
String header = trainMultivariateModelResponse.getDeserializedHeaders().getLocation();
String[] substring = header.split("/");
UUID modelId = UUID.fromString(substring[substring.length - 1]);
System.out.println(modelId);

//Check model status until the model is ready
Response<Model> trainResponse;
while (true) {
    trainResponse = anomalyDetectorClient.getMultivariateModelWithResponse(modelId, Context.NONE);
    ModelStatus modelStatus = trainResponse.getValue().getModelInfo().getStatus();
    if (modelStatus == ModelStatus.READY || modelStatus == ModelStatus.FAILED) {
        break;
    }
    TimeUnit.SECONDS.sleep(10);
}

if (trainResponse.getValue().getModelInfo().getStatus() != ModelStatus.READY){
    System.out.println("Training failed.");
    List<ErrorResponse> errorMessages = trainResponse.getValue().getModelInfo().getErrors();
    for (ErrorResponse errorMessage : errorMessages) {
        System.out.println("Error code:  " + errorMessage.getCode());
        System.out.println("Error message:  " + errorMessage.getMessage());
    }
}

Detekovat anomálie

DetectionRequest detectionRequest = new DetectionRequest().setSource(source).setStartTime(startTime).setEndTime(endTime);
DetectAnomalyResponse detectAnomalyResponse = anomalyDetectorClient.detectAnomalyWithResponse(modelId, detectionRequest, Context.NONE);
String location = detectAnomalyResponse.getDeserializedHeaders().getLocation();
String[] substring = location.split("/");
UUID resultId = UUID.fromString(substring[substring.length - 1]);

DetectionResult detectionResult;
while (true) {
    detectionResult = anomalyDetectorClient.getDetectionResult(resultId);
    DetectionStatus detectionStatus = detectionResult.getSummary().getStatus();;
    if (detectionStatus == DetectionStatus.READY || detectionStatus == DetectionStatus.FAILED) {
        break;
    }
    TimeUnit.SECONDS.sleep(10);
}

if (detectionResult.getSummary().getStatus() != DetectionStatus.READY){
    System.out.println("Inference failed");
    List<ErrorResponse> detectErrorMessages = detectionResult.getSummary().getErrors();
    for (ErrorResponse errorMessage : detectErrorMessages) {
        System.out.println("Error code:  " + errorMessage.getCode());
        System.out.println("Error message:  " + errorMessage.getMessage());
    }
}

Exportovat model

Poznámka

K vyexportování svého vyučeného modelu použijte exportModelWithResponse .

StreamResponse response_export = anomalyDetectorClient.exportModelWithResponse(model_id, Context.NONE);
Flux<ByteBuffer> value = response_export.getValue();
FileOutputStream bw = new FileOutputStream("result.zip");
value.subscribe(s -> write(bw, s), (e) -> close(bw), () -> close(bw));

Odstranit model

Pokud chcete odstranit existující model, který je k dispozici pro aktuální prostředek, použijte deleteMultivariateModelWithResponse funkci.

Response<Void> deleteMultivariateModelWithResponse = anomalyDetectorClient.deleteMultivariateModelWithResponse(model_id, Context.NONE);

Spuštění aplikace

Aplikaci můžete vytvořit pomocí:

gradle build

Spuštění aplikace

Před spuštěním může být užitečné kontrolu kódu pomocí úplného vzorového kódu.

Spusťte aplikaci s run cílem:

gradle run

Rychlý Start: použití klientské knihovny lineární detektoru anomálií

Ohodnoťte vaše zkušenosti

Požadavky

Nastavení

Vytvoření nové aplikace .NET Core

Instalace klientské knihovny

Příklady kódu

Ověření klienta

Trénování modelu

Detekce anomálií

Export modelu

Odstranění modelu

Metoda Main

Spuštění aplikace

Vyčištění prostředků

Další kroky

Požadavky

Nastavení

Vytvoření nové aplikace Node.js

Instalace klientské knihovny

Příklady kódu

Ověření klienta

Učení modelu

Vytvoření výsledku modelu

Trénovat nový model

Detekce anomálií

Export modelu

Odstranění modelu

Spuštění aplikace

Vyčištění prostředků

Další kroky

Požadavky

Nastavení

Instalace klientské knihovny

Vytvoření nové aplikace v Pythonu

Příklady kódu

Ověření klienta

Trénování modelu

Detekovat anomálie

Exportovat model

Odstranit model

Spuštění aplikace

Vyčištění prostředků

Další kroky

Požadavky

Nastavení

Vytvořit nový projekt Gradle

Instalace klientské knihovny

Vytvoření souboru Java

Příklady kódu

Ověření klienta

Učení modelu

Sestavit výsledek modelu a model výuky

Detekovat anomálie

Exportovat model

Odstranit model

Spuštění aplikace

Spuštění aplikace

Vyčištění prostředků

Další kroky