Guida introduttiva: Usare la libreria client multivariate Rilevamento anomalie

  • Articolo

Importante

A partire dal 20 settembre 2023 non sarà possibile creare nuove risorse Rilevamento anomalie. Il servizio Rilevamento anomalie viene ritirato il 1° ottobre 2026.

Introduzione alla libreria client multivariata Rilevamento anomalie per C#. Seguire questa procedura per installare il pacchetto e iniziare a usare gli algoritmi forniti dal servizio. Le nuove API di rilevamento anomalie multivariate consentono agli sviluppatori di integrare facilmente l'intelligenza artificiale avanzata per rilevare anomalie da gruppi di metriche, senza la necessità di conoscere o etichettare i dati di Machine Learning. Le dipendenze e le inter correlazioni tra segnali diversi vengono conteggiate automaticamente come fattori chiave. In questo modo è possibile proteggere in modo proattivo i sistemi complessi da errori.

Usare la libreria client multivariata Rilevamento anomalie per C# per:

  • Rilevare le anomalie a livello di sistema da un gruppo di serie temporali.
  • Quando una singola serie temporale non ti dirà molto e devi esaminare tutti i segnali per rilevare un problema.
  • Manutenzione predicativa di asset fisici costosi con decine a centinaia di diversi tipi di sensori che misurano vari aspetti dell'integrità del sistema.

Documentazione di riferimento della libreria Pacchetto del codice | sorgente della libreria | (NuGet)

Prerequisiti

  • Sottoscrizione di Azure: creare un account gratuito
  • Versione corrente di .NET Core
  • Dopo aver creato la sottoscrizione di Azure, creare una risorsa Rilevamento anomalie nel portale di Azure per ottenere la chiave e l'endpoint. Attendere che venga distribuita, quindi selezionare pulsante Vai alla risorsa.
    • La chiave e l'endpoint della risorsa creata sono necessari per connettere l'applicazione all'API Rilevamento anomalie. Incollare la chiave e l'endpoint nel codice seguente più avanti nella guida introduttiva. È possibile usare il piano tariffario gratuito (F0) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.

Impostazione

Creare un account di archiviazione

L'Rilevamento anomalie multivariato richiede che il file di esempio venga archiviato in Archiviazione BLOB di Azure.

  1. Creare un account Archiviazione di Azure.
  2. Passare a Controllo di accesso(IAM) e selezionare AGGIUNGI per Aggiungere un'assegnazione di ruolo.
  3. Ruolo di ricerca di Archiviazione Lettore dati BLOB, evidenziare questo tipo di account e quindi selezionare Avanti.
  4. Selezionare Assegna l'accesso all'identità gestita e selezionare Membri, quindi scegliere la risorsa Rilevamento anomalie creata in precedenza, quindi selezionare Rivedi e assegna.

Questa configurazione può talvolta creare confusione, se si verificano problemi, è consigliabile consultare l'esempio di Jupyter Notebook multivariato, che illustra questo processo più approfondito.

Scaricare i dati di esempio

Questa guida introduttiva usa un file per i dati sample_data_5_3000.csvdi esempio. Questo file può essere scaricato dai dati di esempio di GitHub

È anche possibile scaricare i dati di esempio eseguendo:

curl "https://github.com/Azure-Samples/AnomalyDetector/blob/master/sampledata/multivariate/sample_data_5_3000.csv" --output sample_data_5_3000_.csv

Caricare dati di esempio nell'account Archiviazione

  1. Passare all'account Archiviazione, selezionare Contenitori e creare un nuovo contenitore.
  2. Selezionare Carica e carica sample_data_5_3000.csv
  3. Selezionare i dati caricati e copiare l'URL del BLOB perché è necessario aggiungerli all'esempio di codice in pochi passaggi.

Recuperare la chiave e l'endpoint

Per effettuare correttamente una chiamata al servizio Rilevamento anomalie, sono necessari i valori seguenti:

Nome variabile Valore
ANOMALY_DETECTOR_ENDPOINT Questo valore è disponibile nella sezione Chiavi &ed endpoint durante l'esame della risorsa dalla portale di Azure. Endpoint di esempio: https://YOUR_RESOURCE_NAME.cognitiveservices.azure.com/
ANOMALY_DETECTOR_API_KEY Il valore della chiave API è disponibile nella sezione Chiavi ed endpoint quando si esamina la risorsa dal portale di Azure. Puoi usare entrambi KEY1 o KEY2.

Passare alla risorsa nel portale di Azure. L'endpoint e le chiavi sono disponibili nella sezione Gestione risorse. Copiare l'endpoint e la chiave di accesso in base alle esigenze per l'autenticazione delle chiamate API. Puoi usare entrambi KEY1 o KEY2. Avere sempre due chiavi consente di ruotare e rigenerare le chiavi in modo sicuro senza causare un'interruzione del servizio.

Creare variabili di ambiente

Creare e assegnare variabili di ambiente persistenti per la chiave e l'endpoint.

setx ANOMALY_DETECTOR_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE"

setx ANOMALY_DETECTOR_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

Creare una nuova applicazione .NET Core

