Início rápido: usar a biblioteca de clientes do Detector de Anomalias Multivariadas

Artigo
01/18/2024

Importante

A partir de 20 de setembro de 2023, você não poderá criar novos recursos do Detector de Anomalias. O serviço Detector de Anomalias será desativado em 01º de outubro de 2026.

Introdução à biblioteca de clientes do Detector de Anomalias multivariadas para C#. Siga estas etapas para instalar o pacote e começar a usar os algoritmos fornecidos pelo serviço. As novas APIs do detector de anomalias multivariadas permitem aos desenvolvedores integrar com facilidade a IA avançada para detecção de anomalias de grupos de métricas, sem a necessidade de conhecimentos sobre machine learning ou dados rotulados. Dependências e intercorrelações entre diferentes sinais são automaticamente contadas como fatores principais. Isso ajuda você a proteger proativamente seus sistemas complexos contra falhas.

Use a biblioteca de clientes do Detector de Anomalias multivariadas para C# para:

Detectar anomalias no nível do sistema de um grupo de séries temporais.
Quando uma série temporal individual não lhe revelar muito e você precisar examinar todos os sinais para detectar um problema.
Manutenção predicativa de ativos físicos caros com dezenas a centenas de diferentes tipos de sensores medindo vários aspectos da integridade do sistema.

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

Pré-requisitos

Assinatura do Azure – Criar uma gratuitamente
Versão atual do .NET Core
Depois de obter sua assinatura do Azure, crie um recurso Detector de Anomalias no portal do Azure para obter a chave e o ponto de extremidade. Aguarde até que ele seja implantado e selecione o botão Ir para o recurso.
- Você precisará da chave e do ponto de extremidade do recurso que você criar para conectar seu aplicativo à API do Detector de Anomalias. Cole a chave e o ponto de extremidade no código abaixo, mais adiante no início rápido. Use o tipo de preço gratuito (F0) para experimentar o serviço e atualizar mais tarde para um nível pago para produção.

Configuração

Criar uma conta de armazenamento

O Detector de Anomalias Multivariadas exige que o arquivo de exemplo seja armazenado no Armazenamento de Blobs do Azure.

Crie uma conta de armazenamento do Azure.
Vá para o Controle de Acesso (IAM) e selecione ADICIONAR para adicionar atribuições de função.
Procure a função Leitor de Dados do Blob de Armazenamento, destaque esse tipo de conta, depois selecione Avançar.
Selecione Atribuir acesso à Identidade gerenciada e Membros, depois escolha o recurso Detector de Anomalias que você criou anteriormente e selecione Revisar + atribuir.

Às vezes, essa configuração pode ser um pouco confusa. Se tiver problemas, recomendamos consultar nosso exemplo multivariado do Jupyter Notebook, que guia esse processo mais detalhadamente.

Baixar dados de exemplo

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

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

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

Acesse sua Conta de armazenamento, selecione Contêineres e crie um novo contêiner.
Selecione Carregar e carregue o arquivo sample_data_5_3000.csv
Selecione os dados que você carregou e copie a URL do blob, pois você precisa adicioná-la ao exemplo de código em algumas etapas.

Recuperar chave e ponto de extremidade

Para fazer uma chamada bem-sucedida no serviço Detector de Anomalias, você precisará dos seguintes valores:

Nome da variável	Valor
`ANOMALY_DETECTOR_ENDPOINT`	Esse valor pode ser encontrado na seção Chaves & Ponto de Extremidade ao examinar o recurso no portal do Azure. Exemplo de ponto de extremidade: `https://YOUR_RESOURCE_NAME.cognitiveservices.azure.com/`
`ANOMALY_DETECTOR_API_KEY`	O valor da chave de API pode ser encontrado na seção Chaves e Ponto de extremidade ao examinar seu recurso no portal do Azure. Você pode usar `KEY1` ou `KEY2`.

