Träna och utvärdera en tidsserieprognosmodell

  • Artikel

I den här notebook-filen skapar vi ett program för att prognostisera tidsseriedata som har säsongscykler. Vi använder datauppsättningen NYC Property Sales med datum från 2003 till 2015 publicerade av NYC Department of Finance på NYC Open Data Portal.

Förutsättningar

Följ med i en notebook-fil

Du kan följa med i en notebook-fil på ett av två sätt:

  • Öppna och kör den inbyggda notebook-filen i Synapse Datavetenskap upplevelse.
  • Ladda upp din notebook-fil från GitHub till Synapse-Datavetenskap upplevelse.

Öppna den inbyggda notebook-filen

Exempelanteckningsboken för Tidsserie medföljer den här självstudien.

Så här öppnar du självstudiekursens inbyggda exempelanteckningsbok i Synapse Datavetenskap upplevelse:

  1. Gå till startsidan för Synapse Datavetenskap.

  2. Välj Använd ett exempel.

  3. Välj motsvarande exempel:

    • Från standardfliken för arbetsflöden från slutpunkt till slutpunkt (Python) om exemplet är för en Python-självstudie.
    • Från fliken Arbetsflöden från slutpunkt till slutpunkt (R) om exemplet är för en R-självstudie.
    • Om exemplet är för en snabb självstudie på fliken Snabbsjälvstudier.

  4. Koppla ett lakehouse till notebook-filen innan du börjar köra kod.

Importera anteckningsboken från GitHub

AIsample – Time Series Forecasting.ipynb är anteckningsboken som medföljer den här självstudien.

Om du vill öppna den medföljande notebook-filen för den här självstudien följer du anvisningarna i Förbereda systemet för självstudier för datavetenskap för att importera anteckningsboken till din arbetsyta.

Om du hellre vill kopiera och klistra in koden från den här sidan kan du skapa en ny notebook-fil.

Se till att bifoga ett lakehouse i notebook-filen innan du börjar köra kod.

Steg 1: Installera anpassade bibliotek

När du utvecklar en maskininlärningsmodell eller hanterar ad hoc-dataanalys kan du snabbt behöva installera ett anpassat bibliotek (till exempel prophet i den här notebook-filen) för Apache Spark-sessionen. För att göra detta har du två alternativ.

  1. Du kan använda in-line-installationsfunktionerna (till exempel %pip, %conda, osv.) för att snabbt komma igång med nya bibliotek. Detta skulle bara installera de anpassade biblioteken i den aktuella notebook-filen, inte på arbetsytan.
# Use pip to install libraries
%pip install <library name>

# Use conda to install libraries
%conda install <library name>
  1. Du kan också skapa en Infrastrukturmiljö, installera bibliotek från offentliga källor eller ladda upp anpassade bibliotek till den och sedan kan din arbetsyteadministratör koppla miljön som standard för arbetsytan. Alla bibliotek i miljön blir sedan tillgängliga för användning i alla notebook-filer och Spark-jobbdefinitioner på arbetsytan. Mer information om miljöer finns i skapa, konfigurera och använda en miljö i Microsoft Fabric.

För den här notebook-filen använder %pip install du för att installera prophet biblioteket. PySpark-kerneln startas om efter %pip install. Det innebär att du måste installera biblioteket innan du kör andra celler.

# Use pip to install Prophet
%pip install prophet

Steg 2: Läs in data

Datamängd

Den här notebook-filen använder datamängden NYC Property Sales. Den omfattar data från 2003 till 2015, publicerade av NYC Department of Finance på NYC Open Data Portal.

Datamängden innehåller ett register över varje fastighetsförsäljning i New York Citys fastighetsmarknad inom en 13-årsperiod. En definition av kolumnerna i datamängden finns i ordlistan med villkor för egenskapsförsäljningsfiler .

