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

Neste caderno, constróis um programa para prever dados de séries temporais com ciclos sazonais. Utilize o conjunto de dados de Vendas de Propriedades NYC com datas entre 2003 e 2015, publicado pelo Departamento de Finance de Nova Iorque no Portal de Dados Abertos NYC.

Pré-requisitos

  • Faça uma subscrição Microsoft Fabric. Ou, inscreva-se para um teste gratuito Microsoft Fabric.

  • Iniciar sessão em Microsoft Fabric.

  • Altera para o Fabric usando o alternador de experiência no canto inferior esquerdo da sua página inicial.

    Captura de ecrã que mostra a seleção de Fabric no menu do comutador de experiências.

Acompanhe num caderno

Você pode acompanhar num notebook de uma das duas maneiras:

  • Abra e execute o bloco de notas incorporado.
  • Carrega o teu caderno do GitHub.

Abra o bloco de notas incorporado

O caderno de notas de exemplo Série Temporal acompanha este tutorial.

  1. Para abrir o bloco de anotações de exemplo para este tutorial, siga as instruções em Preparar seu sistema para tutoriais de ciência de dados.

  2. Certifique-se de anexar um lakehouse ao do bloco de anotações antes de começar a executar o código.

Importar o caderno do GitHub

AIsample - Previsão de Séries Temporais.ipynb é o caderno que acompanha este tutorial.

Etapa 1: Instalar bibliotecas personalizadas

Quando desenvolve um modelo machine learning ou lida com análise de dados ad hoc, pode ser necessário instalar rapidamente uma biblioteca personalizada (por exemplo, prophet neste caderno) para a sessão Apache Spark. Para fazer esta tarefa, tem duas opções.

  1. Use as capacidades de instalação em linha (por exemplo, %pip, %conda, e assim por diante) para começar rapidamente com novas bibliotecas. Este método instala as bibliotecas personalizadas apenas no portátil atual, 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>
  1. Em alternativa, crie um ambiente Fabric, instale bibliotecas a partir de fontes públicas ou carregue bibliotecas personalizadas para ele. O administrador do seu espaço de trabalho pode associar o ambiente como padrão para o espaço de trabalho. Todas as bibliotecas do ambiente ficam disponíveis para uso em quaisquer cadernos e definições de tarefas Spark no espaço de trabalho. Para mais informações sobre ambientes, consulte criar, configurar e usar um ambiente em Microsoft Fabric.

Para este notebook, use %pip install para instalar a biblioteca prophet. O kernel PySpark reinicia após %pip install. Esta ação significa que tens de instalar a biblioteca antes de executares quaisquer outras células.

# Use pip to install Prophet
%pip install prophet

Passo 2: Carregue os dados

Conjunto de dados

Este bloco de anotações usa o conjunto de dados NYC Property Sales. Abrange dados de 2003 a 2015, publicados pelo Departamento de Finance de Nova Iorque no NYC Open Data Portal.

O conjunto de dados inclui um registro de todas as vendas de edifícios no mercado imobiliário da cidade de Nova York, dentro de um período de 13 anos. Consulte o Glossário de Termos para Ficheiros de Vendas de Propriedades para uma definição das colunas no conjunto de dados.

Bairro bairro categoria_classe_de_edifício classe de imposto bloco lote facilidade de direção leste classe_de_construção_atual Endereço número_apartamento zip_code unidades residenciais unidades comerciais total de unidades área_m2 metros quadrados brutos ano_construído classe_de_imposto_à_data_da_venda classe_de_edifício_no_momento_da_venda preço_de_venda data_venda
Manhattan CIDADE DO ALFABETO 07 ARRENDAMENTOS - APARTAMENTOS SEM ELEVADOR 0.0 384.0 17.0 C4 225 EAST 2ND STREET 10009.0 10,0 0.0 10,0 2145.0 6670.0 1900.0 2.0 C4 275000.0 2007-06-19
Manhattan CIDADE DO ALFABETO 07 ARRENDAMENTOS - APARTAMENTOS SEM ELEVADOR 2.0 405.0 12.0 C7 Rua Leste 12, 508 10009.0 28.0 2.0 30.0 3872.0 15428.0 1930.0 2.0 C7 7794005.0 2007-05-21

