Oplær og evaluer en tidsserieprognosemodel

I denne notesbog bygger du et program til at forudsige tidsseriedata, der har sæsoncyklusser. Brug NYC Property Sales-datasættet med datoer fra 2003 til 2015, udgivet af NYC Department of Finance på NYC Open Data Portal.

Forudsætninger

• Få et Microsoft Fabric-abonnement. Du kan også tilmelde dig en gratis Prøveversion af Microsoft Fabric.

• Log på Microsoft Fabric.

• Skift til Fabric ved at bruge experience-switcheren nederst til venstre på din startside.

  

• Kendskab til Microsoft Fabric-notesbøger.
• Et lakehouse til lagring af data for dette eksempel. Du kan få flere oplysninger under Føj et lakehouse til din notesbog.

Følg med i en notesbog

Du kan følge med i en notesbog på to måder:

• Åbn og kør den indbyggede notesbog.
• Upload din notesbog fra GitHub.

Åbn den indbyggede notesbog

Notesbogen med tidsserieeksemplet følger med dette selvstudium.

1. Hvis du vil åbne eksempelnotesbogen til dette selvstudium, skal du følge vejledningen i Forbered dit system til selvstudier om datavidenskab.

2. Sørg for at vedhæfte et lakehouse til notesbogen, før du begynder at køre kode.

Importér notesbogen fra GitHub

AIsample – Time Series Forecasting.ipynb er den notesbog, der følger med dette selvstudium.

• Hvis du vil åbne den medfølgende notesbog til dette selvstudium, skal du følge vejledningen i Forbered dit system til selvstudier om datavidenskab importere notesbogen til dit arbejdsområde.

• Hvis du hellere vil kopiere og indsætte koden fra denne side, kan du oprette en ny notesbog.

• Sørg for at vedhæfte et lakehouse til notesbogen , før du begynder at køre kode.

Trin 1: Installér brugerdefinerede biblioteker

Når du udvikler en maskinlæringsmodel eller håndterer ad hoc dataanalyse, kan det være nødvendigt hurtigt at installere et brugerdefineret bibliotek (for eksempel prophet i denne notesbog) til Apache Spark-sessionen. For at udføre denne opgave har du to valg.

1. Brug de in-line installationsmuligheder (for eksempel %pip, %conda, osv.) til hurtigt at komme i gang med nye biblioteker. Denne metode installerer kun de brugerdefinerede biblioteker i den aktuelle notesbog, ikke i arbejdsområdet.

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

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

1. Alternativt kan du oprette et Fabric-miljø, installere biblioteker fra offentlige kilder eller uploade brugerdefinerede biblioteker til det. Din workspace-administrator kan vedhæfte miljøet som standard for workspace. Alle biblioteker i miljøet bliver tilgængelige til brug i alle notebooks og Spark-jobdefinitioner i arbejdsområdet. Du kan få flere oplysninger om miljøer under Opret, konfigurer og brug et miljø i Microsoft Fabric.

Til denne notesbog, brug %pip install den til at installere biblioteket prophet . PySpark-kernen genstarter efter %pip install. Denne handling betyder, at du skal installere biblioteket, før du kører andre celler.

# Use pip to install Prophet
%pip install prophet

Trin 2: Indlæs dataene

Datasæt

Denne notesbog bruger datasættet NYC Property Sales. Den dækker data fra 2003 til 2015, som udgives af NYC Department of Finance på NYC Open Data Portal.

Datasættet indeholder en oversigt over alle byggesalg på ejendomsmarkedet i New York City inden for en 13-årig periode. Se ordlisten over ord for egenskabssalgsfiler for at få en definition af kolonnerne i datasættet.