Borough Kvarter building_class_category tax_class block Mycket eastment building_class_at_present Adress 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 ALFABETSSTAD 07 LÄGENHETER - WALKUP LÄGENHETER 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 ALFABETSSTAD 07 LÄGENHETER - WALKUP LÄGENHETER 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

Målet är att skapa en modell som förutspår den månatliga totala försäljningen baserat på historiska data. För detta använder du Prophet, ett öppen källkod prognosbibliotek som utvecklats av Facebook. Profeten är baserad på en additiv modell, där icke-linjära trender passar med dagliga, veckovisa och årliga säsongsvariationer och semestereffekter. Prophet fungerar bäst på tidsseriedatauppsättningar som har starka säsongseffekter och flera säsonger av historiska data. Dessutom hanterar Prophet data som saknas och avvikande data.

Prophet använder en förmultnad tidsseriemodell som består av tre komponenter:

  • trend: Profeten förutsätter en bitvis konstant tillväxttakt, med automatisk ändringspunktval
  • säsongsvariation: Som standard använder Prophet Fourier-serien för att passa vecko- och års säsongsvariationer
  • helgdagar: Profeten kräver alla tidigare och framtida händelser av helgdagar. Om en helgdag inte upprepas i framtiden kommer Profeten inte att inkludera den i prognosen.

Den här notebook-filen aggregerar data varje månad, så den ignorerar helgdagarna.

Läs det officiella dokumentet för mer information om profetmodelleringstekniker.

Ladda ned datauppsättningen och ladda upp till ett sjöhus

Datakällan består av 15 .csv filer. Dessa filer innehåller fastighetsförsäljningsposter från fem stadsdelar i New York, mellan 2003 och 2015. För enkelhetens nyc_property_sales.tar skull innehåller filen alla dessa .csv filer och komprimerar dem till en fil. En offentligt tillgänglig bloblagring är värd för den här .tar filen.

Dricks

Med parametrarna som visas i den här kodcellen kan du enkelt använda den här notebook-filen på olika datauppsättningar.

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

Den här koden laddar ned en offentligt tillgänglig version av datamängden och lagrar sedan datauppsättningen i en Fabric Lakehouse.

Viktigt!

Se till att du lägger till ett lakehouse i notebook-filen innan du kör den. Om du inte gör det uppstår ett fel.

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

Börja spela in körningen av den här notebook-filen.

# Record the notebook running time
import time

ts = time.time()

Konfigurera MLflow-experimentspårning

För att utöka MLflow-loggningsfunktionerna samlar automatisk loggning automatiskt in värdena för indataparametrar och utdatamått för en maskininlärningsmodell under träningen. Den här informationen loggas sedan till arbetsytan, där MLflow-API:erna eller motsvarande experiment på arbetsytan kan komma åt och visualisera den. Besök den här resursen om du vill ha mer information om automatisk loggning.

# Set up the MLflow experiment
import mlflow

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

Kommentar

Om du vill inaktivera automatisk loggning av Microsoft Fabric i en notebook-session anropar mlflow.autolog() du och anger disable=True.

Läsa rådata från lakehouse

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

Steg 3: Börja undersöka dataanalys

Om du vill granska datauppsättningen kan du manuellt undersöka en delmängd data för att få en bättre förståelse för den. Du kan använda display funktionen för att skriva ut DataFrame. Du kan också visa diagramvyerna för att enkelt visualisera delmängder av datamängden.

display(df)

