Quickstart: De clientbibliotheek Anomaly Detector meerdere varianten gebruiken

Artikel
11/25/2021
26 minuten om te lezen

Ga aan de slag met Anomaly Detector multivariate clientbibliotheek voor C#. Volg deze stappen om het pakket te installeren en de algoritmen van de service te gaan gebruiken. Met de nieuwe API's voor anomaliedetectie met meerdere afwijkingen kunnen ontwikkelaars eenvoudig geavanceerde AI integreren voor het detecteren van afwijkingen uit groepen met metrische gegevens, zonder dat machine learning kennis of gelabelde gegevens nodig zijn. Afhankelijkheden en onderlinge correlaties tussen verschillende signalen worden automatisch geteld als belangrijke factoren. Dit helpt u om uw complexe systemen proactief te beschermen tegen storingen.

Gebruik de Anomaly Detector multivariate clientbibliotheek voor C# voor het volgende:

Anomalieën op systeemniveau detecteren uit een groep tijdreeksen.
Wanneer een afzonderlijke tijdreeks u niet veel vertelt en u alle signalen moet bekijken om een probleem te detecteren.
Predicatief onderhoud van dure fysieke activa met tientallen tot honderden verschillende soorten sensoren die verschillende aspecten van de systeemtoestand meten.

Referentiedocumentatie voor de bibliotheek | Broncode van bibliotheek | Pakket (NuGet)

Vereisten

Azure-abonnement: Krijg een gratis abonnement
De huidige versie van .NET Core
Zodra u een Azure-abonnement hebt, maakt u een Anomaly Detector-resource in Azure Portal om uw sleutel en eindpunt op te halen. Wacht tot deze is geïmplementeerd en selecteer de knop Ga naar resource.
- U hebt de sleutel en het eindpunt nodig van de resource die u maakt om de toepassing te verbinden met de Anomaly Detector-API. Plak uw sleutel en eindpunt later in de quickstart in de onderstaande code. U kunt de gratis prijscategorie (F0) gebruiken om de service uit te proberen, en later upgraden naar een betaalde laag voor productie.

Instellen

Een nieuwe .NET Core-app maken

Gebruik in een consolevenster (zoals cmd, PowerShell of Bash) de opdracht dotnet new om een nieuwe console-app te maken met de naam anomaly-detector-quickstart-multivariate. Met deze opdracht maakt u een eenvoudig Hallo wereld-project met één C#-bronbestand: Program.cs.

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

Wijzig uw map in de zojuist gemaakte app-map. U kunt de toepassing maken met:

dotnet build

De build-uitvoer mag geen waarschuwingen of fouten bevatten.

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

De clientbibliotheek installeren

Installeer in de toepassingsmap de Anomaly Detector-clientbibliotheek voor .NET met de volgende opdracht:

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

Open vanuit de projectmap het program.cs-bestand en voeg het volgende toe met behulp van 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;

Maak in de -methode van de toepassing variabelen voor het Azure-eindpunt van uw resource, uw main() API-sleutel en een aangepaste gegevensbron.

Notitie

U hebt altijd de mogelijkheid om een van twee sleutels te gebruiken. Dit is om veilige sleutelrotatie toe te staan. Gebruik voor deze quickstart de eerste sleutel.

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

Als u de Anomaly Detector api's wilt gebruiken, moet u eerst uw eigen modellen trainen. Trainingsgegevens zijn een set met meerdere tijdreeksen die aan de volgende vereisten voldoen:

Elke tijdreeks moet een CSV-bestand zijn met twee (en slechts twee) kolommen, 'timestamp' en 'value' (allemaal in kleine letters) als de koprij. De tijdstempelwaarden moeten voldoen aan ISO 8601; de waarde kan gehele getallen of decimalen zijn met een aantal decimalen. Bijvoorbeeld:

tijdstempel	waarde
2019-04-01T00:00:00Z	5
2019-04-01T00:01:00Z	3,6
2019-04-01T00:02:00Z	4
`...`	`...`

