SDK Azure AI Anomaly Detector pour Java

Créez des applications de détection d'anomalies avec le SDK Azure AI Anomaly Detector pour Java.

Installation

<dependency>
  <groupId>com.azure</groupId>
  <artifactId>azure-ai-anomalydetector</artifactId>
  <version>3.0.0-beta.6</version>
</dependency>

Création du client

Clients synchrone et asynchrone

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.identity.DefaultAzureCredentialBuilder;

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

Concepts clés

Détection d'anomalies univariée

• Détection batch : Analysez une série temporelle complète à la fois
• Détection en streaming : Détection en temps réel sur le dernier point de données
• Détection de points de changement : Détectez les changements de tendance dans les séries temporelles

Détection d'anomalies multivariée

• Détectez les anomalies sur 300+ signaux corrélés
• Utilise Graph Attention Network pour les inter-corrélations
• Processus en trois étapes : Entraînement → Inférence → Résultats

Patterns principaux

Détection batch univariée

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

List<TimeSeriesPoint> 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),
    // ... plus de points de données (minimum 12 points requis)
);

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

UnivariateEntireDetectionResult result = univariateClient.detectUnivariateEntireSeries(options);

// Vérifiez les anomalies
for (int i = 0; i < result.getIsAnomaly().size(); i++) {
    if (result.getIsAnomaly().get(i)) {
        System.out.printf("Anomalie détectée à l'index %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("Attendu : %.2f, Supérieur : %.2f, Inférieur : %.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'index %d avec une 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éparez la requête d'entraînement avec les données du blob storage
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înez le modèle (opération longue)
AnomalyDetectionModel trainedModel = multivariateClient.trainMultivariateModel(modelInfo);

String modelId = trainedModel.getModelId();
System.out.println("Model ID: " + modelId);

// Vérifiez le statut de l'entraînement
AnomalyDetectionModel model = multivariateClient.getMultivariateModel(modelId);
System.out.println("Status: " + model.getModelInfo().getStatus());

Inférence batch 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();

// Attendez les résultats
MultivariateDetectionResult result = multivariateClient.getBatchDetectionResult(resultId);
for (AnomalyState state : result.getResults()) {
    if (state.getValue().isAnomaly()) {
        System.out.printf("Anomalie à %s, sévérité : %.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érifiez les variables contributives
    for (AnomalyContributor contributor : lastResult.getValue().getInterpretation()) {
        System.out.printf("Variable : %s, Contribution : %.2f%n",
            contributor.getVariable(),
            contributor.getContributionScore());
    }
}

Gestion des modèles

// Lister tous les modèles
PagedIterable<AnomalyDetectionModel> models = multivariateClient.listMultivariateModels();
for (AnomalyDetectionModel m : models) {
    System.out.printf("Modèle : %s, Status : %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 de statut : " + e.getResponse().getStatusCode());
    System.out.println("Erreur : " + e.getMessage());
}

Variables d'environnement

AZURE_ANOMALY_DETECTOR_ENDPOINT=https://<resource>.cognitiveservices.azure.com/
AZURE_ANOMALY_DETECTOR_API_KEY=<your-api-key>

Bonnes pratiques

1. Points de données minimum : L'univarié nécessite au moins 12 points ; plus de données améliore la précision
2. Alignement de la granularité : Adaptez TimeGranularity à la fréquence réelle de vos données
3. Ajustement de la sensibilité : Des valeurs plus élevées (0-99) détectent plus d'anomalies
4. Entraînement multivarié : Utilisez une fenêtre glissante de 200-1 000 selon la complexité des patterns
5. Gestion des erreurs : Gérez toujours HttpResponseException pour les erreurs d'API

Expressions déclencheurs

• "anomaly detection Java"
• "detect anomalies time series"
• "multivariate anomaly Java"
• "univariate anomaly detection"
• "streaming anomaly detection"
• "change point detection"
• "Azure AI Anomaly Detector"