In una finestra di una console, ad esempio cmd, PowerShell o Bash, usare il comando dotnet new per creare una nuova app console con il nome anomaly-detector-quickstart-multivariate. Questo comando crea un semplice progetto "Hello World" con un singolo file di origine C#: Program.cs.

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

Spostarsi nella cartella dell'app appena creata. È possibile compilare l'applicazione con il comando seguente:

dotnet build

L'output di compilazione non deve contenere alcun avviso o errore.

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

Installare la libreria client

All'interno della directory dell'applicazione, installare la libreria client di Rilevamento anomalie per .NET con il comando seguente:

dotnet add package Azure.AI.AnomalyDetector --prerelease

Dalla directory del progetto aprire il file program.cs e sostituire con il codice seguente:

using Azure.AI.AnomalyDetector;
using Azure;
using static System.Environment;

internal class Program
{
    private static void Main(string[] args)
    {
        string endpoint = GetEnvironmentVariable("ANOMALY_DETECTOR_ENDPOINT"); 
        string apiKey = GetEnvironmentVariable("ANOMALY_DETECTOR_API_KEY");
        string datasource = "Path-to-sample-file-in-your-storage-account";  // example path:https://docstest001.blob.core.windows.net/test/sample_data_5_3000.csv
        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, 2, 0, 0, 0, offset);
        DateTimeOffset end_time = new DateTimeOffset(2021, 1, 2, 5, 0, 0, offset);
        string model_id = null;
        try
        {
            model_id = TrainModel(client, datasource, start_time, end_time);

            // detect
            end_time = new DateTimeOffset(2021, 1, 2, 1, 0, 0, offset);
            MultivariateDetectionResult result = BatchDetect(client, datasource, model_id, start_time, end_time);
            if (result != null)
            {
                Console.WriteLine(string.Format("Result ID: {0}", result.ResultId.ToString()));
                Console.WriteLine(string.Format("Result summary: {0}", result.Summary.ToString()));
                Console.WriteLine(string.Format("Result length: {0}", result.Results.Count));
                Console.WriteLine(string.Format("Anomalies found: {0}", result.Results.Where(r => r.Value.IsAnomaly).Count()));
            }

            // delete
            DeleteModel(client, model_id);
        }
        catch (Exception e)
        {
            string msg = string.Format("Multivariate error. {0}", e.Message);
            Console.WriteLine(msg);
            throw;
        }

        int GetModelNumber(AnomalyDetectorClient client)
        {
            int model_number = 0;
            foreach (var multivariateModel in client.GetMultivariateModels())
            {
                model_number++;
            }
            return model_number;
        }

        string TrainModel(AnomalyDetectorClient client, string datasource, DateTimeOffset start_time, DateTimeOffset end_time, int max_tryout = 500)
        {
            try
            {
                Console.WriteLine("Training new model...");

                Console.WriteLine(string.Format("{0} available models before training.", GetModelNumber(client)));

                ModelInfo request = new ModelInfo(datasource, start_time, end_time);
                request.SlidingWindow = 200;

                Console.WriteLine("Training new model...(it may take a few minutes)");
                AnomalyDetectionModel response = client.TrainMultivariateModel(request);
                string trained_model_id = response.ModelId;
                Console.WriteLine(string.Format("Training model id is {0}", trained_model_id));

                // Wait until the model is ready. It usually takes several minutes
                ModelStatus? model_status = null;
                int tryout_count = 1;
                response = client.GetMultivariateModel(trained_model_id);
                while (tryout_count < max_tryout & model_status != ModelStatus.Ready & model_status != ModelStatus.Failed)
                {
                    Thread.Sleep(1000);
                    response = client.GetMultivariateModel(trained_model_id);
                    model_status = response.ModelInfo.Status;
                    Console.WriteLine(string.Format("try {0}, model_id: {1}, status: {2}.", tryout_count, trained_model_id, model_status));
                    tryout_count += 1;
                };

                if (model_status == ModelStatus.Ready)
                {
                    Console.WriteLine("Creating model succeeds.");
                    Console.WriteLine(string.Format("{0} available models after training.", GetModelNumber(client)));
                    return trained_model_id;
                }

                if (model_status == ModelStatus.Failed)
                {
                    Console.WriteLine("Creating model failed.");
                    Console.WriteLine("Errors:");
                    try
                    {
                        Console.WriteLine(string.Format("Error code: {0}, Message: {1}", response.ModelInfo.Errors[0].Code.ToString(), response.ModelInfo.Errors[0].Message.ToString()));
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine(string.Format("Get error message fail: {0}", e.Message));
                    }
                }
                return null;
            }
            catch (Exception e)
            {
                Console.WriteLine(string.Format("Train error. {0}", e.Message));
                throw;
            }
        }

