Een tijdreeksprognosemodel trainen en evalueren

In dit notebook bouwen we een programma voor het voorspellen van tijdreeksgegevens met seizoensgebonden cycli. We gebruiken de gegevensset NYC Property Sales met datums tussen 2003 en 2015 gepubliceerd door NYC Department of Finance in de NYC Open Data Portal.

Vereisten

• Haal een Microsoft Fabric-abonnement op. Of meld u aan voor een gratis proefversie van Microsoft Fabric.

• Meld u aan bij Microsoft Fabric.

• Gebruik de ervaringswisselaar aan de linkerkant van de startpagina om over te schakelen naar Fabric.

  

• Bekendheid met Microsoft Fabric-notebooks.
• Een lakehouse voor het opslaan van gegevens voor dit voorbeeld. Zie Een lakehouse toevoegen aan uw notitieblok voor meer informatie.

Volgen in een notitieblok

U kunt een notitieblok op twee manieren volgen:

• Open en voer het ingebouwde notebook uit.
• Upload uw notebook vanuit GitHub.

Het ingebouwde notebook openen

Het time series-voorbeeldnotitieblok begeleidt deze zelfstudie.

1. Als u het voorbeeldnotitieblok voor deze zelfstudie wilt openen, volgt u de instructies in Uw systeem voorbereiden op zelfstudies voor gegevenswetenschap.

2. Zorg ervoor dat u een lakehouse koppelt aan het notebook voordat u begint met het uitvoeren van code.

Het notebook importeren vanuit GitHub

AIsample - Time Series Forecasting.ipynb is het notebook dat wordt begeleid bij deze zelfstudie.

• Als u het bijbehorende notitieblok voor deze zelfstudie wilt openen, volgt u de instructies in Uw systeem voorbereiden op zelfstudies voor gegevenswetenschap om het notebook in uw werkruimte te importeren.

• Als u liever de code van deze pagina kopieert en plakt, kunt u een nieuw notitieblok maken.

• Zorg ervoor dat u een lakehouse aan het notebook koppelt voordat u begint met het uitvoeren van code.

Stap 1: Aangepaste bibliotheken installeren

Wanneer u een machine learning-model ontwikkelt of ad-hocgegevensanalyse afhandelt, moet u mogelijk snel een aangepaste bibliotheek (bijvoorbeeld prophet in dit notebook) installeren voor de Apache Spark-sessie. Hiervoor hebt u twee keuzes.

1. U kunt de inline-installatiemogelijkheden (bijvoorbeeld %pip, %condaenzovoort) gebruiken om snel aan de slag te gaan met nieuwe bibliotheken. Hiermee worden alleen de aangepaste bibliotheken in het huidige notitieblok geïnstalleerd, niet in de werkruimte.

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

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

2. U kunt ook een Fabric-omgeving maken, bibliotheken installeren uit openbare bronnen of aangepaste bibliotheken ernaar uploaden. Vervolgens kan uw werkruimtebeheerder de omgeving als standaard voor de werkruimte koppelen. Alle bibliotheken in de omgeving zijn vervolgens beschikbaar voor gebruik in notebooks en Spark-taakdefinities in de werkruimte. Zie een omgeving maken, configureren en gebruiken in Microsoft Fabric voor meer informatie over omgevingen.

Voor dit notebook gebruikt %pip install u om de prophet bibliotheek te installeren. De PySpark-kernel wordt opnieuw opgestart na %pip install. Dit betekent dat u de bibliotheek moet installeren voordat u andere cellen uitvoert.

# Use pip to install Prophet
%pip install prophet

Stap 2: de gegevens laden

Gegevensset

In dit notebook wordt de gegevensset NyC Property Sales gebruikt. Het behandelt gegevens van 2003 tot 2015, gepubliceerd door de NYC Department of Finance in de NYC Open Data Portal.

De gegevensset bevat een record van elke verkoop van gebouwen in de vastgoedmarkt van New York City, binnen een periode van 13 jaar. Raadpleeg de woordenlijst met termen voor eigenschappenverkoopbestanden voor een definitie van de kolommen in de gegevensset.

deelraad	buurt	building_class_category	tax_class	block	lot	eastment	building_class_at_present	adres	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 CITY	07 VERHUUR - WALKUP APPARTEMENTEN	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 CITY	07 VERHUUR - WALKUP APPARTEMENTEN	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