Elk CSV-bestand moet de naam hebben van een andere variabele die wordt gebruikt voor modeltraining. Bijvoorbeeld 'temperature.csv' en 'humidity.csv'. Alle CSV-bestanden moeten worden ingepakt in één zip-bestand zonder submappen. Het zip-bestand kan elke want-naam hebben. Het zip-bestand moet worden geüpload naar Azure Blob Storage. Zodra u de BLOB SAS-URL (Shared Access Signatures) voor het ZIP-bestand hebt gegenereerd, kan deze worden gebruikt voor training. Raadpleeg dit document voor informatie over het genereren van SAS-URL's van Azure Blob Storage.

Codevoorbeelden

Deze codefragmenten laten zien hoe u het volgende kunt doen met de Anomaly Detector clientbibliotheek voor .NET:

De client verifiëren
Het model trainen
Afwijkingen detecteren
Model exporteren
Model verwijderen

De client verifiëren

Instantieer een Anomaly Detector client met uw eindpunt en sleutel.

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

AnomalyDetectorClient client = new AnomalyDetectorClient(endpointUri, credential);

Het model trainen

Maak een nieuwe privé-async-taak zoals hieronder wordt beschreven voor het trainen van uw model. U gebruikt om TrainMultivariateModel het model te trainen en om te controleren wanneer de training is GetMultivariateModelAysnc voltooid.

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

Afwijkingen detecteren

Als u afwijkingen wilt detecteren met behulp van uw zojuist getrainde model, maakt u een met private async Task de naam detectAsync . U maakt een nieuwe DetectionRequest en geeft deze door als parameter aan 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);
    }
}

Model exporteren

Notitie

De exportopdracht is bedoeld om het uitvoeren van Anomaly Detector multivariate modellen in een containeromgeving toe te staan. Dit wordt momenteel niet ondersteund voor multivariate, maar ondersteuning wordt in de toekomst toegevoegd.

Als u het model wilt exporteren dat u eerder hebt getraind, maakt u een private async Task met de naam exportAysnc . U gebruikt en ExportModelAsync geeft de model-id door van het model dat u wilt exporteren.

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

Model verwijderen

Als u een model wilt verwijderen dat u eerder hebt gemaakt, gebruikt en de model-id door te geven DeleteMultivariateModelAsync van het model dat u wilt verwijderen. Als u een model-id wilt ophalen, kunt u getModelNumberAsync ons :

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

De methode Main

Nu u alle onderdelen hebt, moet u extra code toevoegen aan de hoofdmethode om uw zojuist gemaakte taken aan te roepen.


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

De toepassing uitvoeren

Voer de toepassing uit vanuit uw toepassingsmap met de opdracht dotnet run.

dotnet run

Resources opschonen

Als u een Cognitive Services-abonnement wilt opschonen en verwijderen, kunt u de resource of resourcegroep verwijderen. Als u de resourcegroep verwijdert, worden ook andere resources verwijderd die aan de resourcegroep zijn gekoppeld.

Volgende stappen

Ga aan de slag met Anomaly Detector multivariate clientbibliotheek voor JavaScript. Volg deze stappen om het pakket te installeren en de algoritmen van de service te gaan gebruiken. Met de nieuwe API's voor anomaliedetectie met meerdere afwijkingen kunnen ontwikkelaars eenvoudig geavanceerde AI integreren voor het detecteren van afwijkingen uit groepen met metrische gegevens, zonder dat machine learning kennis of gelabelde gegevens nodig zijn. Afhankelijkheden en onderlinge correlaties tussen verschillende signalen worden automatisch geteld als belangrijke factoren. Dit helpt u om uw complexe systemen proactief te beschermen tegen storingen.

Gebruik de Anomaly Detector multivariate clientbibliotheek voor JavaScript voor het volgende:

Anomalieën op systeemniveau detecteren uit een groep tijdreeksen.
Wanneer een afzonderlijke tijdreeks u niet veel vertelt en u alle signalen moet bekijken om een probleem te detecteren.
Predicatief onderhoud van dure fysieke activa met tientallen tot honderden verschillende soorten sensoren die verschillende aspecten van de systeemtoestand meten.

Referentiedocumentatie voor de bibliotheek | Broncode van bibliotheek | Pakket (npm) | Voorbeeldcode

Vereisten

