Partilhar via

Deteção de anomalias multivariável

Para obter informações gerais sobre a deteção de anomalias multivariadas no Real-Time Intelligence, consulte Deteção de anomalias multivariadas no Microsoft Fabric - visão geral. Neste tutorial, você usa dados de exemplo para treinar um modelo de deteção de anomalias multivariado usando o mecanismo Spark em um notebook Python. Em seguida, você prevê anomalias aplicando o modelo treinado a novos dados usando o mecanismo Eventhouse. As primeiras etapas configuram seus ambientes e as etapas seguintes treinam o modelo e preveem anomalias.

Pré-requisitos

Parte 1- Ativar a disponibilidade do OneLake

A disponibilidade do OneLake deve ser habilitada antes de obter dados na Eventhouse. Esta etapa é importante, pois permite que os dados que você ingere fiquem disponíveis no OneLake. Em uma etapa posterior, você acessa esses mesmos dados do seu Spark Notebook para treinar o modelo.

  1. No seu espaço de trabalho, selecione a Casa de Eventos que você criou nos pré-requisitos. Escolha a base de dados onde pretende armazenar os seus dados.

  2. No painel Detalhes do Banco de Dados, alterne o botão de disponibilidade do OneLake para Ativado.

    Captura de ecrã a mostrar como ativar a disponibilidade do OneLake no seu Eventhouse.

Parte 2- Ativar o plugin KQL Python

Nesta etapa, você ativa o plugin python em sua Eventhouse. Esta etapa é necessária para executar o código Python de previsão de anomalias no conjunto de consultas KQL. É importante escolher a imagem correta que contenha o pacote detetor de anomalias de séries temporais .

  1. No ecrã do Eventhouse, selecione Eventhouse>Plugins na fita.

  2. No painel de Plugins, alterne para Ativado a extensão da linguagem Python.

  3. Selecione Python 3.11.7 DL (visualização).

  4. Selecionar Concluído.

    Captura de tela de como habilitar o pacote python 3.11.7 DL na Eventhouse.

Parte 3- Criar um ambiente Spark

Nesta etapa, você cria um ambiente Spark para executar o notebook Python que treina o modelo de deteção de anomalias multivariadas usando o mecanismo Spark. Para obter mais informações sobre como criar ambientes, consulte Criar e gerenciar ambientes.

  1. No teu espaço de trabalho, seleciona + Novo item e depois Ambiente.

    Captura de ecrã do mosaico Ambiente na janela de Novo Item.

  2. Digite o nome MVAD_ENV para o ambiente e, em seguida, selecione Criar.

  3. Em Bibliotecas, selecione Bibliotecas públicas.

  4. Selecionar Adicionar a partir do PyPI.

  5. Na caixa de pesquisa, digite time-series-anomaly-detector. O campo de versão é automaticamente preenchido com a versão mais recente. Mude para a versão 0.3.9, que é a versão mais recente compatível com MLflow 2.19.0 (a versão atual na imagem Python)

  6. Selecione Guardar.

    Captura de tela da adição do pacote PyPI ao ambiente Spark.

  7. Selecione a aba Início no ambiente.

  8. Selecione o ícone Publicar na barra de ferramentas.

  9. Selecione Publicar tudo. Esta etapa pode levar vários minutos para ser concluída.

    Captura de ecrã da publicação do ambiente.

Parte 4- Obter dados para a Eventhouse

  1. Passe o cursor sobre o banco de dados KQL onde você deseja armazenar seus dados. Selecione o menu Mais [...]>Obter dados>Ficheiro local.

    Captura de ecrã de obtenção de dados a partir de ficheiro local.

  2. Selecione + Nova tabela e digite demo_stocks_change como o nome da tabela.

  3. Na caixa de diálogo Carregar dados, selecione Procurar arquivos e carregue o arquivo de dados de exemplo que foi baixado nos Pré-requisitos

  4. Selecione Seguinte.

  5. Na secção Inspecionar os dados, verifique se Primeira linha como cabeçalho da coluna está definido como Ativado.

  6. Selecione Concluir.

  7. Quando os dados forem carregados, selecione Fechar.

Parte 5 - Copiar o caminho do OneLake para a tabela

Certifique-se de que escolhe a tabela demo_stocks_change. No painel de detalhes da tabela , selecione a pasta OneLake para copiar o caminho OneLake para a sua prancheta. Salve esse texto copiado em um editor de texto em algum lugar para ser usado em uma etapa posterior.

Captura de ecrã de copiar o caminho do OneLake.