        MultivariateDetectionResult BatchDetect(AnomalyDetectorClient client, string datasource, string model_id, DateTimeOffset start_time, DateTimeOffset end_time, int max_tryout = 500)
        {
            try
            {
                Console.WriteLine("Start batch detect...");
                MultivariateBatchDetectionOptions request = new MultivariateBatchDetectionOptions(datasource, 10, start_time, end_time);

                Console.WriteLine("Start batch detection, this might take a few minutes...");
                MultivariateDetectionResult response = client.DetectMultivariateBatchAnomaly(model_id, request);
                string result_id = response.ResultId;
                Console.WriteLine(string.Format("result id is: {0}", result_id));

                // get detection result
                MultivariateDetectionResult resultResponse = client.GetMultivariateBatchDetectionResult(result_id);
                MultivariateBatchDetectionStatus result_status = resultResponse.Summary.Status;
                int tryout_count = 0;
                while (tryout_count < max_tryout & result_status != MultivariateBatchDetectionStatus.Ready & result_status != MultivariateBatchDetectionStatus.Failed)
                {
                    Thread.Sleep(1000);
                    resultResponse = client.GetMultivariateBatchDetectionResult(result_id);
                    result_status = resultResponse.Summary.Status;
                    Console.WriteLine(string.Format("try: {0}, result id: {1} Detection status is {2}", tryout_count, result_id, result_status.ToString()));
                    Console.Out.Flush();
                }

                if (result_status == MultivariateBatchDetectionStatus.Failed)
                {
                    Console.WriteLine("Detection failed.");
                    Console.WriteLine("Errors:");
                    try
                    {
                        Console.WriteLine(string.Format("Error code: {}. Message: {}", resultResponse.Summary.Errors[0].Code.ToString(), resultResponse.Summary.Errors[0].Message.ToString()));
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine(string.Format("Get error message fail: {0}", e.Message));
                    }
                    return null;
                }
                return resultResponse;
            }
            catch (Exception e)
            {
                Console.WriteLine(string.Format("Detection error. {0}", e.Message));
                throw;
            }
        }

        void DeleteModel(AnomalyDetectorClient client, string model_id)
        {
            client.DeleteMultivariateModel(model_id);
            int model_number = GetModelNumber(client);
            Console.WriteLine(string.Format("{0} available models after deletion.", model_number));
        }
 
    }
}

Eseguire l'applicazione

Eseguire l'applicazione con il comando dotnet run dalla directory dell'applicazione.

dotnet run

Pulire le risorse

Se si vuole pulire e rimuovere una sottoscrizione dei servizi di intelligenza artificiale di Azure, è possibile eliminare la risorsa o il gruppo di risorse. Eliminando il gruppo di risorse vengono eliminate anche le altre risorse associate al gruppo.

Passaggi successivi

Introduzione alla libreria client multivariata Rilevamento anomalie per JavaScript. Seguire questa procedura per installare il pacchetto e iniziare a usare gli algoritmi forniti dal servizio. Le nuove API di rilevamento anomalie multivariate consentono agli sviluppatori di integrare facilmente l'intelligenza artificiale avanzata per rilevare anomalie da gruppi di metriche, senza la necessità di conoscere o etichettare i dati di Machine Learning. Le dipendenze e le inter correlazioni tra segnali diversi vengono conteggiate automaticamente come fattori chiave. In questo modo è possibile proteggere in modo proattivo i sistemi complessi da errori.

Usare la libreria client multivariata Rilevamento anomalie per JavaScript per:

  • Rilevare le anomalie a livello di sistema da un gruppo di serie temporali.
  • Quando una singola serie temporale non ti dirà molto e devi esaminare tutti i segnali per rilevare un problema.
  • Manutenzione predicativa di asset fisici costosi con decine a centinaia di diversi tipi di sensori che misurano vari aspetti dell'integrità del sistema.

Documentazione di riferimento della libreria | Codice sorgente | Package (npm) | Codice di esempio

Prerequisiti

  • Sottoscrizione di Azure: creare un account gratuito
  • Versione corrente di Node.js
  • Dopo aver creato la sottoscrizione di Azure, creare una risorsa Rilevamento anomalie nel portale di Azure per ottenere la chiave e l'endpoint. Attendere che venga distribuita, quindi selezionare pulsante Vai alla risorsa.
    • Sarà necessaria la chiave e l'endpoint della risorsa creata per connettere l'applicazione all'API Rilevamento anomalie. La chiave e l'endpoint verranno incollati nel codice riportato di seguito nell'argomento di avvio rapido. È possibile usare il piano tariffario gratuito (F0) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.

Configurazione

Creare una nuova applicazione Node.js

In una finestra della console, ad esempio cmd, PowerShell o Bash, creare e passare a una nuova directory per l'app.

mkdir myapp && cd myapp

Eseguire il comando npm init per creare un'applicazione Node con un file package.json.

npm init

Creare un file denominato index.js e importare le librerie seguenti: '

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

Creare le variabili per l'endpoint e per la chiave di Azure della risorsa. Creare un'altra variabile per il file di dati di esempio.

Nota

Si avrà sempre la possibilità di usare una delle due chiavi. Ciò consente la rotazione sicura delle chiavi. Ai fini di questa guida introduttiva, usare la prima chiave.

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

Importante

Al termine, ricordarsi di rimuovere la chiave dal codice e non renderlo mai pubblico. Per l'ambiente di produzione, usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni, vedere l'articolo sulla sicurezza dei servizi di intelligenza artificiale di Azure.