En manuell granskning av datamängden leder till några tidiga observationer:

  • Instanser av försäljningspriser på 0,00 USD. Enligt ordlistan innebär detta en ägaröverföring utan kontant ersättning. Med andra ord flödade inga kassaflöden i transaktionen. Du bör ta bort försäljning med $0,00-värden sales_price från datauppsättningen.

  • Datamängden omfattar olika byggnadsklasser. Den här notebook-filen fokuserar dock på bostadshus som enligt ordlistan markeras som typ "A". Du bör filtrera datamängden så att den endast innehåller bostadshus. Det gör du genom att inkludera antingen kolumnerna building_class_at_time_of_salebuilding_class_at_present eller . Du får bara inkludera building_class_at_time_of_sale data.

  • Datamängden innehåller instanser där total_units värden är lika med 0 eller gross_square_feet värden lika med 0. Du bör ta bort alla instanser där total_units eller gross_square_units värden är lika med 0.

  • Vissa kolumner – till exempel apartment_number, tax_class, build_class_at_presentosv. – har saknade värden eller NULL-värden. Anta att saknade data omfattar skrivfel eller obefintliga data. Analysen beror inte på de saknade värdena, så du kan ignorera dem.

  • Kolumnen sale_price lagras som en sträng med ett förberett $-tecken. Om du vill fortsätta med analysen representerar du den här kolumnen som ett tal. Du bör omvandla sale_price kolumnen som heltal.

Typkonvertering och filtrering

Du kan lösa några av de identifierade problemen genom att importera de bibliotek som krävs.

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

Omvandla försäljningsdata från sträng till heltal

Använd reguljära uttryck för att separera den numeriska delen av strängen från dollartecknet (till exempel i strängen "$300 000", dela "$" och "300 000") och sedan omvandla den numeriska delen som ett heltal.

Filtrera sedan data så att de endast innehåller instanser som uppfyller alla dessa villkor:

  1. Är sales_price större än 0
  2. Är total_units större än 0
  3. Är gross_square_feet större än 0
  4. building_class_at_time_of_sale Är av typ 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%"'
)

Sammansättning per månad

Dataresursen spårar egenskapsförsäljning dagligen, men den här metoden är för detaljerad för den här notebook-filen. Aggregera i stället data varje månad.

Ändra först datumvärdena så att endast månad och år-data visas. Datumvärdena skulle fortfarande innehålla årsdata. Du kan fortfarande skilja mellan till exempel december 2005 och december 2006.

Dessutom behåller du bara kolumnerna som är relevanta för analysen. Dessa inkluderar sales_price, total_unitsoch gross_square_feetsales_date. Du måste också byta namn till sales_datemonth.

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)

sale_priceAggregera värdena och total_unitsgross_square_feet efter månad. Gruppera sedan data monthefter och summera alla värden i varje grupp.

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)

Pyspark till Pandas-konvertering

Pyspark DataFrames hanterar stora datamängder väl. DataFrame-storleken är dock mindre på grund av dataaggregering. Detta tyder på att du nu kan använda Pandas DataFrames.

Den här koden omvandlar datauppsättningen från en pyspark DataFrame till en Pandas DataFrame.

import pandas as pd

df_pandas = summary_df.toPandas()
display(df_pandas)

Visualisering

Du kan undersöka fastighetshandelstrenden i New York City för att bättre förstå data. Detta leder till insikter om potentiella mönster och säsongstrender. Läs mer om Microsoft Fabric-datavisualisering på den här resursen.

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

Sammanfattning av observationer från den undersökande dataanalysen

  • Data visar ett tydligt återkommande mönster på en årlig takt. detta innebär att data har en årlig säsongsvariation
  • Sommarmånaderna verkar ha högre försäljningsvolymer jämfört med vintermånaderna
  • I en jämförelse av år med hög försäljning och år med låg försäljning, överstiger intäktsskillnaden mellan höga försäljningsmånader och låga försäljningsmånader under höga försäljningsår - i absoluta termer - intäktsskillnaden mellan höga försäljningsmånader och låga försäljningsmånader under låga försäljningsår.

År 2004 är till exempel intäktsskillnaden mellan den högsta försäljningsmånaden och den lägsta försäljningsmånaden ungefär:

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

För 2011 handlar den intäktsskillnadsberäkningen om:

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

Detta blir viktigt senare, när du måste bestämma mellan multiplicativa och additiva säsongseffekter.

Steg 4: Modellträning och spårning

Modellanpassning

