SDK Azure AI Anomaly Detector pour Java

Créez des applications de détection d’anomalies à l’aide du SDK Azure AI Anomaly Detector pour Java.

Installation

  com.azure
  azure-ai-anomalydetector
  3.0.0-beta.6

Création de clients

Clients synchrones et asynchrones

import com.azure.ai.anomalydetector.AnomalyDetectorClientBuilder;
import com.azure.ai.anomalydetector.MultivariateClient;
import com.azure.ai.anomalydetector.UnivariateClient;
import com.azure.core.credential.AzureKeyCredential;

String endpoint = System.getenv("AZURE_ANOMALY_DETECTOR_ENDPOINT");
String key = System.getenv("AZURE_ANOMALY_DETECTOR_API_KEY");

// Client multivarié pour plusieurs signaux corrélés
MultivariateClient multivariateClient = new AnomalyDetectorClientBuilder()
    .credential(new AzureKeyCredential(key))
    .endpoint(endpoint)
    .buildMultivariateClient();

// Client univarié pour l'analyse d'une seule variable
UnivariateClient univariateClient = new AnomalyDetectorClientBuilder()
    .credential(new AzureKeyCredential(key))
    .endpoint(endpoint)
    .buildUnivariateClient();

Avec DefaultAzureCredential

import com.azure.core.credential.TokenCredential;
import com.azure.identity.AzureIdentityEnvVars;
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.identity.ManagedIdentityCredentialBuilder;

TokenCredential credential = new DefaultAzureCredentialBuilder()
    .requireEnvVars(AzureIdentityEnvVars.AZURE_TOKEN_CREDENTIALS)
    .build();
// Ou utilisez directement des informations d’identification spécifiques en production :
// Voir https://learn.microsoft.com/java/api/overview/azure/identity-readme?view=azure-java-stable#credential-classes
// TokenCredential credential = new ManagedIdentityCredentialBuilder().build();

MultivariateClient client = new AnomalyDetectorClientBuilder()
    .credential(credential)
    .endpoint(endpoint)
    .buildMultivariateClient();

Concepts clés

Détection d’anomalies univariées

• Détection par lots: analyse d’une série chronologique entière en une seule fois
• Détection en continu: détection en temps réel sur le dernier point de données
• Détection des points de changement: détection des changements de tendance dans les séries chronologiques

Détection d’anomalies multivariées

• Détection d'anomalies parmi plus de 300 signaux corrélés
• Utilise un réseau Graph Attention pour les corrélations entre signaux
• Processus en trois étapes : apprentissage → inférence → résultats

Modèles de base

Détection par lots univariée

import com.azure.ai.anomalydetector.models.*;
import java.time.OffsetDateTime;
import java.util.List;

List series = List.of(
    new TimeSeriesPoint(OffsetDateTime.parse("2023-01-01T00:00:00Z"), 1.0),
    new TimeSeriesPoint(OffsetDateTime.parse("2023-01-02T00:00:00Z"), 2.5),
    // ... autres points de données (12 points minimum requis)
);

UnivariateDetectionOptions options = new UnivariateDetectionOptions(series)
    .setGranularity(TimeGranularity.DAILY)
    .setSensitivity(95);

UnivariateEntireDetectionResult result = univariateClient.detectUnivariateEntireSeries(options);

// Vérification des anomalies
for (int i = 0; i < result.getIsAnomaly().size(); i++) {
    if (result.getIsAnomaly().get(i)) {
        System.out.printf("Anomalie détectée à l’indice %d avec la valeur %.2f%n",
            i, series.get(i).getValue());
    }
}

Détection du dernier point univarié (streaming)

UnivariateLastDetectionResult lastResult = univariateClient.detectUnivariateLastPoint(options);

if (lastResult.isAnomaly()) {
    System.out.println("Le dernier point est une anomalie !");
    System.out.printf("Valeur attendue : %.2f, marge supérieure : %.2f, marge inférieure : %.2f%n",
        lastResult.getExpectedValue(),
        lastResult.getUpperMargin(),
        lastResult.getLowerMargin());
}

Détection de points de changement

UnivariateChangePointDetectionOptions changeOptions = 
    new UnivariateChangePointDetectionOptions(series, TimeGranularity.DAILY);

UnivariateChangePointDetectionResult changeResult = 
    univariateClient.detectUnivariateChangePoint(changeOptions);

for (int i = 0; i < changeResult.getIsChangePoint().size(); i++) {
    if (changeResult.getIsChangePoint().get(i)) {
        System.out.printf("Point de changement à l'indice %d avec un niveau de confiance de %.2f%n",
            i, changeResult.getConfidenceScores().get(i));
    }
}

Entraînement du modèle multivarié

import com.azure.ai.anomalydetector.models.*;
import com.azure.core.util.polling.SyncPoller;