Parte 6- Preparar o bloco de notas

  1. Selecione a área de trabalho.

  2. Selecione Importar, Caderno e depois Sair deste computador.

  3. Selecione Carregar e escolha o notebook que descarregou nos pré-requisitos.

  4. Depois de carregar o bloco de notas, pode localizar e abrir o bloco de notas a partir da sua área de trabalho.

  5. Na barra superior, selecione a lista suspensa padrão do Workspace e escolha o ambiente que criou na etapa anterior.

    Captura de ecrã da seleção do ambiente no notebook.

Parte 7 - Executar o caderno

  1. Importar pacotes padrão.

    import numpy as np
import pandas as pd

  2. O Spark precisa de um URI ABFSS para se conectar com segurança ao armazenamento do OneLake, portanto, a próxima etapa define essa função para converter o URI do OneLake em URI ABFSS.

    def convert_onelake_to_abfss(onelake_uri):
    if not onelake_uri.startswith('https://'):
        raise ValueError("Invalid OneLake URI. It should start with 'https://'.")
    uri_without_scheme = onelake_uri[8:]
    parts = uri_without_scheme.split('/')
    if len(parts) < 3:
        raise ValueError("Invalid OneLake URI format.")
    account_name = parts[0].split('.')[0]
    container_name = parts[1]
    path = '/'.join(parts[2:])
    abfss_uri = f"abfss://{container_name}@{parts[0]}/{path}"
    return abfss_uri

  3. Substitua o placeholder OneLakeTableURI pelo seu URI OneLake copiado da Parte 5 - Copie o caminho OneLake para a tabela para carregar demo_stocks_change tabela num dataframe pandas.

    onelake_uri = "OneLakeTableURI" # Replace with your OneLake table URI
abfss_uri = convert_onelake_to_abfss(onelake_uri)
print(abfss_uri)

    df = spark.read.format('delta').load(abfss_uri)
df = df.toPandas().set_index('Date')
print(df.shape)
df[:3]

  4. Execute as seguintes células para preparar os dataframes de treino e previsão.

    Nota

    As previsões reais serão executadas com dados da Casa de Eventos na parte 9 - Prever anomalias-no-conjunto de consultas kql. Num cenário de produção, se estivesse a transmitir dados para a casa de eventos, as previsões seriam feitas sobre os novos dados em streaming. Para o propósito do tutorial, o conjunto de dados foi dividido por data em duas seções para treinamento e previsão. Isso é para simular dados históricos e novos dados de streaming.

    features_cols = ['AAPL', 'AMZN', 'GOOG', 'MSFT', 'SPY']
cutoff_date = pd.to_datetime('2023-01-01')

    train_df = df[df.Date < cutoff_date]
print(train_df.shape)
train_df[:3]

    train_len = len(train_df)
predict_len = len(df) - train_len
print(f'Total samples: {len(df)}. Split to {train_len} for training, {predict_len} for testing')

  5. Execute as células para treinar o modelo e salvá-lo no registro de modelos Fabric MLflow.

    from anomaly_detector import MultivariateAnomalyDetector
model = MultivariateAnomalyDetector()

    sliding_window = 200
param   s = {"sliding_window": sliding_window}

    model.fit(train_df, params=params)

    model_name = "mvad_5_stocks_model"

    import mlflow

with mlflow.start_run():
    mlflow.log_params(params)
    mlflow.set_tag("Training Info", "MVAD on 5 Stocks Dataset")

    model_info = mlflow.pyfunc.log_model(
        python_model=model,
        artifact_path="mvad_artifacts",
        registered_model_name=model_name,
    )

  6. Execute a célula seguinte para extrair o caminho registado do modelo a ser usado para previsão usando o Kusto Python sandbox.

    from mlflow.tracking import MlflowClient

client = MlflowClient()
mvs = client.search_model_versions(f"name='{model_name}'")
latest = max(mvs, key=lambda v: v.creation_timestamp)
model_abfss = latest.source
print(model_abfss)

  7. Copie o URI do modelo do resultado da última célula para usar numa etapa posterior.

Parte 8- Configurar o conjunto de consultas KQL

Para obter informações gerais, consulte Criar um conjunto de consultas KQL.

  1. No seu espaço de trabalho, selecione +Novo item>KQL Queryset.
  2. Digite o nome MultivariateAnomalyDetectionTutoriale, em seguida, selecione Criar.
  3. Na janela do hub de dados OneLake, selecione o banco de dados KQL onde você armazenou os dados.
  4. Selecione Ligar.