Målet er at bygge en model, der forudsiger det månedlige samlede salg baseret på historiske data. Til dette bruger du Profeten, et åben kildekode prognosebibliotek, der er udviklet af Facebook. Profeten er baseret på en additiv model, hvor ikke-lineære tendenser passer med daglige, ugentlige og årlige sæsonudsving og ferieeffekter. Profeten fungerer bedst på tidsseriedatasæt, der har stærke sæsoneffekter og flere sæsoner med historiske data. Profeten håndterer desuden på en robust måde manglende data og udenforliggende data.

Profeten bruger en tidsseriemodel, der kan nedbrydes, og som består af tre komponenter:

• tendens: Profeten antager en stykkevis konstant vækstrate, med automatisk ændring punkt valg
• sæsonudsving: Profeten bruger som standard Fourier Series til at passe ugentligt og årligt sæsonudsving
• helligdage: Profeten kræver alle tidligere og fremtidige forekomster af helligdage. Hvis en helligdag ikke gentages i fremtiden, inkluderer profeten den ikke i prognosen.

Denne notesbog aggregerer dataene hver måned, så den ignorerer helligdagene.

Læs det officielle papir for mere information om profeten modellering teknikker.

Download datasættet, og upload til et lakehouse

Datakilden består af 15 .csv filer. Disse filer indeholder salg af ejendomme fra fem kommuner i New York mellem 2003 og 2015. For nemheds nyc_property_sales.tar skyld indeholder filen alle disse .csv filer og komprimerer dem til én fil. Denne fil hoster et .tar offentligt tilgængeligt bloblager.

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

Denne kode downloader en offentligt tilgængelig version af datasættet og gemmer derefter dette datasæt i et Fabric Lakehouse.

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

Begynd at optage kørselstidspunktet for denne notesbog.

# Record the notebook running time
import time

ts = time.time()

Konfigurer sporing af MLflow-eksperiment

Hvis du vil udvide MLflow-logføringsfunktionerne, registrerer automatisk logføring automatisk værdierne for inputparametre og outputmetrik for en model til maskinel indlæring under oplæringen. Disse oplysninger logføres derefter i arbejdsområdet, hvor MLflow-API'erne eller det tilsvarende eksperiment i arbejdsområdet kan få adgang til og visualisere dem. For mere information om autologning, se Autologging i Microsoft Fabric.

# Set up the MLflow experiment
import mlflow

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

Læs rådata fra lakehouse

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

Trin 3: Begynd at udforske dataanalyser

For at gennemgå datasættet skal du manuelt undersøge et delsæt af data for at få en bedre forståelse af det. Brug funktionen display til at udskrive DataFrame. Du kan også få vist diagramvisninger for nemt at visualisere undersæt af datasættet.

display(df)

En manuel gennemgang af datasættet fører til nogle tidlige observationer:

• Forekomster af salgspriser på $0,00. Ifølge ordlisten indebærer denne værdi en ejerskabsoverdragelse uden kontant vederlag. Det vil sige, at der ikke er nogen pengestrømme i transaktionen. Fjern salg med værdier på 0,00 sales_price dollars fra datasættet.

• Datasættet dækker forskellige bygningsklasser. Denne notesbog vil dog fokusere på beboelsesejendomme, der ifølge ordlisten er markeret som type "A". Filtrer datasættet, så det kun inkluderer boligbygninger. Det gør du ved enten at inkludere kolonnerne building_class_at_time_of_salebuilding_class_at_present eller . Inkludér building_class_at_time_of_sale kun dataene.

• Datasættet indeholder forekomster, hvor total_units værdier er lig med 0 eller gross_square_feet værdier lig med 0. Fjern alle instanser, hvor total_units eller gross_square_units værdier er lig med 0.

• Nogle kolonner – for eksempel apartment_number, tax_class, , build_class_at_presentog andre – har manglende eller NULL-værdier. Antag, at de manglende data omfatter skrivefejl eller ikke-eksisterende data. Analysen afhænger ikke af disse manglende værdier, så du kan ignorere dem.

