Treinar e avaliar um modelo de previsão de séries temporais

Nesse notebook, desenvolvemos um programa para prever dados de séries temporais que têm ciclos sazonais. Utilizaremos o conjunto de dados Vendas de Propriedades em NYC com datas que variam de 2003 a 2015, publicado pelo Departamento de Finanças de NYC no Portal de Dados Abertos de NYC.

Pré-requisitos

• Obtenha uma assinatura do Microsoft Fabric. Ou, inscreva-se para uma avaliação gratuita do Microsoft Fabric.

• Entre no Microsoft Fabric.

• Use o alternador de experiência no lado esquerdo da sua página inicial para mudar para a experiência de Ciência de Dados Synapse.

  

• Familiaridade com os notebooks do Microsoft Fabric.
• Um lakehouse para armazenar dados para este exemplo. Para obter mais informações, confira Adicionar um lakehouse ao seu notebook.

Acompanhar em um notebook

Você pode acompanhar o processo em um Notebook de duas maneiras:

• Abra e execute o Notebook interno na experiência de Ciência de Dados do Synapse.
• Carregue seu Notebook do GitHub para a experiência de Ciência de Dados do Synapse.

Abrir o Notebook interno

O Notebook de série temporal de amostra acompanha este tutorial.

Para abrir o Notebook de amostra interno do tutorial na experiência de Synapse Data Science:

1. Vá para a página inicial de Synapse Data Science.

2. Selecione Usar um exemplo.

3. Selecione o exemplo correspondente:

   • Na guia padrão fluxos de trabalho de ponta a ponta (Python), se o exemplo for para um tutorial do Python.
   • Na guia fluxos de trabalho de ponta a ponta (R), se o exemplo for para um tutorial do R.
   • Na guia Tutoriais rápidos, se o exemplo for para um tutorial rápido.

4. Anexe um lakehouse ao notebook antes de começar a executar o código.

Importar o Notebook do GitHub

AIsample - Time Series Forecasting.ipynb é o notebook que acompanha este tutorial.

Para abrir o notebook que acompanha este tutorial, siga as instruções em Preparar seu sistema para tutoriais de ciência de dados para importar os notebooks para seu workspace.

Se preferir copiar e colar o código a partir dessa página, você poderá criar um novo notebook.

Certifique-se de anexar um lakehouse ao notebook antes de começar a executar o código.

Etapa 1: Instalar bibliotecas personalizadas

Ao desenvolver um modelo de machine learning ou fazer uma análise de dados ad-hoc, talvez seja necessário instalar rapidamente uma biblioteca personalizada (como prophet) neste notebook para a sessão do Apache Spark. Para isso, há duas opções.

1. Você pode usar os recursos de instalação em linha (por exemplo, %pip, %conda etc.) para começar rapidamente com novas bibliotecas. Essa opção instalará as bibliotecas personalizadas somente no notebook atual e não no espaço de trabalho.

# Use pip to install libraries
%pip install <library name>

# Use conda to install libraries
%conda install <library name>

2. Como alternativa, você pode criar um ambiente de Fabric, instalar bibliotecas de fontes públicas ou carregar bibliotecas personalizadas para ele e, em seguida, o administrador do espaço de trabalho pode anexar o ambiente como padrão para o espaço de trabalho. Todas as bibliotecas no ambiente ficarão disponíveis para uso em quaisquer notebooks e definições de trabalho do Spark no espaço de trabalho. Para obter mais informações sobre ambientes, confira Criar, configurar e usar um ambiente no Microsoft Fabric.

Para este notebook, use %pip install para instalar a biblioteca prophet. O kernel do PySpark será reiniciado após %pip install. Isso significa que você deve instalar a biblioteca antes de executar quaisquer outras células.

# Use pip to install Prophet
%pip install prophet

Etapa 2: Carregar os dados

Conjunto de dados

Este notebook usa o conjunto de dados Vendas de Propriedades de NYC. Ele abrange dados de 2003 a 2015, publicados pelo Departamento de Finanças de Nova York no Portal de Dados Abertos de Nova York.

O conjunto de dados inclui um registro de todas as vendas de edifícios no mercado imobiliário da cidade de Nova York durante um período de 13 anos. Consulte o Glossário de termos para arquivos de vendas de propriedades para obter a definição das colunas no conjunto de dados.

