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

Artigo
03/05/2024

Neste caderno, construímos um programa para prever dados de séries temporais que tenham ciclos sazonais. Usamos o conjunto de dados de Vendas de Propriedades de Nova York com datas que variam de 2003 a 2015, publicado pelo Departamento de Finanças de Nova York no Portal de Dados Abertos de Nova York.

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 seletor de experiência no lado esquerdo da sua página inicial para alternar para a experiência Synapse Data Science.

Familiaridade com notebooks Microsoft Fabric.
Uma casa de lago para armazenar dados para este exemplo. Para obter mais informações, consulte Adicionar uma casa de lago ao seu bloco de anotações.

Acompanhe num caderno

Você pode acompanhar em um bloco de anotações uma das duas maneiras:

Abra e execute o notebook integrado na experiência Synapse Data Science.
Carregue seu bloco de anotações do GitHub para a experiência Synapse Data Science.

Abra o bloco de notas incorporado

O bloco de anotações de série temporal de exemplo acompanha este tutorial.

Para abrir o bloco de anotações de exemplo integrado do tutorial na experiência Synapse Data Science:

Vá para a página inicial do Synapse Data Science.
Selecione Usar uma amostra.
Selecione a amostra correspondente:
- Na guia padrão End-to-end workflows (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 R.
- Na guia Tutoriais rápidos, se o exemplo for para um tutorial rápido.
Anexe um lakehouse ao bloco de anotações antes de começar a executar o código.

Importar o bloco de anotações do GitHub

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

Para abrir o bloco de anotações que acompanha este tutorial, siga as instruções em Preparar seu sistema para tutoriais de ciência de dados, para importar o bloco de anotações para seu espaço de trabalho.

Se preferir copiar e colar o código desta página, pode criar um novo bloco de notas.

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

Etapa 1: Instalar bibliotecas personalizadas

Quando você desenvolve um modelo de aprendizado de máquina ou lida com análise de dados ad-hoc, talvez seja necessário instalar rapidamente uma biblioteca personalizada (por exemplo, prophet neste bloco de anotações) para a sessão do Apache Spark. Para fazer isso, você tem duas opções.

Você pode usar os recursos de instalação em linha (por exemplo, %pip, %conda, etc.) para começar rapidamente com novas bibliotecas. Isso só instalaria as bibliotecas personalizadas no bloco de anotações 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>

Como alternativa, você pode criar um ambiente de malha, 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 blocos de anotações e definições de trabalho do Spark no espaço de trabalho. Para obter mais informações sobre ambientes, consulte criar, configurar e usar um ambiente no Microsoft Fabric.

Para este bloco de anotações, você usa %pip install para instalar a prophet biblioteca. O kernel do PySpark será reiniciado após %pip installo . Isso significa que você deve instalar a biblioteca antes de executar 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 Finanças de Nova Iorque no Portal de Dados Abertos de Nova Iorque.

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 Arquivos de Vendas de Propriedades para obter uma definição das colunas no conjunto de dados.

Bairro	bairro	building_class_category	tax_class	block	lote	Páscoa	building_class_at_present	Endereço	apartment_number	zip_code	residential_units	commercial_units	total_units	land_square_feet	gross_square_feet	year_built	tax_class_at_time_of_sale	building_class_at_time_of_sale	sale_price	sale_date
Manhattan	CIDADE DO ALFABETO	07 ALUGUERES - WALKUP APARTMENTS	0.0	384.0	17.0		C4	225 LESTE 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 ALUGUERES - WALKUP APARTMENTS	2.0	405.0	12.0		C7	508 LESTE 12TH STREET		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, você usa o Prophet, uma biblioteca de previsão de código aberto 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 armazenamento de blob disponível publicamente hospeda esse .tar arquivo.

Gorjeta

Com os parâmetros mostrados nesta célula de código, você pode facilmente aplicar este bloco de anotações a diferentes conjuntos de dados.

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 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 uma casa de lago ao bloco de anotações antes de executá-lo. Se não o fizer, haverá 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}")

Comece a gravar o tempo de execução deste bloco de notas.

# Record the notebook running time
import time

ts = time.time()

Configurar o acompanhamento do experimento MLflow

Para estender os recursos de log do MLflow, o registro automático captura automaticamente os valores dos parâmetros de entrada e métricas de saída de um modelo de aprendizado de máquina durante seu treinamento. Essas informações são então registradas no espaço de trabalho, onde as APIs do MLflow ou o experimento correspondente no espaço de trabalho podem acessá-las e visualizá-las. Visite este recurso para obter mais informações sobre o registro automático.

# Set up the MLflow experiment
import mlflow

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

Nota

Se você quiser desabilitar o registro automático do Microsoft Fabric em uma sessão de bloco de anotações, chame mlflow.autolog() e defina disable=True.

Leia os dados brutos de data da casa do lago

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 revisar o conjunto de dados, você pode examinar manualmente um subconjunto de dados para obter uma melhor compreensão dele. Você pode usar 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:

