Eseguire il training e la valutazione di un modello di previsione delle serie temporali

In questo notebook viene creato un programma per prevedere i dati delle serie temporali con cicli stagionali. Viene usato il set di dati NYC Property Sales con date comprese tra il 2003 e il 2015 pubblicato da NYC Department of Finance nel portale di New York Open Data.

Prerequisiti

• Familiarità con i notebook di Microsoft Fabric.
• Lakehouse per archiviare i dati per questo esempio. Per altre informazioni, vedere Aggiungere un lakehouse al notebook.

Seguire la procedura in un notebook

È possibile seguire la procedura in un notebook in uno dei due modi seguenti:

• Aprire ed eseguire il notebook predefinito nell'esperienza di data science di Synapse.
• Caricare il notebook da GitHub nell'esperienza di data science di Synapse.

Aprire il notebook predefinito

Il notebook time series di esempio accompagna questa esercitazione.

Per aprire il notebook di esempio predefinito dell'esercitazione nell'esperienza di data science di Synapse:

1. Passare alla home page di Synapse Data Science.

2. Selezionare Usa un esempio.

3. Selezionare l'esempio corrispondente:

   • Dalla scheda predefinita Flussi di lavoro end-to-end (Python), se l'esempio è relativo a un'esercitazione su Python.
   • Dalla scheda Flussi di lavoro end-to-end (R), se l'esempio è relativo a un'esercitazione su R.
   • Dalla scheda Esercitazioni rapide, se l'esempio è per un'esercitazione rapida.

4. Collegare una lakehouse al notebook prima di iniziare a eseguire il codice.

Importare il notebook da GitHub

AIsample - Time Series Forecasting.ipynb è il notebook che accompagna questa esercitazione.

Per aprire il notebook a accompagnamento per questa esercitazione, seguire le istruzioni riportate in Preparare il sistema per le esercitazioni sull'analisi scientifica dei dati per importare il notebook nell'area di lavoro.

Se si preferisce copiare e incollare il codice da questa pagina, è possibile creare un nuovo notebook.

Assicurarsi di collegare un lakehouse al notebook prima di iniziare a eseguire il codice.

Passaggio 1: Installare librerie personalizzate

Quando si sviluppa un modello di Machine Learning o si gestisce l'analisi dei dati ad hoc, potrebbe essere necessario installare rapidamente una libreria personalizzata (ad esempio, prophet in questo notebook) per la sessione di Apache Spark. A tale scopo, sono disponibili due opzioni.

1. È possibile usare le funzionalità di installazione in linea (ad esempio, %pip, e %condacosì via) per iniziare rapidamente a usare nuove librerie. In questo modo verranno installate solo le librerie personalizzate nel notebook corrente, non nell'area di lavoro.

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

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

2. In alternativa, è possibile creare un ambiente fabric, installare librerie da origini pubbliche o caricarvi librerie personalizzate e quindi l'amministratore dell'area di lavoro può collegare l'ambiente come predefinito per l'area di lavoro. Tutte le librerie nell'ambiente diventano quindi disponibili per l'uso in qualsiasi notebook e definizioni di processo Spark nell'area di lavoro. Per altre informazioni sugli ambienti, vedere Creare, configurare e usare un ambiente in Microsoft Fabric.

Per questo notebook si usa %pip install per installare la prophet libreria. Il kernel PySpark verrà riavviato dopo %pip install. Ciò significa che è necessario installare la libreria prima di eseguire qualsiasi altra cella.

# Use pip to install Prophet
%pip install prophet

Passaggio 2: Caricare i dati

Set di dati

Questo notebook usa il set di dati NYC Property Sales. Vengono trattati i dati dal 2003 al 2015, pubblicati dal Dipartimento di Finanza di New York nel portale dei dati aperti di New York.

Il set di dati include un record di ogni vendita di edifici nel mercato immobiliare di New York City, entro un periodo di 13 anni. Per una definizione delle colonne nel set di dati, vedere il glossario dei termini per i file di vendita delle proprietà.

borough	quartiere	building_class_category	tax_class	block	tanto	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 AFFITTI - SENZA ASCENSORE	0.0	384.0	17.0		C4	225 EAST 2ND STR edizione Enterprise T		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 AFFITTI - SENZA ASCENSORE	2.0	405.0	12.0		C7	508 EAST 12TH STR edizione Enterprise T		10009.0	28.0	2.0	30.0	3872.0	15428.0	1930.0	2.0	C7	7794005.0	2007-05-21