Azure-abonnement: Krijg een gratis abonnement
De huidige versie van Node.js
Zodra u een Azure-abonnement hebt, Een Anomaly Detector-resource maken in de Azure-portal om uw sleutel en eindpunt op te halen. Wacht tot deze is geïmplementeerd en klik op de knop Naar de resource gaan.
- U hebt de sleutel en het eindpunt nodig van de resource die u maakt om de toepassing te verbinden met de Anomaly Detector-API. Later in de quickstart plakt u uw sleutel en eindpunt in de onderstaande code. U kunt de gratis prijscategorie (F0) gebruiken om de service uit te proberen, en later upgraden naar een betaalde laag voor productie.

Instellen

Een nieuwe Node.js-toepassing maken

Maak in een consolevenster (zoals cmd, PowerShell of Bash) een nieuwe map voor de app, en navigeer naar deze map.

mkdir myapp && cd myapp

Voer de opdracht npm init uit om een knooppunttoepassing te maken met een package.json-bestand.

npm init

Maak een bestand met de index.js naam en importeer de volgende bibliotheken: '

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

Maak variabelen voor het Azure-eindpunt en de Azure-sleutel voor uw resource. Maak nog een variabele voor het voorbeeldgegevensbestand.

Notitie

U hebt altijd de mogelijkheid om een van twee sleutels te gebruiken. Dit is om veilige sleutelrotatie toe te staan. Gebruik voor deze quickstart de eerste sleutel.

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

Als u de Anomaly Detector api's wilt gebruiken, moet u eerst uw eigen modellen trainen. Trainingsgegevens zijn een set met meerdere tijdreeksen die aan de volgende vereisten voldoen:

tijdstempel	waarde
2019-04-01T00:00:00Z	5
2019-04-01T00:01:00Z	3,6
2019-04-01T00:02:00Z	4
`...`	`...`

De clientbibliotheek installeren

Installeer de NPM-pakketten ms-rest-azure en azure-ai-anomalydetector. De CSV-parseerbibliotheek wordt ook gebruikt in deze snelstart:

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

Het package.json-bestand van uw app wordt bijgewerkt met de afhankelijkheden.

Codevoorbeelden

Deze codefragmenten laten zien hoe u de volgende taken kunt uitvoeren met de Anomaly Detector-clientbibliotheek voor Node.js:

De client verifiëren
Een model trainen
Afwijkingen detecteren
Model exporteren
Model verwijderen

De client verifiëren

Instantieer een AnomalyDetectorClient -object met uw eindpunt en referenties.

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

Een model trainen

Een modelresultaat maken

Eerst moeten we een modelaanvraag maken. Zorg ervoor dat de begin- en eindtijd zijn afgestemd op uw gegevensbron.

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

Een nieuw model trainen

U moet uw modelaanvraag doorgeven aan de Anomaly Detector trainMultivariateModel clientmethode.

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)

Als u wilt controleren of de training van uw model is voltooid, kunt u de status van het model volgen:

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

Afwijkingen detecteren

Gebruik de detectAnomaly functies en om te bepalen of er afwijkingen in uw getDectectionResult gegevensbron zijn.

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

Model exporteren

Notitie

Gebruik de functie om uw getrainde model te exportModel exporteren.

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

Model verwijderen

Als u een bestaand model wilt verwijderen dat beschikbaar is voor de huidige resource, gebruikt u de deleteMultivariateModel functie .

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

De toepassing uitvoeren

Voordat u de toepassing gaat uitvoeren, kan het handig zijn om uw code te controleren op de volledige voorbeeldcode

Voer de toepassing uit met de opdracht node in uw quickstart-bestand.

node index.js

Resources opschonen

Volgende stappen

Ga aan de slag met Anomaly Detector multivariate clientbibliotheek voor Python. Voer de volgende stappen uit om het pakket te installeren en de algoritmen te gaan gebruiken die door de service worden geleverd. Met de nieuwe API's voor anomaliedetectie met meerdere afwijkingen kunnen ontwikkelaars eenvoudig geavanceerde AI integreren voor het detecteren van afwijkingen uit groepen met metrische gegevens, zonder dat machine learning kennis of gelabelde gegevens nodig zijn. Afhankelijkheden en onderlinge correlaties tussen verschillende signalen worden automatisch geteld als belangrijke factoren. Dit helpt u om uw complexe systemen proactief te beveiligen tegen storingen.

Gebruik de Anomaly Detector multivariate clientbibliotheek voor Python voor het volgende:

