Kalibrer og evaluer en prognosemodell for tidsserier

I denne notatblokken bygger vi et program for å forutsi tidsseriedata som har sesongsykluser. Vi bruker NYC Property Sales-datasettet med datoer fra 2003 til 2015 publisert av NYC Department of Finance på NYC Open Data Portal.

Forutsetning

• Få et Microsoft Fabric-abonnement. Eller registrer deg for en gratis prøveversjon av Microsoft Fabric.

• Logg på Microsoft Fabric.

• Bruk opplevelsesbryteren til venstre på hjemmesiden for å bytte til Synapse Data Science-opplevelsen.

  

• Kjennskap til Microsoft Fabric-notatblokker.
• Et lakehouse for å lagre data for dette eksemplet. Hvis du vil ha mer informasjon, kan du se Legge til et lakehouse i notatblokken.

Følg med i en notatblokk

Du kan følge med i en notatblokk på én av to måter:

• Åpne og kjør den innebygde notatblokken i Synapse Data Science-opplevelsen.
• Last opp notatblokken fra GitHub til Synapse Data Science-opplevelsen.

Åpne den innebygde notatblokken

Notatblokken i tidsserien følger med denne opplæringen.

Slik åpner du opplæringens innebygde eksempelnotatblokk i Synapse Data Science-opplevelsen:

1. Gå til hjemmesiden for Synapse Data Science.

2. Velg Bruk et eksempel.

3. Velg det tilsvarende eksemplet:

   • Hvis eksemplet er for en Python-opplæring, fra standard fanen Ende-til-ende-arbeidsflyter (Python ).
   • Hvis eksemplet er for en R-opplæring fra R-fanen fra ende til ende-til-ende-arbeidsflyter (R).
   • Hvis eksemplet er for en rask opplæring fra fanen Hurtigopplæringer .

4. Legg ved et lakehouse i notatblokken før du begynner å kjøre kode.

Importere notatblokken fra GitHub

AIsample – Time Series Forecasting.ipynb er notatblokken som følger med denne opplæringen.

Hvis du vil åpne den medfølgende notatblokken for denne opplæringen, følger du instruksjonene i Klargjør systemet for opplæring for datavitenskap, for å importere notatblokken til arbeidsområdet.

Hvis du heller vil kopiere og lime inn koden fra denne siden, kan du opprette en ny notatblokk.

Pass på at du fester et lakehouse til notatblokken før du begynner å kjøre kode.

Trinn 1: Installere egendefinerte biblioteker

Når du utvikler en maskinlæringsmodell, eller du håndterer ad hoc-dataanalyse, må du kanskje raskt installere et egendefinert bibliotek (for eksempel prophet i denne notatblokken) for Apache Spark-økten. Hvis du vil gjøre dette, har du to valg.

1. Du kan bruke de innebygde installasjonsfunksjonene (for eksempel %pip, osv %conda.) til raskt å komme i gang med nye biblioteker. Dette vil bare installere de egendefinerte bibliotekene i gjeldende notatblokk, ikke i arbeidsområdet.

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

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

2. Alternativt kan du opprette et stoffmiljø, installere biblioteker fra offentlige kilder eller laste opp egendefinerte biblioteker til det, og deretter kan administratoren for arbeidsområdet legge ved miljøet som standard for arbeidsområdet. Alle bibliotekene i miljøet blir da tilgjengelige for bruk i alle notatblokker og Spark-jobbdefinisjoner i arbeidsområdet. Hvis du vil ha mer informasjon om miljøer, kan du se opprette, konfigurere og bruke et miljø i Microsoft Fabric.

For denne notatblokken bruker %pip install du til å installere prophet biblioteket. PySpark-kjernen starter på nytt etter %pip install. Dette betyr at du må installere biblioteket før du kjører andre celler.

# Use pip to install Prophet
%pip install prophet

Trinn 2: Laste inn dataene

Datasett

Denne notatblokken bruker datasettet NYC Property Sales. Den dekker data fra 2003 til 2015, publisert av NYC Department of Finance på NYC Open Data Portal.