Per usare le API multivariate Rilevamento anomalie, è necessario prima eseguire il training dei propri modelli. I dati di training sono un set di più serie temporali che soddisfano i requisiti seguenti:

Ogni serie temporale deve essere un file CSV con due colonne (e solo due), "timestamp" e "value" (tutte in minuscolo) come riga di intestazione. I valori "timestamp" devono essere conformi a ISO 8601; "value" può essere integer o decimali con un numero qualsiasi di cifre decimali. Ad esempio:

timestamp value
2019-04-01T00:00:00Z 5
2019-04-01T00:01:00Z 3.6
2019-04-01T00:02:00Z 4
... ...

Ogni file CSV deve essere denominato dopo una variabile diversa che verrà usata per il training del modello. Ad esempio, "temperature.csv" e "humidity.csv". Tutti i file CSV devono essere compressi in un unico file ZIP senza sottocartelle. Il file ZIP può avere qualsiasi nome desiderato. Il file ZIP deve essere caricato nell'archivio BLOB di Azure. Dopo aver generato l'URL della firma di accesso condiviso (firme di accesso condiviso) del BLOB per il file ZIP, può essere usato per il training. Per informazioni su come generare URL di firma di accesso condiviso da Archiviazione BLOB di Azure, vedere questo documento.

Installare la libreria client

Installare i pacchetti NPM ms-rest-azure e azure-ai-anomalydetector. In questo argomento di avvio rapido viene usata anche la libreria csv-parse:

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

Il file package.json dell'app viene aggiornato con le dipendenze.

Esempi di codice

Questi frammenti di codice mostrano come eseguire le operazioni seguenti con la libreria client di Rilevamento anomalie per Node.js:

Autenticare il client

Creare un'istanza di un AnomalyDetectorClient oggetto con l'endpoint e le credenziali.

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

Eseguire il training di un modello

Costruire un risultato del modello

Prima di tutto è necessario costruire una richiesta di modello. Assicurarsi che l'ora di inizio e di fine sia allineata all'origine dati.

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

Eseguire il training di un nuovo modello

Passare la richiesta del modello al metodo client trainMultivariateModel Rilevamento anomalie.

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)

Per verificare se il training del modello è completo, è possibile tenere traccia dello stato del modello:

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

Rileva anomalie

Usare le detectAnomaly funzioni e getDectectionResult per determinare se sono presenti anomalie all'interno dell'origine dati.

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

Esporta modello

Nota

Il comando di esportazione deve essere usato per consentire l'esecuzione di Rilevamento anomalie modelli multivariati in un ambiente in contenitori. Questo non è attualmente supportato per il multivariato, ma il supporto verrà aggiunto in futuro.

Per esportare il modello sottoposto a training, usare la exportModel funzione .

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

Eliminare un modello

Per eliminare un modello esistente disponibile per la risorsa corrente, usare la deleteMultivariateModel funzione .

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

Eseguire l'applicazione

Prima di eseguire l'applicazione, può essere utile controllare il codice con il codice di esempio completo

Eseguire l'applicazione con il comando node nel file quickstart.

node index.js

Pulire le risorse

Se si vuole pulire e rimuovere una sottoscrizione dei servizi di intelligenza artificiale di Azure, è possibile eliminare la risorsa o il gruppo di risorse. Eliminando il gruppo di risorse vengono eliminate anche le altre risorse associate al gruppo.

Passaggi successivi

Documentazione di riferimento della libreria |Codice sorgente della libreria | Pacchetto (PyPi) |Trovare il codice di esempio in GitHub

Introduzione alla libreria client multivariata Rilevamento anomalie per Python. Seguire questa procedura per installare il pacchetto e iniziare a usare gli algoritmi forniti dal servizio. Le nuove API di rilevamento anomalie multivariate consentono agli sviluppatori di integrare facilmente l'intelligenza artificiale avanzata per rilevare anomalie da gruppi di metriche, senza la necessità di conoscere o etichettare i dati di Machine Learning. Le dipendenze e le inter correlazioni tra segnali diversi vengono conteggiate automaticamente come fattori chiave. In questo modo è possibile proteggere in modo proattivo i sistemi complessi da errori.

Usare la libreria client multivariata Rilevamento anomalie per Python per:

  • Rilevare le anomalie a livello di sistema da un gruppo di serie temporali.
  • Quando una singola serie temporale non ti dirà molto e devi esaminare tutti i segnali per rilevare un problema.
  • Manutenzione predicativa di asset fisici costosi con decine a centinaia di diversi tipi di sensori che misurano vari aspetti dell'integrità del sistema.

Prerequisiti

  • Una sottoscrizione di Azure: creare un account gratuitamente
  • Python 3.x
  • Dopo aver creato la sottoscrizione di Azure, creare una risorsa Rilevamento anomalie nel portale di Azure per ottenere la chiave e l'endpoint. Attendere che venga distribuita, quindi selezionare pulsante Vai alla risorsa. È possibile usare il piano tariffario gratuito (F0) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.

Impostazione

Installare la libreria client. È possibile installare la libreria client con:

pip install --upgrade azure.ai.anomalydetector

Creare un account di archiviazione