O objetivo é construir um modelo que preveja as vendas totais mensais, com base em dados históricos. Para isso, você usa o Prophet, uma biblioteca de previsão de código aberto desenvolvida pelo Facebook. O Prophet se baseia em um modelo aditivo, no qual as tendências não lineares são ajustadas com a sazonalidade diária, semanal e anual, e os efeitos de feriados. O Prophet funciona melhor em conjuntos de dados de séries temporais que têm efeitos sazonais fortes e várias estações de dados históricos. Além disso, o Prophet lida de forma robusta com ausência e exceções de dados.

O Prophet usa um modelo de série temporal decomponível, que consiste em três componentes:

• tendência: o Prophet pressupõe uma taxa de crescimento constante por partes, com seleção automática de pontos de mudança.
• sazonalidade: por padrão, o Prophet modela a sazonalidade semanal e anual utilizando a série de Fourier.
• feriados: o Prophet requer todas as ocorrências passadas e futuras de feriados. Se um feriado não se repetir no futuro, o Prophet não o incluirá na previsão.

Este notebook agrega os dados mensalmente, por isso ignora os feriados.

Leia o documento oficial para obter mais informações sobre as técnicas de modelagem do Prophet.

Baixar o conjunto de dados e carregar em um lakehouse

A fonte de dados consiste em 15 arquivos.csv. Esses arquivos contêm registros de vendas de propriedades de cinco bairros de Nova York entre 2003 e 2015. Por conveniência, o arquivo nyc_property_sales.tar contém todos esses arquivos .csv, compactando-os em um arquivo. Um armazenamento de blob disponível publicamente hospeda esse arquivo.tar.

URL = "https://synapseaisolutionsa.blob.core.windows.net/public/NYC_Property_Sales_Dataset/"
TAR_FILE_NAME = "nyc_property_sales.tar"
DATA_FOLDER = "Files/NYC_Property_Sales_Dataset"
TAR_FILE_PATH = f"/lakehouse/default/{DATA_FOLDER}/tar/"
CSV_FILE_PATH = f"/lakehouse/default/{DATA_FOLDER}/csv/"

EXPERIMENT_NAME = "aisample-timeseries" # MLflow experiment name

Esse código faz o download de uma versão disponível publicamente do conjunto de dados e, em seguida, armazena esse conjunto de dados em um Lakehouse do Fabric.

import os

if not os.path.exists("/lakehouse/default"):
    # Add a lakehouse if the notebook has no default lakehouse
    # A new notebook will not link to any lakehouse by default
    raise FileNotFoundError(
        "Default lakehouse not found, please add a lakehouse for the notebook."
    )
else:
    # Verify whether or not the required files are already in the lakehouse, and if not, download and unzip
    if not os.path.exists(f"{TAR_FILE_PATH}{TAR_FILE_NAME}"):
        os.makedirs(TAR_FILE_PATH, exist_ok=True)
        os.system(f"wget {URL}{TAR_FILE_NAME} -O {TAR_FILE_PATH}{TAR_FILE_NAME}")

    os.makedirs(CSV_FILE_PATH, exist_ok=True)
    os.system(f"tar -zxvf {TAR_FILE_PATH}{TAR_FILE_NAME} -C {CSV_FILE_PATH}")

Comece a gravar o tempo necessário para executar esse notebook.

# Record the notebook running time
import time

ts = time.time()

Configurar o acompanhamento de experimentos do MLflow

Para ampliar as capacidades de registro em log do MLflow, o registro automático em log captura automaticamente os valores dos parâmetros de entrada e as métricas de saída de um modelo de machine learning à medida que ele está sendo treinado. Essas informações são, então, registradas no log do espaço de trabalho, onde você pode acessá-lo e visualizá-lo usando as APIs do MLflow ou o experimento correspondente no espaço de trabalho. Visite este recurso para obter mais informações sobre o log automático.

# Set up the MLflow experiment
import mlflow

mlflow.set_experiment(EXPERIMENT_NAME)
mlflow.autolog(disable=True)  # Disable MLflow autologging

Ler dados de data brutos do lakehouse

df = (
    spark.read.format("csv")
    .option("header", "true")
    .load("Files/NYC_Property_Sales_Dataset/csv")
)

Etapa 3: iniciar a análise exploratória de dados

Para analisar o conjunto de dados, você pode percorrer manualmente um subconjunto dos dados para obter uma melhor compreensão. Você pode usar a função display para imprimir o DataFrame. Também é possível mostrar as exibições de Gráficos para visualizar com facilidade os subconjuntos do conjunto de dados.

display(df)

Uma revisão manual do conjunto de dados leva a algumas observações iniciais:

• Instâncias de preços de venda de US$ 0,00. De acordo com o Glossário de Termos, isso implica uma transferência de propriedade sem contraprestação em dinheiro. Ou seja, não houve fluxo de caixa na transação. Você deve remover do conjunto de dados vendas com valores sales_price de US$ 0,00.

• O conjunto de dados abrange diferentes classes de construção. No entanto, este notebook terá seu foco em edifícios residenciais que, de acordo com o Glossário de Termos, estão marcados como tipo "A". Você deve filtrar o conjunto de dados para incluir apenas edifícios residenciais. Para fazer isso, inclua as colunas building_class_at_time_of_sale ou building_class_at_present. Você deve incluir apenas os dados building_class_at_time_of_sale.

• O conjunto de dados inclui instâncias em que valores total_units são iguais a 0 ou valores gross_square_feet são iguais a 0. Você deve remover todas as instâncias em que valores total_units ou gross_square_units sejam iguais a 0.

• Em algumas colunas, por exemplo, apartment_number, tax_class, build_class_at_present etc., faltam valores ou eles são NULL. Suponha que os dados que faltam envolvam erros administrativos ou dados inexistentes. A análise não depende desses valores que faltam; então, você pode ignorá-los.

• A coluna sale_price é armazenada como uma sequência, com um caractere "$" no início. Para prosseguir com a análise, represente esta coluna como um número. Você deve representar a coluna sale_price como número inteiro.

Conversão e filtragem de tipos

Para resolver alguns dos problemas identificados, importe as bibliotecas necessárias.

# Import libraries
import pyspark.sql.functions as F
from pyspark.sql.types import *

Converter os dados de vendas de sequência para número inteiro

Use expressões regulares para separar a parte numérica da cadeia de caracteres do cifrão (por exemplo, na cadeia de caracteres $300,000, dividir $ e 300,000) e, em seguida, converter a parte numérica como um número inteiro.

Em seguida, filtre os dados para incluir apenas instâncias que atendam a todas estas condições:

1. sales_price é maior que 0
2. total_units é maior que 0
3. gross_square_feet é maior que 0
4. building_class_at_time_of_sale é do tipo A

df = df.withColumn(
    "sale_price", F.regexp_replace("sale_price", "[$,]", "").cast(IntegerType())
)
df = df.select("*").where(
    'sale_price > 0 and total_units > 0 and gross_square_feet > 0 and building_class_at_time_of_sale like "A%"'
)

Agregação mensal

O recurso de dados acompanha vendas de propriedades diariamente, mas essa abordagem é muito granular para este notebook. Em vez disso, agregue os dados mensalmente.

Primeiro, altere os valores de data para mostrar apenas dados de mês e ano. Os valores de data ainda incluiriam os dados do ano. Ainda é possível distinguir entre, por exemplo, dezembro de 2005 e dezembro de 2006.

Além disso, mantenha apenas as colunas relevantes para a análise. Elas incluem sales_price, total_units, gross_square_feet e sales_date. Você também deve renomear sales_date para month.

monthly_sale_df = df.select(
    "sale_price",
    "total_units",
    "gross_square_feet",
    F.date_format("sale_date", "yyyy-MM").alias("month"),
)
display(monthly_sale_df)

Agregue os valores sale_price, total_units e gross_square_feet por mês. Em seguida, agrupe os dados por month e some todos os valores dentro de cada grupo.

summary_df = (
    monthly_sale_df.groupBy("month")
    .agg(
        F.sum("sale_price").alias("total_sales"),
        F.sum("total_units").alias("units"),
        F.sum("gross_square_feet").alias("square_feet"),
    )
    .orderBy("month")
)

display(summary_df)

Conversão de Pyspark para Pandas

Os DataFrames do Pyspark lidam bem com grandes conjuntos de dados. No entanto, devido à agregação de dados, o tamanho do DataFrame é menor. Isso sugere que agora você pode usar DataFrames do Pandas.

Esse código converte o conjunto de dados de um DataFrame do Pyspark para um DataFrame do Pandas.

import pandas as pd

df_pandas = summary_df.toPandas()
display(df_pandas)

Visualização

Você pode examinar a tendência do comércio imobiliário da cidade de Nova York para entender melhor os dados. Isso leva a insights sobre padrões potenciais e tendências de sazonalidade. Saiba mais sobre a visualização de dados do Microsoft Fabric neste recurso.

import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np

