Oplær og evaluer en tidsserieprognosemodel

I denne notesbog bygger vi et program til at forudsige tidsseriedata, der har sæsonbestemte cyklusser. Vi bruger datasættet NYC Property Sales 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.

• Brug oplevelsesskifteren i venstre side af startsiden til at skifte til Synapse Data Science-oplevelsen.

  

• 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 i Synapse Data Science-oplevelsen.
• Upload din notesbog fra GitHub til Synapse Data Science-oplevelsen.

Åbn den indbyggede notesbog

Notesbogen med tidsserieeksemplet følger med dette selvstudium.

Sådan åbner du selvstudiets indbyggede eksempelnotesbog i Synapse Data Science-oplevelsen:

1. Gå til startsiden Synapse Data Science.

2. Vælg Brug et eksempel.

3. Vælg det tilsvarende eksempel:

   • Fra standardfanen End-to-end-arbejdsprocesser (Python), hvis eksemplet er til et Python-selvstudium.
   • Fra fanen Komplette arbejdsprocesser (R), hvis eksemplet er til et R-selvstudium.
   • Fra fanen Hurtige selvstudier , hvis eksemplet er til et hurtigt selvstudium.

4. Vedhæft 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 for at 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 model til maskinel indlæring, eller du håndterer ad hoc-dataanalyser, skal du muligvis hurtigt installere et brugerdefineret bibliotek (f.eks prophet . i denne notesbog) til Apache Spark-sessionen. For at gøre dette har du to valgmuligheder.

1. Du kan bruge de indbyggede installationsfunktioner (f.eks. %pip, %condaosv.) til hurtigt at komme i gang med nye biblioteker. Dette vil kun installere de brugerdefinerede biblioteker i den aktuelle notesbog og ikke i arbejdsområdet.

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

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

2. Du kan også oprette et Fabric-miljø, installere biblioteker fra offentlige kilder eller uploade brugerdefinerede biblioteker til det, og derefter kan administratoren af arbejdsområdet vedhæfte miljøet som standard for arbejdsområdet. Alle biblioteker i miljøet bliver derefter tilgængelige til brug i alle notesbøger 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 skal du bruge %pip install til at installere prophet biblioteket. PySpark-kernen genstartes efter %pip install. Det 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.

Borough	Kvarter	building_class_category	tax_class	bloker	Masse	eastment	building_class_at_present	Adresse	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	ALFABET BY	07 UDLEJNINGER - WALKUP LEJLIGHEDER	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	ALFABET BY	07 UDLEJNINGER - WALKUP LEJLIGHEDER	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 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.

Tip

Med de parametre, der vises i denne kodecelle, kan du nemt anvende denne notesbog på forskellige datasæt.

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

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

Vigtigt

Sørg for at føje et lakehouse til notesbogen, før du kører den. Hvis du ikke gør det, medfører det en fejl.

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. Besøg denne ressource for at få flere oplysninger om automatisk logning.

# Set up the MLflow experiment
import mlflow

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

Bemærk

Hvis du vil deaktivere automatisk logning af Microsoft Fabric i en notesbogsession, skal du ringe mlflow.autolog() til og angive disable=True.

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

Hvis du vil gennemse datasættet, kan du manuelt undersøge et undersæt af data for at få en bedre forståelse af det. Du kan bruge 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 dette en overdragelse af ejerskab uden kontant betaling. Det vil sige, at der ikke er nogen pengestrømme i transaktionen. Du bør fjerne salg med $0,00-værdier sales_price 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". Du skal filtrere datasættet, så det kun omfatter beboelsesbygninger. Det gør du ved enten at inkludere kolonnerne building_class_at_time_of_salebuilding_class_at_present eller . Du må kun inkludere building_class_at_time_of_sale dataene.

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

• Nogle kolonner – f.eks apartment_number. , tax_class, build_class_at_presentosv. – har manglende værdier 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. Du skal angive kolonnen sale_price som et 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. sales_price er større end 0
2. total_units er større end 0
3. gross_square_feet er større end 0
4. building_class_at_time_of_sale er af typen 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 indeholder stadig årsdata. Du kan stadig skelne mellem f.eks. december 2005 og december 2006.

Derudover skal du kun bevare de kolonner, der er relevante for analysen. Disse omfatter sales_price, total_unitsgross_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)

Aggregere sale_priceværdierne , total_units og gross_square_feet 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. Dette 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. Dette fører til indsigt i potentielle mønstre og sæsonudsvingstendenser. Få mere at vide om Microsoft Fabric-datavisualisering på denne ressource.

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 tydeligt tilbagevendende mønster på en årlig kadence. det betyder, at dataene har en årlig sæsonudsving
• Sommermånederne synes at have højere salgsmængder sammenlignet med vintermånederne
• I en sammenligning af år med højt salg og år med lavt salg overstiger indtægtsforskellen mellem høje salgsmåneder og måneder med lavt salg i høje salgsår - i absolutte tal - indtægtsforskellen mellem måneder med højt salg og måneder med lavt salg i lave salgsår.

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