L'Rilevamento anomalie multivariato richiede che il file di esempio venga archiviato in Archiviazione BLOB di Azure.

  1. Creare un account Archiviazione di Azure.
  2. Passare a Controllo di accesso(IAM) e selezionare AGGIUNGI per Aggiungere un'assegnazione di ruolo.
  3. Ruolo di ricerca di Archiviazione Lettore dati BLOB, evidenziare questo tipo di account e quindi selezionare Avanti.
  4. Selezionare Assegna l'accesso all'identità gestita e selezionare Membri, quindi scegliere la risorsa Rilevamento anomalie creata in precedenza, quindi selezionare Rivedi e assegna.

Questa configurazione può talvolta creare confusione, se si verificano problemi, è consigliabile consultare l'esempio di Jupyter Notebook multivariato, che illustra questo processo più approfondito.

Scaricare i dati di esempio

Questa guida introduttiva usa un file per i dati sample_data_5_3000.csvdi esempio. Questo file può essere scaricato dai dati di esempio di GitHub

È anche possibile scaricare i dati di esempio eseguendo:

curl "https://github.com/Azure-Samples/AnomalyDetector/blob/master/sampledata/multivariate/sample_data_5_3000.csv" --output sample_data_5_3000_.csv

Caricare dati di esempio nell'account Archiviazione

  1. Passare all'account Archiviazione, selezionare Contenitori e creare un nuovo contenitore.
  2. Selezionare Carica e carica sample_data_5_3000.csv
  3. Selezionare i dati caricati e copiare l'URL del BLOB perché è necessario aggiungerli all'esempio di codice in pochi passaggi.

Recuperare la chiave e l'endpoint

Per effettuare correttamente una chiamata al servizio Rilevamento anomalie, sono necessari i valori seguenti:

Nome variabile Valore
ANOMALY_DETECTOR_ENDPOINT Questo valore è disponibile nella sezione Chiavi &ed endpoint durante l'esame della risorsa dalla portale di Azure. Endpoint di esempio: https://YOUR_RESOURCE_NAME.cognitiveservices.azure.com/
ANOMALY_DETECTOR_API_KEY Il valore della chiave API è disponibile nella sezione Chiavi ed endpoint quando si esamina la risorsa dal portale di Azure. Puoi usare entrambi KEY1 o KEY2.

Passare alla risorsa nel portale di Azure. L'endpoint e le chiavi sono disponibili nella sezione Gestione risorse. Copiare l'endpoint e la chiave di accesso in base alle esigenze per l'autenticazione delle chiamate API. Puoi usare entrambi KEY1 o KEY2. Avere sempre due chiavi consente di ruotare e rigenerare le chiavi in modo sicuro senza causare un'interruzione del servizio.

Creare variabili di ambiente

Creare e assegnare variabili di ambiente persistenti per la chiave e l'endpoint.

setx ANOMALY_DETECTOR_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE"

setx ANOMALY_DETECTOR_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

Creare una nuova applicazione Python

  1. Creare un nuovo file Python denominato sample_multivariate_detect.py. Aprirlo quindi nell'editor o nell'IDE preferito.

  2. Sostituire il contenuto di sample_multivariate_detect.py con il codice seguente. È necessario modificare i percorsi per le variabili blob_url.

import time
from datetime import datetime, timezone
from azure.ai.anomalydetector import AnomalyDetectorClient
from azure.core.credentials import AzureKeyCredential
from azure.ai.anomalydetector.models import *

SUBSCRIPTION_KEY =  os.environ['ANOMALY_DETECTOR_API_KEY']
ANOMALY_DETECTOR_ENDPOINT = os.environ['ANOMALY_DETECTOR_ENDPOINT']

ad_client = AnomalyDetectorClient(ANOMALY_DETECTOR_ENDPOINT, AzureKeyCredential(SUBSCRIPTION_KEY))

time_format = "%Y-%m-%dT%H:%M:%SZ"
blob_url = "Path-to-sample-file-in-your-storage-account"  # example path: https://docstest001.blob.core.windows.net/test/sample_data_5_3000.csv

train_body = ModelInfo(
    data_source=blob_url,
    start_time=datetime.strptime("2021-01-02T00:00:00Z", time_format),
    end_time=datetime.strptime("2021-01-02T05:00:00Z", time_format),
    data_schema="OneTable",
    display_name="sample",
    sliding_window=200,
    align_policy=AlignPolicy(
        align_mode=AlignMode.OUTER,
        fill_n_a_method=FillNAMethod.LINEAR,
        padding_value=0,
    ),
)

batch_inference_body = MultivariateBatchDetectionOptions(
       data_source=blob_url,
       top_contributor_count=10,
       start_time=datetime.strptime("2021-01-02T00:00:00Z", time_format),
       end_time=datetime.strptime("2021-01-02T05:00:00Z", time_format),
   )


print("Training new model...(it may take a few minutes)")
model = ad_client.train_multivariate_model(train_body)
model_id = model.model_id
print("Training model id is {}".format(model_id))

## Wait until the model is ready. It usually takes several minutes
model_status = None
model = None

