Entrenamiento y evaluación de un modelo de previsión de series temporales

En este cuaderno, vamos a compilar un programa para predecir los datos de series temporales que tienen ciclos estacionales. Vamos a utilizar el conjunto de datos NYC Property Sales con fechas comprendidas entre 2003 y 2015 publicado por el Departamento de Finanzas de la ciudad de Nueva York en el Portal NYC Open Data.

Requisitos previos

• Conocer los cuadernos de Microsoft Fabric.
• Un almacén de lago para almacenar datos de este ejemplo. Para obtener más información, consulte Adición del almacén de lago al cuaderno.

Seguir en un cuaderno

Puede seguir en un bloc de notas de dos maneras:

• Abra y ejecute el cuaderno integrado en la experiencia de ciencia de datos de Synapse.
• Cargue su cuaderno desde GitHub a la experiencia de ciencia de datos de Synapse.

Abrir el cuaderno de notas integrado

El cuaderno de notas de muestra Series temporales acompaña a este tutorial.

Para abrir el cuaderno de muestra integrado en el tutorial en la experiencia de ciencia de datos de Synapse:

1. Vaya a la página principal de ciencia de datos de Synapse.

2. Seleccione Utilizar una muestra.

3. Seleccione la muestra correspondiente:

   • Desde la pestaña predeterminada Flujos de trabajo de un extremo a otro (Python), si la muestra es para un tutorial de Python.
   • Desde la pestaña Flujos de trabajo de un extremo a otro (R), si la muestra es para un tutorial de R.
   • En la pestaña Tutoriales rápidos, si la muestra es para un tutorial rápido.

4. Adjunte una instancia de LakeHouse al cuaderno antes de empezar a ejecutar código.

Importación del cuaderno desde GitHub

AIsample: Time Series Forecasting.ipynb es el cuaderno que acompaña a este tutorial.

Para abrir el cuaderno complementario para este tutorial, siga las instrucciones en Preparación del sistema para los tutoriales de ciencia de datos para importar el cuaderno en el área de trabajo.

Si prefiere copiar y pegar el código de esta página, puede crear un cuaderno nuevo.

Asegúrese de adjuntar una instancia de LakeHouse al cuaderno antes de empezar a ejecutar código.

Paso 1: Instalación de bibliotecas personalizadas

Al desarrollar un modelo de Machine Learning o realizar análisis de datos para un fin específico, es posible que tenga que instalar rápidamente una biblioteca personalizada (como prophet en este cuaderno) para la sesión de Apache Spark. Para ello, tiene dos opciones.

1. Puede utilizar las funcionalidades de instalación en línea (por ejemplo, %pip, %conda, etc.) para empezar a trabajar rápidamente con nuevas bibliotecas. Esta opción solo instalaría las bibliotecas personalizadas en el cuaderno actual y no en el área de trabajo.

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

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

2. Como alternativa, puede crear un entorno de Fabric, instalar bibliotecas desde orígenes públicos o cargar bibliotecas personalizadas en él y, después, el administrador del área de trabajo puede asociar el entorno como valor predeterminado para el área de trabajo. Todas las bibliotecas del entorno estarán disponibles para su uso en los cuadernos y las definiciones de trabajo de Spark del área de trabajo. Para obtener más información sobre los entornos, consulte Creación, configuración y uso de un entorno en Microsoft Fabric.

Para este cuaderno, usará %pip install para instalar la biblioteca prophet. El kernel de PySpark se iniciará después de %pip install. Es decir, debe instalar la biblioteca antes de ejecutar cualquier otra celda.

# Use pip to install Prophet
%pip install prophet

Paso 2: Carga de los datos

Dataset

Este cuaderno utiliza el conjunto de datos NYC Property Sales. Abarca datos de 2003 a 2015, publicados por el Departamento de Finanzas de la ciudad de Nueva York en el Portal NYC Open Data.

El conjunto de datos incluye un registro de cada venta de una edificación en el mercado inmobiliario de la ciudad de Nueva York durante un período de 13 años. Consulte el glosario de términos para archivos de ventas de inmuebles para consultar la definición de las columnas en el conjunto de datos.

