Snabbstart: Använda Avvikelseidentifiering flera klientbibliotek

Artikel
11/25/2021
24 minuter för att läsa

Kom igång med Avvikelseidentifiering flervarierat klientbibliotek för C#. Följ de här stegen för att installera paketet och börja använda algoritmerna som tillhandahålls av tjänsten. De nya API:erna för avvikelseidentifiering med flera variabler gör det möjligt för utvecklare att enkelt integrera avancerad AI för att identifiera avvikelser från grupper av mått, utan att behöva maskininlärningskunskaper eller märkta data. Beroenden och interkorrelationer mellan olika signaler räknas automatiskt som viktiga faktorer. På så sätt kan du proaktivt skydda komplexa system mot fel.

Använd Avvikelseidentifiering multivariate-klientbibliotek för C# för att:

Identifiera avvikelser på systemnivå från en grupp med tidsserier.
När en enskild tidsserie inte berättar så mycket och du måste titta på alla signaler för att identifiera ett problem.
Predikatiskt underhåll av dyra fysiska tillgångar med tiotals till hundratals olika typer av sensorer som mäter olika aspekter av systemets hälsa.

Biblioteksreferensdokumentation | Bibliotekskällkod | Paket (NuGet)

Förutsättningar

Azure-prenumeration – Skapa en kostnadsfritt
Den aktuella versionen av .NET Core
När du har din Azure-prenumeration skapar Avvikelseidentifiering en Avvikelseidentifiering resurs i Azure Portal för att slutpunkt. Vänta tills den har distribuerats och välj knappen Gå till resurs.
- Du behöver nyckeln och slutpunkten från den resurs som du skapar för att ansluta ditt program till Avvikelseidentifiering-API:et. Klistra in nyckeln och slutpunkten i koden nedan senare i snabbstarten. Du kan använda den kostnadsfria prisnivån ( F0 ) för att prova tjänsten och senare uppgradera till en betald nivå för produktion.

Inrätta

Skapa ett nytt .NET Core-program

I ett konsolfönster (till exempel cmd, PowerShell eller Bash) använder du kommandot för att skapa en dotnet new ny konsolapp med namnet anomaly-detector-quickstart-multivariate . Det här kommandot skapar ett enkelt "Hello World"-projekt med en enda C#-källfil: Program.cs.

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

Ändra katalogen till den nyligen skapade appmappen. Du kan skapa programmet med:

dotnet build

Build-utdata får inte innehålla några varningar eller fel.

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

Installera klientbiblioteket

I programkatalogen installerar du Avvikelseidentifiering för .NET med följande kommando:

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

Från projektkatalogen öppnar du filen program.cs och lägger till följande med directives :

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;

I programmets main() -metod skapar du variabler för resursens Azure-slutpunkt, DIN API-nyckel och en anpassad datakälla.

Anteckning

Du har alltid möjlighet att använda en av två nycklar. Detta är för att tillåta säker nyckelrotation. I den här snabbstarten använder du den första nyckeln.

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

Om du vill Avvikelseidentifiering flervarierade API:er måste du först träna dina egna modeller. Träningsdata är en uppsättning med flera tidsserier som uppfyller följande krav:

Varje tidsserie ska vara en CSV-fil med två (och endast två) kolumner, "timestamp" och "value" (alla i gemener) som rubrikrad. Värdena för "tidsstämpel" ska överensstämma med ISO 8601. "value" kan vara heltal eller decimaler med val annat antal decimaler. Exempel:

timestamp	värde
2019-04-01T00:00:00Z	5
2019-04-01T00:01:00Z	3,6
2019-04-01T00:02:00Z	4
`...`	`...`