while model_status != ModelStatus.READY and model_status != ModelStatus.FAILED:
    model = ad_client.get_multivariate_model(model_id)
    print(model)
    model_status = model.model_info.status
    print("Model is {}".format(model_status))
    time.sleep(30)
if model_status == ModelStatus.READY:
    print("Done.\n--------------------")
    # Return the latest model id

# Detect anomaly in the same data source (but a different interval)
result = ad_client.detect_multivariate_batch_anomaly(model_id, batch_inference_body)
result_id = result.result_id

# Get results (may need a few seconds)
r = ad_client.get_multivariate_batch_detection_result(result_id)
print("Get detection result...(it may take a few seconds)")

while r.summary.status != MultivariateBatchDetectionStatus.READY and r.summary.status != MultivariateBatchDetectionStatus.FAILED and r.summary.status !=MultivariateBatchDetectionStatus.CREATED:
    anomaly_results = ad_client.get_multivariate_batch_detection_result(result_id)
    print("Detection is {}".format(r.summary.status))
    time.sleep(5)
    
   
print("Result ID:\t", anomaly_results.result_id)
print("Result status:\t", anomaly_results.summary.status)
print("Result length:\t", len(anomaly_results.results))

# See detailed inference result
for r in anomaly_results.results:
    print(
        "timestamp: {}, is_anomaly: {:<5}, anomaly score: {:.4f}, severity: {:.4f}, contributor count: {:<4d}".format(
            r.timestamp,
            r.value.is_anomaly,
            r.value.score,
            r.value.severity,
            len(r.value.interpretation) if r.value.is_anomaly else 0,
        )
    )
    if r.value.interpretation:
        for contributor in r.value.interpretation:
            print(
                "\tcontributor variable: {:<10}, contributor score: {:.4f}".format(
                    contributor.variable, contributor.contribution_score
                )
            )

Eseguire l'applicazione

Eseguire l'applicazione con il comando python nel file quickstart.

python sample_multivariate_detect.py

Output