f, (ax1, ax2) = plt.subplots(2, 1, figsize=(35, 10))
plt.sca(ax1)
plt.xticks(np.arange(0, 15 * 12, step=12))
plt.ticklabel_format(style="plain", axis="y")
sns.lineplot(x="month", y="total_sales", data=df_pandas)
plt.ylabel("Total Sales")
plt.xlabel("Time")
plt.title("Total Property Sales by Month")

plt.sca(ax2)
plt.xticks(np.arange(0, 15 * 12, step=12))
plt.ticklabel_format(style="plain", axis="y")
sns.lineplot(x="month", y="square_feet", data=df_pandas)
plt.ylabel("Total Square Feet")
plt.xlabel("Time")
plt.title("Total Property Square Feet Sold by Month")
plt.show()

Resumo das observações da análise exploratória de dados

• Os dados mostram um claro padrão recorrente em uma cadência anual; isso significa que os dados têm uma sazonalidade anual
• Os meses de verão parecem ter maiores volumes de vendas em comparação com os meses de inverno
• Em uma comparação de anos com vendas altas e anos com vendas baixas, a diferença de receita entre meses de vendas altas e meses de vendas baixas em anos de vendas altas supera, em termos absolutos, a diferença de receita entre meses de vendas altas e meses de vendas baixas em anos de vendas baixas.

Por exemplo, em 2004, a diferença de receita entre o mês de vendas mais alto e o mês de vendas mais baixo é de cerca de:

$900,000,000 - $500,000,000 = $400,000,000

para 2011, esse cálculo de diferença de receita é de cerca de:

$400,000,000 - $300,000,000 = $100,000,000

Isso se torna importante mais tarde, quando você deve decidir entre os efeitos de sazonalidade multiplicativa e aditiva.

Etapa 4: treinamento e acompanhamento do modelo

Ajuste do modelo

A entrada do Prophet é sempre um DataFrame de duas colunas. Uma coluna de entrada é uma coluna de tempo chamada ds, e uma coluna de entrada é uma coluna de valor chamada y. A coluna de tempo deve ter um formato de dados de data, hora ou data/hora (por exemplo, YYYY_MM). O conjunto de dados aqui atende a essa condição. A coluna de valor deve ter um formato de dados numérico.

Para o ajuste do modelo, você só deve renomear a coluna de tempo para ds e a coluna de valor para y, e passar os dados para o Prophet. Para obter mais informações, leia a documentação da API do Prophet Python.

df_pandas["ds"] = pd.to_datetime(df_pandas["month"])
df_pandas["y"] = df_pandas["total_sales"]

O Prophet segue a convenção scikit-learn. Primeiro, crie uma nova instância do Prophet, defina determinados parâmetros (por exemplo, seasonality_mode) e, em seguida, ajuste essa instância ao conjunto de dados.

• Embora um fator aditivo constante seja o efeito de sazonalidade padrão para o Prophet, você deve usar a sazonalidade multiplicativa para o parâmetro de efeito de sazonalidade. A análise na seção anterior mostrou que, devido a mudanças na amplitude da sazonalidade, uma simples sazonalidade aditiva não se ajusta bem aos dados.

• Defina o parâmetro weekly_seasonality como desativado, pois os dados foram agregados por mês. Como resultado, não há disponibilidade de dados semanais.

• Use os métodos de Monte Carlo via Cadeia de Markov (MCMC) para capturar as estimativas de incerteza de sazonalidade. Por padrão, o Prophet pode fornecer estimativas de incerteza sobre a tendência e o ruído de observação, mas não para a sazonalidade. Os MCMC requerem mais tempo de processamento, mas permitem que o algoritmo forneça estimativas de incerteza sobre a sazonalidade, a tendência e o ruído de observação. Leia a documentação sobre Intervalos de Incerteza do Prophet para obter mais informações.

• Ajuste a sensibilidade de detecção automática do ponto de alteração por meio do parâmetro changepoint_prior_scale. O algoritmo do Prophet tenta encontrar automaticamente instâncias nos dados em que as trajetórias mudam abruptamente. Pode ficar difícil encontrar o valor correto. Para resolver isso, você pode tentar valores diferentes e, em seguida, selecionar o modelo com o melhor desempenho. Leia a documentação sobre Pontos de alteração de tendência do Prophet para obter mais informações.

from prophet import Prophet

def fit_model(dataframe, seasonality_mode, weekly_seasonality, chpt_prior, mcmc_samples):
    m = Prophet(
        seasonality_mode=seasonality_mode,
        weekly_seasonality=weekly_seasonality,
        changepoint_prior_scale=chpt_prior,
        mcmc_samples=mcmc_samples,
    )
    m.fit(dataframe)
    return m