Acesse o seu recurso no portal do Azure. O Ponto de extremidade e as Chaves podem ser encontrados na seção Gerenciamento de recursos. Copie o ponto de extremidade e a chave de acesso, pois você precisa de ambos para autenticar suas chamadas à API. Você pode usar KEY1 ou KEY2. Ter sempre duas chaves permite girar e regenerar chaves com segurança, sem causar interrupção de serviço.

Criar variáveis de ambiente

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

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

Criar um aplicativo .NET Core

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

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

Altere o diretório para a pasta do aplicativo recém-criado. É possível criar o aplicativo com:

dotnet build

A saída de compilação não deve conter nenhum aviso ou erro.

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

Instalar a biblioteca de clientes

Dentro do diretório do aplicativo, instale a biblioteca de clientes do Detector 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));
        }
 
    }
}

Executar o aplicativo

Execute o aplicativo com o comando dotnet run do seu próprio diretório de aplicativo.

dotnet run

Limpar os recursos

Se quiser limpar e remover uma assinatura dos serviços de IA do Azure, você poderá excluir o recurso ou grupo de recursos. Excluir o grupo de recursos também exclui todos os recursos associados ao grupo de recursos.

Próximas etapas

Introdução à biblioteca de clientes do Detector de Anomalias multivariadas para JavaScript. Siga estas etapas para instalar o pacote e começar a usar os algoritmos fornecidos pelo serviço. As novas APIs do detector de anomalias multivariadas permitem aos desenvolvedores integrar com facilidade a IA avançada para detecção de anomalias de grupos de métricas, sem a necessidade de conhecimentos sobre machine learning ou dados rotulados. Dependências e intercorrelações entre diferentes sinais são automaticamente contadas como fatores principais. Isso ajuda você a proteger proativamente seus sistemas complexos contra falhas.

Use a biblioteca de clientes do Detector de Anomalias multivariadas para JavaScript para:

Detectar anomalias no nível do sistema de um grupo de séries temporais.
Quando as séries temporais individuais não informarem muito e você precisar observar todos os sinais para detectar um problema.
Manutenção predicativa de ativos físicos caros com dezenas a centenas de diferentes tipos de sensores medindo vários aspectos da integridade do sistema.

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

Pré-requisitos

Assinatura do Azure – Criar uma gratuitamente
A versão atual do Node.js
Depois de obter sua assinatura do Azure, crie um recurso Detector de Anomalias no portal do Azure para obter a chave e o ponto de extremidade. Aguarde até que ele seja implantado e selecione o botão Ir para o recurso.
- Você precisará da chave e do ponto de extremidade do recurso criado para conectar seu aplicativo à API do Detector de Anomalias. Cole a chave e o ponto de extremidade no código abaixo mais adiante no guia de início rápido. Use o tipo de preço gratuito (F0) para experimentar o serviço e atualizar mais tarde para um nível pago para produção.

Configurando

Criar um novo aplicativo do Node.js

Em uma janela de console (como cmd, PowerShell ou Bash), crie um novo diretório para seu aplicativo e navegue até ele.

mkdir myapp && cd myapp

Execute o comando npm init para criar um aplicativo do Node com um arquivo 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 para a chave e o Ponto de Extremidade do Azure do recurso. Crie outra variável para o arquivo de dados de exemplo.

Observação

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

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

Importante

Lembre-se de remover a chave do seu código quando terminar e nunca poste-a publicamente. Para produção, use uma maneira segura de armazenar e acessar suas credenciais, como o Azure Key Vault. Consulte o artigo segurança dos serviços de IA do Azure para obter mais informações.

Para usar as APIs multivariadas do Detector de Anomalias, primeiro, você precisará treinar modelos próprios. 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 as letras em minúsculas) como a linha de cabeçalho. Os valores de "timestamp" devem estar em conformidade com a ISO 8601; o "value" podem ser inteiros ou decimais com qualquer número de casas decimais. Por exemplo:

timestamp	value
2019-04-01T00:00:00Z	5
2019-04-01T00:01:00Z	3,6
2019-04-01T00:02:00Z	4
`...`	`...`