L'obiettivo è quello di creare un modello che prevede le vendite totali mensili, in base ai dati cronologici. Per questo, si usa Profeta, una libreria di previsione open source sviluppata da Facebook. Il Profeta si basa su un modello additivio, in cui le tendenze non lineari si adattano alla stagionalità giornaliera, settimanale e annuale e agli effetti delle festività. Prophet funziona meglio sui set di dati delle serie temporali con forti effetti stagionali e diverse stagioni di dati cronologici. Inoltre, Prophet gestisce in modo affidabile i dati mancanti e gli outlier dei dati.

Prophet usa un modello di serie temporale scomposbile, costituito da tre componenti:

• trend: Profeta presuppone un tasso costante costante di crescita, con la selezione automatica dei punti di cambiamento
• stagionalità: per impostazione predefinita, Prophet usa Fourier Series per adattarsi alla stagionalità settimanale e annuale
• vacanze: profeta richiede tutte le occorrenze passate e future delle vacanze. Se una vacanza non si ripete in futuro, il Profeta non lo includerà nella previsione.

Questo notebook aggrega i dati su base mensile, quindi ignora le festività.

Per altre informazioni sulle tecniche di modellazione del Profeta, leggere il documento ufficiale.

Scaricare il set di dati e caricarlo in un lakehouse

L'origine dati è costituita da 15 .csv file. Questi file contengono i record di vendita delle proprietà di cinque distretti di New York, tra il 2003 e il 2015. Per praticità, il nyc_property_sales.tar file contiene tutti questi .csv file, comprimendoli in un unico file. Un archivio BLOB disponibile pubblicamente ospita questo .tar file.

Suggerimento

Con i parametri mostrati in questa cella di codice, è possibile applicare facilmente questo notebook a set di dati diversi.

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

Questo codice scarica una versione disponibile pubblicamente del set di dati e quindi archivia tale set di dati in un'infrastruttura Lakehouse.

Importante

Assicurarsi di aggiungere un lakehouse al notebook prima di eseguirlo. In caso contrario, verrà generato un errore.

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

Avviare la registrazione del runtime di questo notebook.

# Record the notebook running time
import time

ts = time.time()

Configurare il rilevamento dell'esperimento MLflow

Per estendere le funzionalità di registrazione di MLflow, l'assegnazione automatica acquisisce automaticamente i valori dei parametri di input e le metriche di output di un modello di Machine Learning durante il training. Queste informazioni vengono quindi registrate nell'area di lavoro, in cui le API MLflow o l'esperimento corrispondente nell'area di lavoro possono accedervi e visualizzarlo. Visitare questa risorsa per altre informazioni sull'assegnazione automatica dei tag.

# Set up the MLflow experiment
import mlflow

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

Nota

Se si vuole disabilitare l'assegnazione automatica di tag di Microsoft Fabric in una sessione del notebook, chiamare mlflow.autolog() e impostare disable=True.

Leggere i dati di data non elaborati dal lakehouse

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

Passaggio 3: Iniziare l'analisi esplorativa dei dati

Per esaminare il set di dati, è possibile esaminare manualmente un sottoinsieme di dati per ottenere una migliore comprensione. È possibile usare la display funzione per stampare il dataframe. È anche possibile visualizzare le visualizzazioni grafico per visualizzare facilmente i subset del set di dati.

display(df)

Una revisione manuale del set di dati porta ad alcune osservazioni iniziali:

• Istanze di $0,00 prezzi di vendita. Secondo il glossario dei termini, ciò implica un trasferimento di proprietà senza considerazioni in denaro. In altre parole, nessun flusso di cassa nella transazione. È consigliabile rimuovere le vendite con valori $0,00 sales_price dal set di dati.

• Il set di dati copre diverse classi di compilazione. Tuttavia, questo notebook si concentrerà sugli edifici residenziali che, in base al glossario dei termini, sono contrassegnati come tipo "A". È necessario filtrare il set di dati in modo da includere solo edifici residenziali. A tale scopo, includere le building_class_at_time_of_sale colonne o building_class_at_present . È necessario includere solo i building_class_at_time_of_sale dati.