O objetivo é construir um modelo que preveja as vendas totais mensais, com base em dados históricos. Para isso, usa o Prophet, uma biblioteca de previsão de open source desenvolvida pelo Facebook. O Prophet baseia-se num modelo aditivo, onde as tendências não lineares se ajustam à sazonalidade diária, semanal e anual e aos efeitos de férias. O Prophet funciona melhor em conjuntos de dados de séries temporais que têm fortes efeitos sazonais e em várias estações de dados históricos. Além disso, o Prophet lida de forma robusta com dados ausentes e dados atípicos.

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

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

Este caderno agrega os dados mensalmente, ignorando os feriados.

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

Faça o download do conjunto de dados e carregue em uma casa do lago

A fonte de dados consiste em 15 .csv arquivos. Esses arquivos contêm registros de vendas de imóveis de cinco distritos de Nova York, entre 2003 e 2015. Por conveniência, o nyc_property_sales.tar arquivo contém todos esses .csv arquivos, compactando-os em um arquivo. Um blob storage disponível publicamente aloja este ficheiro .tar.

Gorjeta

Ao usar os parâmetros apresentados nesta célula de código, pode facilmente aplicar este caderno a diferentes conjuntos de dados.

URL = "https://synapseaisolutionsa.z13.web.core.windows.net/data/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 baixa uma versão disponível publicamente do conjunto de dados e, em seguida, armazena esse conjunto de dados em um Fabric Lakehouse.

Importante

Certifique-se de adicionar um lakehouse ao notebook antes de executá-lo. Se não o fizer, ocorre um erro.

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

Inicie a gravação do tempo de execução deste notebook.

# Record the notebook running time
import time

ts = time.time()

Configurar o acompanhamento do experimento MLflow

Para expandir as capacidades de registo de MLflow, o autologging captura automaticamente os valores dos parâmetros de entrada e das métricas de saída de um modelo de machine learning durante o seu treino. Esta informação é depois registada no espaço de trabalho, onde as APIs do MLflow ou o experimento correspondente no espaço de trabalho podem acessá-lo e visualizá-lo. Para mais informações sobre autologging, consulte Autologging in Microsoft Fabric.

# Set up the MLflow experiment
import mlflow

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

Nota

Para desativar Microsoft Fabric autolog numa sessão de notebook, chame mlflow.autolog() e defina disable=True.

Leia os dados brutos temporais 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 dos dados

Para rever o conjunto de dados, examine manualmente um subconjunto de dados para obter uma melhor compreensão. Use a display função para imprimir o DataFrame. Você também pode mostrar as visualizações de gráfico, para visualizar facilmente subconjuntos do conjunto de dados.

display(df)

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

  • Casos de vendas a $0,00. De acordo com o Glossário de Termos, este valor implica uma transferência de propriedade sem qualquer contraprestação em dinheiro. Ou seja, nenhum fluxo de caixa na transação. Remova as vendas com valores de $0,00 sales_price do conjunto de dados.

  • O conjunto de dados abrange diferentes classes de construção. No entanto, este caderno irá centrar-se em edifícios residenciais que, segundo o Glossário de Termos, são marcados como tipo "A". Filtre o conjunto de dados para incluir apenas edifícios residenciais. Para fazer isto, inclua uma das colunas building_class_at_time_of_sale ou building_class_at_present. Inclui apenas os building_class_at_time_of_sale dados.

  • O conjunto de dados inclui instâncias em que total_units valores são iguais a 0 ou gross_square_feet valores iguais a 0. Remova todas as instâncias onde total_units ou gross_square_units valores são 0.

  • Algumas colunas – por exemplo, apartment_number, tax_class, build_class_at_present, e outras – têm valores em falta ou NULL. Suponha que os dados ausentes envolvem erros administrativos ou dados inexistentes. A análise não depende desses valores ausentes, então você pode ignorá-los.

  • A sale_price coluna é armazenada como uma cadeia de caracteres, com um caractere "$" predefinido. Para prosseguir com a análise, represente esta coluna como um número. Converter a sale_price coluna para 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 *