Cada arquivo CSV deve receber o nome de uma variável diferente que será usada para treinamento do modelo. Por exemplo, "temperature.csv" e "humidity.csv". Todos os arquivos CSV devem ser compactados em um arquivo zip sem nenhuma subpasta. O arquivo zip poderá ter qualquer nome que você desejar. Ele deve ser carregado no Armazenamento de Blobs do Azure. Depois que você gerar a URL SAS (Assinaturas de Acesso Compartilhado) do blob para o arquivo zip, ele poderá ser usado para treinamento. Veja este documento para saber como gerar URLs SAS do Armazenamento de Blobs do Azure.

Instalar a biblioteca de clientes

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

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

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

Exemplos de código

Esses snippets de códigos mostram como fazer o seguinte com a biblioteca de clientes do Detector de Anomalias para Node.js:

Autenticar o cliente
Treinar um modelo
Detectar anomalias
Exportar modelo
Excluir modelo

Autenticar o cliente

Crie uma instância de um objeto AnomalyDetectorClient com seu ponto de extremidade e suas credenciais.

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

Treinar um modelo

Construir um resultado de modelo

Primeiro, precisamos construir uma solicitação de modelo. Verifique se as horas de início e de término 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
};

Treinar um novo modelo

Você passa sua solicitação de modelo para o método trainMultivariateModel do cliente do Detector 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á concluído, 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.");

Detectar anomalias

Use as funções detectAnomaly e getDectectionResult para determinar se há alguma anomalia dentro da 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);

Exportar modelo

Observação

O comando de exportação permite a execução dos modelos do Detector de Anomalias multivariadas em um ambiente conteinerizado. No momento, não há suporte para multivariadas, mas o suporte será adicionado no futuro.

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

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 função deleteMultivariateModel.

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

Executar o aplicativo

Antes que você execute o aplicativo, pode ser útil verificar o código em relação ao código de exemplo completo

Execute o aplicativo com o comando node no seu arquivo de início rápido.

node index.js

Limpar os recursos

Próximas etapas

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

Introdução à biblioteca de clientes do Detector de Anomalias multivariadas para Python. Siga estas etapas para instalar o pacote e comece a usar os algoritmos fornecidos pelo serviço. As novas APIs do detector de anomalias multivariadas permitem aos desenvolvedores integrar com facilidade a IA avançada para detecção de anomalias de grupos de métricas, sem a necessidade de conhecimentos sobre machine learning ou dados rotulados. Dependências e intercorrelações entre diferentes sinais são automaticamente contadas como fatores principais. Isso ajuda você a proteger proativamente seus sistemas complexos contra falhas.

Use a biblioteca de clientes do Detector de Anomalias multivariadas para Python para:

Detectar anomalias no nível do sistema de um grupo de séries temporais.
Quando as séries temporais individuais não informarem muito e você precisar observar todos os sinais para detectar um problema.
Manutenção predicativa de ativos físicos caros com dezenas a centenas de diferentes tipos de sensores medindo vários aspectos da integridade do sistema.

Pré-requisitos

Uma assinatura do Azure – crie uma gratuitamente
Python 3.x
Depois de obter sua assinatura do Azure, crie um recurso Detector de Anomalias no portal do Azure para obter a chave e o ponto de extremidade. Aguarde até que ele seja implantado e selecione o botão Ir para o recurso. Use o tipo de preço gratuito (F0) para experimentar o serviço e atualizar mais tarde para um nível pago para produção.

Configuração

Instalar a biblioteca de clientes. É possível instalar a biblioteca de clientes com:

pip install --upgrade azure.ai.anomalydetector

Criar uma conta de armazenamento

O Detector de Anomalias Multivariadas exige que o arquivo de exemplo seja armazenado no Armazenamento de Blobs do Azure.

Crie uma conta de armazenamento do Azure.
Vá para o Controle de Acesso (IAM) e selecione ADICIONAR para adicionar atribuições de função.
Procure a função Leitor de Dados do Blob de Armazenamento, destaque esse tipo de conta, depois selecione Avançar.
Selecione Atribuir acesso à Identidade gerenciada e Membros, depois escolha o recurso Detector de Anomalias que você criou anteriormente e selecione Revisar + atribuir.