Het doel is om een model te bouwen dat de maandelijkse totale verkoop voorspelt op basis van historische gegevens. Hiervoor gebruikt u Prophet, een open source voorspellende bibliotheek die is ontwikkeld door Facebook. Prophet is gebaseerd op een additief model, waarbij niet-lineaire trends passen bij dagelijkse, wekelijkse en jaarlijkse seizoensgebondenheid en vakantie-effecten. Prophet werkt het beste op gegevenssets van tijdreeksen die sterke seizoensgebonden effecten hebben en verschillende seizoenen van historische gegevens. Daarnaast verwerkt Prophet krachtig ontbrekende gegevens en uitbijters van gegevens.

Prophet maakt gebruik van een decomposeerbaar tijdreeksmodel, bestaande uit drie onderdelen:

• trend: Prophet gaat ervan uit dat een stukgewijze constante groeisnelheid, met automatische wijzigingspuntselectie
• seizoensgebondenheid: Prophet maakt standaard gebruik van Fourier Series om wekelijkse en jaarlijkse seizoensgebondenheid aan te passen
• feestdagen: Prophet vereist alle eerdere en toekomstige gebeurtenissen van feestdagen. Als een vakantie in de toekomst niet wordt herhaald, neemt Prophet deze niet op in de prognose.

Met dit notebook worden de gegevens maandelijks samengevoegd, zodat de feestdagen worden genegeerd.

Lees het officiële document voor meer informatie over de Prophet-modelleringstechnieken.

De gegevensset downloaden en uploaden naar een lakehouse

De gegevensbron bestaat uit 15 .csv bestanden. Deze bestanden bevatten verkooprecords van eigenschappen uit vijf stadsdelen in New York, tussen 2003 en 2015. Voor het gemak bevat het nyc_property_sales.tar bestand al deze .csv bestanden en comprimeert het ze in één bestand. Een openbaar beschikbare blobopslag fungeert als host voor dit .tar bestand.

Tip

Met de parameters die in deze codecel worden weergegeven, kunt u dit notebook eenvoudig toepassen op verschillende gegevenssets.

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

Met deze code wordt een openbaar beschikbare versie van de gegevensset gedownload en wordt die gegevensset vervolgens opgeslagen in een Fabric Lakehouse.

Belangrijk

Zorg ervoor dat u een lakehouse toevoegt aan het notebook voordat u het uitvoert. Als u dit niet doet, treedt er een fout op.

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

Begin met het opnemen van de runtime van dit notebook.

# Record the notebook running time
import time

ts = time.time()

Het bijhouden van MLflow-experimenten instellen

Als u de MLflow-logboekregistratiemogelijkheden wilt uitbreiden, worden de waarden van invoerparameters en metrische uitvoergegevens van een machine learning-model automatisch vastgelegd tijdens de training. Deze informatie wordt vervolgens geregistreerd bij de werkruimte, waar de MLflow-API's of het bijbehorende experiment in de werkruimte deze kunnen openen en visualiseren. Ga naar deze resource voor meer informatie over automatisch inloggen.

# Set up the MLflow experiment
import mlflow

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

Notitie

Als u automatische aanmelding van Microsoft Fabric in een notebooksessie wilt uitschakelen, roept mlflow.autolog() u aan en stelt u deze in disable=True.

Onbewerkte datumgegevens uit lakehouse lezen

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

Stap 3: Verkennende gegevensanalyse starten

Als u de gegevensset wilt bekijken, kunt u handmatig een subset met gegevens onderzoeken om er een beter inzicht in te krijgen. U kunt de display functie gebruiken om het DataFrame af te drukken. U kunt ook de grafiekweergaven weergeven om eenvoudig subsets van de gegevensset te visualiseren.

display(df)

Een handmatige beoordeling van de gegevensset leidt tot enkele vroege waarnemingen:

• Exemplaren van $ 0,00 verkoopprijzen. Volgens de woordenlijst van de Voorwaarden impliceert dit een overdracht van eigendom zonder contant geld. Met andere woorden, er is geen cashflow in de transactie. U moet verkopen met $ 0,00-waarden sales_price uit de gegevensset verwijderen.

• De gegevensset bevat verschillende bouwklassen. Dit notitieblok richt zich echter op woongebouwen die volgens de woordenlijst van de termen zijn gemarkeerd als het type "A". U moet de gegevensset filteren om alleen woongebouwen op te nemen. U doet dit door de building_class_at_time_of_sale of de building_class_at_present kolommen op te nemen. U moet alleen de building_class_at_time_of_sale gegevens opnemen.

• De gegevensset bevat exemplaren waarbij total_units waarden gelijk zijn aan 0 of gross_square_feet waarden gelijk zijn aan 0. U moet alle exemplaren verwijderen waarbij total_units of gross_square_units waarden gelijk zijn aan 0.