• Il set di dati include istanze in cui total_units i valori sono uguali a 0 o gross_square_feet valori uguali a 0. È necessario rimuovere tutte le istanze in cui total_units o gross_square_units i valori sono uguali a 0.

• Alcune colonne, ad esempio , apartment_numbertax_class, e build_class_at_presentcosì via, contengono valori NULL o mancanti. Si supponga che i dati mancanti comportino errori clericali o dati inesistenti. L'analisi non dipende da questi valori mancanti, quindi è possibile ignorarli.

• La sale_price colonna viene archiviata come stringa, con un carattere "$" anteporto. Per procedere con l'analisi, rappresentare questa colonna come numero. È necessario eseguire il cast della sale_price colonna come numero intero.

Conversione e filtro dei tipi

Per risolvere alcuni dei problemi identificati, importare le librerie necessarie.

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

Eseguire il cast dei dati di vendita da stringa a integer

Usare espressioni regolari per separare la parte numerica della stringa dal segno di dollaro (ad esempio, nella stringa "$300.000", dividere "$" e "300.000") e quindi eseguire il cast della parte numerica come intero.

Filtrare quindi i dati in modo da includere solo le istanze che soddisfano tutte queste condizioni:

1. è sales_price maggiore di 0
2. è total_units maggiore di 0
3. è gross_square_feet maggiore di 0
4. è building_class_at_time_of_sale di 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%"'
)

Aggregazione mensile

La risorsa dati tiene traccia delle vendite di proprietà su base giornaliera, ma questo approccio è troppo granulare per questo notebook. Aggregare invece i dati su base mensile.

Prima di tutto, modificare i valori di data in modo da visualizzare solo i dati relativi a mese e anno. I valori di data includono comunque i dati dell'anno. È comunque possibile distinguere tra dicembre 2005 e dicembre 2006.

Inoltre, mantenere solo le colonne rilevanti per l'analisi. Questi includono sales_price, gross_square_feettotal_unitse sales_date. È anche necessario rinominare sales_datemonthin .

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)

Aggregare i sale_pricevalori e total_unitsgross_square_feet per mese. Raggruppare quindi i dati in monthbase a e sommare tutti i valori all'interno di ogni gruppo.

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)

Conversione da Pyspark a Pandas

I dataframe Pyspark gestiscono bene set di dati di grandi dimensioni. Tuttavia, a causa dell'aggregazione dei dati, le dimensioni del dataframe sono inferiori. Ciò suggerisce che è ora possibile usare i dataframe pandas.

Questo codice esegue il cast del set di dati da un dataframe pyspark a un dataframe pandas.

import pandas as pd

df_pandas = summary_df.toPandas()
display(df_pandas)

Visualizzazione

È possibile esaminare la tendenza del commercio immobiliare di New York City per comprendere meglio i dati. Ciò porta a dati analitici su potenziali modelli e tendenze di stagionalità. Altre informazioni sulla visualizzazione dei dati di Microsoft Fabric sono disponibili in questa risorsa.

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()

Riepilogo delle osservazioni dell'analisi esplorativa dei dati

• I dati mostrano un chiaro modello ricorrente su cadenza annuale; ciò significa che i dati hanno una stagionalità annuale
• I mesi estivi sembrano avere volumi di vendita più elevati rispetto ai mesi invernali
• In un confronto di anni con vendite elevate e anni con vendite basse, la differenza di ricavi tra i mesi di vendita elevati e i mesi di vendita bassi negli anni di vendita elevati supera - in termini assoluti - la differenza di ricavi tra mesi di vendita elevati e mesi di vendita bassi in anni di vendita bassi.

Ad esempio, nel 2004, la differenza di ricavi tra il mese di vendita più alto e il mese di vendita più basso è circa:

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

Per il 2011, il calcolo della differenza di ricavi riguarda:

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

Questo diventa importante in seguito, quando è necessario decidere tra effetti di stagionalità moltiplicativi e additivi .

Passaggio 4: Training e rilevamento del modello

Adattamento del modello

L'input profeta è sempre un dataframe a due colonne. Una colonna di input è una colonna temporale denominata dse una colonna di input è una colonna di valore denominata y. La colonna time deve avere un formato di dati date, time o datetime, ad esempio YYYY_MM. Il set di dati soddisfa tale condizione. La colonna del valore deve essere un formato dati numerico.

