Guia de início rápido: usar a biblioteca de cliente do Multivariate Anomaly Detetor

Introdução à biblioteca de cliente multivariada do Detetor de Anomalias para C#. Siga estas etapas para instalar o pacote e começar a usar os algoritmos fornecidos pelo serviço. As novas APIs de detetor de anomalias multivariadas permitem que os desenvolvedores integrem facilmente IA avançada para detetar anomalias de grupos de métricas, sem a necessidade de conhecimento de aprendizado de máquina ou dados rotulados. As dependências e inter-correlações entre diferentes sinais são automaticamente contadas como factores-chave. Isso ajuda você a proteger proativamente seus sistemas complexos contra falhas.

Use a biblioteca de cliente multivariada do Detetor de Anomalias para C# para:

• Detete anomalias no nível do sistema a partir de um grupo de séries temporais.
• Quando qualquer série temporal individual não lhe diz muito e você tem que olhar para todos os sinais para detetar um problema.
• Manutenção predicativa de ativos físicos caros com dezenas a centenas de tipos diferentes de sensores medindo vários aspetos da integridade do sistema.

Documentação | de referência da biblioteca Pacote de código-fonte | da biblioteca (NuGet)

• Subscrição do Azure - Criar uma gratuitamente
• A versão atual do .NET Core
• Depois de ter sua assinatura do Azure, crie um recurso do Detetor de Anomalias no portal do Azure para obter sua chave e ponto de extremidade. Aguarde até que ele seja implantado e selecione o botão Ir para recurso.
  • Você precisará da chave e do ponto de extremidade do recurso criado para conectar seu aplicativo à API do Detetor de Anomalias. Cole sua chave e ponto de extremidade no código abaixo mais adiante no início rápido. Você pode usar o nível de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para um nível pago para produção.

O Detetor de Anomalias Multivariado requer que seu arquivo de exemplo seja armazenado no Armazenamento de Blobs do Azure.

1. Crie uma conta de Armazenamento do Azure.
2. Vá para Controle de Acesso (IAM) e selecione ADICIONAR para Adicionar atribuição de função.
3. Função de pesquisa do Leitor de Dados de Blob de Armazenamento, realce este tipo de conta e selecione Avançar.
4. Selecione atribuir acesso à identidade gerenciada e selecione Membros, escolha o recurso Detetor de anomalias que você criou anteriormente e selecione Revisar + atribuir.

Essa configuração às vezes pode ser um pouco confusa, se você tiver problemas, recomendamos consultar nossa amostra multivariada de Jupyter Notebook, que acompanha esse processo mais detalhadamente.

Este guia de início rápido usa um arquivo para dados sample_data_5_3000.csvde exemplo. Este arquivo pode ser baixado de nossos dados de exemplo do GitHub

Você também pode baixar os dados de exemplo executando:

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

1. Aceda à sua Conta de Armazenamento, selecione Contentores e crie um novo contentor.
2. Selecione Carregar e carregar sample_data_5_3000.csv
3. Selecione os dados que você carregou e copie a URL do Blob conforme necessário para adicioná-la ao exemplo de código em algumas etapas.

Para fazer uma chamada com êxito no serviço Detetor de Anomalias, você precisa dos seguintes valores:

Vá para o seu recurso no portal do Azure. O Ponto de Extremidade e as Chaves podem ser encontrados na seção Gerenciamento de Recursos. Copie seu ponto de extremidade e chave de acesso conforme necessário para autenticar suas chamadas de API. Pode utilizar KEY1 ou KEY2. Ter sempre duas chaves permite-lhe rodar e regenerar chaves de forma segura sem causar uma interrupção do serviço.

Crie e atribua variáveis de ambiente persistentes para sua chave e endpoint.

setx ANOMALY_DETECTOR_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE"

setx ANOMALY_DETECTOR_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

[System.Environment]::SetEnvironmentVariable('ANOMALY_DETECTOR_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')