• Sommige kolommen, bijvoorbeeld apartment_number, tax_class, build_class_at_presentenzovoort, bevatten ontbrekende of NULL-waarden. Stel dat de ontbrekende gegevens betrekking hebben op administratieve fouten of niet-bestaande gegevens. De analyse is niet afhankelijk van deze ontbrekende waarden, dus u kunt ze negeren.

• De sale_price kolom wordt opgeslagen als een tekenreeks, met een voorgeprependeerd '$'-teken. Als u door wilt gaan met de analyse, vertegenwoordigt u deze kolom als een getal. U moet de sale_price kolom casten als geheel getal.

Typeconversie en -filtering

Als u enkele van de geïdentificeerde problemen wilt oplossen, importeert u de vereiste bibliotheken.

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

De verkoopgegevens van tekenreeks naar geheel getal casten

Gebruik reguliere expressies om het numerieke gedeelte van de tekenreeks te scheiden van het dollarteken (bijvoorbeeld in de tekenreeks $300,000, splitsen $ en 300,000) en het numerieke gedeelte vervolgens als een geheel getal te casten.

Filter vervolgens de gegevens om alleen exemplaren op te nemen die aan al deze voorwaarden voldoen:

1. De sales_price waarde is groter dan 0
2. De total_units waarde is groter dan 0
3. De gross_square_feet waarde is groter dan 0
4. De building_class_at_time_of_sale is van het 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%"'
)

Aggregatie per maand

De gegevensresource houdt de verkoop van eigenschappen dagelijks bij, maar deze benadering is te gedetailleerd voor dit notebook. In plaats daarvan aggregeren u de gegevens maandelijks.

Wijzig eerst de datumwaarden zodat alleen gegevens van maand en jaar worden weergegeven. De datumwaarden bevatten nog steeds de jaargegevens. U kunt nog steeds onderscheid maken tussen bijvoorbeeld december 2005 en december 2006.

Houd bovendien alleen de kolommen relevant voor de analyse. Dit zijn onder andere sales_price, total_unitsen gross_square_feetsales_date. U moet ook de naam wijzigen in 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)

Aggregeren de sale_priceen total_unitsgross_square_feet waarden per maand. Vervolgens groepeer u de gegevens monthop en somt u alle waarden in elke groep op.

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)

Conversie van Pyspark naar Pandas

Pyspark DataFrames verwerken grote gegevenssets goed. Vanwege gegevensaggregatie is de DataFrame-grootte echter kleiner. Dit stelt voor dat u nu pandas DataFrames kunt gebruiken.

Met deze code wordt de gegevensset van een pyspark DataFrame omgezet in een Pandas DataFrame.

import pandas as pd

df_pandas = summary_df.toPandas()
display(df_pandas)

Visualisatie

U kunt de trend van de vastgoedhandel van New York City onderzoeken om meer inzicht te krijgen in de gegevens. Dit leidt tot inzichten in potentiële patronen en seizoensgebonden trends. Meer informatie over microsoft Fabric-gegevensvisualisatie in deze resource.

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

Samenvatting van waarnemingen van de verkennende gegevensanalyse

• De gegevens tonen een duidelijk terugkerend patroon op een jaarlijkse frequentie; dit betekent dat de gegevens een jaarlijkse seizoensgebondenheid hebben
• De zomermaanden lijken hogere verkoopvolumes te hebben vergeleken met de wintermaanden
• In een vergelijking van jaren met hoge verkoop en jaren met lage verkoop, is het omzetverschil tussen hoge verkoopmaanden en lage verkoopmaanden in hoge verkoopjaren in absolute termen groter dan het omzetverschil tussen hoge verkoopmaanden en lage verkoopmaanden in lage verkoopjaren.

In 2004 is het omzetverschil tussen de hoogste verkoopmaand en de laagste verkoopmaand bijvoorbeeld ongeveer:

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

Voor 2011 gaat het om de berekening van het omzetverschil:

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

Dit wordt later belangrijk, wanneer u moet beslissen tussen vermenigvuldigende en additieve seizoensgebondenheidseffecten.

Stap 4: Modeltraining en -tracering

Modelfitting

Prophet-invoer is altijd een DataFrame met twee kolommen. Eén invoerkolom is een tijdkolom met de naam dsen één invoerkolom is een waardekolom met de naam y. De tijdkolom moet een datum-, tijd- of datum/tijd-gegevensindeling hebben (bijvoorbeeld YYYY_MM). De gegevensset hier voldoet aan die voorwaarde. De waardekolom moet een numerieke gegevensindeling zijn.