Datasettet inkluderer en oversikt over hvert byggesalg i eiendomsmarkedet i New York City, innen en 13-årsperiode. Se ordlisten for vilkår for egenskapssalgsfiler for en definisjon av kolonnene i datasettet.

Borough	Nabolaget	building_class_category	tax_class	block	Mye	østover	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	ALFABETBY	07 UTLEIE - WALKUP APARTMENTS	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	ALFABETBY	07 UTLEIE - WALKUP APARTMENTS	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 å bygge en modell som spår det månedlige totale salget, basert på historiske data. For dette bruker du Prophet, et åpen kilde prognosebibliotek utviklet av Facebook. Profeten er basert på en additiv modell, hvor ikke-lineære trender passer med daglige, ukentlige og årlige sesongavhengighet og ferieeffekter. Profeten fungerer best på tidsseriedatasett som har sterke sesongeffekter, og flere sesonger med historiske data. I tillegg håndterer profeten robust manglende data og data ytterpunkter.

Profeten bruker en nedbrytbar tidsseriemodell, bestående av tre komponenter:

• trend: Profeten antar en stykkevis konstant vekstrate, med automatisk endringspunktvalg
• sesongavhengighet: Som standard bruker Profeten Fourier-serien til å passe ukentlig og årlig sesongavhengighet
• helligdager: Profeten krever alle tidligere og fremtidige forekomster av helligdager. Hvis en ferie ikke gjentas i fremtiden, vil profeten ikke inkludere den i prognosen.

Denne notatblokken aggregerer dataene på månedlig basis, slik at den ignorerer helligdagene.

Les den offisielle artikkelen for mer informasjon om profetens modelleringsteknikker.

Last ned datasettet, og last opp til et lakehouse

Datakilden består av 15 .csv filer. Disse filene inneholder eiendomssalgsposter fra fem bydeler i New York, mellom 2003 og 2015. For enkelhets nyc_property_sales.tar skyld inneholder filen alle disse .csv filene, og komprimerer dem til én fil. En offentlig tilgjengelig blob-lagring er vert for denne .tar filen.

Tips

Med parameterne som vises i denne kodecellen, kan du enkelt bruke denne notatblokken på forskjellige datasett.

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 koden laster ned en offentlig tilgjengelig versjon av datasettet, og lagrer deretter datasettet i et Fabric Lakehouse.

Viktig

Pass på at du legger til et lakehouse i notatblokken før du kjører den. Hvis du ikke gjør dette, vil det føre til en feil.

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

Start innspillingen av kjøretidspunktet for denne notatblokken.

# Record the notebook running time
import time

ts = time.time()

Konfigurere sporing av MLflow-eksperimenter

Hvis du vil utvide loggingsfunksjonene for MLflow, registreres verdiene for inndataparametere og utdatadata for en maskinlæringsmodell automatisk under opplæringen. Denne informasjonen logges deretter til arbeidsområdet, der MLflow-API-ene eller det tilsvarende eksperimentet i arbeidsområdet kan få tilgang til og visualisere det. Gå til denne ressursen for mer informasjon om autologging.

# Set up the MLflow experiment
import mlflow

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

Merk

Hvis du vil deaktivere Automatisk tillogging av Microsoft Fabric i en notatblokkøkt, kan du ringe mlflow.autolog() og angi disable=True.

Les rå datodata fra lakehouse

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

Trinn 3: Begynne utforskende dataanalyse

Hvis du vil se gjennom datasettet, kan du manuelt undersøke et delsett med data for å få en bedre forståelse av det. Du kan bruke display funksjonen til å skrive ut DataFrame. Du kan også vise diagramvisningene, slik at du enkelt kan visualisere delsett av datasettet.

display(df)

En manuell gjennomgang av datasettet fører til noen tidlige observasjoner:

• Forekomster av salgspriser på USD 0,00. I henhold til ordlisten innebærer dette en overføring av eierskap uten kontantvurdering. Med andre ord, ingen kontantstrømmer i transaksjonen. Du bør fjerne salg med $0,00-verdier sales_price fra datasettet.