[System.Environment]::SetEnvironmentVariable('ANOMALY_DETECTOR_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

echo export ANOMALY_DETECTOR_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE" >> /etc/environment && source /etc/environment

echo export ANOMALY_DETECTOR_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE" >> /etc/environment && source /etc/environment

Em uma janela de console (como cmd, PowerShell ou Bash), use o dotnet new comando para criar um novo aplicativo de console com o nome anomaly-detector-quickstart-multivariate. Este comando cria um projeto "Hello World" simples com um único arquivo de origem C#: Program.cs.

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

Altere seu diretório para a pasta do aplicativo recém-criada. Você pode criar o aplicativo com:

dotnet build

A saída da compilação não deve conter avisos ou erros.

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

Dentro do diretório do aplicativo, instale a biblioteca de cliente do Detetor de Anomalias para .NET com o seguinte comando:

dotnet add package Azure.AI.AnomalyDetector --prerelease

No diretório do projeto, abra o arquivo program.cs e substitua pelo seguinte código:

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

Execute o aplicativo com o dotnet run comando do diretório do aplicativo.

dotnet run

Se quiser limpar e remover uma assinatura de serviços do Azure AI, você pode excluir o recurso ou grupo de recursos. A exclusão do grupo de recursos também exclui quaisquer outros recursos associados ao grupo de recursos.

• Portal do Azure
• CLI do Azure

• O que é a API do Detetor de Anomalias?
• Práticas recomendadas ao usar a API do Detetor de Anomalias.

Introdução à biblioteca de cliente multivariada do Detetor de Anomalias para JavaScript. Siga estas etapas para instalar o pacote e começar a usar os algoritmos fornecidos pelo serviço. As novas APIs de detetor de anomalias multivariadas permitem que os desenvolvedores integrem facilmente IA avançada para detetar anomalias de grupos de métricas, sem a necessidade de conhecimento de aprendizado de máquina ou dados rotulados. As dependências e inter-correlações entre diferentes sinais são automaticamente contadas como factores-chave. Isso ajuda você a proteger proativamente seus sistemas complexos contra falhas.

Use a biblioteca de cliente multivariada do Detetor de Anomalias para JavaScript para:

• Detete anomalias no nível do sistema a partir de um grupo de séries temporais.
• Quando qualquer série temporal individual não lhe diz muito, e você tem que olhar para todos os sinais para detetar um problema.
• Manutenção predicativa de ativos físicos caros com dezenas a centenas de tipos diferentes de sensores medindo vários aspetos da integridade do sistema.

Documentação | de referência da biblioteca Código fonte | da biblioteca Pacote (npm) | Código de exemplo

• Subscrição do Azure - Criar uma gratuitamente
• A versão atual do Node.js
• Depois de ter sua assinatura do Azure, crie um recurso do Detetor de Anomalias no portal do Azure para obter sua chave e ponto de extremidade. Aguarde até que ele seja implantado e selecione o botão Ir para recurso.
  • Você precisa da chave e do ponto de extremidade do recurso criado para conectar seu aplicativo à API do Detetor de Anomalias. Você cola sua chave e ponto de extremidade no código abaixo mais adiante no início rápido. Você pode usar o nível de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para um nível pago para produção.

Numa janela de consola (como cmd, PowerShell ou Bash), crie um novo diretório para a sua aplicação e navegue para a mesma.

mkdir myapp && cd myapp

Execute o comando npm init para criar uma aplicação de nó com um ficheiro package.json.

npm init

Crie um arquivo chamado index.js e importe as seguintes bibliotecas: '

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

Crie variáveis do ponto de extremidade e da chave do Azure do seu recurso. Crie outra variável para o arquivo de dados de exemplo.

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

Para usar as APIs multivariadas do Detetor de Anomalias, você precisa primeiro treinar seus próprios modelos. Os dados de treinamento são um conjunto de várias séries temporais que atendem aos seguintes requisitos:

Cada série temporal deve ser um arquivo CSV com duas (e apenas duas) colunas, "timestamp" e "value" (todas em minúsculas) como linha de cabeçalho. Os valores de "carimbo de data/hora" devem estar em conformidade com a norma ISO 8601; O "valor" pode ser inteiro ou decimal com qualquer número de casas decimais. Por exemplo:

Cada arquivo CSV deve ter o nome de uma variável diferente que será usada para o treinamento do modelo. Por exemplo, "temperature.csv" e "humidity.csv". Todos os arquivos CSV devem ser compactados em um arquivo zip sem subpastas. O arquivo zip pode ter o nome que você quiser. O arquivo zip deve ser carregado no armazenamento de Blob do Azure. Depois de gerar o URL do blob SAS (Assinaturas de acesso compartilhado) para o arquivo zip, ele pode ser usado para treinamento. Consulte este documento para saber como gerar URLs SAS do Armazenamento de Blobs do Azure.

Instale os ms-rest-azure pacotes e azure-ai-anomalydetector NPM. A biblioteca csv-parse também é usada neste início rápido:

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

O arquivo do package.json seu aplicativo é atualizado com as dependências.

Esses trechos de código mostram como fazer o seguinte com a biblioteca de cliente do Detetor de Anomalias para Node.js:

• Autenticar o cliente
• Preparar um modelo
• Detetar anomalias
• Modelo de exportação
• Excluir modelo

Instancie um AnomalyDetectorClient objeto com seu ponto de extremidade e credenciais.

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

Primeiro precisamos construir um modelo de solicitação. Certifique-se de que as horas de início e de fim estão alinhadas com a sua fonte de dados.

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

Você passa sua solicitação de modelo para o método de cliente trainMultivariateModel do Detetor de Anomalias.

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)

