Guia de início rápido: deteção de anomalias usando a biblioteca de cliente do Detetor de anomalias para deteção de anomalias multivariadas - Azure AI services

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)

Pré-requisitos

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.

Configurar

Criar uma conta de armazenamento

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

Crie uma conta de Armazenamento do Azure.
Vá para Controle de Acesso (IAM) e selecione ADICIONAR para Adicionar atribuição de função.
Função de pesquisa do Leitor de Dados de Blob de Armazenamento, realce este tipo de conta e selecione Avançar.
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.

Transferir dados de exemplo

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:

Windows Command Prompt

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

Carregar dados de exemplo para a conta de armazenamento

Aceda à sua Conta de Armazenamento, selecione Contentores e crie um novo contentor.
Selecione Carregar e carregar sample_data_5_3000.csv
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.

Recuperar chave e ponto de extremidade

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

Nome da variável	Valor
`ANOMALY_DETECTOR_ENDPOINT`	Este valor pode ser encontrado na secção Chaves e Ponto Final ao examinar o recurso no portal do Azure. Exemplo de parâmetro de avaliação: `https://YOUR_RESOURCE_NAME.cognitiveservices.azure.com/`
`ANOMALY_DETECTOR_API_KEY`	O valor da chave da API pode ser encontrado na seção Chaves & Ponto de Extremidade ao examinar seu recurso no portal do Azure. Pode utilizar `KEY1` ou `KEY2`.

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.

Criar variáveis de ambiente

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

Importante

Recomendamos a autenticação do Microsoft Entra ID com identidades gerenciadas para recursos do Azure para evitar o armazenamento de credenciais com seus aplicativos executados na nuvem.

Use chaves de API com cuidado. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente. Se estiver usando chaves de API, armazene-as com segurança no Cofre de Chaves do Azure, gire as chaves regularmente e restrinja o acesso ao Cofre de Chaves do Azure usando controle de acesso baseado em função e restrições de acesso à rede. Para obter mais informações sobre como usar chaves de API com segurança em seus aplicativos, consulte Chaves de API com o Cofre de Chaves do Azure.

Para obter mais informações sobre segurança de serviços de IA, consulte Autenticar solicitações para serviços de IA do Azure.

CMD

setx ANOMALY_DETECTOR_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE"

CMD

setx ANOMALY_DETECTOR_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

PowerShell

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

PowerShell

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

Bash

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

Bash

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

Criar uma nova aplicação .NET Core

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.

.NET CLI

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:

.NET CLI

dotnet build

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

Output

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

Instalar a biblioteca de cliente

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

.NET CLI

dotnet add package Azure.AI.AnomalyDetector --prerelease

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

C#

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

Executar a aplicação

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

.NET CLI

dotnet run

Clean up resources (Limpar recursos)

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.

Próximos passos

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

Pré-requisitos

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.

Configuração

Criar uma nova aplicação Node.js

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

Console

mkdir myapp && cd myapp

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

Console

npm init

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

JavaScript

'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.

Nota

Você sempre terá a opção de usar uma das duas chaves. Isto é para permitir a rotação segura da chave. Para efeitos deste início rápido, utilize a primeira chave.

JavaScript

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

Importante

Recomendamos a autenticação do Microsoft Entra ID com identidades gerenciadas para recursos do Azure para evitar o armazenamento de credenciais com seus aplicativos executados na nuvem.

Use chaves de API com cuidado. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente. Se estiver usando chaves de API, armazene-as com segurança no Cofre de Chaves do Azure, gire as chaves regularmente e restrinja o acesso ao Cofre de Chaves do Azure usando controle de acesso baseado em função e restrições de acesso à rede. Para obter mais informações sobre como usar chaves de API com segurança em seus aplicativos, consulte Chaves de API com o Cofre de Chaves do Azure.

Para obter mais informações sobre segurança de serviços de IA, consulte Autenticar solicitações para serviços de IA do Azure.

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:

carimbo de data/hora	valor
2019-04-01T00:00:00Z	5
2019-04-01T00:01:00Z	3.6
2019-04-01T00:02:00Z	4
`...`	`...`

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.

Instalar a biblioteca de cliente

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

Console

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

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

Exemplos de código

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

Autenticar o cliente

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

JavaScript

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

Preparar um modelo

Construir um resultado de modelo

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.

JavaScript

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

Treinar um novo modelo

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

JavaScript

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:

JavaScript

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

Detetar anomalias

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

JavaScript

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

Modelo de exportação

Nota

O comando export destina-se a ser usado para permitir a execução de modelos multivariados do Detetor de Anomalias em um ambiente conteinerizado. No momento, isso não é suportado para multivariado, mas o suporte será adicionado no futuro.

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

JavaScript

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

Excluir modelo

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

JavaScript

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

Executar a aplicação

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.

Console

node index.js

Clean up resources (Limpar recursos)

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.

Próximos passos

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.

Pré-requisitos

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.

Configurar

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

Console

pip install --upgrade azure.ai.anomalydetector

Criar uma conta de armazenamento

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

Crie uma conta de Armazenamento do Azure.
Vá para Controle de Acesso (IAM) e selecione ADICIONAR para Adicionar atribuição de função.
Função de pesquisa do Leitor de Dados de Blob de Armazenamento, realce este tipo de conta e selecione Avançar.
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.

Transferir dados de exemplo

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:

Windows Command Prompt

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

Carregar dados de exemplo para a conta de armazenamento

Aceda à sua Conta de Armazenamento, selecione Contentores e crie um novo contentor.
Selecione Carregar e carregar sample_data_5_3000.csv
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.

Recuperar chave e ponto de extremidade

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