Varje CSV-fil ska namnges efter en annan variabel som ska användas för modellträning. Till exempel "temperature.csv" och "humidity.csv". Alla CSV-filer ska zippas upp i en zip-fil utan undermappar. Zip-filen kan ha vilket namn du vill. ZIP-filen ska laddas upp till Azure Blob Storage. När du har genererat URL:en för blob-SAS (signaturer för delad åtkomst) för ZIP-filen kan den användas för träning. I det här dokumentet finns information om hur du genererar SAS-URL:er från Azure Blob Storage.

Kodexempel

De här kodfragmenten visar hur du gör följande med Avvikelseidentifiering multivariate-klientbibliotek för .NET:

Autentisera klienten
Träna modellen
Identifiera avvikelser
Exportera modell
Ta bort modell

Autentisera klienten

Instansiera Avvikelseidentifiering klient med din slutpunkt och nyckel.

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

AnomalyDetectorClient client = new AnomalyDetectorClient(endpointUri, credential);

Träna modellen

Skapa en ny privat asynkron uppgift enligt nedan för att hantera träning av din modell. Du använder för TrainMultivariateModel att träna modellen och för att kontrollera när GetMultivariateModelAysnc träningen är klar.

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);
    }
}

Identifiera avvikelser

Om du vill identifiera avvikelser med hjälp av din nyligen tränade modell skapar du en private async Task med namnet detectAsync . Du skapar en ny och DetectionRequest skickar den som en parameter till 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);
    }
}

Exportera modell

Anteckning

Exportkommandot är avsett att användas för att tillåta körning Avvikelseidentifiering flervarierade modeller i en containermiljö. Detta stöds för närvarande inte för multivariat, men stöd kommer att läggas till i framtiden.

Om du vill exportera modellen som du tränade tidigare skapar du en private async Task med namnet exportAysnc . Du använder och ExportModelAsync skickar modell-ID:t för den modell som du vill exportera.

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);
    }
}

Ta bort modell

Ta bort en modell som du har skapat tidigare och DeleteMultivariateModelAsync skicka modell-ID för den modell som du vill ta bort. Om du vill hämta ett modell-ID kan du använda getModelNumberAsync :

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;
}

Main-metoden

Nu när du har alla komponentdelar måste du lägga till ytterligare kod i huvudmetoden för att anropa dina nya uppgifter.


{
    //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);
    }
}

Kör programmet

Kör programmet med kommandot dotnet run från programkatalogen.

dotnet run

Rensa resurser

Om du vill rensa och ta bort en Cognitive Services prenumeration kan du ta bort resursen eller resursgruppen. När du tar bort resursgruppen tas även alla andra resurser som är associerade med resursgruppen bort.

Nästa steg

Kom igång med Avvikelseidentifiering flervarierat klientbibliotek för JavaScript. Följ de här stegen för att installera paketet och börja använda algoritmerna som tillhandahålls av tjänsten. De nya API:erna för avvikelseidentifiering med flera variabler gör det möjligt för utvecklare att enkelt integrera avancerad AI för att identifiera avvikelser från grupper av mått, utan att behöva maskininlärningskunskaper eller märkta data. Beroenden och interkorrelationer mellan olika signaler räknas automatiskt som viktiga faktorer. På så sätt kan du proaktivt skydda komplexa system mot fel.

Använd Avvikelseidentifiering flervarierat klientbibliotek för JavaScript för att:

Identifiera avvikelser på systemnivå från en grupp med tidsserier.
När en enskild tidsserie inte berättar så mycket och du måste titta på alla signaler för att identifiera ett problem.
Predikatiskt underhåll av dyra fysiska tillgångar med tiotals till hundratals olika typer av sensorer som mäter olika aspekter av systemets hälsa.

Biblioteksreferensdokumentation | Bibliotekskällkod | Paket (npm) | Exempelkod

Förutsättningar