borough	neighborhood	building_class_category	tax_class	block	lot	eastment	building_class_at_present	address	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	ALPHABET CITY	07 RENTALS - WALKUP APARTMENTS	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	ALPHABET CITY	07 RENTALS - WALKUP APARTMENTS	2.0	405.0	12.0		C7	508 EAST 12TH STREET		10009.0	28,0	2.0	30.0	3872.0	15428.0	1930.0	2.0	C7	7794005.0	2007-05-21

El objetivo es crear un modelo que pronostique las ventas mensuales totales en función de los datos históricos. Para ello, utilice Prophet, una biblioteca de pronóstico de código abierto desarrollada por Facebook. Prophet se basa en un modelo aditivo, donde las tendencias no lineales se ajustan con la estacionalidad diaria, semanal y anual, y con los efectos de los días festivos. Prophet funciona mejor con conjuntos de datos de series temporales que tienen efectos estacionales fuertes y varias estaciones de datos históricos. Además, Prophet controla de manera sólida los datos que faltan y los valores atípicos de datos.

Prophet utiliza un modelo de series temporales que puede descomponerse, que consta de tres componentes:

• tendencia: Prophet asume una tasa constante de crecimiento por partes, con selección automática de puntos de cambio.
• estacionalidad: De manera predeterminada, Prophet utiliza series de Fourier para ajustar la estacionalidad semanal y anual.
• días festivos: Prophet requiere todas las repeticiones pasadas y futuras de días festivos. Si un día festivo no se repite en el futuro, Prophet no lo incluirá en el pronóstico.

Este cuaderno agrega los datos mensualmente, por lo que omite los días festivos.

Lea el documento oficial para obtener más información sobre las técnicas de modelado de Prophet.

Descarga del conjunto de datos y carga en un almacén de lago

El origen de datos consta de 15 archivos .csv. Estos archivos contienen registros de ventas de inmuebles de cinco distritos en Nueva York desde 2003 a 2015. Por comodidad, el archivo nyc_property_sales.tar contiene todos estos archivos .csv, comprimidos en uno solo. Un almacenamiento de blobs disponible públicamente hospeda este archivo .tar.

Sugerencia

Con los parámetros que se muestran en esta celda de código, puede aplicar fácilmente este cuaderno a distintos conjuntos de datos.

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

El código siguiente descarga una versión disponible públicamente del conjunto de datos y lo almacena en un almacén de lago de Fabric.

Importante

Asegúrese de agregar un lago de datos al cuaderno antes de ejecutarlo. De lo contrario, se producirá un error.

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 la grabación del tiempo de ejecución de este cuaderno.

# Record the notebook running time
import time

ts = time.time()

Configuración del seguimiento del experimento de MLflow

Para ampliar las funcionalidades de registro de MLflow, el registro automático captura automáticamente los valores de los parámetros de entrada y las métricas de salida de un modelo de Machine Learning durante su entrenamiento. A continuación, esta información se registra en el área de trabajo, donde las API de MLflow o el experimento correspondiente en el área de trabajo pueden acceder a ella y visualizarla. Visite este recurso para obtener más información sobre el registro automático.

# Set up the MLflow experiment
import mlflow

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

Nota:

Si desea deshabilitar el registro automático de Microsoft Fabric en una sesión de cuaderno, llame a mlflow.autolog() y establezca disable=True.

Lectura de datos sin procesar desde el almacén de lago

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

Paso 3: Comienzo del análisis de datos exploratorios

Para revisar el conjunto de datos, podría examinar manualmente un subconjunto de los datos para comprenderlos mejor. Puede utilizar la función display para imprimir el DataFrame. También puede mostrar las vistas de gráfico para visualizar fácilmente los subconjuntos del conjunto de datos.

display(df)

Una revisión manual del conjunto de datos conduce a algunas observaciones tempranas:

• Instancias de precios de ventas de 0,00 USD. Según el glosario de términos, esto implica una transferencia de la propiedad sin contraprestación en efectivo. En otras palabras, en la transacción no hubo ningún flujo de efectivo. Debe quitar del conjunto de datos las ventas con valores de sales_price de 0,00 USD.

• El conjunto de datos abarca diferentes clases de edificios. Sin embargo, este cuaderno se centrará en edificios residenciales que, según el glosario de términos, se marcan como de tipo “A”. Debe filtrar el conjunto de datos para incluir solo edificios residenciales. Para ello, incluya las columnas building_class_at_time_of_sale o building_class_at_present. Solo debe incluir los datos de building_class_at_time_of_sale.