Nome da variável	Valor
`ANOMALY_DETECTOR_ENDPOINT`	Este valor pode ser encontrado na secção Chaves e Ponto Final ao examinar o recurso no portal do Azure. Exemplo de parâmetro de avaliação: `https://YOUR_RESOURCE_NAME.cognitiveservices.azure.com/`
`ANOMALY_DETECTOR_API_KEY`	O valor da chave da API pode ser encontrado na seção Chaves & Ponto de Extremidade ao examinar seu recurso no portal do Azure. Pode utilizar `KEY1` ou `KEY2`.

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.

Criar variáveis de ambiente

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

Importante

Recomendamos a autenticação do Microsoft Entra ID com identidades gerenciadas para recursos do Azure para evitar o armazenamento de credenciais com seus aplicativos executados na nuvem.

Use chaves de API com cuidado. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente. Se estiver usando chaves de API, armazene-as com segurança no Cofre de Chaves do Azure, gire as chaves regularmente e restrinja o acesso ao Cofre de Chaves do Azure usando controle de acesso baseado em função e restrições de acesso à rede. Para obter mais informações sobre como usar chaves de API com segurança em seus aplicativos, consulte Chaves de API com o Cofre de Chaves do Azure.

Para obter mais informações sobre segurança de serviços de IA, consulte Autenticar solicitações para serviços de IA do Azure.

CMD

setx ANOMALY_DETECTOR_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE"

CMD

setx ANOMALY_DETECTOR_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

PowerShell

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

PowerShell

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

Bash

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

Bash

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

Criar uma aplicação Python nova

Crie um novo arquivo Python chamado sample_multivariate_detect.py. Em seguida, abra-o no seu editor ou IDE preferido.
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.

Python

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

Executar a aplicação

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

Console

python sample_multivariate_detect.py

Saída

Console

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.

Clean up resources (Limpar recursos)

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.

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

Pré-requisitos

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.

Configuração

Criar um novo projeto Gradle

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.

Console

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.

Console

gradle init --type basic

Quando solicitado a escolher uma DSL, selecione Kotlin.

Instalar a biblioteca de cliente

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.

Kotlin

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

Criar um arquivo Java

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

Console

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:

Java

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.

Nota

Você sempre terá a opção de usar uma das duas chaves. Isto é para permitir a rotação segura da chave. Para os fins deste início rápido, use a primeira chave.

Java

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

Importante

Recomendamos a autenticação do Microsoft Entra ID com identidades gerenciadas para recursos do Azure para evitar o armazenamento de credenciais com seus aplicativos executados na nuvem.

Use chaves de API com cuidado. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente. Se estiver usando chaves de API, armazene-as com segurança no Cofre de Chaves do Azure, gire as chaves regularmente e restrinja o acesso ao Cofre de Chaves do Azure usando controle de acesso baseado em função e restrições de acesso à rede. Para obter mais informações sobre como usar chaves de API com segurança em seus aplicativos, consulte Chaves de API com o Cofre de Chaves do Azure.

Para obter mais informações sobre segurança de serviços de IA, consulte Autenticar solicitações para serviços de IA do Azure.

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:

carimbo de data/hora	valor
2019-04-01T00:00:00Z	5
2019-04-01T00:01:00Z	3.6
2019-04-01T00:02:00Z	4
`...`	`...`

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.

Exemplos de código

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

Autenticar o cliente

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

Java

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

Preparar um modelo

Construir um resultado de modelo e treinar um modelo

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.

Java

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

Detetar anomalias

Java

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

Modelo de exportação

Nota

O comando export destina-se a ser usado para permitir a execução de modelos multivariados do Detetor de Anomalias em um ambiente conteinerizado. No momento, isso não é suportado para multivariado, mas o suporte será adicionado no futuro.

Para exportar seu modelo treinado, use o exportModelWithResponse.

Java

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

Excluir modelo

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

Java

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

Executar a aplicação

Você pode criar o aplicativo com:

Console

gradle build

Executar a aplicação

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:

Console

gradle run

Clean up resources (Limpar recursos)

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.

Partilhar via

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

Pré-requisitos

Configurar

Criar uma conta de armazenamento

Transferir dados de exemplo

Carregar dados de exemplo para a conta de armazenamento

Recuperar chave e ponto de extremidade

Criar variáveis de ambiente

Criar uma nova aplicação .NET Core

Instalar a biblioteca de cliente

Executar a aplicação

Clean up resources (Limpar recursos)

Próximos passos

Pré-requisitos

Configuração

Criar uma nova aplicação Node.js

Instalar a biblioteca de cliente

Exemplos de código

Autenticar o cliente

Preparar um modelo

Construir um resultado de modelo

Treinar um novo modelo

Detetar anomalias

Modelo de exportação

Excluir modelo

Executar a aplicação

Clean up resources (Limpar recursos)

Próximos passos

Pré-requisitos

Configurar

Criar uma conta de armazenamento

Transferir dados de exemplo

Carregar dados de exemplo para a conta de armazenamento

Recuperar chave e ponto de extremidade

Criar variáveis de ambiente

Criar uma aplicação Python nova

Executar a aplicação

Saída

Clean up resources (Limpar recursos)

Pré-requisitos

Configuração

Criar um novo projeto Gradle

Instalar a biblioteca de cliente

Criar um arquivo Java

Exemplos de código

Autenticar o cliente

Preparar um modelo

Construir um resultado de modelo e treinar um modelo

Detetar anomalias

Modelo de exportação

Excluir modelo

Executar a aplicação

Executar a aplicação

Clean up resources (Limpar recursos)

Próximos passos

Recursos adicionais