Azure-prenumeration – Skapa en kostnadsfritt
Den aktuella versionen av Node.js
När du har din Azure-prenumeration skapar du en Avvikelseidentifiering-resurs för att skapa Avvikelseidentifiering resurs i Azure Portal för att slutpunkt. Vänta tills den har distribuerats och klicka på knappen Gå till resurs.
- Du behöver nyckeln och slutpunkten från den resurs som du skapar för att ansluta ditt program till Avvikelseidentifiering-API:et. Du klistrar in din nyckel och slutpunkt i koden nedan senare i snabbstarten. Du kan använda den kostnadsfria prisnivån ( F0 ) för att prova tjänsten och senare uppgradera till en betald nivå för produktion.

Inrätta

Skapa ett nytt Node.js-program

I ett konsolfönster (till exempel cmd, PowerShell eller Bash) skapar du en ny katalog för din app och navigerar till den.

mkdir myapp && cd myapp

Kör kommandot npm init för att skapa ett nodprogram med en package.json fil.

npm init

Skapa en fil med index.js namnet och importera följande bibliotek: '

'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');

Skapa variabler för resursens Azure-slutpunkt och nyckel. Skapa en annan variabel för exempeldatafilen.

Anteckning

Du har alltid möjlighet att använda en av två nycklar. Detta är för att tillåta säker nyckelrotation. I den här snabbstarten använder du den första nyckeln.

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

Om du vill Avvikelseidentifiering flervarierade API:er måste du först träna dina egna modeller. Träningsdata är en uppsättning med flera tidsserier som uppfyller följande krav:

timestamp	värde
2019-04-01T00:00:00Z	5
2019-04-01T00:01:00Z	3,6
2019-04-01T00:02:00Z	4
`...`	`...`

Installera klientbiblioteket

Installera ms-rest-azure azure-ai-anomalydetector NPM-paketen och . Csv-parse-biblioteket används också i den här snabbstarten:

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

Appens package.json fil uppdateras med beroendena.

Kodexempel

De här kodfragmenten visar hur du gör följande med Avvikelseidentifiering klientbibliotek för Node.js:

Autentisera klienten
Träna en modell
Identifiera avvikelser
Exportera modell
Ta bort modell

Autentisera klienten

Skapa en instans av AnomalyDetectorClient ett objekt med din slutpunkt och dina autentiseringsuppgifter.

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

Träna en modell

Skapa ett modellresultat

Först måste vi skapa en modellbegäran. Se till att start- och sluttiden överensstämmer med datakällan.

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äna en ny modell

Du måste skicka din modellbegäran till den Avvikelseidentifiering trainMultivariateModel klientmetoden.

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)

Om du vill kontrollera om träningen av din modell är klar kan du spåra modellens status:

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.");

Identifiera avvikelser

Använd funktionerna detectAnomaly och för att avgöra om det finns några avvikelser i getDectectionResult datakällan.

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);

Exportera modell

Anteckning

Använd funktionen för att exportera den exportModel tränade modellen.

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+".")

Ta bort modell

Om du vill ta bort en befintlig modell som är tillgänglig för den aktuella resursen använder du deleteMultivariateModel funktionen .

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

Kör programmet

Innan du kör programmet kan det vara bra att kontrollera koden mot den fullständiga exempelkoden

Kör programmet med kommandot node i snabbstartsfilen.

node index.js

Rensa resurser

Nästa steg

Kom igång med Avvikelseidentifiering flervarierat klientbibliotek för Python. Följ de här stegen för att installera paketet och börja använda de algoritmer som tillhandahålls av tjänsten. De nya API:erna för avvikelseidentifiering med flera variabler gör det möjligt för utvecklare att enkelt integrera avancerad AI för att identifiera avvikelser från grupper av mått, utan att behöva maskininlärningskunskaper eller märkta data. Beroenden och interkorrelationer mellan olika signaler räknas automatiskt som viktiga faktorer. På så sätt kan du proaktivt skydda komplexa system mot fel.

Använd Avvikelseidentifiering flervarierat klientbibliotek för Python för att:

