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 NYC Open Data Portal.

Prerequisiti

• Ottenere una sottoscrizione di Microsoft Fabric. In alternativa, iscriversi per ottenere una versione di valutazione di Microsoft Fabric gratuita.

• Accedere a Microsoft Fabric.

• Usare l’opzione esperienza sul lato sinistro della home page per passare all'esperienza Science di Synapse.

  

• Familiarità con 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 Synapse Data Science.
• Caricare il notebook da GitHub nell'esperienza di data science di Synapse.

Aprire il notebook predefinito

Il notebook di esempio serie temporale 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 è relativo a un'esercitazione rapida.

4. Collegare un 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 di accompagnamento per questa esercitazione, seguire le istruzioni riportate in Preparare il sistema per le esercitazioni di data science 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. Per farlo, esistono due opzioni.

1. È possibile usare le funzionalità di installazione in linea (ad esempio %pip, %conda e così 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 definizione del 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 libreria prophet. 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 NYC Department of Finance nel NYC Open Data Portal.

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	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 AFFITTI - SENZA ASCENSORE	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 AFFITTI - SENZA ASCENSORE	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

L'obiettivo è quello di creare un modello che preveda le vendite totali mensili, in base ai dati cronologici. Per questo, si usa Prophet, una libreria di previsione open source sviluppata da Facebook. Prophet si basa su un modello additivo, in cui le tendenze non lineari si adattano alla stagionalità giornaliera, settimanale e annuale e agli effetti delle festività. Il modello Prophet funziona meglio con le serie temporali con effetti stagionali forti 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 scomponibile, costituito da tre componenti:

• trend: Prophet presuppone un tasso 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: Prophet richiede tutte le occorrenze passate e future delle vacanze. Se una vacanza non si ripete in futuro, Prophet non lo includerà nella previsione.

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

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

Scaricare il set di dati e caricarlo in un lakehouse

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

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 archivia quel set di dati in un lakehouse di Fabric.

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 di MLflow

Per estendere le funzionalità di registrazione di MLflow, la registrazione 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, da cui le API MLflow o l'esperimento corrispondente nell'area di lavoro possono accedervi e visualizzarle. Visitare questa risorsa per altre informazioni sulla registrazione automatica.

# Set up the MLflow experiment
import mlflow

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

Nota

Se si desidera disabilitare la registrazione automatica di tag di Microsoft Fabric in una sessione del notebook, chiamare mlflow.autolog() e impostare disable=True.

Leggere i dati non elaborati di data 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 funzione display 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 prezzi di vendita di $0,00. 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 dati building_class_at_time_of_sale.

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

• Alcune colonne, ad esempio, apartment_number, tax_class, build_class_at_present e così 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 colonna sale_price viene archiviata come stringa, con un carattere "$" anteposto. Per procedere con l'analisi, rappresentare questa colonna come numero. È necessario eseguire il cast della colonna sale_price 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 numero intero

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 numero 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. Tali attributi includono sales_price, total_units, gross_square_feet e sales_date. È anche necessario rinominare sales_date in 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)

Aggregare i valori sale_price, total_units e gross_square_feet per mese. Raggruppare quindi i dati per month 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 di Prophet è sempre un DataFrame a due colonne. Una colonna di input è una colonna temporale denominata ds e una colonna di input è una colonna di valore denominata y. La colonna temporale deve avere un formato di dati data, ora 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 temporale in ds e la colonna valore in y e passare i dati a Prophet. 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"]

Prophet segue la convenzione scikit-learn. Creare prima di tutto una nuova istanza di Prophet, impostare determinati parametri, ad esempio seasonality_mode, 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, Prophet 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 degli intervalli di incertezza di Prophet.

• 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, vedi la documentazione sulle tendenze dei changepoint di 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

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 sottoinsieme del set di dati ed esegue test su un sottoinsieme 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 si tenta di fare previsioni 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 fare previsioni per il futuro, ossia per le regioni non visibili.

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 previsione.

In questo scenario, iniziare con 11 anni di dati di training e quindi eseguire previsioni 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 previsioni da gennaio 2014 a gennaio 2015. L'esecuzione successiva gestisce le previsioni 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 previsioni con valori reali per stabilire la qualità delle previsioni 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 registrazione 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à primaria di organizzazione e controllo per tutte le esecuzioni di Machine Learning correlate. Un'esecuzione corrisponde a una singola esecuzione del codice dei modelli. 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 Prophet 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 Prophet

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 previsione e l'area blu chiaro mostra gli intervalli di incertezza. Sono stati creati tre modelli con diversi valori 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 changepoint_prior_scale più 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 Prophet

Prophet 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 diminuiscono. 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 (MSE)
• radice errore quadratico medio (RMSE)
• errore assoluto medio (MAE)
• errore percentuale assoluto medio (MAPE)
• errore percentuale mediano assoluto (MDAPE)
• errore percentuale medio assoluto simmetrico (SMAPE)

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

display(df_metrics[BEST_MODEL_INDEX])

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

Passaggio 5: assegnare un punteggio al modello e salvare i risultati della previsione

Assegnare un punteggio al modello e salvare i risultati della previsione.

Eseguire previsioni con Predict Transformer

È ora possibile caricare il modello e usarlo per eseguire previsioni. 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 PREDICT e 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 apprendimento automatico in Microsoft Fabric
• Eseguire il training di modelli di Machine Learning
• Esperimenti di apprendimento automatico in Microsoft Fabric