Addestrare e valutare un modello di previsione delle serie temporali

In questo notebook si crea un programma per prevedere i dati delle serie temporali con cicli stagionali. Usare il set di dati NYC Property Sales con date comprese tra il 2003 e il 2015 pubblicato dal Dipartimento di New York Finance nel portale NYC Open Data Portal.

Prerequisiti

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

• Accedere a Microsoft Fabric.

• Passare a Fabric usando il commutatore dell'esperienza in basso a sinistra della tua home page.

  

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

Segui con un blocco per appunti

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

• Aprire ed eseguire il notebook predefinito.
• Caricare il notebook da GitHub.

Aprire il notebook predefinito

Il notebook di esempio Serie Temporale accompagna questa esercitazione.

1. Per aprire il notebook di esempio per questa esercitazione, seguire le istruzioni riportate in Preparare il sistema per le esercitazioni sull'analisi scientifica dei dati.

2. Assicurati di 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 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.

• Assicurati 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 fare questo compito, hai due opzioni.

1. Usare le funzionalità di installazione integrata (ad esempio, %pip, %conda e così via) per iniziare rapidamente con nuove librerie. Questo metodo installa le librerie personalizzate solo 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>

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

Per questo notebook, usare %pip install per installare la prophet libreria. Il kernel PySpark viene riavviato dopo %pip install. Questa azione 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 utilizza l'insieme di dati delle vendite immobiliari di New York City. Vengono trattati i dati dal 2003 al 2015, pubblicati dal Dipartimento di New York Finance nel portale 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 Glossario dei termini per i file di vendita delle proprietà.

L'obiettivo è quello di creare un modello che preveda le vendite totali mensili, in base ai dati cronologici. A questo scopo, 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 robusto i dati mancanti e gli outlier.

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

• trend: Prophet considera un tasso di crescita costante a tratti, con 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 blob storage disponibile pubblicamente ospita questo file .tar.

URL = "https://synapseaisolutionsa.z13.web.core.windows.net/data/NYC_Property_Sales_Dataset/"
TAR_FILE_NAME = "nyc_property_sales.tar"
DATA_FOLDER = "Files/NYC_Property_Sales_Dataset"
TAR_FILE_PATH = f"/lakehouse/default/{DATA_FOLDER}/tar/"
CSV_FILE_PATH = f"/lakehouse/default/{DATA_FOLDER}/csv/"

EXPERIMENT_NAME = "aisample-timeseries" # MLflow experiment name

Questo codice scarica una versione disponibile pubblicamente del set di dati e archivia quel set di dati in un lakehouse di Fabric.

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

Avvia 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, l'autologging cattura automaticamente i valori dei parametri di input e delle metriche di output di un modello di machine learning durante l'addestramento. Queste informazioni vengono quindi registrate nell'area di lavoro, in cui le API MLflow o l'esperimento corrispondente nell'area di lavoro possono access e visualizzarle. Per altre informazioni sulla registrazione automatica, vedere Autologging in Microsoft Fabric.

# Set up the MLflow experiment
import mlflow

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

Leggere i dati grezzi 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, esaminare manualmente un subset di dati per ottenere una migliore comprensione. Usare la display funzione per stampare il dataframe. È anche possibile mostrare le viste grafiche per visualizzare facilmente i sottoinsiemi del set di dati.

display(df)

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

• Casi di prezzo di vendita di $0,00. Secondo il Glossario delle Condizioni, questo valore implica un trasferimento di proprietà senza alcuna considerazione in denaro. In altre parole, nessun flusso di cassa nella transazione. Rimuovere le vendite con valori di $ 0,00 sales_price dal set di dati.

• Il set di dati copre diverse categorie di edifici. Tuttavia, questo notebook si concentrerà sugli edifici residenziali che, in base al Glossario dei termini, sono contrassegnati come tipo "A". Filtrare il set di dati in modo da includere solo edifici residenziali. Per fare ciò, includere la colonna building_class_at_time_of_sale o la colonna building_class_at_present. Includere solo i building_class_at_time_of_sale dati.

• 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. 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, build_class_at_presente altre, 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. Eseguire il cast della sale_price colonna come integer.

Conversione dei tipi e filtraggio

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

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

Convertire i 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. Il sales_price è maggiore di 0.
2. Il total_units è maggiore di 0.
3. Il gross_square_feet è maggiore di 0.
4. Il 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 ancora i dati dell'anno. È comunque possibile distinguere tra, ad esempio, dicembre 2005 e dicembre 2006.