Para verificar se o treinamento do seu modelo está completo, você pode acompanhar o status do modelo:

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

Use as detectAnomaly funções e getDectectionResult para determinar se há alguma anomalia em sua fonte de dados.

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

Para exportar seu modelo treinado, use a exportModel função.

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

Para excluir um modelo existente que está disponível para o recurso atual, use a deleteMultivariateModel função.

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

Antes de executar o aplicativo, pode ser útil verificar seu código em relação ao código de exemplo completo

Execute a aplicação com o comando node no seu ficheiro de início rápido.

node index.js

Se quiser limpar e remover uma assinatura de serviços do Azure AI, você pode excluir o recurso ou grupo de recursos. A exclusão do grupo de recursos também exclui quaisquer outros recursos associados ao grupo de recursos.

• Portal do Azure
• CLI do Azure

• O que é a API do Detetor de Anomalias?
• Práticas recomendadas ao usar a API do Detetor de Anomalias.

Documentação |de referência da biblioteca Pacote de código-fonte | da biblioteca (PyPi) |Encontre o código de exemplo no GitHub

Comece a usar a biblioteca de cliente multivariada do Detetor de Anomalias para Python. Siga estas etapas para instalar o pacote e começar a usar os algoritmos fornecidos pelo serviço. As novas APIs de detetor de anomalias multivariadas permitem que os desenvolvedores integrem facilmente IA avançada para detetar anomalias de grupos de métricas, sem a necessidade de conhecimento de aprendizado de máquina ou dados rotulados. As dependências e inter-correlações entre diferentes sinais são automaticamente contadas como factores-chave. Isso ajuda você a proteger proativamente seus sistemas complexos contra falhas.

Use a biblioteca de cliente multivariada Anomaly Detetor para Python para:

• Detete anomalias no nível do sistema a partir de um grupo de séries temporais.
• Quando qualquer série temporal individual não lhe diz muito, e você tem que olhar para todos os sinais para detetar um problema.
• Manutenção predicativa de ativos físicos caros com dezenas a centenas de tipos diferentes de sensores medindo vários aspetos da integridade do sistema.

• Uma assinatura do Azure - Crie uma gratuitamente
• Python 3.x
• Depois de ter sua assinatura do Azure, crie um recurso do Detetor de Anomalias no portal do Azure para obter sua chave e ponto de extremidade. Aguarde até que ele seja implantado e selecione o botão Ir para recurso. Você pode usar o nível de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para um nível pago para produção.

Instale a biblioteca do cliente. Você pode instalar a biblioteca de cliente com:

pip install --upgrade azure.ai.anomalydetector

O Detetor de Anomalias Multivariado requer que seu arquivo de exemplo seja armazenado no Armazenamento de Blobs do Azure.

1. Crie uma conta de Armazenamento do Azure.
2. Vá para Controle de Acesso (IAM) e selecione ADICIONAR para Adicionar atribuição de função.
3. Função de pesquisa do Leitor de Dados de Blob de Armazenamento, realce este tipo de conta e selecione Avançar.
4. Selecione atribuir acesso à identidade gerenciada e selecione Membros, escolha o recurso Detetor de anomalias que você criou anteriormente e selecione Revisar + atribuir.

Essa configuração às vezes pode ser um pouco confusa, se você tiver problemas, recomendamos consultar nossa amostra multivariada de Jupyter Notebook, que acompanha esse processo mais detalhadamente.

Este guia de início rápido usa um arquivo para dados sample_data_5_3000.csvde exemplo. Este arquivo pode ser baixado de nossos dados de exemplo do GitHub

Você também pode baixar os dados de exemplo executando:

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