• Datasettet dekker ulike bygningsklasser. Denne notatblokken vil imidlertid fokusere på boligbygg som, i henhold til ordlisten, er merket som typen "A". Du bør filtrere datasettet slik at det bare inkluderer boligbygg. Hvis du vil gjøre dette, kan du inkludere enten building_class_at_time_of_sale kolonnene eller building_class_at_present kolonnene. Du må bare inkludere building_class_at_time_of_sale dataene.

• Datasettet inneholder forekomster der total_units verdier er lik 0, eller gross_square_feet verdier lik 0. Du bør fjerne alle forekomstene der total_units eller gross_square_units verdiene er lik 0.

• Noen kolonner – for eksempel , apartment_number, tax_class, build_class_at_presentosv. – har manglende verdier eller NULL-verdier. Anta at manglende data innebærer geistlige feil eller ikke-eksisterende data. Analysen avhenger ikke av disse manglende verdiene, så du kan ignorere dem.

• Kolonnen sale_price lagres som en streng, med et klargjørt «$»-tegn. Hvis du vil fortsette med analysen, kan du representere denne kolonnen som et tall. Du bør angi sale_price kolonnen som heltall.

Typekonvertering og filtrering

Hvis du vil løse noen av de identifiserte problemene, importerer du de nødvendige bibliotekene.

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

Kast salgsdataene fra streng til heltall

Bruk vanlige uttrykk til å skille den numeriske delen av strengen fra dollartegnet (for eksempel i strengen $300 000, del «$» og «300 000»), og kast deretter den numeriske delen som et heltall.

Deretter filtrerer du dataene slik at de bare inkluderer forekomster som oppfyller alle disse betingelsene:

1. Den sales_price er større enn 0
2. Den total_units er større enn 0
3. Den gross_square_feet er større enn 0
4. Er building_class_at_time_of_sale av 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%"'
)

Aggregasjon på månedlig basis

Dataressursen sporer eiendomssalg daglig, men denne tilnærmingen er for detaljert for denne notatblokken. I stedet aggregerer du dataene på månedlig basis.

Først endrer du datoverdiene til å vise bare måneds- og årdata. Datoverdiene vil fortsatt inneholde årdataene. Du kan fortsatt skille mellom for eksempel desember 2005 og desember 2006.

I tillegg holder du bare kolonnene relevante for analysen. Disse inkluderer sales_price, total_unitsgross_square_feet og sales_date. Du må også gi nytt navn 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)

sale_priceAggreger , total_units og gross_square_feet verdier etter måned. Deretter grupperer du dataene monthetter og summerer alle verdiene 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 datasett godt. På grunn av dataaggregasjon er imidlertid DataFrame-størrelsen mindre. Dette tyder på at du nå kan bruke pandas DataFrames.

Denne koden kaster datasettet fra en pyspark DataFrame til en pandas DataFrame.

import pandas as pd

df_pandas = summary_df.toPandas()
display(df_pandas)

Visualisering

Du kan undersøke eiendomshandelstrenden i New York City for bedre å forstå dataene. Dette fører til innsikt i potensielle mønstre og sesongtrender. Mer informasjon om Microsoft Fabric-datavisualisering på denne ressursen.

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

Sammendrag av observasjoner fra den utforskende dataanalysen

• Dataene viser et tydelig regelmessig mønster på en årlig frekvens. dette betyr at dataene har en årlig sesongavhengighet
• Sommermånedene ser ut til å ha høyere salgsvolum sammenlignet med vintermånedene
• I en sammenligning av år med høyt salg og år med lavt salg, overstiger inntektsforskjellen mellom høye salgsmåneder og lave salgsmåneder i høye salgsår - i absolutte termer - inntektsforskjellen mellom høye salgsmåneder og lave salgsmåneder i lave salgsår.

I 2004 er for eksempel inntektsforskjellen mellom den høyeste salgsmåneden og den laveste salgsmåneden om:

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

For 2011 handler beregningen av inntektsforskjell om:

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

Dette blir viktig senere, når du må bestemme mellom multiplikative og additive sesongavhengighetseffekter.

Trinn 4: Modellopplæring og -sporing

Modelltilpasning