• El conjunto de datos incluye instancias en las que los valores de total_units son iguales a 0, o valores de gross_square_feet iguales a 0. Debe quitar todas las instancias en las que los valores de total_units o gross_square_units sean iguales a 0.

• Algunas columnas (por ejemplo, apartment_number, tax_class, build_class_at_present, etc.) tienen valores que faltan o son NULL. Vamos a suponer que los datos que faltan implican errores administrativos o datos inexistentes. El análisis no depende de estos valores que faltan, por lo que puede omitirlos.

• La columna sale_price se almacena como cadena, con un carácter “$” antepuesto. Para continuar con el análisis, represente esta columna como número. Debe convertir la columna sale_price a entero.

Conversión y filtrado de tipos

Para resolver algunos de los problemas identificados, importe las bibliotecas necesarias.

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

Conversión de los datos de ventas de cadena a entero

Use expresiones regulares para separar la parte numérica de la cadena del signo de dólar (por ejemplo, en la cadena “$300,000”, divida “$” y “300,000”) y, a continuación, convierta la parte numérica a entero.

A continuación, filtre los datos para incluir solo instancias que cumplan todas estas condiciones:

1. sales_price es mayor que 0
2. total_units es mayor que 0
3. gross_square_feet es mayor que 0
4. building_class_at_time_of_sale es de 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%"'
)

Agregación mensual

El recurso de datos realiza un seguimiento de las ventas de inmuebles a diario, pero este enfoque es demasiado granular para este cuaderno. En su lugar, agregue los datos mensuales.

En primer lugar, cambie los valores de fecha para mostrar solo los datos de mes y año. Los valores de fecha todavía incluirían los datos del año. Todavía podría distinguir entre, por ejemplo, diciembre de 2005 y diciembre de 2006.

Además, solo mantenga las columnas pertinentes para el análisis. Estas incluyen sales_price, total_units, gross_square_feet y sales_date. También debe cambiar el nombre de sales_date a 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 los valores de sale_price, total_units y gross_square_feet por mes. Luego, agrupe los datos por month y sume todos los valores 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)

Conversión de Pyspark a Pandas

Los DataFrames de Pyspark controlan bien grandes conjuntos de datos. Sin embargo, debido a la agregación de datos, el tamaño de DataFrame es menor. Esto sugiere que ahora puede usar DataFrames de Pandas.

Este código convierte el conjunto de datos de un DataFrame de Pyspark a un DataFrame de Pandas.

import pandas as pd

df_pandas = summary_df.toPandas()
display(df_pandas)

Visualización

Puede examinar la tendencia del comercio inmobiliario de la ciudad de Nueva York para comprender mejor los datos. Esto lleva a información sobre posibles patrones y tendencias de estacionalidad. Obtenga más información sobre la visualización de datos de Microsoft Fabric en este 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()

Resumen de las observaciones del análisis de datos exploratorios

• Los datos muestran un claro patrón recurrente con una cadencia anual; esto significa que los datos tienen una estacionalidad anual.
• Los meses de verano parecen tener mayores volúmenes de ventas en comparación con los meses de invierno.
• En una comparación entre años con ventas altas y años con ventas bajas, la diferencia de ingresos entre los meses de ventas altas y los meses de ventas bajas en años de ventas altas supera —en términos absolutos— la diferencia de ingresos entre los meses de ventas altas y los meses de ventas bajas en los años de ventas bajas.

Por ejemplo, en 2004, la diferencia de ingresos entre el mes de ventas más altas y el mes de ventas más bajas es aproximadamente:

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

Para 2011, ese cálculo de la diferencia de ingresos es aproximadamente:

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

Esto se vuelve importante más adelante, cuando debe decidir entre efectos de estacionalidad multiplicativos y aditivos.

Paso 4: Entrenamiento y seguimiento del modelo

Ajuste del modelo

La entrada de Prophet siempre es un DataFrame de dos columnas. Una columna de entrada es una columna de hora denominada ds, y una columna de entrada es una columna de valor denominada y. La columna de hora debe tener un formato de datos de fecha, hora o fecha y hora (por ejemplo, YYYY_MM). El conjunto de datos aquí cumple esa condición. La columna de valor debe tener un formato de datos numérico.