1. Aceda à sua Conta de Armazenamento, selecione Contentores e crie um novo contentor.
2. Selecione Carregar e carregar sample_data_5_3000.csv
3. Selecione os dados que você carregou e copie a URL do Blob conforme necessário para adicioná-la ao exemplo de código em algumas etapas.

Para fazer uma chamada com êxito no serviço Detetor de Anomalias, você precisa dos seguintes valores:

Vá para o seu recurso no portal do Azure. O Ponto de Extremidade e as Chaves podem ser encontrados na seção Gerenciamento de Recursos. Copie seu ponto de extremidade e chave de acesso conforme necessário para autenticar suas chamadas de API. Pode utilizar KEY1 ou KEY2. Ter sempre duas chaves permite-lhe rodar e regenerar chaves de forma segura sem causar uma interrupção do serviço.

Crie e atribua variáveis de ambiente persistentes para sua chave e endpoint.

setx ANOMALY_DETECTOR_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE"

setx ANOMALY_DETECTOR_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

[System.Environment]::SetEnvironmentVariable('ANOMALY_DETECTOR_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')

[System.Environment]::SetEnvironmentVariable('ANOMALY_DETECTOR_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

echo export ANOMALY_DETECTOR_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE" >> /etc/environment && source /etc/environment

echo export ANOMALY_DETECTOR_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE" >> /etc/environment && source /etc/environment

1. Crie um novo arquivo Python chamado sample_multivariate_detect.py. Em seguida, abra-o no seu editor ou IDE preferido.

2. Substitua o conteúdo do sample_multivariate_detect.py pelo código a seguir. Você precisa modificar os caminhos para as variáveis 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 *
import os

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)
anomaly_results = ad_client.get_multivariate_batch_detection_result(result_id)
print("Get detection result...(it may take a few seconds)")

while anomaly_results.summary.status != MultivariateBatchDetectionStatus.READY and anomaly_results.summary.status != MultivariateBatchDetectionStatus.FAILED:
    anomaly_results = ad_client.get_multivariate_batch_detection_result(result_id)
    print("Detection is {}".format(anomaly_results.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
                )
            )

Execute a aplicação com o comando python no seu ficheiro de início rápido.

python sample_multivariate_detect.py

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

Os resultados dos resultados foram truncados para maior brevidade.

Se quiser limpar e remover um recurso do Detetor de Anomalias, você pode excluir o recurso ou grupo de recursos. A exclusão do grupo de recursos também exclui quaisquer outros recursos associados a ele. Você também pode considerar a exclusão das variáveis de ambiente criadas se não pretende mais usá-las.

• Portal do Azure
• CLI do Azure

Comece a usar a biblioteca de cliente multivariada do Detetor de Anomalias para Java. Siga estas etapas para instalar o pacote e começar a usar os algoritmos fornecidos pelo serviço. As novas APIs de detetor de anomalias multivariadas permitem que os desenvolvedores integrem facilmente IA avançada para detetar anomalias de grupos de métricas, sem a necessidade de conhecimento de aprendizado de máquina ou dados rotulados. As dependências e inter-correlações entre diferentes sinais são automaticamente contadas como factores-chave. Isso ajuda você a proteger proativamente seus sistemas complexos contra falhas.

Use a biblioteca de cliente multivariada do Detetor de Anomalias para Java para:

• Detete anomalias no nível do sistema a partir de um grupo de séries temporais.
• Quando qualquer série temporal individual não lhe diz muito, e você tem que olhar para todos os sinais para detetar um problema.
• Manutenção predicativa de ativos físicos caros com dezenas a centenas de tipos diferentes de sensores medindo vários aspetos da integridade do sistema.

Documentação | de referência da biblioteca Código fonte | da biblioteca Pacote (Maven) | Código de exemplo

• Subscrição do Azure - Criar uma gratuitamente
• A versão atual do Java Development Kit (JDK)
• A ferramenta de compilação Gradle ou outro gerenciador de dependência.
• Depois de ter sua assinatura do Azure, crie um recurso do Detetor de Anomalias no portal do Azure para obter sua chave e ponto de extremidade. Aguarde até que ele seja implantado e selecione o botão Ir para recurso.
  • Você precisará da chave e do ponto de extremidade do recurso criado para conectar seu aplicativo à API do Detetor de Anomalias. Você colará sua chave e ponto de extremidade no código abaixo mais adiante no início rápido. Você pode usar o nível de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para um nível pago para produção.

Este guia de início rápido usa o gerenciador de dependência do Gradle. Você pode encontrar mais informações sobre a biblioteca do cliente no Maven Central Repository.