10 available models before training.
Training new model...(it may take a few minutes)
Training model id is 3a695878-a88f-11ed-a16c-b290e72010e0
{'modelId': '3a695878-a88f-11ed-a16c-b290e72010e0', 'createdTime': '2023-02-09T15:34:23Z', 'lastUpdatedTime': '2023-02-09T15:34:23Z', 'modelInfo': {'dataSource': 'https://docstest001.blob.core.windows.net/test/sample_data_5_3000 (1).csv', 'dataSchema': 'OneTable', 'startTime': '2021-01-02T00:00:00Z', 'endTime': '2021-01-02T05:00:00Z', 'displayName': 'sample', 'slidingWindow': 200, 'alignPolicy': {'alignMode': 'Outer', 'fillNAMethod': 'Linear', 'paddingValue': 0.0}, 'status': 'CREATED', 'errors': [], 'diagnosticsInfo': {'modelState': {'epochIds': [], 'trainLosses': [], 'validationLosses': [], 'latenciesInSeconds': []}, 'variableStates': []}}}
Model is CREATED
{'modelId': '3a695878-a88f-11ed-a16c-b290e72010e0', 'createdTime': '2023-02-09T15:34:23Z', 'lastUpdatedTime': '2023-02-09T15:34:55Z', 'modelInfo': {'dataSource': 'https://docstest001.blob.core.windows.net/test/sample_data_5_3000 (1).csv', 'dataSchema': 'OneTable', 'startTime': '2021-01-02T00:00:00Z', 'endTime': '2021-01-02T05:00:00Z', 'displayName': 'sample', 'slidingWindow': 200, 'alignPolicy': {'alignMode': 'Outer', 'fillNAMethod': 'Linear', 'paddingValue': 0.0}, 'status': 'READY', 'errors': [], 'diagnosticsInfo': {'modelState': {'epochIds': [10, 20, 30, 40, 50, 60, 70, 80, 90, 100], 'trainLosses': [1.0493712276220322, 0.5454281121492386, 0.42524269968271255, 0.38019897043704987, 0.3472398854792118, 0.34301353991031647, 0.3219067454338074, 0.3108387663960457, 0.30357857793569565, 0.29986055195331573], 'validationLosses': [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 'latenciesInSeconds': [0.3412797451019287, 0.25798678398132324, 0.2556419372558594, 0.3165152072906494, 0.2748451232910156, 0.26111531257629395, 0.2571413516998291, 0.257282018661499, 0.2549862861633301, 0.25806593894958496]}, 'variableStates': [{'variable': 'series_0', 'filledNARatio': 0.0, 'effectiveCount': 301, 'firstTimestamp': '2021-01-02T00:00:00Z', 'lastTimestamp': '2021-01-02T05:00:00Z'}, {'variable': 'series_1', 'filledNARatio': 0.0, 'effectiveCount': 301, 'firstTimestamp': '2021-01-02T00:00:00Z', 'lastTimestamp': '2021-01-02T05:00:00Z'}, {'variable': 'series_2', 'filledNARatio': 0.0, 'effectiveCount': 301, 'firstTimestamp': '2021-01-02T00:00:00Z', 'lastTimestamp': '2021-01-02T05:00:00Z'}, {'variable': 'series_3', 'filledNARatio': 0.0, 'effectiveCount': 301, 'firstTimestamp': '2021-01-02T00:00:00Z', 'lastTimestamp': '2021-01-02T05:00:00Z'}, {'variable': 'series_4', 'filledNARatio': 0.0, 'effectiveCount': 301, 'firstTimestamp': '2021-01-02T00:00:00Z', 'lastTimestamp': '2021-01-02T05:00:00Z'}]}}}
Model is READY
Done.
--------------------
10 available models after training.
Get detection result...(it may take a few seconds)
Detection is CREATED
Detection is READY
Result ID:	 70a6cdf8-a88f-11ed-a461-928899e62c38
Result status:	 READY
Result length:	 301
timestamp: 2021-01-02 00:00:00+00:00, is_anomaly: 0    , anomaly score: 0.1770, severity: 0.0000, contributor count: 0   
timestamp: 2021-01-02 00:01:00+00:00, is_anomaly: 0    , anomaly score: 0.3446, severity: 0.0000, contributor count: 0   
timestamp: 2021-01-02 00:02:00+00:00, is_anomaly: 0    , anomaly score: 0.2397, severity: 0.0000, contributor count: 0   
timestamp: 2021-01-02 00:03:00+00:00, is_anomaly: 0    , anomaly score: 0.1270, severity: 0.0000, contributor count: 0   
timestamp: 2021-01-02 00:04:00+00:00, is_anomaly: 0    , anomaly score: 0.3321, severity: 0.0000, contributor count: 0   
timestamp: 2021-01-02 00:05:00+00:00, is_anomaly: 0    , anomaly score: 0.4053, severity: 0.0000, contributor count: 0   
timestamp: 2021-01-02 00:06:00+00:00, is_anomaly: 0    , anomaly score: 0.4371, severity: 0.0000, contributor count: 0   
timestamp: 2021-01-02 00:07:00+00:00, is_anomaly: 1    , anomaly score: 0.6615, severity: 0.3850, contributor count: 5   
	contributor variable: series_3  , contributor score: 0.2939
	contributor variable: series_1  , contributor score: 0.2834
	contributor variable: series_4  , contributor score: 0.2329
	contributor variable: series_0  , contributor score: 0.1543
	contributor variable: series_2  , contributor score: 0.0354

I risultati dell'output sono stati troncati per brevità.

Pulire le risorse

Se si vuole pulire e rimuovere una risorsa Rilevamento anomalie, è possibile eliminare la risorsa o il gruppo di risorse. L'eliminazione del gruppo di risorse comporta anche l'eliminazione di tutte le altre risorse associate. È anche possibile prendere in considerazione l'eliminazione delle variabili di ambiente create se non si intende più usarle.

Introduzione alla libreria client multivariata Rilevamento anomalie per Java. Seguire questi passaggi per installare il pacchetto e iniziare a usare gli algoritmi forniti dal servizio. Le nuove API di rilevamento anomalie multivariate consentono agli sviluppatori di integrare facilmente l'intelligenza artificiale avanzata per rilevare anomalie da gruppi di metriche, senza la necessità di conoscere o etichettare i dati di Machine Learning. Le dipendenze e le inter correlazioni tra segnali diversi vengono conteggiate automaticamente come fattori chiave. In questo modo è possibile proteggere in modo proattivo i sistemi complessi da errori.

Usare la libreria client multivariata Rilevamento anomalie per Java per:

  • Rilevare le anomalie a livello di sistema da un gruppo di serie temporali.
  • Quando una singola serie temporale non ti dirà molto e devi esaminare tutti i segnali per rilevare un problema.
  • Manutenzione predicativa di asset fisici costosi con decine a centinaia di diversi tipi di sensori che misurano vari aspetti dell'integrità del sistema.

Codice sorgente | della libreria della documentazione | di riferimento libreria (Maven) | Codice di esempio

Prerequisiti

  • Sottoscrizione di Azure: creare un account gratuito
  • La versione corrente di Java Development Kit (JDK)
  • Lo strumento di compilazione Gradle o un'altra utilità di gestione dipendenze.
  • Dopo aver creato la sottoscrizione di Azure, creare una risorsa Rilevamento anomalie nel portale di Azure per ottenere la chiave e l'endpoint. Attendere che venga distribuita, quindi selezionare pulsante Vai alla risorsa.
    • Sarà necessaria la chiave e l'endpoint della risorsa creata per connettere l'applicazione all'API Rilevamento anomalie. La chiave e l'endpoint verranno incollati nel codice riportato di seguito nell'argomento di avvio rapido. È possibile usare il piano tariffario gratuito (F0) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.

Configurazione

Creare un nuovo progetto Gradle

Questo argomento di avvio rapido usa l'utilità di gestione dipendenze Gradle. Per altre informazioni sulla libreria client, vedere Maven Central Repository.

In una finestra della console, ad esempio cmd, PowerShell o Bash, creare e passare a una nuova directory per l'app.

mkdir myapp && cd myapp

Eseguire il comando gradle init dalla directory di lavoro. Questo comando crea file di compilazione essenziali per Gradle, inclusi build.gradle.kts usati in fase di esecuzione per creare e configurare l'applicazione.

gradle init --type basic

Quando viene chiesto di scegliere un linguaggio DSL, selezionare Kotlin.

Installare la libreria client

Individuare il file build.gradle.kts e aprirlo con un IDE o un editor di testo a scelta. Quindi copiare questa configurazione della build. Assicurarsi di includere le dipendenze del progetto.

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

Creare un file Java

Creare una cartella per l'app di esempio. Dalla directory di lavoro eseguire il comando seguente:

mkdir -p src/main/java

Passare alla nuova cartella e creare un file denominato MetricsAdvisorQuickstarts.Java. Aprirlo in un editor o un IDE a scelta e importare le istruzioni import seguenti:

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;

Creare le variabili per l'endpoint e per la chiave di Azure della risorsa. Creare un'altra variabile per il file di dati di esempio.

Nota

Si avrà sempre la possibilità di usare una delle due chiavi. Ciò consente la rotazione sicura delle chiavi. Ai fini di questa guida introduttiva, usare la prima chiave.

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

Importante

Al termine, ricordarsi di rimuovere la chiave dal codice e non renderlo mai pubblico. Per l'ambiente di produzione, usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni, vedere l'articolo sulla sicurezza dei servizi di intelligenza artificiale di Azure.

Per usare le API multivariate Rilevamento anomalie, è necessario prima eseguire il training dei propri modelli. I dati di training sono un set di più serie temporali che soddisfano i requisiti seguenti:

Ogni serie temporale deve essere un file CSV con due colonne (e solo due), "timestamp" e "value" (tutte in minuscolo) come riga di intestazione. I valori "timestamp" devono essere conformi a ISO 8601; "value" può essere integer o decimali con un numero qualsiasi di cifre decimali. Ad esempio:

timestamp value
2019-04-01T00:00:00Z 5
2019-04-01T00:01:00Z 3.6
2019-04-01T00:02:00Z 4
... ...

Ogni file CSV deve essere denominato dopo una variabile diversa che verrà usata per il training del modello. Ad esempio, "temperature.csv" e "humidity.csv". Tutti i file CSV devono essere compressi in un unico file ZIP senza sottocartelle. Il file ZIP può avere qualsiasi nome desiderato. Il file ZIP deve essere caricato nell'archivio BLOB di Azure. Dopo aver generato l'URL della firma di accesso condiviso (firme di accesso condiviso) del BLOB per il file ZIP, può essere usato per il training. Per informazioni su come generare URL di firma di accesso condiviso da Archiviazione BLOB di Azure, vedere questo documento.

Esempi di codice

Questi frammenti di codice mostrano come eseguire le operazioni seguenti con la libreria client di Rilevamento anomalie per Node.js:

Autenticare il client

Creare un'istanza di un anomalyDetectorClient oggetto con l'endpoint e le credenziali.

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

HttpPipelinePolicy authPolicy = new AzureKeyCredentialPolicy("Ocp-Apim-Subscription-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();

Eseguire il training di un modello

Costruire un risultato del modello ed eseguire il training del modello

Prima di tutto è necessario costruire una richiesta di modello. Assicurarsi che l'ora di inizio e di fine sia allineata all'origine dati.

Per usare le API multivariate Rilevamento anomalie, è necessario eseguire il training del modello prima di usare il rilevamento. I dati usati per il training sono un batch di serie temporali, ogni serie temporale deve trovarsi in un file CSV con solo due colonne, "timestamp" e "value"(i nomi delle colonne devono essere esattamente uguali). Ogni file CSV deve essere denominato dopo ogni variabile per la serie temporale. Tutte le serie temporali devono essere compresse in un unico file ZIP e caricate nell'archivio BLOB di Azure e non è necessario specificare il nome del file ZIP. In alternativa, un file meta.json aggiuntivo può essere incluso nel file ZIP se si desidera che il nome della variabile sia diverso dal nome del file ZIP. Dopo aver generato l'URL della firma di accesso condiviso blob (Firme di accesso condiviso), è possibile usare l'URL per il file ZIP per il 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());
    }
}

Rileva anomalie

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

Esporta modello

Nota

Il comando di esportazione deve essere usato per consentire l'esecuzione di Rilevamento anomalie modelli multivariati in un ambiente in contenitori. Questo non è attualmente supportato per il multivariato, ma il supporto verrà aggiunto in futuro.

Per esportare il modello sottoposto a training, usare .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));

Eliminare un modello

Per eliminare un modello esistente disponibile per la risorsa corrente, usare la deleteMultivariateModelWithResponse funzione .

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

Eseguire l'applicazione

È possibile compilare l'app con:

gradle build

Eseguire l'applicazione

Prima di eseguirlo, può essere utile controllare il codice con il codice di esempio completo.

Eseguire l'applicazione con il comando run:

gradle run

Pulire le risorse

Se si vuole pulire e rimuovere una sottoscrizione dei servizi di intelligenza artificiale di Azure, è possibile eliminare la risorsa o il gruppo di risorse. Eliminando il gruppo di risorse vengono eliminate anche le altre risorse associate al gruppo.

Passaggi successivi