Para el ajuste del modelo, solo debe cambiar el nombre de la columna de hora a ds, la columna de valor a y y pasar los datos a Prophet. Para obtener más información, consulte la documentación de la API Prophet para Python.

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

Prophet sigue la convención Scikit-learn. En primer lugar, cree una nueva instancia de Prophet, establezca determinados parámetros (por ejemplo, seasonality_mode) y, a continuación, ajuste esa instancia al conjunto de datos.

• Aunque un factor aditivo constante es el efecto de estacionalidad predeterminado para Prophet, debe usar la estacionalidad “multiplicativa” para el parámetro de efecto estacionalidad. El análisis de la sección anterior mostró que, debido a los cambios en la amplitud de la estacionalidad, una estacionalidad aditiva simple no ajustará bien los datos en absoluto.

• Desactive el parámetro weekly_seasonality, ya que los datos se agregaron por mes. Como consecuencia, los datos semanales no están disponibles.

• Use los métodos de Montecarlo basados en cadenas de Markov (MCMC) para capturar las estimaciones de incertidumbre de estacionalidad. De manera predeterminada, Prophet puede proporcionar estimaciones de incertidumbre en relación con el ruido de tendencia y observación, pero no para la estacionalidad. Los métodos MCMC requieren más tiempo de procesamiento, pero permiten que el algoritmo proporcione estimaciones de incertidumbre sobre la estacionalidad y el ruido de tendencia y observación. Para obtener más información, lea la documentación sobre los intervalos de incertidumbre de Prophet.

• Ajuste la sensibilidad de detección automática de puntos de cambio mediante el parámetro changepoint_prior_scale. El algoritmo de Prophet intenta buscar automáticamente instancias en los datos donde las trayectorias cambian de manera abrupta. Puede resultar difícil encontrar el valor correcto. Para resolverlo, puede probar valores diferentes y, a continuación, seleccionar el modelo con el mejor rendimiento. Para obtener más información, lea la documentación sobre los puntos de cambio de tendencias de 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

Validación cruzada

Prophet tiene una herramienta integrada de validación cruzada. Esta herramienta puede calcular el error de pronóstico y encontrar el modelo con el mejor rendimiento.

La técnica de validación cruzada puede validar la eficacia del modelo. Esta técnica entrena el modelo con un subconjunto del conjunto de datos y ejecuta pruebas en un subconjunto previamente no visto del conjunto de datos. Esta técnica puede comprobar qué tanto sirve un modelo estadístico para generalizar un conjunto de datos independiente.

Para la validación cruzada, reserve una muestra determinada del conjunto de datos, que no formaba parte del conjunto de datos de entrenamiento. A continuación, pruebe el modelo entrenado con ese ejemplo, antes de la implementación. Sin embargo, este enfoque no funciona para los datos de series temporales, ya que si el modelo ha visto datos de los meses de enero de 2005 y marzo de 2005 e intenta predecir para el mes de febrero de 2005, el modelo puede simplemente hacer trampa, ya que podría ver adónde conducen las tendencias de datos. En las aplicaciones reales, el objetivo es pronosticar el futuro, como las regiones no vistas.

Para controlar esto y hacer que la prueba sea confiable, divida el conjunto de datos en función de las fechas. Utilice el conjunto de datos hasta una fecha determinada (por ejemplo, los primeros 11 años de datos) para el entrenamiento y, luego, utilice los datos restantes no vistos para la predicción.

En este escenario, comience con 11 años de datos de entrenamiento y, luego, haga predicciones mensuales con un horizonte de un año. En concreto, los datos de entrenamiento contienen todo entre 2003 y 2013. Luego, la primera ejecución controla las predicciones de enero de 2014 a enero de 2015. La siguiente ejecución controla las predicciones de febrero de 2014 a febrero de 2015, etc.

Repita este proceso para cada uno de los tres modelos entrenados para ver qué modelo funciona mejor. A continuación, compare estas predicciones con los valores reales para establecer la calidad de predicción del mejor 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

Registro de un modelo con MLflow