Profetindata är alltid en dataram med två kolumner. En indatakolumn är en tidskolumn med namnet ds, och en indatakolumn är en värdekolumn med namnet y. Tidskolumnen ska ha dataformatet date, time eller datetime (till exempel YYYY_MM). Datauppsättningen här uppfyller det villkoret. Värdekolumnen måste vara ett numeriskt dataformat.

För modellanpassningen får du bara byta namn på tidskolumnen till ds och värdekolumnen till yoch skicka data till Profeten. Mer information finns i dokumentationen om Python-API:et för profeten.

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

Profeten följer scikit-learn-konventionen . Skapa först en ny instans av Prophet, ange vissa parametrar (till exempelseasonality_mode) och anpassa sedan instansen till datauppsättningen.

  • Även om en konstant additiv faktor är standardvariationen för Prophet bör du använda säsongsvariationen "multiplicativ" för parametern säsongseffekt. Analysen i föregående avsnitt visade att på grund av förändringar i säsongsmässig amplitud kommer en enkel additiv säsongsvariation inte att passa data bra alls.

  • Ställ in parametern weekly_seasonality på av eftersom data aggregerades per månad. Därför är veckodata inte tillgängliga.

  • Använd Metoder för Markov Chain Monte Carlo (MCMC) för att fånga upp uppskattningarna av säsongsosäkerhet. Som standard kan Profeten ge osäkerhetsuppskattningar på trend- och observationsbruset, men inte för säsongsvariationen. MCMC kräver mer bearbetningstid, men de gör det möjligt för algoritmen att ge osäkerhetsuppskattningar om säsongsvariation och trend- och observationsbrus. Mer information finns i dokumentationen om profetens osäkerhetsintervall.

  • Justera känsligheten för automatisk identifiering av ändringspunkter via parametern changepoint_prior_scale . Profetalgoritmen försöker automatiskt hitta instanser i de data där banorna plötsligt ändras. Det kan bli svårt att hitta rätt värde. För att lösa detta kan du prova olika värden och sedan välja modellen med bästa prestanda. Mer information finns i dokumentationen om profettrendändringspunkter.

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

Korsvalidering

Prophet har ett inbyggt korsvalideringsverktyg. Det här verktyget kan beräkna prognosfelet och hitta modellen med bästa prestanda.

Korsvalideringstekniken kan verifiera modellens effektivitet. Den här tekniken tränar modellen på en delmängd av datamängden och kör tester på en tidigare osedda delmängd av datamängden. Den här tekniken kan kontrollera hur väl en statistisk modell generaliserar till en oberoende datauppsättning.

För korsvalidering reserverar du ett visst urval av datamängden, som inte ingick i träningsdatauppsättningen. Testa sedan den tränade modellen i exemplet före distributionen. Den här metoden fungerar dock inte för tidsseriedata, för om modellen har sett data från månaderna januari 2005 och mars 2005, och du försöker förutsäga för månaden februari 2005, kan modellen i princip fuska eftersom den kan se var datatrenden leder. I verkliga program är målet att prognostisera för framtiden, som de osynliga regionerna.

Om du vill hantera detta och göra testet tillförlitligt delar du upp datamängden baserat på datumen. Använd datauppsättningen upp till ett visst datum (till exempel de första 11 åren av data) för träning och använd sedan återstående osedda data för förutsägelse.

I det här scenariot börjar du med 11 års träningsdata och gör sedan månatliga förutsägelser med en ettårshorisont. Mer specifikt innehåller träningsdata allt från 2003 till 2013. Sedan hanterar den första körningen förutsägelser för januari 2014 till januari 2015. Nästa körning hanterar förutsägelser för februari 2014 till februari 2015 och så vidare.

Upprepa den här processen för var och en av de tre tränade modellerna för att se vilken modell som presterar bäst. Jämför sedan dessa förutsägelser med verkliga värden för att fastställa förutsägelsekvaliteten för den bästa modellen.

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

Loggmodell med MLflow