• Kolonnen sale_price gemmes som en streng med et forudberedt "$"-tegn. Hvis du vil fortsætte med analysen, skal du repræsentere denne kolonne som et tal. Støb kolonnen sale_price som heltal.

Typekonvertering og filtrering

Importér de nødvendige biblioteker for at løse nogle af de identificerede problemer.

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

Cast salgsdataene fra streng til heltal

Brug regulære udtryk til at adskille den numeriske del af strengen fra dollartegnet (f.eks. i strengen $300,000, split $ og 300,000), og angiv derefter den numeriske del som et heltal.

Filtrer derefter dataene, så de kun indeholder forekomster, der opfylder alle disse betingelser:

1. Er sales_price større end 0.
2. Er total_units større end 0.
3. Er gross_square_feet større end 0.
4. Er building_class_at_time_of_sale af type 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%"'
)

Sammenlægning på månedsbasis

Dataressourcen sporer salg af egenskaber dagligt, men denne fremgangsmåde er for detaljeret til denne notesbog. Aggregerer i stedet dataene på månedsbasis.

Først skal du ændre datoværdierne, så de kun viser data for måned og år. Datoværdierne inkluderer stadig årdataene. Man kan stadig skelne mellem for eksempel december 2005 og december 2006.

Derudover skal du kun bevare de kolonner, der er relevante for analysen. Disse kolonner inkluderer sales_price, total_units, gross_square_feet, og sales_date. Du skal også omdøbe sales_date til 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)

Aggregér sale_price, total_units, og gross_square_feet værdierne efter måned. Gruppér derefter dataene efter month, og sumér alle værdierne i hver gruppe.

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 til Pandas-konvertering

Pyspark DataFrames håndterer store datasæt godt. Men på grund af datasammenlægning er DataFrame-størrelsen mindre. Denne ændring antyder, at du nu kan bruge pandas DataFrames.

Denne kode konverterer datasættet fra en pyspark-dataramme til en pandas DataFrame.

import pandas as pd

df_pandas = summary_df.toPandas()
display(df_pandas)

Visualisering

Du kan undersøge ejendomshandelstendensen i New York City for bedre at forstå dataene. Denne undersøgelse giver indsigt i potentielle mønstre og sæsonmæssige tendenser. For mere information om Microsoft Fabric-datavisualisering, se Notebook visualiseringsressource .

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

Oversigt over observationer fra den udforskende dataanalyse

• Dataene viser et klart tilbagevendende mønster på en årlig kadence, hvilket betyder, at dataene har en årlig sæsonvariation.
• Sommermånederne ser ud til at have højere salgsvolumen sammenlignet med vintermånederne.
• Når man sammenligner år med højt salg og år med lavt salg, ser man, at omsætningsforskellen mellem måneder med højt salg og måneder med lavt salg i år med højt salg overstiger - i absolutte termer - forskellen i omsætningen mellem måneder med højt salg og måneder med lavt salg i år med lavt salg.

I 2004 er indtægtsforskellen mellem den højeste salgsmåned og den laveste salgsmåned f.eks. ca.:

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

For 2011 er beregningen af indtægtsforskellen ca.:

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

Denne observation bliver vigtig senere, når man skal vælge mellem multiplikative og additive sæsonmæssige effekter.

Trin 4: Modeltræning og -sporing

Modeltilpasning

Prophet tager altid en to-kolonne DataFrame som input. Den ene inputkolonne er en tidskolonne kaldet ds, og den anden inputkolonne er en værdikolonne kaldet y. Klokkeslætskolonnen skal have dataformatet dato, klokkeslæt eller datetime (f.eks. YYYY_MM). Datasættet her opfylder denne betingelse. Værdikolonnen skal være et numerisk dataformat.

For modeltilpasning omdøbes tidskolonnen til og ds værdikolonnen til y. Derefter videregiver du dataene til Prophet. For mere information, se Prophet Python API-dokumentationen.

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