Per l'adattamento del modello, è necessario rinominare solo la colonna time in e la colonna dsyvalore in e passare i dati al Profeta. Per altre informazioni, vedere la documentazione dell'API Prophet Python.

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

Profeta segue la convenzione scikit-learn . Creare prima di tutto una nuova istanza di Prophet, impostare determinati parametri (ad esempio,seasonality_mode ) e quindi adattarla al set di dati.

• Sebbene un fattore aggiuntivo costante sia l'effetto stagionalità predefinito per Prophet, è consigliabile usare la stagionalità moltiplicativa per il parametro dell'effetto stagionalità. L'analisi nella sezione precedente ha mostrato che, a causa delle variazioni nell'ampiezza della stagionalità, una semplice stagionalità additiva non si adatta affatto ai dati.

• Impostare il parametro weekly_seasonality su disattivato, perché i dati sono stati aggregati per mese. Di conseguenza, i dati settimanali non sono disponibili.

• Utilizzare i metodi Markov Chain Monte Carlo (MCMC) per acquisire le stime dell'incertezza stagionalità. Per impostazione predefinita, Profeta può fornire stime di incertezza sulla tendenza e sul rumore di osservazione, ma non per la stagionalità. MCMC richiede più tempo di elaborazione, ma consente all'algoritmo di fornire stime di incertezza sulla stagionalità e il rumore di tendenza e osservazione. Per altre informazioni, vedere la documentazione relativa agli intervalli di incertezza del Profeta.

• Ottimizzare la sensibilità di rilevamento automatico dei punti di modifica tramite il parametro changepoint_prior_scale . L'algoritmo Prophet tenta automaticamente di trovare istanze nei dati in cui le traiettorie cambiano improvvisamente. Può diventare difficile trovare il valore corretto. Per risolvere questo problema, è possibile provare valori diversi e quindi selezionare il modello con le migliori prestazioni. Per altre informazioni, vedere la documentazione relativa ai punti di modifica di tendenza del Profeta.

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

Convalida incrociata

Prophet ha uno strumento di convalida incrociata predefinito. Questo strumento può stimare l'errore di previsione e trovare il modello con le migliori prestazioni.

La tecnica di convalida incrociata può convalidare l'efficienza del modello. Questa tecnica esegue il training del modello su un subset del set di dati ed esegue test su un subset precedentemente non visibile del set di dati. Questa tecnica può controllare l'integrità di un modello statistico generalizzato in un set di dati indipendente.

Per la convalida incrociata, riservare un particolare campione del set di dati, che non fa parte del set di dati di training. Testare quindi il modello sottoposto a training su tale esempio, prima della distribuzione. Tuttavia, questo approccio non funziona per i dati delle serie temporali, perché se il modello ha visto dati dai mesi di gennaio 2005 e marzo 2005 e marzo 2005 e si tenta di stimare per il mese febbraio 2005, il modello può essenzialmente ingannare, perché potrebbe vedere dove conduce la tendenza dei dati. In applicazioni reali, l'obiettivo è quello di prevedere il futuro, come le regioni invisibile.

Per gestirlo e rendere affidabile il test, suddividere il set di dati in base alle date. Usare il set di dati fino a una determinata data (ad esempio, i primi 11 anni di dati) per il training e quindi usare i dati rimanenti non visualizzati per la stima.

In questo scenario, iniziare con 11 anni di dati di training e quindi eseguire stime mensili usando un orizzonte di un anno. In particolare, i dati di training contengono tutti gli elementi dal 2003 al 2013. La prima esecuzione gestisce quindi le stime da gennaio 2014 a gennaio 2015. L'esecuzione successiva gestisce le stime da febbraio 2014 a febbraio 2015 e così via.

Ripetere questo processo per ognuno dei tre modelli sottoposti a training per vedere quale modello offre prestazioni ottimali. Confrontare quindi queste stime con valori reali per stabilire la qualità della stima del modello migliore.

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

Modello di log con MLflow

Registrare i modelli per tenere traccia dei relativi parametri e salvare i modelli per usarli in un secondo momento. Tutte le informazioni pertinenti sul modello vengono registrate nell'area di lavoro, sotto il nome dell'esperimento. Il modello, i parametri e le metriche, insieme agli elementi di assegnazione automatica di MLflow, viene salvato in un'esecuzione MLflow.