Voor het aanpassen van het model moet u alleen de naam van de tijdkolom wijzigen in ds en de waardekolom wijzigen in y, en de gegevens doorgeven aan Prophet. Lees de Python API-documentatie van Prophet voor meer informatie.

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

Prophet volgt de scikit-learn-conventie . Maak eerst een nieuw exemplaar van Prophet, stel bepaalde parameters in (bijvoorbeeldseasonality_mode) en pas die instantie vervolgens aan de gegevensset toe.

• Hoewel een constante additieve factor het standaardseizoensgebondenheidseffect voor Prophet is, moet u de 'vermenigvuldigende' seizoensgebondenheid gebruiken voor de parameter seizoensgebondenheidseffect. Uit de analyse in de vorige sectie bleek dat vanwege wijzigingen in de seizoensgebondenheidsamplitude een eenvoudige additieve seizoensgebondenheid helemaal niet goed bij de gegevens past.

• Stel de parameter weekly_seasonalityuit, omdat de gegevens per maand zijn geaggregeerd. Als gevolg hiervan zijn wekelijkse gegevens niet beschikbaar.

• Gebruik de Methoden markov Chain Monte Carlo (MCMC) om de seizoensgebonden onzekerheidsramingen vast te leggen. Prophet kan standaard onzekerheidsramingen geven over de trend en observatieruis, maar niet voor de seizoensgebondenheid. MCMC vereist meer verwerkingstijd, maar het algoritme biedt onzekerheidsramingen voor de seizoensgebondenheid en de trend en observatieruis. Lees de documentatie over de prophet-onzekerheidsintervallen voor meer informatie.

• Stem de gevoeligheid van de automatische wijzigingspuntdetectie af via de parameter changepoint_prior_scale . Het Prophet-algoritme probeert automatisch instanties te vinden in de gegevens waar de trajecten plotseling veranderen. Het kan lastig worden om de juiste waarde te vinden. U kunt dit oplossen door verschillende waarden uit te proberen en vervolgens het model te selecteren met de beste prestaties. Lees de documentatie van Prophet Trend Changepoints voor meer informatie.

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

Kruisvalidatie

Prophet heeft een ingebouwd hulpmiddel voor kruisvalidatie. Met dit hulpprogramma kunt u de prognosefout schatten en het model vinden met de beste prestaties.

De techniek voor kruisvalidatie kan modelefficiëntie valideren. Met deze techniek traint u het model op een subset van de gegevensset en voert u tests uit op een eerder niet-gebruikte subset van de gegevensset. Met deze techniek kunt u controleren hoe goed een statistisch model generaliseert naar een onafhankelijke gegevensset.

Voor kruisvalidatie reserveert u een bepaald voorbeeld van de gegevensset, die geen deel uitmaakte van de trainingsgegevensset. Test vervolgens het getrainde model op dat voorbeeld, voorafgaand aan de implementatie. Deze benadering werkt echter niet voor tijdreeksgegevens, omdat als het model gegevens uit de maanden januari 2005 en maart 2005 heeft gezien en u probeert te voorspellen voor de maand februari 2005, het model in wezen kan bedriegen, omdat het kan zien waar de gegevenstrend leidt. In echte toepassingen is het doel om te voorspellen voor de toekomst, als de ongelezen regio's.

Als u dit wilt afhandelen en de test betrouwbaar wilt maken, splitst u de gegevensset op basis van de datums. Gebruik de gegevensset tot een bepaalde datum (bijvoorbeeld de eerste 11 jaar aan gegevens) voor training en gebruik vervolgens de resterende ongelezen gegevens voor voorspelling.

In dit scenario begint u met 11 jaar trainingsgegevens en maakt u vervolgens maandelijkse voorspellingen met behulp van een horizon van één jaar. Met name de trainingsgegevens bevatten alles van 2003 tot en met 2013. Vervolgens verwerkt de eerste uitvoering voorspellingen voor januari 2014 tot en met januari 2015. De volgende uitvoering verwerkt voorspellingen voor februari 2014 tot en met februari 2015, enzovoort.

Herhaal dit proces voor elk van de drie getrainde modellen om te zien welk model het beste presteert. Vergelijk deze voorspellingen vervolgens met echte waarden om de voorspellingskwaliteit van het beste model te bepalen.

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

Logboekmodel met MLflow