Anomalieën op systeemniveau detecteren uit een groep tijdreeksen.
Wanneer een afzonderlijke tijdreeks u niet veel vertelt en u alle signalen moet bekijken om een probleem te detecteren.
Predicatief onderhoud van dure fysieke activa met tientallen tot honderden verschillende soorten sensoren die verschillende aspecten van de systeemtoestand meten.

Referentiedocumentatie voor de bibliotheek | Broncode van bibliotheek | Pakket (PyPi) | Voorbeeldcode

Vereisten

Python 3.x
De bibliotheek voor Pandas-gegevensanalyse
Azure-abonnement: Krijg een gratis abonnement
Zodra u een Azure-abonnement hebt, maakt u een Anomaly Detector-resource in Azure Portal om uw sleutel en eindpunt op te halen. Wacht tot deze is geïmplementeerd en klik op de knop Naar de resource gaan.
- U hebt de sleutel en het eindpunt nodig van de resource die u maakt om de toepassing te verbinden met de Anomaly Detector-API. Later in de quickstart plakt u uw sleutel en eindpunt in de onderstaande code. U kunt de gratis prijscategorie (F0) gebruiken om de service uit te proberen, en later upgraden naar een betaalde laag voor productie.

Instellen

De clientbibliotheek installeren

Nadat u Python hebt geïnstalleerd, kunt u de clientbibliotheken installeren met:

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

Een nieuwe Python-toepassing maken

Maak een nieuw Python-bestand en importeer de volgende bibliotheken.

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

Maak variabelen voor uw sleutel als een omgevingsvariabele, het pad naar een tijdreeksgegevensbestand en de Azure-locatie van uw abonnement.

Notitie

U hebt altijd de mogelijkheid om een van de twee sleutels te gebruiken. Dit is om veilige sleutelrotatie toe te staan. Gebruik voor deze quickstart de eerste sleutel.

subscription_key = "ANOMALY_DETECTOR_KEY"
anomaly_detector_endpoint = "ANOMALY_DETECTOR_ENDPOINT"

Codevoorbeelden

Deze codefragmenten laten zien hoe u de volgende taken kunt uitvoeren met de Anomaly Detector-clientbibliotheek voor Python:

De client verifiëren
Het model trainen
Afwijkingen detecteren
Model exporteren
Model verwijderen

De client verifiëren

Als u een nieuwe client wilt Anomaly Detector, moet u de Anomaly Detector en het bijbehorende eindpunt doorgeven. We maken ook een gegevensbron.

Als u de Anomaly Detector api's wilt gebruiken, moet u eerst uw eigen modellen trainen. Trainingsgegevens zijn een set met meerdere tijdreeksen die aan de volgende vereisten voldoen:

tijdstempel	waarde
2019-04-01T00:00:00Z	5
2019-04-01T00:01:00Z	3,6
2019-04-01T00:02:00Z	4
`...`	`...`

Elk CSV-bestand moet worden genoemd naar een andere variabele die wordt gebruikt voor modeltraining. Bijvoorbeeld 'temperature.csv' en 'humidity.csv'. Alle CSV-bestanden moeten worden ingepakt in één zip-bestand zonder submappen. Het ZIP-bestand kan elke want-naam hebben. Het ZIP-bestand moet worden geüpload naar Azure Blob Storage. Zodra u de BLOB SAS-URL (Shared Access Signatures) voor het ZIP-bestand hebt gegenereerd, kan deze worden gebruikt voor training. Raadpleeg dit document voor informatie over het genereren van SAS-URL's van 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"

Het model trainen

We trainen eerst het model, controleren de status van het model tijdens de training om te bepalen wanneer de training is voltooid en halen vervolgens de meest recente model-id op die we nodig hebben wanneer we naar de detectiefase gaan.

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

Afwijkingen detecteren

Gebruik de detect_anomaly en om te bepalen of er afwijkingen in uw get_dectection_result gegevensbron zijn. U moet de model-id doorgeven voor het model dat u zojuist hebt getraind.

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

Model exporteren

Notitie

De exportopdracht is bedoeld om het uitvoeren van meerdere Anomaly Detector in een containeromgeving toe te staan. Dit wordt momenteel niet ondersteund voor meerdere varianten, maar ondersteuning wordt in de toekomst toegevoegd.

Als u een modelgebruik wilt exporteren en export_model de model-id wilt doorgeven van het model dat u wilt exporteren:

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