Validação cruzada

O Prophet tem uma ferramenta de validação cruzada integrada. Essa ferramenta pode estimar o erro de previsão, e encontrar o modelo com o melhor desempenho.

A técnica de validação cruzada pode validar a eficiência do modelo. Essa técnica treina o modelo em um subconjunto do conjunto de dados e executa testes em um subconjunto do conjunto de dados inédito anteriormente. Essa técnica pode verificar quão bem um modelo estatístico generaliza para um conjunto de dados independente.

Para validação cruzada, reserve uma amostra específica do conjunto de dados, que não fazia parte do conjunto de dados de treinamento. Em seguida, teste o modelo treinado nessa amostra, antes da implantação. No entanto, essa abordagem não funciona para dados de séries temporais, porque se o modelo viu dados dos meses de janeiro de 2005 e março de 2005, e você tenta prever para o mês de fevereiro de 2005, o modelo pode essencialmente trapacear, porque ele pode ver aonde a tendência de dados leva. Em aplicações reais, o objetivo é prever para o futuro, como as regiões invisíveis.

Para lidar com isso e tornar o teste confiável, divida o conjunto de dados com base nas datas. Use o conjunto de dados até uma determinada data (por exemplo, os primeiros 11 anos de dados) para treinamento e, em seguida, use os dados não vistos restantes para previsão.

Nesse cenário, comece com 11 anos de dados de treinamento e, em seguida, faça previsões mensais usando um horizonte de um ano. Especificamente, os dados de treinamento contêm tudo de 2003 a 2013. Em seguida, a primeira execução lida com previsões de janeiro de 2014 a janeiro de 2015. A próxima execução lida com previsões de fevereiro de 2014 a fevereiro de 2015 e assim por diante.

Repita esse processo para cada um dos três modelos treinados, para ver qual modelo tem o melhor desempenho. Em seguida, compare essas previsões com valores do mundo real, para estabelecer a qualidade da previsão do melhor modelo.

from prophet.diagnostics import cross_validation
from prophet.diagnostics import performance_metrics

def evaluation(m):
    df_cv = cross_validation(m, initial="4017 days", period="30 days", horizon="365 days")
    df_p = performance_metrics(df_cv, monthly=True)
    future = m.make_future_dataframe(periods=12, freq="M")
    forecast = m.predict(future)
    return df_p, future, forecast

Modelo de log com o MLflow

Registre os modelos, para acompanhar seus parâmetros, e salve os modelos para uso posterior. Todas as informações relevantes sobre o modelo são registradas em log com o nome do experimento no workspace. O modelo, os parâmetros e as métricas, juntamente com os itens de log automático do MLflow, são salvos em uma execução do MLflow.

# Setup MLflow
from mlflow.models.signature import infer_signature

Realizar experimentos

Um experimento de aprendizado de máquina serve como a principal unidade de organização e controle para todas as execuções de aprendizado de máquina relacionadas. Uma execução corresponde a uma única execução do código do modelo. O acompanhamento de experimentos de aprendizado de máquina refere-se ao gerenciamento de todos os diferentes experimentos e seus componentes. Isso inclui parâmetros, métricas, modelos e outros artefatos e ajuda a organizar os componentes necessários de um experimento de aprendizado de máquina específico. O acompanhamento de experimentos de aprendizado de máquina também permite a fácil duplicação de resultados anteriores com experimentos salvos. Saiba mais sobre experimentos de machine learning no Microsoft Fabric. Depois de determinar as etapas que você pretende incluir (por exemplo, ajustar e avaliar o modelo do Prophet neste Notebook), você pode executar o experimento.

model_name = f"{EXPERIMENT_NAME}-prophet"

models = []
df_metrics = []
forecasts = []
seasonality_mode = "multiplicative"
weekly_seasonality = False
changepoint_priors = [0.01, 0.05, 0.1]
mcmc_samples = 100

for chpt_prior in changepoint_priors:
    with mlflow.start_run(run_name=f"prophet_changepoint_{chpt_prior}"):
        # init model and fit
        m = fit_model(df_pandas, seasonality_mode, weekly_seasonality, chpt_prior, mcmc_samples)
        models.append(m)
        # Validation
        df_p, future, forecast = evaluation(m)
        df_metrics.append(df_p)
        forecasts.append(forecast)
        # Log model and parameters with MLflow
        mlflow.prophet.log_model(
            m,
            model_name,
            registered_model_name=model_name,
            signature=infer_signature(future, forecast),
        )
        mlflow.log_params(
            {
                "seasonality_mode": seasonality_mode,
                "mcmc_samples": mcmc_samples,
                "weekly_seasonality": weekly_seasonality,
                "changepoint_prior": chpt_prior,
            }
        )
        metrics = df_p.mean().to_dict()
        metrics.pop("horizon")
        mlflow.log_metrics(metrics)