Profeten følger scikit-learn-konventionen . Først skal du oprette en ny forekomst af profeten, angive visse parametre (f.eks.seasonality_mode), og derefter tilpasse denne forekomst til datasættet.

• Selvom en konstant additiv faktor er standardsæsoneffekten for Prophet, skal du bruge den 'multiplikative' sæsonvariation som sæsoneffektparameter. Analysen i det forrige afsnit viste, at på grund af ændringer i sæsonvariationsamplituden passer en simpel additiv sæsonvariation slet ikke godt til dataene.

• Sæt weekly_seasonality-parameterenfra, fordi dataene aggregeres efter måned. Derfor er ugentlige data ikke tilgængelige.

• Brug McMC-metoder (Markov Chain Monte Carlo) til at registrere usikkerhedsestimaterne for sæsonudsving. Profeten kan som standard give usikkerhedsestimater over tendensen og observationsstøjen, men ikke for sæsonudsving. MCMC kræver mere behandlingstid, men de giver algoritmen mulighed for at give usikkerhedsestimater over sæsonudsving og tendens- og observationsstøj. For mere information, se Prophet Uncertainty Intervals-dokumentationen.

• Juster følsomheden for automatisk ændring af punktregistrering via parameteren changepoint_prior_scale . Profetens algoritme forsøger automatisk at finde forekomster i dataene, hvor forløbene pludselig ændres. Det kan blive svært at finde den korrekte værdi. For at løse dette problem skal du prøve forskellige værdier og derefter vælge modellen med den bedste ydeevne. For mere information, se Prophet Trend Changepoints-dokumentationen.

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

Krydsvalidering

Profeten har et indbygget krydsvalideringsværktøj. Dette værktøj kan estimere prognosefejlen og finde den model med den bedste præstation.

Den tværgående valideringsteknik kan validere modellens effektivitet. Denne teknik træner modellen på et delsæt af datasættet og udfører tests på et hidtil uset delsæt af datasættet. Denne teknik kan kontrollere, hvor godt en statistisk model generaliseres til et uafhængigt datasæt.

Til krydsvalidering skal du reservere et bestemt udvalg af datasættet, som ikke var en del af træningsdatasættet. Test derefter den oplærte model på det pågældende eksempel, før du udruller den. Denne tilgang virker dog ikke for tidsseriedata. Hvis modellen ser data fra månederne januar 2005 og marts 2005, og du prøver at forudsige for februar 2005, kan modellen i bund og grund snyde , fordi den ser, hvor datatrenden fører hen. I reelle applikationer er målet at forudsige fremtiden som de usete regioner.

For at håndtere dette problem og gøre testen pålidelig, opdel datasættet baseret på datoerne. Brug datasættet op til en bestemt dato (f.eks. de første 11 års data) til oplæring, og brug derefter de resterende usete data til forudsigelse.

I dette scenarie skal du starte med 11 års oplæringsdata og derefter foretage månedlige forudsigelser ved hjælp af en etårig horisont. Træningsdataene indeholder specifikt alt fra 2003 til og med 2013. Derefter håndterer den første kørsel forudsigelser for januar 2014 til og med januar 2015. Den næste kørsel håndterer forudsigelser for februar 2014 til og med februar 2015 osv.

Gentag denne proces for hver af de tre oplærte modeller for at se, hvilken model der fungerer bedst. Sammenlign derefter disse forudsigelser med værdier fra den virkelige verden for at fastslå forudsigelseskvaliteten for den bedste model.

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

Logmodel med MLflow

Log modellerne for at holde styr på deres parametre og gem dem til senere brug. Alle relevante modeloplysninger logføres i arbejdsområdet under eksperimentnavnet. Modellen, parametrene og metrikkerne sammen med MLflow-autologing-elementer gemmes i én MLflow-kørsel.

# Setup MLflow
from mlflow.models.signature import infer_signature