Às vezes, essa configuração pode ser um pouco confusa. Se tiver problemas, recomendamos consultar nosso exemplo multivariado do Jupyter Notebook, que guia esse processo mais detalhadamente.

Baixar dados de exemplo

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

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

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

Acesse sua Conta de armazenamento, selecione Contêineres e crie um novo contêiner.
Selecione Carregar e carregue o arquivo sample_data_5_3000.csv
Selecione os dados que você carregou e copie a URL do blob, pois você precisa adicioná-la ao exemplo de código em algumas etapas.

Recuperar chave e ponto de extremidade

Para fazer uma chamada bem-sucedida no serviço Detector de Anomalias, você precisará dos seguintes valores:

Nome da variável	Valor
`ANOMALY_DETECTOR_ENDPOINT`	Esse valor pode ser encontrado na seção Chaves & Ponto de Extremidade ao examinar o recurso no portal do Azure. Exemplo de ponto de extremidade: `https://YOUR_RESOURCE_NAME.cognitiveservices.azure.com/`
`ANOMALY_DETECTOR_API_KEY`	O valor da chave de API pode ser encontrado na seção Chaves e Ponto de extremidade ao examinar seu recurso no portal do Azure. Você pode usar `KEY1` ou `KEY2`.

Criar variáveis de ambiente

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

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

Criar um novo aplicativo Python

Crie um novo arquivo do Python chamado sample_multivariate_detect.py. Depois, abra-o no editor ou IDE de sua preferência.
Substitua o conteúdo do arquivo 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 *

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

ad_client = AnomalyDetectorClient(ANOMALY_DETECTOR_ENDPOINT, AzureKeyCredential(SUBSCRIPTION_KEY))

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

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

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


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

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

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

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

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

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

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

Executar o aplicativo

Execute o aplicativo com o comando python no seu arquivo de início rápido.

python sample_multivariate_detect.py

Saída

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 da saída foram truncados para fins de brevidade.

Limpar os recursos

Se você quiser limpar e remover um recurso do Detector de Anomalias, poderá excluir o recurso ou o grupo de recursos. Excluir o grupo de recursos também exclui todos os recursos associados a ele. Você também pode considerar excluir as variáveis de ambiente que você criou se não pretende mais usá-las.

Introdução à biblioteca de clientes do Detector de Anomalias multivariadas para Java. Siga estas etapas para instalar o pacote e começar a usar os algoritmos fornecidos pelo serviço. As novas APIs do detector de anomalias multivariadas permitem aos desenvolvedores integrar com facilidade a IA avançada para detecção de anomalias de grupos de métricas, sem a necessidade de conhecimentos sobre machine learning ou dados rotulados. Dependências e intercorrelações entre diferentes sinais são automaticamente contadas como fatores principais. Isso ajuda você a proteger proativamente seus sistemas complexos contra falhas.

Use a biblioteca de clientes do Detector de Anomalias multivariadas para Java para:

Detectar anomalias no nível do sistema de um grupo de séries temporais.
Quando as séries temporais individuais não informarem muito e você precisar observar todos os sinais para detectar um problema.
Manutenção predicativa de ativos físicos caros com dezenas a centenas de diferentes tipos de sensores medindo vários aspectos da integridade do sistema.

Documentação de referência da | Biblioteca de códigos-fonte | Pacote (Maven) | Exemplos de código

Pré-requisitos

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

Configurando

Criar um novo projeto Gradle

Este início rápido usa o gerenciador de dependência do Gradle. Encontre mais informações sobre a biblioteca de clientes no Repositório Central do Maven.

Em uma janela de console (como cmd, PowerShell ou Bash), crie um novo diretório para seu aplicativo e navegue até ele.

mkdir myapp && cd myapp

Execute o comando gradle init em seu diretório de trabalho. Esse comando cria arquivos de build essenciais para o Gradle, incluindo o build.gradle.kts que é usado no runtime para criar e configurar seu aplicativo.

gradle init --type basic

Quando solicitado a escolher uma DSL, escolha Kotlin.