Identifiera avvikelser på systemnivå från en grupp med tidsserier.
När en enskild tidsserie inte berättar så mycket och du måste titta på alla signaler för att identifiera ett problem.
Predikatiskt underhåll av dyra fysiska tillgångar med tiotals till hundratals olika typer av sensorer som mäter olika aspekter av systemets hälsa.

Biblioteksreferensdokumentation | Bibliotekskällkod | Paket (PyPi) | Exempelkod

Förutsättningar

Python 3.x
Pandas-dataanalysbiblioteket
Azure-prenumeration – Skapa en kostnadsfritt
När du har din Azure-prenumeration skapar Avvikelseidentifiering en Avvikelseidentifiering resurs i Azure Portal för att slutpunkt. Vänta tills den har distribuerats och klicka på knappen Gå till resurs.
- Du behöver nyckeln och slutpunkten från den resurs som du skapar för att ansluta ditt program till Avvikelseidentifiering-API:et. Du klistrar in din nyckel och slutpunkt i koden nedan senare i snabbstarten. Du kan använda den kostnadsfria prisnivån ( F0 ) för att prova tjänsten och senare uppgradera till en betald nivå för produktion.

Inrätta

Installera klientbiblioteket

När du har installerat Python kan du installera klientbiblioteken med:

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

Skapa ett nytt Python-program

Skapa en ny Python-fil och importera följande bibliotek.

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

Skapa variabler för din nyckel som en miljövariabel, sökvägen till en tidsseriedatafil och Azure-platsen för din prenumeration.

Anteckning

Du har alltid möjlighet att använda en av två nycklar. Detta är för att tillåta säker nyckelrotation. I den här snabbstarten använder du den första nyckeln.

subscription_key = "ANOMALY_DETECTOR_KEY"
anomaly_detector_endpoint = "ANOMALY_DETECTOR_ENDPOINT"

Kodexempel

De här kodfragmenten visar hur du gör följande med Avvikelseidentifiering klientbiblioteket för Python:

Autentisera klienten
Träna modellen
Identifiera avvikelser
Exportera modell
Ta bort modell

Autentisera klienten

För att instansiera en Avvikelseidentifiering klient måste du skicka Avvikelseidentifiering prenumerationsnyckel och associerad slutpunkt. Vi kommer också att upprätta en datakälla.

Om du vill Avvikelseidentifiering flervarierade API:er måste du först träna dina egna modeller. Träningsdata är en uppsättning med flera tidsserier som uppfyller följande krav:

timestamp	värde
2019-04-01T00:00:00Z	5
2019-04-01T00:01:00Z	3,6
2019-04-01T00:02:00Z	4
`...`	`...`

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äna modellen

Vi tränar först modellen, kontrollerar modellens status under träningen för att avgöra när träningen är klar och hämtar sedan det senaste modell-ID:t som vi behöver när vi går över till identifieringsfasen.

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

Identifiera avvikelser

Använd och detect_anomaly för att avgöra om det finns några avvikelser i get_dectection_result datakällan. Du måste skicka modell-ID:t för den modell som du precis har tränat.

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

Exportera modell

Anteckning

Om du vill exportera en modell använder export_model och skickar modell-ID för den modell som du vill exportera:

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

Ta bort modell

Så här tar du bort delete_multivariate_model en modellanvändning och skickar modell-ID:t för den modell som du vill ta bort:

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)))

Kör programmet

Innan du kör programmet måste vi lägga till kod som anropar de nya funktionerna.

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)

Innan du kör det kan vara bra att kontrollera projektet mot den fullständiga exempelkod som den här snabbstarten härleds från.

Vi har också en detaljerad Jupyter Notebook som hjälper dig att komma igång.

Kör programmet med python kommandot och filnamnet.

Rensa resurser

Nästa steg