Registreer de modellen om hun parameters bij te houden en sla de modellen op voor later gebruik. Alle relevante modelgegevens worden vastgelegd in de werkruimte, onder de naam van het experiment. Het model, de parameters en metrische gegevens, samen met MLflow-items voor automatische logboeken, wordt opgeslagen in één MLflow-uitvoering.

# Setup MLflow
from mlflow.models.signature import infer_signature

Experimenten uitvoeren

Een machine learning-experiment fungeert als de primaire eenheid van de organisatie en controle voor alle gerelateerde machine learning-uitvoeringen. Een uitvoering komt overeen met één uitvoering van modelcode. Het bijhouden van machine learning-experimenten verwijst naar het beheer van alle verschillende experimenten en hun onderdelen. Dit omvat parameters, metrische gegevens, modellen en andere artefacten en helpt bij het organiseren van de vereiste onderdelen van een specifiek machine learning-experiment. Het bijhouden van machine learning-experimenten maakt ook het eenvoudig dupliceren van eerdere resultaten mogelijk met opgeslagen experimenten. Meer informatie over machine learning-experimenten in Microsoft Fabric. Zodra u de stappen hebt vastgesteld die u wilt opnemen (bijvoorbeeld het model Prophet in dit notebook aanpassen en evalueren), kunt u het experiment uitvoeren.

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)

Een model visualiseren met Prophet

Prophet heeft ingebouwde visualisatiefuncties, die de resultaten van het model passend maken.

De zwarte stippen geven de gegevenspunten aan die worden gebruikt om het model te trainen. De blauwe lijn is de voorspelling en het lichtblauwe gebied toont de onzekerheidsintervallen. U hebt drie modellen met verschillende changepoint_prior_scale waarden gebouwd. De voorspellingen van deze drie modellen worden weergegeven in de resultaten van dit codeblok.

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

De kleinste changepoint_prior_scale waarde in de eerste grafiek leidt tot een onderfitting van trendwijzigingen. De grootste changepoint_prior_scale in de derde grafiek kan leiden tot overfitting. De tweede grafiek lijkt dus de optimale keuze te zijn. Dit impliceert dat het tweede model het meest geschikt is.

Trends en seizoensgebondenheid visualiseren met Prophet

Prophet kan ook eenvoudig de onderliggende trends en seizoensgebondenheden visualiseren. Visualisaties van het tweede model worden weergegeven in de resultaten van dit codeblok.

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

In deze grafieken weerspiegelt de lichtblauwe arcering de onzekerheid. In de bovenste grafiek ziet u een sterke, lange periode schommelingende trend. Over een paar jaar stijgen de verkoopvolumes en dalen. In de onderste grafiek ziet u dat de verkoop in februari en september piekt, waardoor de maximumwaarden voor het jaar in die maanden worden bereikt. Kort na die maanden, in maart en oktober, vallen ze in de minimumwaarden van het jaar.

Evalueer de prestaties van de modellen met behulp van verschillende metrische gegevens, bijvoorbeeld:

• gemiddelde kwadratische fout (MSE)
• wortel gemiddelde kwadratische fout (RMSE)
• gemiddelde absolute fout (MAE)
• gemiddelde absolute procentfout (MAPE)
• mediaan absolute procentfout (MDAPE)
• symmetrische gemiddelde absolute percentagefout (SMAPE)

Evalueer de dekking met behulp van de yhat_lower en yhat_upper schattingen. Let op de verschillende horizonten waar u een jaar in de toekomst voorspelt, 12 keer.

display(df_metrics[BEST_MODEL_INDEX])

Met de MAPE-metrische gegevens, voor dit prognosemodel, omvatten voorspellingen die één maand in de toekomst uitbreiden doorgaans fouten van ongeveer 8%. Voor voorspellingen één jaar in de toekomst neemt de fout echter toe tot ongeveer 10%.

Stap 5: Het model beoordelen en voorspellingsresultaten opslaan

Score nu het model en sla de voorspellingsresultaten op.

Voorspellingen doen met Predict Transformer

Nu kunt u het model laden en gebruiken om voorspellingen te doen. Gebruikers kunnen machine learning-modellen operationeel maken met PREDICT, een schaalbare Microsoft Fabric-functie die ondersteuning biedt voor batchgewijs scoren in elke rekenengine. Meer informatie over PREDICTen het gebruik ervan in Microsoft Fabric vindt u in deze resource.

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

Gerelateerde inhoud

• Machine learning-model in Microsoft Fabric
• Machine learning-modellen trainen
• Machine learning-experimenten in Microsoft Fabric