// Préparation de la requête d'entraînement avec les données du stockage Blob
ModelInfo modelInfo = new ModelInfo()
    .setDataSource("https://storage.blob.core.windows.net/container/data.zip?sasToken")
    .setStartTime(OffsetDateTime.parse("2023-01-01T00:00:00Z"))
    .setEndTime(OffsetDateTime.parse("2023-06-01T00:00:00Z"))
    .setSlidingWindow(200)
    .setDisplayName("MyMultivariateModel");

// Entraînement du modèle (opération de longue durée)
AnomalyDetectionModel trainedModel = multivariateClient.trainMultivariateModel(modelInfo);

String modelId = trainedModel.getModelId();
System.out.println("ID du modèle : " + modelId);

// Vérification de l'état de l'entraînement
AnomalyDetectionModel model = multivariateClient.getMultivariateModel(modelId);
System.out.println("État : " + model.getModelInfo().getStatus());

Inférence par lots multivariée

MultivariateBatchDetectionOptions detectionOptions = new MultivariateBatchDetectionOptions()
    .setDataSource("https://storage.blob.core.windows.net/container/inference-data.zip?sasToken")
    .setStartTime(OffsetDateTime.parse("2023-07-01T00:00:00Z"))
    .setEndTime(OffsetDateTime.parse("2023-07-31T00:00:00Z"))
    .setTopContributorCount(10);

MultivariateDetectionResult detectionResult = 
    multivariateClient.detectMultivariateBatchAnomaly(modelId, detectionOptions);

String resultId = detectionResult.getResultId();

// Récupération des résultats
MultivariateDetectionResult result = multivariateClient.getBatchDetectionResult(resultId);
for (AnomalyState state : result.getResults()) {
    if (state.getValue().isAnomaly()) {
        System.out.printf("Anomalie à %s, gravité : %.2f%n",
            state.getTimestamp(),
            state.getValue().getSeverity());
    }
}

Détection du dernier point multivarié

MultivariateLastDetectionOptions lastOptions = new MultivariateLastDetectionOptions()
    .setVariables(List.of(
        new VariableValues("variable1", List.of("timestamp1"), List.of(1.0f)),
        new VariableValues("variable2", List.of("timestamp1"), List.of(2.5f))
    ))
    .setTopContributorCount(5);

MultivariateLastDetectionResult lastResult = 
    multivariateClient.detectMultivariateLastAnomaly(modelId, lastOptions);

if (lastResult.getValue().isAnomaly()) {
    System.out.println("Anomalie détectée !");
    // Vérification des variables contributrices
    for (AnomalyContributor contributor : lastResult.getValue().getInterpretation()) {
        System.out.printf("Variable : %s, Contribution : %.2f%n",
            contributor.getVariable(),
            contributor.getContributionScore());
    }
}

Gestion des modèles

// Liste de tous les modèles
PagedIterable models = multivariateClient.listMultivariateModels();
for (AnomalyDetectionModel m : models) {
    System.out.printf("Modèle : %s, Statut : %s%n",
        m.getModelId(),
        m.getModelInfo().getStatus());
}

// Supprimer un modèle
multivariateClient.deleteMultivariateModel(modelId);

Gestion des erreurs

import com.azure.core.exception.HttpResponseException;

try {
    univariateClient.detectUnivariateEntireSeries(options);
} catch (HttpResponseException e) {
    System.out.println("Code d'état : " + e.getResponse().getStatusCode());
    System.out.println("Erreur : " + e.getMessage());
}

Variables d’environnement

AZURE_ANOMALY_DETECTOR_ENDPOINT=https://.cognitiveservices.azure.com/ # Requis pour toutes les méthodes d’authentification
AZURE_ANOMALY_DETECTOR_API_KEY= # Requis uniquement pour l'authentification AzureKeyCredential
AZURE_TOKEN_CREDENTIALS=prod  # Requis uniquement si DefaultAzureCredential est utilisé en production

Bonnes pratiques

1. Nombre minimum de points de données: l'analyse univariée nécessite au moins 12 points ; plus le nombre de données est élevé, plus la précision est grande
2. Alignement de la granularité: adaptez la paramètre TimeGranularity à la fréquence réelle de vos données
3. Réglage de la sensibilité: des valeurs plus élevées (0-99) permettent de détecter davantage d’anomalies
4. Entraînement multivarié: utilisez une fenêtre glissante de 200 à 1 000 points en fonction de la complexité du modèle
5. Gestion des erreurs: traitez toujours les exceptions HttpResponseException en cas d'erreurs d'API

Expressions déclencheuses

• « détection d'anomalies Java »
• « détection d'anomalies séries chronologiques »
• « détection d'anomalies multivariées Java »
• « détection d'anomalies univariées »
• « détection d'anomalies en temps réel »
• « détection de points de changement »
• « Détecteur d'anomalies Azure AI »