Guia de início rápido: usar a biblioteca de cliente do Multivariate Anomaly Detetor
Artigo
Importante
A partir de 20 de setembro de 2023, você não poderá criar novos recursos do Detetor de Anomalias. O serviço de Detetor de Anomalias está a ser desativado no dia 1 de outubro de 2026.
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.
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.
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:
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.
Em uma janela de console (como cmd, PowerShell ou Bash), use o dotnet new comando para criar um novo aplicativo de console com o nome anomaly-detector-quickstart-multivariate. Este comando cria um projeto "Hello World" simples com um único arquivo de origem C#: Program.cs.
dotnet new console -n anomaly-detector-quickstart-multivariate
Altere seu diretório para a pasta do aplicativo recém-criada. Você pode criar o aplicativo com:
dotnet build
A saída da compilação não deve conter avisos ou erros.
...
Build succeeded.
0 Warning(s)
0 Error(s)
...
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:
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 a aplicação
Execute o aplicativo com o dotnet run comando do diretório do aplicativo.
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.
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.
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.
mkdir myapp && cd myapp
Execute o comando npm init para criar uma aplicação de nó com um ficheiro package.json.
npm init
Crie um arquivo chamado index.js e importe as seguintes bibliotecas: '
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.
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 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:
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:
Instancie um AnomalyDetectorClient objeto com seu ponto de extremidade e credenciais.
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.
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.
console.log("Training a new model...")
const train_response = await client.trainMultivariateModel(Modelrequest)
const model_id = train_response.location?.split("/").pop() ?? ""
console.log("New model ID: " + model_id)
Para verificar se o treinamento do seu modelo está completo, você pode acompanhar o status do modelo:
let model_response = await client.getMultivariateModel(model_id);
let model_status = model_response.modelInfo.status;
while (model_status != 'READY' && model_status != 'FAILED'){
await sleep(10000).then(() => {});
model_response = await client.getMultivariateModel(model_id);
model_status = model_response.modelInfo.status;
}
if (model_status == 'FAILED') {
console.log("Training failed.\nErrors:");
for (let error of model_response.modelInfo?.errors ?? []) {
console.log("Error code: " + error.code + ". Message: " + error.message);
}
}
console.log("TRAINING FINISHED.");
Detetar anomalias
Use as detectAnomaly funções e getDectectionResult para determinar se há alguma anomalia em sua fonte de dados.
console.log("Start detecting...");
const detect_request = {
source: data_source,
startTime: new Date(2021,0,2,12,0,0),
endTime: new Date(2021,0,3,0,0,0)
};
const result_header = await client.detectAnomaly(model_id, detect_request);
const result_id = result_header.location?.split("/").pop() ?? "";
let result = await client.getDetectionResult(result_id);
let result_status = result.summary.status;
while (result_status != 'READY' && result_status != 'FAILED'){
await sleep(2000).then(() => {});
result = await client.getDetectionResult(result_id);
result_status = result.summary.status;
}
if (result_status == 'FAILED') {
console.log("Detection failed.\nErrors:");
for (let error of result.summary.errors ?? []) {
console.log("Error code: " + error.code + ". Message: " + error.message)
}
}
console.log("Result status: " + result_status);
console.log("Result Id: " + result.resultId);
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.
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.
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.
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.
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.
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:
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.
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:
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.
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.
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.
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.
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.
mkdir myapp && cd myapp
Execute o comando a gradle init partir do seu diretório de trabalho. Este comando cria arquivos de compilação essenciais para o Gradle, incluindo build.gradle.kts que é usado em tempo de execução para criar e configurar seu aplicativo.
gradle init --type basic
Quando solicitado a escolher uma DSL, selecione Kotlin.
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.
Crie uma pasta para seu aplicativo de exemplo. No diretório de trabalho, execute o seguinte comando:
mkdir -p src/main/java
Navegue até a nova pasta e crie um arquivo chamado MetricsAdvisorQuickstarts.java. Abra-o em seu editor ou IDE preferido e adicione as seguintes import instruções:
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.
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 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:
Instancie um anomalyDetectorClient objeto com seu ponto de extremidade e credenciais.
HttpHeaders headers = new HttpHeaders()
.put("Accept", ContentType.APPLICATION_JSON);
HttpPipelinePolicy authPolicy = new AzureKeyCredentialPolicy("Ocp-Apim-Subscription-Key",
new AzureKeyCredential(key));
AddHeadersPolicy addHeadersPolicy = new AddHeadersPolicy(headers);
HttpPipeline httpPipeline = new HttpPipelineBuilder().httpClient(HttpClient.createDefault())
.policies(authPolicy, addHeadersPolicy).build();
// Instantiate a client that will be used to call the service.
HttpLogOptions httpLogOptions = new HttpLogOptions();
httpLogOptions.setLogLevel(HttpLogDetailLevel.BODY_AND_HEADERS);
AnomalyDetectorClient anomalyDetectorClient = new AnomalyDetectorClientBuilder()
.pipeline(httpPipeline)
.endpoint(endpoint)
.httpLogOptions(httpLogOptions)
.buildClient();
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.
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.
Antes de executá-lo, pode ser útil verificar seu código em relação ao código de exemplo completo.
Execute o aplicativo com o run objetivo:
gradle run
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.
O Azure HPC é um recurso de nuvem criado especificamente para a carga de trabalho HPC & AI, usando processadores de ponta e interconexão InfiniBand de classe HPC, para oferecer o melhor desempenho, escalabilidade e valor de aplicativos. O Azure HPC permite que os utilizadores desbloqueiem a inovação, a produtividade e a agilidade empresarial, através de uma gama altamente disponível de tecnologias de HPC ou IA que podem ser alocadas dinamicamente à medida que as suas necessidades empresariais e técnicas mud
Gerencie a ingestão e a preparação de dados, o treinamento e a implantação de modelos e o monitoramento de soluções de aprendizado de máquina com Python, Azure Machine Learning e MLflow.