Instalar a biblioteca de clientes

Localize o build.gradle.kts e abra-o com seu IDE ou editor de texto preferencial. Depois copie nessa configuração de build. Lembre-se de incluir as dependências do projeto.

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

Criar um arquivo Java

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

mkdir -p src/main/java

Acesse a nova pasta e crie um arquivo chamado MetricsAdvisorQuickstarts.java. Abra-a no editor ou IDE de sua preferência e adicione as seguintes instruções import:

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 para a chave e o Ponto de Extremidade do Azure do recurso. Crie outra variável para o arquivo de dados de exemplo.

Observação

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

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

Importante

timestamp	value
2019-04-01T00:00:00Z	5
2019-04-01T00:01:00Z	3,6
2019-04-01T00:02:00Z	4
`...`	`...`

Exemplos de código

Esses snippets de códigos mostram como fazer o seguinte com a biblioteca de clientes do Detector de Anomalias para Node.js:

Autenticar o cliente
Treinar um modelo
Detectar anomalias
Exportar modelo
Excluir modelo

Autenticar o cliente

Crie uma instância de um objeto anomalyDetectorClient com seu ponto de extremidade e suas 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();

Treinar um modelo

Construir um modelo de resultados e treinar o modelo

Primeiro, precisamos construir uma solicitação de modelo. Verifique se as horas de início e de término estão alinhadas com a sua fonte de dados.

Para usar as APIs do Detector de Anomalias multivariadas, precisamos treinar nosso modelo antes de usar a detecção. Os dados usados para treinamento são um lote de séries temporais, e cada uma delas deve estar em um arquivo CSV com apenas duas colunas, "timestamp" e "value" (os nomes da coluna devem ser exatamente iguais). Cada arquivo CSV deve ser nomeado depois de 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 Blobs do Azure, e não há nenhum requisito para o nome do arquivo zip. Como alternativa, um arquivo adicional meta.json pode ser incluído no arquivo zip se você quiser que o nome da variável seja diferente do nome do arquivo zip. Depois de gerarmos a URL de SAS (Assinaturas de Acesso Compartilhado) do blob, poderemos usar a URL do 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());
    }
}

Detectar anomalias

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

Exportar modelo

Observação

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

Excluir modelo

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

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

Executar o aplicativo

É possível criar o aplicativo com:

gradle build

Executar o aplicativo

Antes da execução, pode ser útil verificar o código em relação ao código de exemplo completo.

Execute o aplicativo com a meta run:

gradle run

Início rápido: usar a biblioteca de clientes do Detector de Anomalias Multivariadas

Pré-requisitos

Configuração

Criar uma conta de armazenamento

Baixar dados de exemplo

Carregar dados de exemplo para a Conta de armazenamento

Recuperar chave e ponto de extremidade

Criar variáveis de ambiente

Criar um aplicativo .NET Core

Instalar a biblioteca de clientes

Executar o aplicativo

Limpar os recursos

Próximas etapas

Pré-requisitos

Configurando

Criar um novo aplicativo do Node.js

Instalar a biblioteca de clientes

Exemplos de código

Autenticar o cliente

Treinar um modelo

Construir um resultado de modelo

Treinar um novo modelo

Detectar anomalias

Exportar modelo

Excluir modelo

Executar o aplicativo

Limpar os recursos

Próximas etapas

Pré-requisitos

Configuração

Criar uma conta de armazenamento

Baixar dados de exemplo

Carregar dados de exemplo para a Conta de armazenamento

Recuperar chave e ponto de extremidade

Criar variáveis de ambiente

Criar um novo aplicativo Python

Executar o aplicativo

Saída

Limpar os recursos

Pré-requisitos

Configurando

Criar um novo projeto Gradle

Instalar a biblioteca de clientes

Criar um arquivo Java

Exemplos de código

Autenticar o cliente

Treinar um modelo

Construir um modelo de resultados e treinar o modelo

Detectar anomalias

Exportar modelo

Excluir modelo

Executar o aplicativo

Executar o aplicativo

Limpar os recursos

Próximas etapas

Recursos adicionais