Dette bliver vigtigt senere, når du skal beslutte mellem multiplikative og additive sæsonudsvingseffekter.

Trin 4: Modeltræning og -sporing

Modeltilpasning

Profetinput er altid en dataramme med to kolonner. Én inputkolonne er en klokkeslætskolonne med navnet ds, og én inputkolonne er en værdikolonne med navnet 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 at tilpasse modellen skal du kun omdøbe kolonnen Klokkeslæt til ds og værdikolonnen til yog overføre dataene til Profeten. Læs dokumentationen til Profeten Python API for at få flere oplysninger.

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 standard sæsoneffekten for profeten, skal du bruge " multiplikativ" sæsonudsving for parameteren sæsoneffekt. Analysen i forrige afsnit viste, at på grund af ændringer i sæsonudsvings amplitude passer en simpel additiv sæsonbestemthed slet ikke til dataene.

• Indstil parameteren weekly_seasonality til fra, fordi dataene blev aggregeret 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. Læs dokumentationen om profetens usikkerhedsintervaller for at få flere oplysninger.

• 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. Du kan løse dette problem ved at prøve forskellige værdier og derefter vælge modellen med den bedste ydeevne. Læs dokumentationen til Profeten Trend Changepoints for at få flere oplysninger.

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 modellen med den bedste ydeevne.

Den tværgående valideringsteknik kan validere modellens effektivitet. Denne teknik oplærer modellen på et undersæt af datasættet og kører test på et tidligere uset undersæ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 eksempel på datasættet, som ikke var en del af oplæringsdatasættet. Test derefter den oplærte model på det pågældende eksempel, før du udruller den. Denne fremgangsmåde fungerer dog ikke for tidsseriedata, for hvis modellen har set data fra januar 2005 og marts 2005, og du forsøger at forudsige for februar 2005, kan modellen i bund og grund snyde, fordi den kan se, hvor datatendensen fører hen. I reelle applikationer er målet at forudsige fremtiden som de usete regioner.

Hvis du vil håndtere dette og gøre testen pålidelig, skal du opdele 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

Logfør modellerne for at holde styr på deres parametre, og gem modellerne til senere brug. Alle relevante modeloplysninger logføres i arbejdsområdet under eksperimentnavnet. Modellen, parametrene og målepunkterne gemmes sammen med elementer til automatisk logning af MLflow i én MLflow-kørsel.

# Setup MLflow
from mlflow.models.signature import infer_signature

Udfør eksperimenter

Et maskinel indlæringseksperiment fungerer som den primære enhed i organisationen og styringen for alle relaterede kørsler af maskinel indlæring. 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. Dette omfatter parametre, målepunkter, modeller og andre artefakter, og det hjælper med at organisere de påkrævede komponenter i et bestemt maskinel indlæringseksperiment. Sporing af eksperimenter med maskinel indlæring giver også mulighed for nem duplikering af tidligere resultater med gemte eksperimenter. Få mere at vide om eksperimenter med maskinel indlæring 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

Profeten har indbyggede visualiseringsfunktioner, som kan vise resultaterne af modellens tilpasning.

De sorte prikker angiver de datapunkter, der bruges til at oplære modellen. Den blå linje er forudsigelsen, og det lyseblå område viser usikkerhedsintervallerne. Du har bygget tre modeller med forskellige changepoint_prior_scale værdier. Forudsigelserne for disse tre modeller vises i 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 fører til en underfitting af tendensændringer. Den største changepoint_prior_scale i den tredje graf kan resultere i overfitting. Så den anden graf synes at være det optimale valg. Dette indebærer, 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)

Evaluer dækningen ved hjælp af estimaterne yhat_lower og yhat_upper . Bemærk de forskellige horisonter, hvor du forudsiger et år i fremtiden 12 gange.

display(df_metrics[BEST_MODEL_INDEX])

Med MAPE-metrikværdien for denne prognosemodel medfører forudsigelser, der strækker sig en måned ind i fremtiden, typisk fejl på ca. 8 %. Men for forudsigelser et år i fremtiden stiger fejlen til ca. 10 %.

Trin 5: Scor modellen, og gem forudsigelsesresultater

Scor nu modellen, og gem forudsigelsesresultaterne.

Foretag forudsigelser med Forudsig transformer

Nu kan du indlæse modellen og bruge den til at foretage forudsigelser. Brugerne kan operationalisere modeller til maskinel indlæring med PREDICT, en skalerbar Microsoft Fabric-funktion, der understøtter batchscore i et hvilket som helst beregningsprogram. Få mere at vide om PREDICT, og hvordan du bruger den i Microsoft Fabric, på 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