Transmitir os dados de vendas de cadeia de caracteres para 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 para um inteiro.

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

  1. O sales_price é maior que 0.
  2. O total_units é maior que 0.
  3. O gross_square_feet é maior que 0.
  4. O 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 rastreia as vendas de imóveis diariamente, mas essa abordagem é muito granular para este bloco de anotações. Em vez disso, agregue os dados mensalmente.

Primeiro, altere os valores de data para mostrar apenas dados de mês e ano. Os valores das datas continuam a incluir os dados do ano. Ainda se pode distinguir, por exemplo, entre dezembro de 2005 e dezembro de 2006.

Além disso, mantenha apenas as colunas relevantes para a análise. Estas colunas 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)

Agrega os sale_price, total_units, e gross_square_feet os valores por mês. Em seguida, agrupe os dados por monthe 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. Esta mudança sugere que agora pode usar pandas DataFrames.

Este código converte o conjunto de dados de um pyspark DataFrame para um pandas DataFrame.

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. Este exame conduz a insights sobre potenciais padrões e tendências de sazonalidade. Para mais informações sobre visualização de dados Microsoft Fabric, consulte o recurso Visualização de cadernos.

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 dos dados

  • Os dados mostram um padrão claro e recorrente numa cadência anual, o que significa que os dados têm uma sazonalidade anual.
  • Os meses de verão parecem ter volumes de vendas mais elevados em comparação com os meses de inverno.
  • Quando compara anos com vendas elevadas e anos com vendas baixas, vê-se que a diferença de receita entre meses de vendas elevadas e meses de vendas baixas em anos de vendas elevadas excede — em termos absolutos — a diferença de receita entre meses de vendas elevadas 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:

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

Para 2011, esse cálculo da diferença de receitas diz respeito:

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

Esta observação torna-se importante mais tarde, quando é preciso decidir entre efeitos de sazonalidade multiplicativos e aditivos .

Etapa 4: Treinamento e acompanhamento do modelo

Montagem do modelo

Prophet recebe sempre um DataFrame de duas colunas como entrada. Uma coluna de entrada é uma coluna de tempo chamada ds, e a outra coluna de entrada é uma coluna de valor chamada y. A coluna de hora 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 valores deve ser um formato de dados numéricos.

Para ajuste do modelo, renomear a coluna de tempo para ds e a coluna de valor para y. Depois, passa os dados ao Profeta. Para mais informações, consulte a documentação da API Python Prophet.

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

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

  • Embora um fator aditivo constante seja o efeito padrão de sazonalidade para o Prophet, use a sazonalidade 'multiplicativa' para o parâmetro do efeito de sazonalidade. A análise da secção anterior mostrou que, devido a alterações na amplitude da sazonalidade, uma simples sazonalidade aditiva não se ajusta bem aos dados.

  • Defina o parâmetro weekly_seasonalitycomo desligado, porque os dados são agregados por mês. Como resultado, os dados semanais não estão disponíveis.

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

  • Ajuste a sensibilidade de deteção automática do ponto de alteração através do parâmetro changepoint_prior_scale . O algoritmo Prophet tenta automaticamente encontrar instâncias nos dados onde as trajetórias mudam abruptamente. Pode tornar-se difícil encontrar o valor correto. Para resolver este problema, experimente diferentes valores e depois selecione o modelo com melhor desempenho. Para obter mais informações, consulte a documentação dos Pontos de Mudança de Tendências do Prophet.

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. Esta ferramenta pode estimar o erro de previsão e encontrar o modelo com melhor desempenho.

A técnica de validação cruzada pode validar a eficiência do modelo. Esta técnica treina o modelo num subconjunto do conjunto de dados e executa testes num subconjunto do conjunto de dados nunca antes visto. Esta técnica pode verificar até que ponto um modelo estatístico se generaliza para um conjunto de dados independente.