Inoltre, mantenere solo le colonne rilevanti per l'analisi. Queste colonne includono sales_price, total_units, gross_square_feete 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 sale_pricevalori , total_unitse 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. Questa modifica 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. Questo esame porta a dati analitici su potenziali modelli e tendenze di stagionalità. Per altre informazioni sulla visualizzazione dei dati di Microsoft Fabric, vedere la risorsa visualizzazione notebook.

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, il che significa che i dati hanno una stagionalità annuale.
• I mesi estivi sembrano avere volumi di vendita più elevati rispetto ai mesi invernali.
• Quando si confrontano anni con vendite elevate e anni con vendite basse, si noterà che 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 i mesi di vendita elevati e i 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

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

Passaggio 4: Addestramento e monitoraggio del modello

Adattamento del modello

Prophet accetta sempre un dataframe a due colonne come input. Una colonna di input è una colonna temporale denominata dse l'altra 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, rinominare la colonna time in ds e la colonna del valore in y. Quindi, passare i dati al Profeta. Per altre informazioni, vedere la documentazione dell'API Python Prophet.

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 di stagionalità predefinito per Prophet, usare la stagionalità moltiplicativa per il parametro dell'effetto stagionalità. L'analisi nella sezione precedente ha mostrato che a causa dei cambiamenti nell'ampiezza della stagionalità, una semplice stagionalità additiva non si adatta affatto bene ai dati.

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

• Utilizzare i metodi Markov Chain Monte Carlo (MCMC) per catturare le stime delle incertezze delle stagionalità. Per impostazione predefinita, Prophet può fornire stime di incertezza sulla tendenza e sul rumore di osservazione, ma non per la stagionalità. MCMC richiedono più tempo di elaborazione, ma consentono all'algoritmo di fornire stime di incertezza sulla stagionalità e sul rumore di tendenza e di osservazione. Per altre informazioni, vedere la documentazione Prophet Uncertainty Intervals.

• 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, provare valori diversi e quindi selezionare il modello con le migliori prestazioni. Per ulteriori informazioni, consultare la documentazione Prophet Trend Changepoints.

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 integrato. 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 campione specifico del set di dati che non è stato utilizzato nel set di dati di addestramento. Testare quindi il modello sottoposto a training su tale esempio, prima della distribuzione. Tuttavia, questo approccio non funziona per i dati delle serie temporali. Se il modello visualizza i dati dei mesi di gennaio 2005 e marzo 2005 e si tenta di stimare per il mese febbraio 2005, il modello può essenzialmente ingannare perché rileva dove si trova la tendenza dei dati. In applicazioni reali, l'obiettivo è quello di fare previsioni per il futuro, ossia per le regioni non visibili.

Per gestire questo problema 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. La prossima esecuzione gestisce le previsioni da febbraio 2014 fino 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, vengono salvati in un'unica esecuzione di MLflow.

# Setup MLflow
from mlflow.models.signature import infer_signature

Condurre esperimenti

Un esperimento machine learning funge da unità principale dell'organizzazione e controllo per tutte le esecuzioni di machine learning correlate. Un'esecuzione corrisponde a una singola esecuzione del codice dei modelli. Il tracciamento degli esperimenti di machine learning si riferisce alla gestione di tutti i diversi esperimenti e dei loro componenti. Questa gestione include parametri, metriche, modelli e altri artefatti. Consente di organizzare i componenti necessari di un esperimento di machine learning specifico. Il tracciamento degli esperimenti di machine learning permette di duplicare facilmente i risultati passati usando esperimenti salvati. Per altre informazioni, vedere 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 mostrano i risultati dell'adattamento del modello.

I punti neri rappresentano i punti dati che addestrano il modello. La linea blu è la previsione 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 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 può causare overfitting. Quindi, il secondo grafico è la scelta migliore. Questo risultato indica 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)
• errore quadratico medio della radice (RMSE)
• errore assoluto medio (MAE)
• errore percentuale assoluto medio (MAPE)
• errore percentuale mediano assoluto (MDAPE)
• errore percentuale medio assoluto simmetrico (SMAPE)

Valuta la copertura utilizzando le stime yhat_lower e yhat_upper. Si notino i diversi intervalli temporali in cui si prevede un anno nel futuro, ripetuto 12 volte.

display(df_metrics[BEST_MODEL_INDEX])

Usando la metrica MAPE per questo modello di previsione, le stime che estendono un mese nel futuro in genere comportano errori di circa 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 stima.

Eseguire previsioni con Predict Transformer

Caricare il modello e usarlo per eseguire stime. Per rendere operativi i modelli di machine learning, usare PREDICT, una funzione di Microsoft Fabric scalabile che supporta l'assegnazione dei punteggi batch in qualsiasi motore di calcolo. Per altre informazioni su PREDICT e su come usarlo all'interno di Microsoft Fabric, vedere 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
• Allena modelli di apprendimento automatico
• Esperimenti di machine learning in Microsoft Fabric