Logga modellerna för att hålla reda på deras parametrar och spara modellerna för senare användning. All relevant modellinformation loggas på arbetsytan under experimentnamnet. Modellen, parametrarna och måtten, tillsammans med autologgningsobjekt för MLflow, sparas i en MLflow-körning.

# Setup MLflow
from mlflow.models.signature import infer_signature

Utföra experiment

Ett maskininlärningsexperiment fungerar som den primära enheten för organisation och kontroll för alla relaterade maskininlärningskörningar. En körning motsvarar en enda körning av modellkod. Spårning av maskininlärningsexperiment avser hanteringen av alla olika experiment och deras komponenter. Detta inkluderar parametrar, mått, modeller och andra artefakter, och det hjälper till att organisera nödvändiga komponenter i ett specifikt maskininlärningsexperiment. Spårning av maskininlärningsexperiment möjliggör också enkel duplicering av tidigare resultat med sparade experiment. Läs mer om maskininlärningsexperiment i Microsoft Fabric. När du har fastställt vilka steg du tänker ta med (till exempel anpassning och utvärdering av Profetens modell i den här notebook-filen) kan du köra experimentet.

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)

Screenshot of the properties panel.

Visualisera en modell med Prophet

Prophet har inbyggda visualiseringsfunktioner som kan visa modellanpassningsresultatet.

De svarta punkterna anger de datapunkter som används för att träna modellen. Den blå linjen är förutsägelsen och det ljusblå området visar osäkerhetsintervallen. Du har skapat tre modeller med olika changepoint_prior_scale värden. Förutsägelserna för dessa tre modeller visas i resultatet av det här kodblocket.

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

Det minsta changepoint_prior_scale värdet i den första grafen leder till underanpassning av trendändringar. Den största changepoint_prior_scale i den tredje grafen kan leda till överanpassning. Så den andra grafen verkar vara det optimala valet. Detta innebär att den andra modellen är den lämpligaste.

Profeten kan också enkelt visualisera underliggande trender och säsongsvariationer. Visualiseringar av den andra modellen visas i resultatet av det här kodblocket.

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

Screenshot of a graph of yearly trends in the pricing data.

I dessa grafer återspeglar den ljusblå skuggningen osäkerheten. Det översta diagrammet visar en stark, lång period som svänger trend. Under några år har försäljningsvolymerna ökat och minskat. Det lägre diagrammet visar att försäljningen tenderar att nå sin topp i februari och september och nå sina högsta värden för året under dessa månader. Kort efter dessa månader, i mars och oktober, faller de till årets minimivärden.

Utvärdera modellernas prestanda med hjälp av olika mått, till exempel:

  • genomsnittligt kvadratfel (MSE)
  • rot medelvärde kvadratfel (RMSE)
  • genomsnittligt absolut fel (MAE)
  • genomsnittligt absolut procentfel (MAPE)
  • medianfel för absolut procent (MDAPE)
  • symmetriskt genomsnittligt absolut procentfel (SMAPE)

Utvärdera täckningen med hjälp av uppskattningarna yhat_lower och yhat_upper . Observera de varierande horisonter där du förutsäger ett år i framtiden, 12 gånger.

display(df_metrics[BEST_MODEL_INDEX])

Med MAPE-måttet för den här prognosmodellen innebär förutsägelser som sträcker sig en månad in i framtiden vanligtvis fel på ungefär 8 %. För förutsägelser ett år in i framtiden ökar dock felet till ungefär 10 %.

Steg 5: Poängsätta modellen och spara förutsägelseresultat

Gör nu en poäng för modellen och spara förutsägelseresultatet.

Göra förutsägelser med Predict Transformer

Nu kan du läsa in modellen och använda den för att göra förutsägelser. Användare kan operationalisera maskininlärningsmodeller med PREDICT, en skalbar Microsoft Fabric-funktion som stöder batchbedömning i alla beräkningsmotorer. Läs mer om PREDICToch hur du använder det i Microsoft Fabric på den här resursen.

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

Relaterat innehåll