Para validação cruzada, reserve uma amostra específica do conjunto de dados que não faça parte do conjunto de treino. Em seguida, teste o modelo treinado nessa amostra, antes da implantação. No entanto, esta abordagem não funciona para dados de séries temporais. Se o modelo vir dados dos meses de janeiro de 2005 e março de 2005 e, então, tentar prever para o mês de fevereiro de 2005, o modelo pode essencialmente trapacear porque vê para onde a tendência dos dados leva. Em aplicações reais, o objetivo é prever para o futuro, como as regiões invisíveis.

Para lidar com este problema e tornar o teste fiá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 para 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 MLflow

Registe os modelos para acompanhar os seus parâmetros e guarda os modelos para uso posterior. Todas as informações relevantes do modelo são registradas no espaço de trabalho, sob o nome do experimento. O modelo, os parâmetros e as métricas, juntamente com os itens de autologging do MLflow, são guardados numa única execução do MLflow.

# Setup MLflow
from mlflow.models.signature import infer_signature

Realizar experiências

Um experimento de machine learning serve como a principal unidade de organização e controlo para todas as execuções de machine learning relacionadas. Uma execução corresponde a uma única execução do código do modelo. O rastreamento de experiências de Machine Learning refere-se à gestão de todos os diferentes experimentos e dos seus componentes. Esta gestão inclui parâmetros, métricas, modelos e outros artefactos. Ajuda a organizar os componentes necessários de um experimento específico de machine learning. O rastreamento de experiências de Machine learning também permite a fácil duplicação de resultados anteriores com experiências guardadas. Para mais informações, consulte experiências de machine learning em Microsoft Fabric. Depois de determinar as etapas que pretende incluir (por exemplo, ajustar e avaliar o modelo do Profeta neste caderno), 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)

Captura de tela do painel de propriedades.

Visualize um modelo com o Prophet

O Prophet tem funções de visualização incorporadas que mostram os resultados do ajuste do modelo.

Os pontos pretos representam os pontos de dados que treinam o modelo. A linha azul é a previsão, e a área azul clara mostra os intervalos de incerteza. Construíste três modelos com valores diferentes changepoint_prior_scale . As previsões destes três modelos aparecem 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 changepoint_prior_scale valor no primeiro gráfico causa subajuste das mudanças de tendência. O maior changepoint_prior_scale no terceiro gráfico pode causar sobreajustamento. Portanto, o segundo gráfico é a melhor escolha. Este resultado significa que o segundo modelo é o mais adequado.

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)

Captura de tela de um gráfico de tendências anuais nos dados de preços.

Nestes gráficos, o sombreamento azul claro reflete a incerteza. O gráfico superior mostra uma forte tendência oscilante de longo período. Ao longo de alguns anos, os volumes de vendas sobem 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. Pouco depois desses meses, em março e outubro, caem para os valores mínimos do ano.

Avalie o desempenho dos modelos usando várias métricas, por exemplo:

  • erro quadrático médio (MSE)
  • erro quadrático médio da raiz (RMSE)
  • erro absoluto médio (MAE)
  • erro percentual absoluto médio (MAPE)
  • erro percentual absoluto mediano (MDAPE)
  • erro percentual absoluto médio simétrico (SMAPE)

Avalie a cobertura utilizando as estimativas yhat_lower e yhat_upper. Observe os horizontes variáveis onde você prevê um ano no futuro, 12 vezes.

display(df_metrics[BEST_MODEL_INDEX])

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

Etapa 5: Avaliar o modelo e guardar os resultados da previsão

Pontuar o modelo e guardar os resultados da previsão.

Faça previsões com o Predict Transformer

Carrega o modelo e usa-o para fazer previsões. Para operacionalizar machine learning modelos, utilize PREDICT, uma função de Microsoft Fabric escalável que suporta pontuação em lote em qualquer motor de computação. Para mais informações sobre PREDICT e como o usar dentro de Microsoft Fabric, consulte este 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údos relacionados

  • Last updated on