Model verwijderen

Als u een modelgebruik wilt delete_multivariate_model verwijderen en de model-id wilt doorgeven van het model dat u wilt verwijderen:

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

De toepassing uitvoeren

Voordat u de toepassing gaat uitvoeren, moeten we code toevoegen om onze zojuist gemaakte functies aan te roepen.

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)

Voordat u het project gaat uitvoeren, kan het handig zijn om uw project te controleren aan de hand van de volledige voorbeeldcode waar deze quickstart van is afgeleid.

We hebben ook een uitgebreide Jupyter Notebook om u op weg te helpen.

Voer de toepassing uit met de opdracht python en uw bestandsnaam.

Resources opschonen

Volgende stappen

Ga aan de slag met Anomaly Detector multivariate clientbibliotheek voor Java. Voer de volgende stappen uit om het pakket te installeren en de algoritmen te gaan gebruiken die door de service worden geleverd. Met de nieuwe API's voor anomaliedetectie met meerdere afwijkingen kunnen ontwikkelaars eenvoudig geavanceerde AI integreren voor het detecteren van afwijkingen in groepen met metrische gegevens, zonder dat machine learning kennis of gelabelde gegevens nodig zijn. Afhankelijkheden en onderlinge correlaties tussen verschillende signalen worden automatisch geteld als belangrijke factoren. Dit helpt u om uw complexe systemen proactief te beschermen tegen storingen.

Gebruik de Anomaly Detector multivariate clientbibliotheek voor Java voor het volgende:

Anomalieën op systeemniveau detecteren uit een groep tijdreeksen.
Wanneer een afzonderlijke tijdreeks u niet veel vertelt en u alle signalen moet bekijken om een probleem te detecteren.
Predicatief onderhoud van dure fysieke activa met tientallen tot honderden verschillende soorten sensoren die verschillende aspecten van de systeemtoestand meten.

Referentiedocumentatie voor de bibliotheek | Broncode van bibliotheek | Pakket (Maven) | Voorbeeldcode

Vereisten

Azure-abonnement: Krijg een gratis abonnement
De huidige versie van de Java Development Kit (JDK)
Het hulpprogramma Gradle of een andere afhankelijkheidsbeheerder.
Zodra u een Azure-abonnement hebt, maakt u een Anomaly Detector-resource in Azure Portal om uw sleutel en eindpunt op te halen. Wacht tot deze is geïmplementeerd en klik op de knop Naar de resource gaan.
- U hebt de sleutel en het eindpunt nodig van de resource die u maakt om de toepassing te verbinden met de Anomaly Detector-API. Later in de quickstart plakt u uw sleutel en eindpunt in de onderstaande code. U kunt de gratis prijscategorie (F0) gebruiken om de service uit te proberen, en later upgraden naar een betaalde laag voor productie.

Instellen

Een nieuw Gradle-project maken

Deze quickstart maakt gebruik van de Gradle-afhankelijkheidsmanager. U vindt meer informatie over clientbibliotheken in de centrale opslagplaats van Maven.

Maak in een consolevenster (zoals cmd, PowerShell of Bash) een nieuwe map voor de app, en navigeer naar deze map.

mkdir myapp && cd myapp

Voer de opdracht gradle init uit vanuit uw werkmap. Met deze opdracht maakt u essentiële buildbestanden voor Gradle, inclusief build.gradle.kts, dat tijdens runtime wordt gebruikt om de toepassing te maken en te configureren.

gradle init --type basic

Wanneer u wordt gevraagd om een DSL te kiezen, selecteert u Kotlin.

De clientbibliotheek installeren

Zoek build.gradle.kts op en open het met uw favoriete IDE of teksteditor. Kopieer het vervolgens in deze buildconfiguratie. Zorg ervoor dat u de projectafhankelijkheden mee kopieert.

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

Een Java-bestand maken

Maak een map voor de voorbeeld-app. Voer de volgende opdracht uit vanuit uw werkmap:

mkdir -p src/main/java

Ga naar de nieuwe map en maak een bestand met de naam MetricsAdvisorQuickstarts.java. Open het bestand in uw voorkeurseditor of IDE en voeg de volgende import-instructies toe:

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;

Maak variabelen voor het Azure-eindpunt en de Azure-sleutel voor uw resource. Maak nog een variabele voor het voorbeeldgegevensbestand.