Visualize um modelo com o Prophet

As funções integradas do Prophet podem mostrar os resultados de ajuste do modelo.

Os pontos pretos são pontos de dados utilizados para treinar o modelo. A linha azul é a previsão e a área azul clara mostra os intervalos de incerteza. Você construiu três modelos com valores changepoint_prior_scale diferentes. As previsões desses três modelos são mostradas nos resultados deste bloco de código.

for idx, pack in enumerate(zip(models, forecasts)):
    m, forecast = pack
    fig = m.plot(forecast)
    fig.suptitle(f"changepoint = {changepoint_priors[idx]}")

O menor valor changepoint_prior_scale no primeiro gráfico leva a um subajuste (underfitting) das mudanças de tendência. O maior valor changepoint_prior_scale no terceiro gráfico poderia resultar em sobreajuste (overfitting). Assim, o segundo gráfico parece ser a escolha ideal. Isso implica que o segundo modelo é o mais adequado.

Visualize tendências e sazonalidade com o Prophet

O Prophet também pode visualizar facilmente as tendências e sazonalidades subjacentes. As visualizações do segundo modelo são mostradas nos resultados deste bloco de código.

BEST_MODEL_INDEX = 1  # Set the best model index according to the previous results
fig2 = models[BEST_MODEL_INDEX].plot_components(forecast)

Nesses gráficos, o sombreamento azul claro reflete a incerteza. O gráfico superior mostra uma forte tendência oscilante de longo prazo. Ao longo de alguns anos, os volumes de vendas aumentam e diminuem. O gráfico inferior mostra que as vendas tendem a atingir o pico em fevereiro e setembro, atingindo seus valores máximos para o ano nesses meses. Logo após esses meses, em março e outubro, caem para os valores mínimos do ano.

Avalie o desempenho dos modelos utilizando diversas métricas, por exemplo:

• MSE (Erro Quadrático Médio)
• RMSE (Raiz do Erro Quadrático Médio)
• MAE (Erro Médio Absoluto)
• MAPE (Erro Percentual Absoluto Médio)
• MDAPE (Erro Percentual Absoluto Mediano)
• SMAPE (Erro Percentual Médio Absoluto Simétrico)

Avalie a cobertura usando as estimativas yhat_lower e yhat_upper. Observe os horizontes variados em que você prevê um ano no futuro, 12 vezes.

display(df_metrics[BEST_MODEL_INDEX])

Com a métrica MAPE, para esse modelo de previsão, as previsões que se estendem por um mês no futuro normalmente envolvem erros de aproximadamente 8%. No entanto, para previsões de um ano no futuro, o erro aumenta para cerca de 10%.

Etapa 5: pontuar o modelo e salvar os resultados da previsão

Agora pontue o modelo e salve os resultados da previsão.

Faça previsões com o Transformador de Previsão

Agora é possível carregar o modelo e usá-lo para fazer previsões. Os usuários podem operacionalizar modelos de machine learning com uma função escalonável do Microsoft Fabric chamada PREDICT, que dá suporte à pontuação em lote em qualquer mecanismo de computação. Saiba mais sobre a função PREDICT e como usá-la no Microsoft Fabric, neste recurso.

from synapse.ml.predict import MLFlowTransformer

spark.conf.set("spark.synapse.ml.predict.enabled", "true")

model = MLFlowTransformer(
    inputCols=future.columns.values,
    outputCol="prediction",
    modelName=f"{EXPERIMENT_NAME}-prophet",
    modelVersion=BEST_MODEL_INDEX,
)

test_spark = spark.createDataFrame(data=future, schema=future.columns.to_list())

batch_predictions = model.transform(test_spark)

display(batch_predictions)

# Code for saving predictions into lakehouse
batch_predictions.write.format("delta").mode("overwrite").save(
    f"{DATA_FOLDER}/predictions/batch_predictions"
)

# Determine the entire runtime
print(f"Full run cost {int(time.time() - ts)} seconds.")

Conteúdo relacionado

• Modelo de machine learning no Microsoft Fabric
• Compilar modelos de aprendizado de máquina
• Experimentos de machine learning no Microsoft Fabric