Udfør eksperimenter

Et maskinlæringseksperiment fungerer som den primære enhed for organisering og kontrol for alle relaterede maskinlæringskørsler. En kørsel svarer til en enkelt udførelse af modelkoden. Sporing af maskinel indlæringseksperiment refererer til administration af alle de forskellige eksperimenter og deres komponenter. Denne forvaltning omfatter parametre, målepunkter, modeller og andre artefakter. Det hjælper med at organisere de nødvendige komponenter i et specifikt maskinlæringseksperiment. Sporing af eksperimenter med maskinel indlæring giver også mulighed for nem duplikering af tidligere resultater med gemte eksperimenter. For mere information, se maskinlæringseksperimenter i Microsoft Fabric. Når du har fundet ud af, hvilke trin du vil medtage (f.eks. montering og evaluering af profetmodellen i denne notesbog), kan du køre eksperimentet.

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)

Visualiser en model med profeten

Prophet har indbyggede visualiseringsfunktioner, der viser modellens tilpasningsresultater.

De sorte prikker repræsenterer datapunkterne, der træner modellen. Den blå linje er forudsigelsen, og det lyseblå område viser usikkerhedsintervallerne. Du byggede tre modeller med forskellige changepoint_prior_scale værdier. Forudsigelserne fra disse tre modeller fremgår af resultaterne af denne kodeblok.

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

Den mindste changepoint_prior_scale værdi i den første graf forårsager undertilpasning af trendændringer. Den største changepoint_prior_scale i den tredje graf kan forårsage overfitting. Så den anden graf er det bedste valg. Dette resultat betyder, at den anden model er den mest egnede.

Visualiser tendenser og sæsonudsving med profeten

Profeten kan også nemt visualisere de underliggende tendenser og sæsonudsving. Visualiseringer af den anden model vises i resultaterne af denne kodeblok.

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

I disse grafer afspejler den lyseblå skygge usikkerheden. Den øverste graf viser en stærk, lang periode oscillerende tendens. I løbet af nogle få år stiger og falder salgsmængden. Den lavere graf viser, at salget har tendens til at toppe i februar og september og når deres maksimumværdier for året i disse måneder. Kort efter disse måneder i marts og oktober falder de til årets minimumværdier.

Evaluer ydeevnen for modellerne ved hjælp af forskellige målepunkter, f.eks.:

• middel kvadreret fejl (MSE)
• rodens middelværdi kvadreret fejl (RMSE)
• middelværdi for absolut fejl (MAE)
• fejl i middel absolutte procent (MAPE)
• median-fejl i absolut procent (MDAPE)
• symmetrisk middelværdi for absolut procentdelsfejl (SMAPE)

Vurder dækningen ved at bruge og yhat_loweryhat_upper estimater. Bemærk de forskellige horisonter, hvor du forudsiger et år i fremtiden 12 gange.

display(df_metrics[BEST_MODEL_INDEX])

Ved at bruge MAPE-metrikken til denne prognosemodel involverer forudsigelser, der strækker sig en måned ud i fremtiden, typisk fejl på cirka 8%. Men for forudsigelser et år i fremtiden stiger fejlen til ca. 10 %.

Trin 5: Scor modellen, og gem forudsigelsesresultater

Giv modellen en score og gem forudsigelsesresultaterne.

Foretag forudsigelser med Forudsig transformer

Indlæs modellen og brug den til at lave forudsigelser. For at operationalisere maskinlæringsmodeller kan man bruge PREDICT, en skalerbar Microsoft Fabric-funktion, der understøtter batch-scoring i enhver compute-engine. For mere information om PREDICT og hvordan du bruger det inden for Microsoft Fabric, se denne ressource.

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

Relateret indhold

• Model til maskinel indlæring i Microsoft Fabric
• Oplær modeller til maskinel indlæring
• Eksperimenter med maskinel indlæring i Microsoft Fabric