Notitie

U hebt altijd de mogelijkheid om een van twee sleutels te gebruiken. Dit is om veilige sleutelrotatie toe te staan. Gebruik voor deze quickstart de eerste sleutel.

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

Als u de Anomaly Detector api's wilt gebruiken, moet u eerst uw eigen modellen trainen. Trainingsgegevens zijn een set met meerdere tijdreeksen die aan de volgende vereisten voldoen:

tijdstempel	waarde
2019-04-01T00:00:00Z	5
2019-04-01T00:01:00Z	3,6
2019-04-01T00:02:00Z	4
`...`	`...`

Codevoorbeelden

Deze codefragmenten laten zien hoe u de volgende taken kunt uitvoeren met de Anomaly Detector-clientbibliotheek voor Node.js:

De client verifiëren
Een model trainen
Afwijkingen detecteren
Model exporteren
Model verwijderen

De client verifiëren

Instantieer een anomalyDetectorClient -object met uw eindpunt en referenties.

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

Een model trainen

Een modelresultaat maken en het model trainen

Eerst moeten we een modelaanvraag maken. Zorg ervoor dat de begin- en eindtijd zijn afgestemd op uw gegevensbron.

Als u de Anomaly Detector api's wilt gebruiken, moeten we ons eigen model trainen voordat u detectie gebruikt. Gegevens die worden gebruikt voor training zijn een batch tijdreeksen. Elke tijdreeks moet zich in een CSV-bestand met slechts twee kolommen, 'timestamp' en 'value'(de kolomnamen moeten exact hetzelfde zijn). Elk CSV-bestand moet de naam hebben van elke variabele voor de tijdreeks. Alle tijdreeksen moeten worden ingepakt in één zip-bestand en worden geüpload naar Azure Blob-opslagen er is geen vereiste voor de naam van het ZIP-bestand. U kunt ook een extra meta.jsin het zip-bestand als u wilt dat de naam van de variabele verschilt van de .zip bestandsnaam. Zodra we de BLOB SAS-URL (Shared Access Signatures)hebben gegenereerd, kunnen we de URL naar het ZIP-bestand gebruiken voor training.

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

Afwijkingen detecteren

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

Model exporteren

Notitie

Gebruik de om uw getrainde model te exportModelWithResponse exporteren.

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

Model verwijderen

Als u een bestaand model wilt verwijderen dat beschikbaar is voor de huidige resource, gebruikt u de deleteMultivariateModelWithResponse functie .

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

De toepassing uitvoeren

U kunt de app maken met:

gradle build

De toepassing uitvoeren

Voordat u gaat uitvoeren, kan het handig zijn om uw code te controleren op de volledige voorbeeldcode.

De toepassing uitvoeren met het doel run:

gradle run

Quickstart: De clientbibliotheek Anomaly Detector meerdere varianten gebruiken

Beoordeel uw ervaring

Vereisten

Instellen

Een nieuwe .NET Core-app maken

De clientbibliotheek installeren

Codevoorbeelden

De client verifiëren

Het model trainen

Afwijkingen detecteren

Model exporteren

Model verwijderen

De methode Main

De toepassing uitvoeren

Resources opschonen

Volgende stappen

Vereisten

Instellen

Een nieuwe Node.js-toepassing maken

De clientbibliotheek installeren

Codevoorbeelden

De client verifiëren

Een model trainen

Een modelresultaat maken

Een nieuw model trainen

Afwijkingen detecteren

Model exporteren

Model verwijderen

De toepassing uitvoeren

Resources opschonen

Volgende stappen

Vereisten

Instellen

De clientbibliotheek installeren

Een nieuwe Python-toepassing maken

Codevoorbeelden

De client verifiëren

Het model trainen

Afwijkingen detecteren

Model exporteren

Model verwijderen

De toepassing uitvoeren

Resources opschonen

Volgende stappen

Vereisten

Instellen

Een nieuw Gradle-project maken

De clientbibliotheek installeren

Een Java-bestand maken

Codevoorbeelden

De client verifiëren

Een model trainen

Een modelresultaat maken en het model trainen

Afwijkingen detecteren

Model exporteren

Model verwijderen

De toepassing uitvoeren

De toepassing uitvoeren

Resources opschonen

Volgende stappen