Kom igång med Avvikelseidentifiering flervariat klientbibliotek för Java. Följ de här stegen för att installera paketet med hjälp av de algoritmer som tillhandahålls av tjänsten. Med de nya API:erna för multivarierad avvikelseidentifiering kan utvecklare enkelt integrera avancerad AI för att identifiera avvikelser från grupper med mått, utan att behöva maskininlärning eller märkta data. Beroenden och interkorrelationer mellan olika signaler räknas automatiskt som viktiga faktorer. Detta hjälper dig att proaktivt skydda dina komplexa system mot fel.

Använd Avvikelseidentifiering flervariat klientbibliotek för Java för att:

Identifiera avvikelser på systemnivå från en grupp med tidsserier.
När en enskild tidsserie inte berättar så mycket och du måste titta på alla signaler för att identifiera ett problem.
Predikatiskt underhåll av dyra fysiska tillgångar med tiotals till hundratals olika typer av sensorer som mäter olika aspekter av systemhälsan.

Biblioteksreferensdokumentation | Bibliotekskällkod | Paket (Maven) | Exempelkod

Förutsättningar

Azure-prenumeration – Skapa en utan kostnad
Den aktuella versionen av Java Development Kit (JDK)
Gradle-byggverktyget, eller någon annan beroendehanterare.
När du har din Azure-prenumeration skapar Avvikelseidentifiering en Avvikelseidentifiering resurs i Azure Portal för slutpunkt. Vänta tills den har distribuerats och klicka på knappen Gå till resurs.
- Du behöver nyckeln och slutpunkten från den resurs som du skapar för att ansluta ditt program till Avvikelseidentifiering API. Du klistrar in nyckeln och slutpunkten i koden nedan senare i snabbstarten. Du kan använda den kostnadsfria prisnivån ( F0 ) för att prova tjänsten och uppgradera senare till en betald nivå för produktion.

Inrätta

Skapa ett nytt Gradle-projekt

I den här snabbstarten används Gradle-beroendehanteraren. Du hittar mer information om klientbibliotek på Maven Central Repository.

I ett konsolfönster (till exempel cmd, PowerShell eller Bash) skapar du en ny katalog för din app och navigerar till den.

mkdir myapp && cd myapp

Kör kommandot gradle init från arbetskatalogen. Det här kommandot skapar viktiga byggfiler för Gradle, inklusive build.gradle.kts som används vid körning för att skapa och konfigurera ditt program.

gradle init --type basic

Välj en DSL när du uppmanas till det och välj Kotlin.

Installera klientbiblioteket

Leta upp build.gradle.kts och öppna det med önskad IDE eller textredigerare. Kopiera sedan den här byggkonfigurationen. Se till att inkludera projektberoendena.

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

Skapa en Java-fil

Skapa en mapp för exempelappen. Kör följande kommando från arbetskatalogen:

mkdir -p src/main/java

Navigera till den nya mappen och skapa en fil med namnet MetricsAdvisorQuickstarts.java. Öppna den i önskat redigeringsprogram eller IDE och lägg till följande import -instruktioner:

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;

Skapa variabler för resursens Azure-slutpunkt och nyckel. Skapa en annan variabel för exempeldatafilen.

Anteckning

Du kan alltid välja att använda en av två nycklar. Detta är för att tillåta säker nyckelrotation. I den här snabbstarten använder du den första nyckeln.

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

Om du vill Avvikelseidentifiering flervarierade API:er måste du först träna dina egna modeller. Träningsdata är en uppsättning med flera tidsserier som uppfyller följande krav:

Varje tidsserie ska vara en CSV-fil med två (och endast två) kolumner, "timestamp" och "value" (alla i gemener) som rubrikrad. "Tidsstämpelvärdena" ska överensstämma med ISO 8601. "value" kan vara heltal eller decimaler med val annat antal decimaler. Exempel:

timestamp	värde
2019-04-01T00:00:00Z	5
2019-04-01T00:01:00Z	3,6
2019-04-01T00:02:00Z	4
`...`	`...`