Registre los modelos para hacer un seguimiento de sus parámetros y guarde los modelos para su uso posterior. Toda la información pertinente de los modelos se registra en el área de trabajo bajo el nombre del experimento. El modelo, los parámetros y las métricas, junto con los elementos de registro automático de MLflow, se guardan en una ejecución de MLflow.

# Setup MLflow
from mlflow.models.signature import infer_signature

Realización de experimentos

Un experimento de aprendizaje automático sirve como unidad principal de organización y control para todas las ejecuciones de aprendizaje automático relacionadas. Una ejecución corresponde a una única ejecución del código del modelo. El seguimiento de experimentos de aprendizaje automático hace referencia a la administración de todos los diferentes experimentos y sus componentes. Esto incluye parámetros, métricas, modelos y otros artefactos, y ayuda a organizar los componentes necesarios de un experimento de aprendizaje automático específico. El seguimiento de experimentos de aprendizaje automático también permite la duplicación sencilla de los resultados pasados con experimentos guardados. Obtenga más información sobre los experimentos de aprendizaje automático en Microsoft Fabric. Una vez que decida los pasos que quiere incluir (por ejemplo, ajuste y evaluación del modelo de Prophet en este cuaderno), puede ejecutar el 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)

Visualización de un modelo con Prophet

Prophet tiene funciones de visualización integradas, que pueden mostrar los resultados del ajuste de un modelo.

Los puntos negros indican los puntos de datos que se utilizan para entrenar el modelo. La línea azul es la predicción, y el área en azul claro muestra los intervalos de incertidumbre. Creó tres modelos con distintos valores de changepoint_prior_scale. Las predicciones de estos tres modelos se muestran en los resultados de este bloque 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]}")

El valor de changepoint_prior_scale más pequeño en el primer gráfico lleva a un ajuste deficiente de los cambios de tendencia. El valor de changepoint_prior_scale más grande en el tercer gráfico podría dar lugar a un sobreajuste. Por lo tanto, el segundo gráfico parece ser la opción óptima. Esto conlleva que el segundo modelo sea el más adecuado.

Visualización de tendencias y estacionalidad con Prophet

Prophet también puede visualizar fácilmente las tendencias y estacionalidades subyacentes. Las visualizaciones del segundo modelo se muestran en los resultados de este bloque 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)

En estos gráficos, el sombreado azul claro refleja la incertidumbre. En el gráfico superior se muestra una tendencia oscilante fuerte y de periodo largo. A lo largo de algunos años, los volúmenes de ventas suben y bajan. En el gráfico inferior se muestra que las ventas tienden a alcanzar el pico en febrero y septiembre, y alcanzan sus valores máximos del año en esos meses. Poco después de esos meses, en marzo y octubre, caen a los valores mínimos del año.

Evalúe el rendimiento de los modelos mediante varias métricas, por ejemplo:

• error cuadrático medio (ECM)
• raíz del error cuadrático medio (RMSE)
• error absoluto medio (MAE)
• error porcentual absoluto medio (MAPE)
• error porcentual absoluto mediano (MDAPE)
• error porcentual absoluto medio simétrico (SMAPE)

Evalúe la cobertura con las estimaciones yhat_lower y yhat_upper. Tenga en cuenta los distintos horizontes en los que se predice un año en el futuro, 12 veces.

display(df_metrics[BEST_MODEL_INDEX])

Con la métrica MAPE, para este modelo de pronóstico, las predicciones que se extienden un mes en el futuro suelen implicar errores de aproximadamente el 8 %. Sin embargo, para las predicciones un año hacia el futuro, el error aumenta aproximadamente al 10 %.

Paso 5: Puntuación del modelo y guardado de los resultados de las predicciones

Ahora puntúe el modelo y guarde los resultados de la predicción.

Realización de predicciones con Predict Transformer

Ahora puede cargar el modelo y utilizarlo para hacer predicciones. Los usuarios pueden poner en marcha modelos de Machine Learning con una función escalable de Microsoft Fabric denominada PREDICT, que admite la puntuación por lotes en cualquier motor de proceso. Para obtener más información sobre PREDICT y cómo se usa en 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.")

Contenido relacionado

• Modelo de Machine Learning en Microsoft Fabric
• Entrenamiento de modelos de Machine Learning
• Experimentos de aprendizaje automático en Microsoft Fabric