Profetinndata er alltid en dataramme med to kolonner. Én inndatakolonne er en tidskolonne med navnet ds, og én inndatakolonne er en verdikolonne med navnet y. Tidskolonnen skal ha et dato-, klokkeslett- eller datetime-dataformat (for eksempel YYYY_MM). Datasettet her oppfyller denne betingelsen. Verdikolonnen må være et numerisk dataformat.

For modelltilpasning må du bare gi nytt navn til tidskolonnen til ds og verdikolonnen til y, og sende dataene til Profeten. Les prophet Python API-dokumentasjonen for mer informasjon.

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

Profeten følger scikit-learn-konvensjonen . Først oppretter du en ny forekomst av profeten, angir bestemte parametere (for eksempelseasonality_mode), og deretter tilpasser du denne forekomsten til datasettet.

• Selv om en konstant additivfaktor er standard sesongavhengighetseffekt for profeten, bør du bruke den multiplikative sesongavhengigheten for sesongavhengighetseffektparameteren. Analysen i forrige del viste at på grunn av endringer i sesongavhengighetsamplitude, vil en enkel additiv sesongavhengighet ikke passe dataene godt i det hele tatt.

• Sett weekly_seasonality parameteren til av, fordi dataene ble aggregert etter måned. Som et resultat er ikke ukentlige data tilgjengelige.

• Bruk Markov Chain Monte Carlo (MCMC) metoder for å fange opp sesongusikkerhetsestimatene. Som standard kan profeten gi usikkerhetsestimater på trenden og observasjonsstøyen, men ikke for sesongavhengigheten. MCMC krever mer behandlingstid, men de tillater algoritmen å gi usikkerhetsestimater på sesongavhengigheten, og trenden og observasjonsstøyen. Les dokumentasjonen om usikkerhetsintervaller for profeten for mer informasjon.

• Juster følsomheten for automatisk endringspunktgjenkjenning gjennom parameteren changepoint_prior_scale . Profetalgoritmen prøver automatisk å finne forekomster i dataene der banene brått endres. Det kan bli vanskelig å finne riktig verdi. Du kan løse dette ved å prøve forskjellige verdier og deretter velge modellen med best ytelse. Les dokumentasjonen for profettrendendringspunkter hvis du vil ha mer informasjon.

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

Kryssvalidering

Profeten har et innebygd kryssvalideringsverktøy. Dette verktøyet kan beregne prognosefeilen og finne modellen med best ytelse.

Kryssvalideringsteknikken kan validere modelleffektivitet. Denne teknikken trener modellen på et delsett av datasettet, og kjører tester på et tidligere usett delsett av datasettet. Denne teknikken kan kontrollere hvor godt en statistisk modell generaliserer til et uavhengig datasett.

For kryssvalidering reserverer du et bestemt utvalg av datasettet, som ikke var en del av opplæringsdatasettet. Deretter tester du den opplærte modellen på dette eksemplet, før distribusjon. Denne tilnærmingen fungerer imidlertid ikke for tidsseriedata, fordi hvis modellen har sett data fra månedene januar 2005 og mars 2005, og du prøver å forutsi for måneden februar 2005, kan modellen i hovedsak jukse, fordi den kan se hvor datatrenden fører. I reelle programmer er målet å forutsi for fremtiden, som de usynlige områdene.

Hvis du vil håndtere dette, og gjøre testen pålitelig, kan du dele datasettet basert på datoene. Bruk datasettet frem til en bestemt dato (for eksempel de første 11 årene med data) for opplæring, og bruk deretter de gjenværende usette dataene for prognose.

I dette scenarioet starter du med 11 års opplæringsdata, og deretter foretar du månedlige prognoser ved hjelp av en horisont på ett år. Opplæringsdataene inneholder alt fra 2003 til 2013. Deretter håndterer den første kjøringen prognoser for januar 2014 til og med januar 2015. Neste kjøring håndterer spådommer for februar 2014 til februar 2015, og så videre.

Gjenta denne prosessen for hver av de tre opplærte modellene for å se hvilken modell som yter best. Sammenlign deretter disse prognosene med virkelige verdier, for å etablere prognosekvaliteten til den beste 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