Instâncias de preços de venda de $0,00. De acordo com o Glossário de Termos, isto implica uma transferência de propriedade sem contrapartida pecuniária. Ou seja, nenhum fluxo de caixa na transação. Você deve remover vendas com valores de US$ 0,00 sales_price do conjunto de dados.
O conjunto de dados abrange diferentes classes de construção. No entanto, este caderno incidirá sobre 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 building_class_at_time_of_sale colunas ou as building_class_at_present colunas. Você deve incluir 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. Você deve remover todas as instâncias em que total_units ou gross_square_units valores iguais a 0.
Algumas colunas - por exemplo, apartment_number, , build_class_at_presenttax_class, etc. - têm valores ausentes 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. Você deve converter a sale_price coluna como 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, divisão $ e 300,000) e, em seguida, lance a parte numérica como um inteiro.

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

O sales_price é maior que 0
O total_units é maior que 0
O gross_square_feet é maior que 0
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 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. Estes 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)

Agregar o 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. Isso sugere que agora você 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. 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 dos 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 volumes de vendas mais elevados em comparação com os meses de inverno
Numa comparação de anos com vendas elevadas e anos com vendas baixas, 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

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

Etapa 4: Treinamento e acompanhamento do modelo

Montagem do modelo

A entrada do profeta é 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 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 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. Leia a documentação da API do Prophet Python para obter mais informações.

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

Prophet segue a convenção 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 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 encaixa bem nos dados.
Defina o parâmetro weekly_seasonality como desativado, porque os dados foram agregados por mês. Como resultado, os dados semanais não estão disponíveis.
Use os métodos Markov Chain Monte Carlo (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 e o ruído de tendência e observação. Leia a documentação dos Intervalos de Incerteza do Profeta para obter mais informações.
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 isso, você pode tentar valores diferentes e, em seguida, selecionar o modelo com o melhor desempenho. Leia a documentação do Prophet Trend Changepoints 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. Esta 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 inédito do conjunto de dados. 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 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 onde 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 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

Registre os modelos, para manter o controle de seus parâmetros, e salve 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 registro automático do MLflow, são salvos em uma execução do MLflow.

# Setup MLflow
from mlflow.models.signature import infer_signature

Realizar experiências

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 rastreamento 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 rastreamento de experimentos de aprendizado de máquina também permite a fácil duplicação de resultados passados com experimentos salvos. Saiba mais sobre experimentos de aprendizado de máquina no 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 ecrã do painel de propriedades.

Visualize um modelo com o Prophet

O Prophet tem funções de visualização integradas, que podem mostrar os resultados de ajuste do modelo.

Os pontos pretos denotam os pontos de dados que são usados 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 diferentes changepoint_prior_scale . 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 changepoint_prior_scale valor no primeiro gráfico leva a um subajuste das mudanças de tendência. O maior changepoint_prior_scale no terceiro gráfico pode resultar em sobreajuste. Assim, o segundo gráfico parece ser a escolha ideal. Isto 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)

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 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 usando o yhat_lower e yhat_upper estimativas. Observe os horizontes variáveis onde você prevê um ano no futuro, 12 vezes.

display(df_metrics[BEST_MODEL_INDEX])

Com a métrica MAPE, para este 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: Marcar o modelo e salvar os resultados da previsão

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

Faça previsões com o Predict Transformer

Agora, você pode carregar o modelo e usá-lo para fazer previsões. Os usuários podem operacionalizar modelos de aprendizado de máquina com o PREDICT, uma função escalável do Microsoft Fabric que oferece suporte à pontuação em lote em qualquer mecanismo de computação. Saiba mais sobre PREDICTo e como usá-lo 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.")

Partilhar via

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

Pré-requisitos

Acompanhe num caderno

Abra o bloco de notas incorporado

Importar o bloco de anotações do GitHub

Etapa 1: Instalar bibliotecas personalizadas

Passo 2: Carregue os dados

Conjunto de dados

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

Configurar o acompanhamento do experimento MLflow

Leia os dados brutos de data da casa do lago

Etapa 3: Iniciar a análise exploratória dos dados

Conversão e filtragem de tipos

Agregação mensal

Conversão de Pyspark para Pandas

Visualização

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

Etapa 4: Treinamento e acompanhamento do modelo

Montagem do modelo

Validação cruzada

Modelo de log com MLflow

Realizar experiências

Visualize um modelo com o Prophet

Visualize tendências e sazonalidade com o Prophet

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

Faça previsões com o Predict Transformer

Comentários

Recursos adicionais

Partilhar via

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

Pré-requisitos

Acompanhe num caderno

Abra o bloco de notas incorporado

Importar o bloco de anotações do GitHub

Etapa 1: Instalar bibliotecas personalizadas

Passo 2: Carregue os dados

Conjunto de dados

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

Configurar o acompanhamento do experimento MLflow

Leia os dados brutos de data da casa do lago

Etapa 3: Iniciar a análise exploratória dos dados

Conversão e filtragem de tipos

Agregação mensal

Conversão de Pyspark para Pandas

Visualização

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

Etapa 4: Treinamento e acompanhamento do modelo

Montagem do modelo

Validação cruzada

Modelo de log com MLflow

Realizar experiências

Visualize um modelo com o Prophet

Visualize tendências e sazonalidade com o Prophet

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

Faça previsões com o Predict Transformer

Conteúdos relacionados

Comentários

Recursos adicionais