Parte 9- Prever anomalias no conjunto de resultados de consulta KQL

  1. Execute a seguinte consulta '.create-or-alter function' para definir a predict_fabric_mvad_fl() função armazenada:

    .create-or-alter function with (folder = "Packages\\ML", docstring = "Predict MVAD model in Microsoft Fabric")
predict_fabric_mvad_fl(samples:(*), features_cols:dynamic, artifacts_uri:string, trim_result:bool=false)
{
    let s = artifacts_uri;
    let artifacts = bag_pack('MLmodel', strcat(s, '/MLmodel;impersonate'), 'conda.yaml', strcat(s, '/conda.yaml;impersonate'),
                             'requirements.txt', strcat(s, '/requirements.txt;impersonate'), 'python_env.yaml', strcat(s, '/python_env.yaml;impersonate'),
                             'python_model.pkl', strcat(s, '/python_model.pkl;impersonate'));
    let kwargs = bag_pack('features_cols', features_cols, 'trim_result', trim_result);
    let code = ```if 1:
        import os
        import shutil
        import mlflow
        model_dir = 'C:/Temp/mvad_model'
        model_data_dir = model_dir + '/data'
        os.mkdir(model_dir)
        shutil.move('C:/Temp/MLmodel', model_dir)
        shutil.move('C:/Temp/conda.yaml', model_dir)
        shutil.move('C:/Temp/requirements.txt', model_dir)
        shutil.move('C:/Temp/python_env.yaml', model_dir)
        shutil.move('C:/Temp/python_model.pkl', model_dir)
        features_cols = kargs["features_cols"]
        trim_result = kargs["trim_result"]
        test_data = df[features_cols]
        model = mlflow.pyfunc.load_model(model_dir)
        predictions = model.predict(test_data)
        predict_result = pd.DataFrame(predictions)
        samples_offset = len(df) - len(predict_result)        # this model doesn't output predictions for the first sliding_window-1 samples
        if trim_result:                                       # trim the prefix samples
            result = df[samples_offset:]
            result.iloc[:,-4:] = predict_result.iloc[:, 1:]   # no need to copy 1st column which is the timestamp index
        else:
            result = df                                       # output all samples
            result.iloc[samples_offset:,-4:] = predict_result.iloc[:, 1:]
        ```;
    samples
    | evaluate python(typeof(*), code, kwargs, external_artifacts=artifacts)
}

  2. Execute a seguinte consulta de previsão, substituindo o URI do modelo de saída pelo URI copiado no final da etapa 7 .

    A consulta deteta anomalias multivariadas nas cinco ações, com base no modelo treinado, e apresenta os resultados como anomalychart. Os pontos anômalos são renderizados na primeira unidade populacional (AAPL), embora representem anomalias multivariadas (por outras palavras, anomalias das variações conjuntas das cinco unidades populacionais na data específica).

    let cutoff_date=datetime(2023-01-01);
let num_predictions=toscalar(demo_stocks_change | where Date >= cutoff_date | count);   //  number of latest points to predict
let sliding_window=200;                                                                 //  should match the window that was set for model training
let prefix_score_len = sliding_window/2+min_of(sliding_window/2, 200)-1;
let num_samples = prefix_score_len + num_predictions;
demo_stocks_change
| top num_samples by Date desc
| order by Date asc
| extend is_anomaly=bool(false), score=real(null), severity=real(null), interpretation=dynamic(null)
| invoke predict_fabric_mvad_fl(pack_array('AAPL', 'AMZN', 'GOOG', 'MSFT', 'SPY'),
            // NOTE: Update artifacts_uri to model path
            artifacts_uri='enter your model URI here',
            trim_result=true)
| summarize Date=make_list(Date), AAPL=make_list(AAPL), AMZN=make_list(AMZN), GOOG=make_list(GOOG), MSFT=make_list(MSFT), SPY=make_list(SPY), anomaly=make_list(toint(is_anomaly))
| render anomalychart with(anomalycolumns=anomaly, title='Stock Price Changest in % with Anomalies')

O gráfico de anomalias resultante deve ser semelhante à seguinte imagem:

Captura de ecrã da saída de anomalia multivariada.

Limpar recursos

Ao terminar o tutorial, você pode excluir os recursos criados para evitar incorrer em outros custos. Para eliminar os recursos, siga estes passos:

  1. Navegue até a página inicial do seu espaço de trabalho.
  2. Exclua o ambiente criado neste tutorial.
  3. Exclua o bloco de anotações criado neste tutorial.
  4. Exclua a Eventhouse ou o banco de dados usado neste tutorial.
  5. Exclua o conjunto de consultas KQL criado neste tutorial.
  • Last updated on