Logg modellene, for å holde oversikt over parameterne, og lagre modellene for senere bruk. All relevant modellinformasjon logges i arbeidsområdet under eksperimentnavnet. Modellen, parameterne og måledataene, sammen med autologgingselementer for MLflow, lagres i én MLflow-kjøring.

# Setup MLflow
from mlflow.models.signature import infer_signature

Utføre eksperimenter

Et maskinlæringseksperiment fungerer som den primære enheten for organisering og kontroll, for alle relaterte maskinlæringskjøringer. En kjøring tilsvarer en enkelt kjøring av modellkode. Sporing av maskinlæringseksperiment refererer til administrasjon av alle de ulike eksperimentene og komponentene. Dette omfatter parametere, måledata, modeller og andre artefakter, og det bidrar til å organisere de nødvendige komponentene i et bestemt maskinlæringseksperiment. Sporing av maskinlæringseksperimenter gir også enkel duplisering av tidligere resultater med lagrede eksperimenter. Mer informasjon om maskinlæringseksperimenter i Microsoft Fabric. Når du har bestemt trinnene du har tenkt å inkludere (for eksempel tilpasning og evaluering av profetmodellen i denne notatblokken), kan du kjø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 modell med profeten

Profeten har innebygde visualiseringsfunksjoner, som kan vise modelltilpasningsresultatene.

De svarte prikkene angir datapunktene som brukes til å lære opp modellen. Den blå linjen er prognosen, og det lyseblå området viser usikkerhetsintervallene. Du har bygget tre modeller med forskjellige changepoint_prior_scale verdier. Prognosene for disse tre modellene vises i resultatene av denne kodeblokken.

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

Den minste changepoint_prior_scale verdien i den første grafen fører til en undertilpasset trendendringer. Den største changepoint_prior_scale i den tredje grafen kan føre til overfitting. Så den andre grafen ser ut til å være det optimale valget. Dette innebærer at den andre modellen er den mest passende.

Visualiser trender og sesongavhengighet med profeten

Profeten kan også enkelt visualisere de underliggende trendene og sesongavhengighetene. Visualiseringer av den andre modellen vises i resultatene av denne kodeblokken.

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

I disse grafene gjenspeiler den lyseblå skyggeleggingen usikkerheten. Den øverste grafen viser en sterk, lang periode oscillerende trend. Salgsvolumet stiger og faller i løpet av noen få år. Den lavere grafen viser at salget har en tendens til å toppe i februar og september, og når sine maksimale verdier for året i disse månedene. Kort tid etter disse månedene, i mars og oktober, faller de til årets minimumsverdier.

Evaluer ytelsen til modellene ved hjelp av ulike måledata, for eksempel:

• gjennomsnittlig kvadrert feil (MSE)
• rotgjennomsnittet kvadrert feil (RMSE)
• gjennomsnittlig absolutt feil (MAE)
• gjennomsnittlig absolutt prosentfeil (MAPE)
• median absolutt prosentfeil (MDAPE)
• symmetrisk gjennomsnittlig absolutt prosentfeil (SMAPE)

Evaluer dekningen ved hjelp av yhat_lower og yhat_upper estimater. Legg merke til de varierende horisontene der du forutser ett år i fremtiden, 12 ganger.

display(df_metrics[BEST_MODEL_INDEX])

Med MAPE-metrikkverdien, for denne prognosemodellen, innebærer prognoser som strekker seg én måned inn i fremtiden vanligvis feil på omtrent 8 %. Men for prognoser ett år inn i fremtiden øker feilen til omtrent 10%.

Trinn 5: Score modellen og lagre prognoseresultater

Nå scorer du modellen, og lagrer prognoseresultatene.

Lage prognoser med Forutsi transformator

Nå kan du laste inn modellen og bruke den til å lage prognoser. Brukere kan operasjonalisere maskinlæringsmodeller med PREDICT, en skalerbar Microsoft Fabric-funksjon som støtter satsvis poengsum i alle databehandlingsmotorer. Mer informasjon om PREDICT, og hvordan du bruker det i Microsoft Fabric, på denne ressursen.

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

Relatert innhold

• Maskinlæringsmodell i Microsoft Fabric
• Lære opp maskinlæringsmodeller
• Maskinlæringseksperimenter i Microsoft Fabric