# Setup MLflow
from mlflow.models.signature import infer_signature

Condurre esperimenti

Un esperimento di Machine Learning funge da unità principale dell'organizzazione e del controllo per tutte le esecuzioni di Machine Learning correlate. Un'esecuzione corrisponde a una singola esecuzione del codice del modello. Il rilevamento degli esperimenti di Machine Learning si riferisce alla gestione di tutti i diversi esperimenti e dei relativi componenti. Sono inclusi parametri, metriche, modelli e altri artefatti e consente di organizzare i componenti necessari di un esperimento di Machine Learning specifico. Il rilevamento degli esperimenti di Machine Learning consente anche la facile duplicazione dei risultati precedenti con esperimenti salvati. Altre informazioni sugli esperimenti di Machine Learning in Microsoft Fabric. Dopo aver determinato i passaggi da includere (ad esempio, adattando e valutando il modello Profeta in questo notebook), è possibile eseguire l'esperimento.

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)

Visualizzare un modello con Profeta

Prophet ha funzioni di visualizzazione predefinite, che possono mostrare i risultati dell'adattamento del modello.

I punti neri indicano i punti dati usati per eseguire il training del modello. La linea blu è la stima e l'area blu chiaro mostra gli intervalli di incertezza. Sono stati creati tre modelli con valori diversi changepoint_prior_scale . Le stime di questi tre modelli vengono visualizzate nei risultati di questo blocco di codice.

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

Il valore più changepoint_prior_scale piccolo nel primo grafico porta a un'underfitting delle variazioni di tendenza. Il più grande changepoint_prior_scale nel terzo grafico potrebbe comportare l'overfitting. Quindi, il secondo grafico sembra essere la scelta ottimale. Ciò implica che il secondo modello è il più adatto.

Visualizzare le tendenze e la stagionalità con il Profeta

Il Profeta può anche visualizzare facilmente le tendenze e le stagionalità sottostanti. Le visualizzazioni del secondo modello vengono visualizzate nei risultati di questo blocco di codice.

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

In questi grafici, l'ombreggiatura blu chiaro riflette l'incertezza. Il grafico superiore mostra una tendenza oscillante forte e lunga. Nel corso di alcuni anni, i volumi di vendita aumentano e diminuiscno. Il grafico inferiore mostra che le vendite tendono a raggiungere il picco nel mese di febbraio e settembre, raggiungendo i valori massimi per l'anno in quei mesi. Poco dopo questi mesi, a marzo e ottobre, scendono ai valori minimi dell'anno.

Valutare le prestazioni dei modelli usando diverse metriche, ad esempio:

• errore quadratico medio (M edizione Standard)
• radice errore quadratico medio (RM edizione Standard)
• errore assoluto medio (MAE)
• errore di percentuale assoluta media (MAPE)
• median absolute percent error (MDAPE)
• errore percentuale assoluta media simmetrica (SMAPE)

Valutare la copertura usando le yhat_lower stime e yhat_upper . Si notino i diversi orizzonti in cui si stima un anno in futuro, 12 volte.

display(df_metrics[BEST_MODEL_INDEX])

Con la metrica MAPE, per questo modello di previsione, le stime che estendono un mese nel futuro in genere comportano errori di circa l'8%. Tuttavia, per le stime di un anno in futuro, l'errore aumenta a circa il 10%.

Passaggio 5: Assegnare un punteggio al modello e salvare i risultati della stima

Assegnare ora un punteggio al modello e salvare i risultati della stima.

Eseguire stime con Predict Transformer

È ora possibile caricare il modello e usarlo per eseguire stime. Gli utenti possono rendere operativi i modelli di Machine Learning con PREDICT, una funzione scalabile di Microsoft Fabric che supporta l'assegnazione dei punteggi batch in qualsiasi motore di calcolo. Altre informazioni su PREDICTe su come usarlo all'interno di Microsoft Fabric, in questa risorsa.

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

Contenuto correlato

• Modello di Machine Learning in Microsoft Fabric
• Eseguire il training di modelli di Machine Learning
• Esperimenti di Machine Learning in Microsoft Fabric