Varje CSV-fil ska namnges efter en annan variabel som ska användas för modellträning. Till exempel "temperature.csv" och "humidity.csv". Alla CSV-filer ska komprimeras till en zip-fil utan några undermappar. Zip-filen kan ha vilket namn du vill. ZIP-filen ska laddas upp till Azure Blob Storage. När du har genererat URL:en för blob-SAS (signaturer för delad åtkomst) för ZIP-filen kan den användas för träning. Läs det här dokumentet om hur du genererar SAS-URL:er från Azure Blob Storage.

Kodexempel

Dessa kodfragment visar hur du gör följande med Avvikelseidentifiering klientbibliotek för Node.js:

Autentisera klienten
Träna en modell
Identifiera avvikelser
Exportera modell
Ta bort modell

Autentisera klienten

Instansiera ett anomalyDetectorClient objekt med din slutpunkt och dina autentiseringsuppgifter.

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();

Träna en modell

Skapa ett modellresultat och träna modellen

Först måste vi skapa en modellbegäran. Se till att start- och sluttiden överensstämmer med din datakälla.

För att kunna Avvikelseidentifiering fleravarierade API:er måste vi träna vår egen modell innan vi använder identifiering. Data som används för träning är en batch med tidsserier. Varje tidsserie bör finnas i en CSV-fil med bara två kolumner, "tidsstämpel" och "värde"(kolumnnamnen ska vara exakt samma). Varje CSV-fil ska namnges efter varje variabel för tidsserien. Alla tidsserier ska zippas upp i en zip-fil och laddas upp till Azure Blob Storage,och det finns inget krav på zip-filnamnet. Alternativt kan en extra meta.jspå filen inkluderas i zip-filen om du vill att namnet på variabeln ska vara ett annat än .zip filnamnet. När vi har genererat blob-SAS-URL:en (signaturer för delad åtkomst)kan vi använda URL:en till ZIP-filen för träning.

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());
    }
}

Identifiera avvikelser

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());
    }
}

Exportera modell

Anteckning

Om du vill exportera den tränade modellen använder du 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));

Ta bort modell

Om du vill ta bort en befintlig modell som är tillgänglig för den aktuella resursen använder du deleteMultivariateModelWithResponse funktionen .

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

Kör programmet

Du kan skapa appen med:

gradle build

Kör programmet

Innan du kör kan det vara bra att kontrollera koden mot den fullständiga exempelkoden.

Kör programmet med run målet:

gradle run

Snabbstart: Använda Avvikelseidentifiering flera klientbibliotek

Betygsätta din upplevelse

Förutsättningar

Inrätta

Skapa ett nytt .NET Core-program

Installera klientbiblioteket

Kodexempel

Autentisera klienten

Träna modellen

Identifiera avvikelser

Exportera modell

Ta bort modell

Main-metoden

Kör programmet

Rensa resurser

Nästa steg

Förutsättningar

Inrätta

Skapa ett nytt Node.js-program

Installera klientbiblioteket

Kodexempel

Autentisera klienten

Träna en modell

Skapa ett modellresultat

Träna en ny modell

Identifiera avvikelser

Exportera modell

Ta bort modell

Kör programmet

Rensa resurser

Nästa steg

Förutsättningar

Inrätta

Installera klientbiblioteket

Skapa ett nytt Python-program

Kodexempel

Autentisera klienten

Träna modellen

Identifiera avvikelser

Exportera modell

Ta bort modell

Kör programmet

Rensa resurser

Nästa steg

Förutsättningar

Inrätta

Skapa ett nytt Gradle-projekt

Installera klientbiblioteket

Skapa en Java-fil

Kodexempel

Autentisera klienten

Träna en modell

Skapa ett modellresultat och träna modellen

Identifiera avvikelser

Exportera modell

Ta bort modell

Kör programmet

Kör programmet

Rensa resurser

Nästa steg