Numa janela de consola (como cmd, PowerShell ou Bash), crie um novo diretório para a sua aplicação e navegue para a mesma.

mkdir myapp && cd myapp

Execute o comando a gradle init partir do seu diretório de trabalho. Este comando cria arquivos de compilação essenciais para o Gradle, incluindo build.gradle.kts que é usado em tempo de execução para criar e configurar seu aplicativo.

gradle init --type basic

Quando solicitado a escolher uma DSL, selecione Kotlin.

Localize build.gradle.kts e abra-o com o seu IDE ou editor de texto preferido. Em seguida, copie nesta configuração de compilação. Certifique-se de incluir as dependências do projeto.

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

Crie uma pasta para seu aplicativo de exemplo. No diretório de trabalho, execute o seguinte comando:

mkdir -p src/main/java

Navegue até a nova pasta e crie um arquivo chamado MetricsAdvisorQuickstarts.java. Abra-o em seu editor ou IDE preferido e adicione as seguintes import instruções:

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;

Crie variáveis do ponto de extremidade e da chave do Azure do seu recurso. Crie outra variável para o arquivo de dados de exemplo.

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

Para usar as APIs multivariadas do Detetor de Anomalias, você precisa primeiro treinar seus próprios modelos. Os dados de treinamento são um conjunto de várias séries temporais que atendem aos seguintes requisitos:

Cada série temporal deve ser um arquivo CSV com duas (e apenas duas) colunas, "timestamp" e "value" (todas em minúsculas) como linha de cabeçalho. Os valores de "carimbo de data/hora" devem estar em conformidade com a norma ISO 8601; O "valor" pode ser inteiro ou decimal com qualquer número de casas decimais. Por exemplo:

Cada arquivo CSV deve ter o nome de uma variável diferente que será usada para o treinamento do modelo. Por exemplo, "temperature.csv" e "humidity.csv". Todos os arquivos CSV devem ser compactados em um arquivo zip sem subpastas. O arquivo zip pode ter o nome que você quiser. O arquivo zip deve ser carregado no armazenamento de Blob do Azure. Depois de gerar o URL do blob SAS (Assinaturas de acesso compartilhado) para o arquivo zip, ele pode ser usado para treinamento. Consulte este documento para saber como gerar URLs SAS do Armazenamento de Blobs do Azure.

Esses trechos de código mostram como fazer o seguinte com a biblioteca de cliente do Detetor de Anomalias para Node.js:

• Autenticar o cliente
• Preparar um modelo
• Detetar anomalias
• Modelo de exportação
• Excluir modelo

Instancie um anomalyDetectorClient objeto com seu ponto de extremidade e credenciais.

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

Primeiro precisamos construir um modelo de solicitação. Certifique-se de que as horas de início e de fim estão alinhadas com a sua fonte de dados.

Para usar as APIs multivariadas do Detetor de Anomalias, precisamos treinar nosso próprio modelo antes de usar a deteção. Os dados usados para treinamento são um lote de séries temporais, cada série temporal deve estar em um arquivo CSV com apenas duas colunas, "timestamp" e "value" (os nomes das colunas devem ser exatamente os mesmos). Cada arquivo CSV deve ser nomeado após cada variável para a série temporal. Todas as séries temporais devem ser compactadas em um arquivo zip e carregadas no armazenamento de Blob do Azure, e não há nenhum requisito para o nome do arquivo zip. Como alternativa, um arquivo meta.json extra pode ser incluído no arquivo zip se você desejar que o nome da variável seja diferente do nome do arquivo .zip. Depois de gerar o URL do blob SAS (Assinaturas de acesso compartilhado), podemos usar o url para o arquivo zip para treinamento.

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

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

Para exportar seu modelo treinado, use o 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));

Para excluir um modelo existente que está disponível para o recurso atual, use a deleteMultivariateModelWithResponse função.

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

Você pode criar o aplicativo com:

gradle build

Antes de executá-lo, pode ser útil verificar seu código em relação ao código de exemplo completo.

Execute o aplicativo com o run objetivo:

gradle run

Se quiser limpar e remover uma assinatura de serviços do Azure AI, você pode excluir o recurso ou grupo de recursos. A exclusão do grupo de recursos também exclui quaisquer outros recursos associados ao grupo de recursos.

• Portal do Azure
• CLI do Azure

• O que é a API do Detetor de Anomalias?
• Práticas recomendadas ao usar a API do Detetor de Anomalias.