Entwickeln, Auswerten und Bewerten eines Vorhersagemodells für Supermarktumsätze

  • Artikel

Dieses Tutorial stellt ein umfassendes Beispiel für einen Synapse Data Science-Workflow in Microsoft Fabric vor. In diesem Szenario wird ein Prognosemodell erstellt, das anhand von historischen Umsatzdaten den Umsatz eines Supermarkts nach Produktkategorien vorhersagt.

Die Prognose ist eine entscheidende Ressource beim Umsatz. Eine Kombination aus historischen Daten und prädiktiven Methoden liefert Erkenntnisse über zukünftige Trends. Mit der Prognose können Sie vergangene Umsätze analysieren, um Muster zu erkennen, und mithilfe von Erkenntnissen zum Verbraucherverhalten die Bestands-, Produktions- und Marketingstrategien optimieren. Dieser proaktive Ansatz verbessert die Anpassungsfähigkeit, Reaktionsfähigkeit und Gesamtleistung von Unternehmen in einem dynamischen Markt.

Dieses Tutorial umfasst die folgenden Schritte:

  • Laden der Daten
  • Verstehen und Verarbeiten der Daten durch explorative Datenanalyse
  • Trainieren eines Machine Learning-Modells mit einem Open-Source-Softwarepaket und Nachverfolgen von Experimenten mit der automatischen Protokollierungsfunktion von MLflow und Fabric
  • Speichern des Machine Learning-Modells und Erstellen von Vorhersagen
  • Darstellen der Modellleistung mit Power BI-Visualisierungen

Voraussetzungen

Notebook für das Tutorial

Für das Notebook können Sie eine der folgenden Optionen wählen:

  • Öffnen Sie das integrierte Notebook in der Synapse Data Science-Umgebung, und führen Sie es aus
  • Laden Sie Ihr Notebook von GitHub in die Synapse Data Science-Umgebung hoch

Öffnen des integrierten Notebooks

Das Beispiel Umsatzprognose ist das Notebook für dieses Tutorial.

So öffnen Sie das integrierte Beispiel-Notebook für das Tutorial in der Synapse Data Science-Umgebung:

  1. Wechseln Sie zur Synapse Data Science-Startseite.

  2. Wählen Sie Beispiel verwenden aus.

  3. Wählen Sie das zugehörige Beispiel aus:

    • Wählen Sie es auf der Standardregisterkarte End-to-End-Workflows (Python) aus, wenn es sich bei dem Beispiel um ein Python-Tutorial handelt.
    • Wählen Sie es auf der Registerkarte End-to-End-Workflows (R) aus, wenn es sich bei dem Beispiel um ein R-Tutorial handelt.
    • Wählen Sie es auf der Registerkarte Schnelltutorials aus, wenn es sich bei dem Beispiel um ein Schnelltutorial handelt.

  4. Fügen Sie ein Lakehouse an das Notebook an, bevor Sie mit der Ausführung von Code beginnen.

Importieren des Notebooks von GitHub

AIsample – Superstore Forecast.ipynb ist das Notebook, das dieses Tutorial begleitet.

Befolgen Sie zum Öffnen des zugehörigen Notebooks für dieses Tutorial die Anweisungen unter Vorbereiten Ihres Systems für Data Science-Tutorials zum Importieren des Notebooks in Ihren Arbeitsbereich.

Wenn Sie den Code lieber von dieser Seite kopieren und einfügen möchten, können Sie ein neues Notebook erstellen.

Fügen Sie unbedingt ein Lakehouse an das Notebook an, bevor Sie mit der Ausführung von Code beginnen.

Schritt 1. Laden der Daten

Das Dataset enthält 9.995 Instanzen des Umsatzes verschiedener Produkte. Es enthält auch 21 Attribute. Diese Tabelle stammt aus der Datei Superstore.xlsx, die in diesem Notebook verwendet wird:

Zeilen-ID Auftrags-ID Auftragsdatum Ship Date Ship Mode Kundenkennung Kundenname Segment Land Stadt Staat Postleitzahl Region Produkt-ID Kategorie Unterkategorie Produktname Sales Menge Rabatt „Profit“ (Gewinn)
4 US-2015-108966 2015-10-11 2015-10-18 Standard-Klasse SO-20335 Sean O'Donnell Verbraucher USA Fort Lauderdale Florida 33311 Süd FUR-TA-10000577 Möbel Tabellen Bretford CR4500 Series Slim Rectangular Table 957.5775 5 0.45 -383.0310
11 CA-2014-115812 2014-06-09 2014-06-09 Standard-Klasse Standard-Klasse Brosina Hoffman Verbraucher USA Los Angeles Kalifornien 90032 West FUR-TA-10001539 Möbel Tabellen Chromcraft Rectangular Conference Tables 1706.184 9 0.2 85.3092
31 US-2015-150630 2015-09-17 2015-09-21 Standard-Klasse TB-21520 Tracy Blumstein Verbraucher USA Philadelphia Pennsylvania 19140 Ost OFF-EN-10001509 Office Supplies Umschläge Poly String Tie Envelopes 3.264 2 0.2 1.1016

Durch Definieren dieser Parameter können Sie dieses Notebook auf verschiedene Datasets anwenden:

IS_CUSTOM_DATA = False  # If TRUE, the dataset has to be uploaded manually

IS_SAMPLE = False  # If TRUE, use only rows of data for training; otherwise, use all data
SAMPLE_ROWS = 5000  # If IS_SAMPLE is True, use only this number of rows for training

DATA_ROOT = "/lakehouse/default"
DATA_FOLDER = "Files/salesforecast"  # Folder with data files
DATA_FILE = "Superstore.xlsx"  # Data file name

EXPERIMENT_NAME = "aisample-superstore-forecast"  # MLflow experiment name

Herunterladen des Datensatzes und Hochladen in Lakehouse

Dieser Code lädt eine öffentlich verfügbare Version des Datasets herunter und speichert es dann in einem Fabric-Lakehouse:

Wichtig

Denken Sie daran, ein Lakehouse zum Notebook hinzuzufügen, bevor Sie es ausführen. Andernfalls wird eine Fehlermeldung angezeigt.

import os, requests
if not IS_CUSTOM_DATA:
    # Download data files into the lakehouse if they're not already there
    remote_url = "https://synapseaisolutionsa.blob.core.windows.net/public/Forecast_Superstore_Sales"
    file_list = ["Superstore.xlsx"]
    download_path = "/lakehouse/default/Files/salesforecast/raw"

    if not os.path.exists("/lakehouse/default"):
        raise FileNotFoundError(
            "Default lakehouse not found, please add a lakehouse and restart the session."
        )
    os.makedirs(download_path, exist_ok=True)
    for fname in file_list:
        if not os.path.exists(f"{download_path}/{fname}"):
            r = requests.get(f"{remote_url}/{fname}", timeout=30)
            with open(f"{download_path}/{fname}", "wb") as f:
                f.write(r.content)
    print("Downloaded demo data files into lakehouse.")

Einrichten der MLflow-Experimentnachverfolgung

Microsoft Fabric erfasst automatisch die Werte von Eingabeparametern und Ausgabemetriken eines Machine Learning-Modells, während es von Ihnen trainiert wird. Dadurch werden die automatischen Protokollierungsfunktionen von MLflow erweitert. Die Informationen werden dann im Arbeitsbereich protokolliert, wo Sie sie über die MLflow-APIs oder die entsprechenden Experimente im Arbeitsbereich anzeigen und visualisieren können. Weitere Informationen zur automatischen Protokollierung finden Sie unter Automatische Protokollierung in Microsoft Fabric.

Rufen Sie zum Deaktivieren der automatischen Microsoft Fabric-Protokollierung in einer Notebooksitzung mlflow.autolog() auf und legen Sie disable=True fest:

# Set up MLflow for experiment tracking
import mlflow

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

Lesen von Rohdaten aus dem Lakehouse

Dieser Code liest Rohdaten aus dem Datei-Abschnitt des Lakehouses. Fügen Sie weitere Spalten für verschiedene Datumsteile hinzu. Dieselben Informationen werden zum Erstellen einer partitionierten Delta-Tabelle verwendet. Da die Rohdaten als Excel-Datei gespeichert sind, müssen Sie Pandas verwenden, um die Rohdaten zu lesen:

import pandas as pd
df = pd.read_excel("/lakehouse/default/Files/salesforecast/raw/Superstore.xlsx")

Schritt 2: Durchführen einer explorativen Datenanalyse

Importbibliotheken

Importieren Sie vor jeder Analyse die erforderlichen Bibliotheken:

# Importing required libraries
import warnings
import itertools
import numpy as np
import matplotlib.pyplot as plt
warnings.filterwarnings("ignore")
plt.style.use('fivethirtyeight')
import pandas as pd
import statsmodels.api as sm
import matplotlib
matplotlib.rcParams['axes.labelsize'] = 14
matplotlib.rcParams['xtick.labelsize'] = 12
matplotlib.rcParams['ytick.labelsize'] = 12
matplotlib.rcParams['text.color'] = 'k'
from sklearn.metrics import mean_squared_error,mean_absolute_percentage_error

Rohdaten anzeigen

Gehen Sie manuell eine Teilmenge der Daten durch, um das Dataset selbst besser zu verstehen, und drucken Sie den DataFrame über die Funktion display. Darüber hinaus lassen sich mit Chart-Ansichten Teilmengen des Datasets einfach visualisieren.

display(df)

Der Schwerpunkt dieses Notebooks liegt in erster Linie auf der Umsatzprognose für die Kategorie Furniture. Es dient zum Beschleunigen der Berechnung und zum Anzeigen der Leistung des Modells. Dieses Notebook verwendet jedoch anpassbare Techniken. Sie können diese Techniken erweitern, um den Umsatz anderer Produktkategorien vorherzusagen.

# Select "Furniture" as the product category
furniture = df.loc[df['Category'] == 'Furniture']
print(furniture['Order Date'].min(), furniture['Order Date'].max())

Vorverarbeiten der Daten

In realen Geschäftsszenarien ist es häufig erforderlich, den Umsatz in drei verschiedenen Kategorien vorherzusagen:

  • Eine bestimmte Produktkategorie
  • Eine bestimmte Kundenkategorie
  • Eine bestimmte Kombination aus Produktkategorie und Kundenkategorie

Löschen Sie zunächst unnötige Spalten zur Vorverarbeitung der Daten. Einige der Spalten (Row ID, Order ID,Customer ID und Customer Name) sind unnötig, da sie keine Auswirkungen haben. Da wir den Gesamtumsatz für eine bestimmte Produktkategorie (Furniture) im gesamten Bundesland und in der Region vorhersagen möchten, können wir die Spalten State, Region, Country, City und Postal Code entfernen. Für eine Prognose des Umsatzes für einen bestimmten Standort oder eine bestimmte Kategorie müssen Sie möglicherweise den Vorverarbeitungsschritt entsprechend anpassen.

# Data preprocessing
cols = ['Row ID', 'Order ID', 'Ship Date', 'Ship Mode', 'Customer ID', 'Customer Name', 
'Segment', 'Country', 'City', 'State', 'Postal Code', 'Region', 'Product ID', 'Category', 
'Sub-Category', 'Product Name', 'Quantity', 'Discount', 'Profit']
# Drop unnecessary columns
furniture.drop(cols, axis=1, inplace=True)
furniture = furniture.sort_values('Order Date')
furniture.isnull().sum()

Das Dataset wird täglich strukturiert. Wir müssen an der Spalte Order Date ein Resampling vornehmen, da wir ein Modell für eine monatliche Umsatzprognose erstellen möchten.

Gruppieren Sie zuerst die Furniture-Kategorie nach Order Date. Berechnen Sie dann die Summe der Spalte Sales für jede Gruppe, um den Gesamtumsatz für jeden eindeutigen Order Date-Wert zu bestimmen. Nehmen Sie ein Resampling der Spalte Sales mit der Frequenz MS vor, um die Daten nach Monat zu aggregieren. Berechnen Sie zum Schluss den mittleren Umsatzwert für jeden Monat.

# Data preparation
furniture = furniture.groupby('Order Date')['Sales'].sum().reset_index()
furniture = furniture.set_index('Order Date')
furniture.index
y = furniture['Sales'].resample('MS').mean()
y = y.reset_index()
y['Order Date'] = pd.to_datetime(y['Order Date'])
y['Order Date'] = [i+pd.DateOffset(months=67) for i in y['Order Date']]
y = y.set_index(['Order Date'])
maximim_date = y.reset_index()['Order Date'].max()

Veranschaulichen Sie die Auswirkungen von Order Date auf Sales für die Kategorie Furniture:

# Impact of order date on the sales
y.plot(figsize=(12, 3))
plt.show()

Vor einer statistischen Analyse müssen Sie das Python-Modul statsmodels importieren. Es stellt Klassen und Funktionen für die Schätzung vieler statistischer Modelle bereit. Es stellt außerdem Klassen und Funktionen für die Durchführung statistischer Tests und statistischer Datenuntersuchungen bereit.

import statsmodels.api as sm

Ausführen einer statistischen Analyse

Eine Zeitreihe verfolgt diese Datenelemente in festgelegten Intervallen, um die Variation dieser Elemente im Zeitreihenmuster zu bestimmen:

  • Niveau: Die grundlegende Komponente, die den Mittelwert für einen bestimmten Zeitraum darstellt

  • Trend: Beschreibt, ob die Zeitreihe im Laufe der Zeit abnimmt, konstant bleibt oder zunimmt

  • Saisonalität: Beschreibt das periodische Signal in der Zeitreihe und sucht nach zyklischen Vorkommen, die sich auf die Zunahme- oder Abnahmemuster der Zeitreihe auswirken

  • Rauschen/Rest: Bezieht sich auf die zufälligen Schwankungen in den Zeitreihendaten, die das Modell nicht erklären kann.

In diesem Code beobachten Sie diese Komponenten für Ihr Dataset nach der Vorverarbeitung:

# Decompose the time series into its components by using statsmodels
result = sm.tsa.seasonal_decompose(y, model='additive')

# Labels and corresponding data for plotting
components = [('Seasonality', result.seasonal),
              ('Trend', result.trend),
              ('Residual', result.resid),
              ('Observed Data', y)]

# Create subplots in a grid
fig, axes = plt.subplots(nrows=4, ncols=1, figsize=(12, 7))
plt.subplots_adjust(hspace=0.8)  # Adjust vertical space
axes = axes.ravel()

# Plot the components
for ax, (label, data) in zip(axes, components):
    ax.plot(data, label=label, color='blue' if label != 'Observed Data' else 'purple')
    ax.set_xlabel('Time')
    ax.set_ylabel(label)
    ax.set_xlabel('Time', fontsize=10)
    ax.set_ylabel(label, fontsize=10)
    ax.legend(fontsize=10)

plt.show()

Die Plots beschreiben die Saisonalität, den Trend und das Rauschen in den Vorhersagedaten. Sie können die zugrunde liegenden Muster erfassen und Modelle entwickeln, die präzise und für zufällige Schwankungen resiliente Vorhersagen bereitstellen.

Schritt 3: Trainieren und Nachverfolgen des Modells

Nachdem nun die Daten zur Verfügung stehen, muss das Prognosemodell definiert werden. Wenden Sie in diesem Notebook den saisonalen autoregressiven integrierten gleitenden Mittelwert mit exogenen Faktoren (SARIMAX) an. SARIMAX kombiniert autoregressive (AR)-Komponenten und Komponenten für gleitende Mittelwerte (MA) mit saisonalen und externen Prädiktoren, um genaue und flexible Vorhersagen für Zeitreihendaten zu erstellen.

Sie können auch die automatische MLfLow- und Fabric-Protokollierung verwenden, um die Experimente nachzuverfolgen. Laden Sie hier die Delta-Tabelle aus dem Lakehouse. Sie können andere Delta-Tabellen mit dem Lakehouse als Quelle verwenden.

# Import required libraries for model evaluation
from sklearn.metrics import mean_squared_error, mean_absolute_percentage_error

Optimieren von Hyperparametern

SARIMAX berücksichtigt die Parameter des regulären ARIMA-Modells (autoregressiver integrierter gleitender Mittelwert) (p, d, q) sowie zusätzlich die saisonalen Parameter(P, D, Q, s) . Diese Argumente für das SARIMAX-Modell werden als Ordnung (p, d, q) bzw. saisonale Ordnung (P, D, Q, s) bezeichnet. Zum Trainieren des Modells müssen wir daher zunächst sieben Parameter optimieren.

Die Ordnungsparameter:

  • p: Die Ordnung der AR-Komponente, die die Anzahl der vergangenen Werte in der Zeitreihe darstellt, die zum Vorhersagen des aktuellen Werts verwendet werden.

    In der Regel sollte dieser Parameter eine nicht negative ganze Zahl sein. Gängige Werte liegen im Bereich von 0 bis 3, obwohl höhere Werte je nach den spezifischen Merkmalen der Daten möglich sind. Ein höherer p-Wert gibt einen längeren Speicherzeitraum vergangener Werte im Modell an.

  • d: Die Ordnung für Differenzenbildung, die die Häufigkeit darstellt, mit der die Zeitreihen differenziert werden müssen, um Stationarität zu erreichen.

    Dieser Parameter sollte eine nicht negative ganze Zahl sein. Gängige Werte liegen im Bereich von 0 bis 2. Ein d-Wert von 0 bedeutet, dass die Zeitreihe bereits stationär ist. Höhere Werte geben die Anzahl der unterschiedlichen Vorgänge an, die erforderlich sind, um sie stationär zu machen.

  • q: Die Ordnung der MA-Komponente, die die Anzahl der vergangenen Rauschterme (weißes Rauschen) darstellt, die zur Vorhersage des aktuellen Werts verwendet werden.

    Dieser Parameter sollte eine nicht negative ganze Zahl sein. Gängige Werte liegen im Bereich von 0 bis 3, wobei für bestimmte Zeitreihen möglicherweise höhere Werte erforderlich sind. Ein höherer q-Wert zeigt eine stärkere Abhängigkeit von vergangenen Rauschtermen an, um Vorhersagen zu treffen.

Die saisonalen Ordnungsparameter:

  • P: Die saisonale Ordnung der AR-Komponente, ähnlich wie p, aber für den saisonalen Teil
  • D: Die saisonale Ordnung für Differenzenbildung, ähnlich wie d, aber für den saisonalen Teil
  • Q: Die saisonale Ordnung der MA-Komponente, ähnlich wie q, aber für den saisonalen Teil
  • s: Die Anzahl der Zeitschritte pro saisonalem Zyklus (z. B. 12 für Monatsdaten mit jährlicher Saisonalität)
# Hyperparameter tuning
p = d = q = range(0, 2)
pdq = list(itertools.product(p, d, q))
seasonal_pdq = [(x[0], x[1], x[2], 12) for x in list(itertools.product(p, d, q))]
print('Examples of parameter combinations for Seasonal ARIMA...')
print('SARIMAX: {} x {}'.format(pdq[1], seasonal_pdq[1]))
print('SARIMAX: {} x {}'.format(pdq[1], seasonal_pdq[2]))
print('SARIMAX: {} x {}'.format(pdq[2], seasonal_pdq[3]))
print('SARIMAX: {} x {}'.format(pdq[2], seasonal_pdq[4]))

SARIMAX hat andere Parameter:

  • enforce_stationarity: Steuert, ob das Modell die Stationarität für die Zeitreihendaten erzwingen soll, bevor das SARIMAX-Modell angepasst wird.

    Wenn enforce_stationarity auf True (Standardeinstellung) festgelegt ist, wird damit angegeben, dass das SARIMAX-Modell die Stationarität für die Zeitreihendaten erzwingen soll. Das SARIMAX-Modell wendet dann vor der Anpassung des Modells automatisch die Differenzenbildung auf die Zeitreihendaten an, damit diese stationär werden, wie durch die d- und D-Ordnungen angegeben. Dies ist eine gängige Praxis, da viele Zeitreihenmodelle, einschließlich SARIMAX, davon ausgehen, dass die Daten stationär sind.

    Bei einer nicht stationären Zeitreihe (die z. B. Trends oder saisonale Effekte aufweist) empfiehlt es sich, enforce_stationarity auf True festzulegen, damit das SARIMAX-Modell durch Differenzenbildung Stationarität erreichen kann. Legen Sie bei einer stationären Zeitreihe (die z. B. keine Trends oder saisonalen Schwankungen enthält) enforce_stationarity auf False fest, um die unnötige Differenzenbildung zu vermeiden.

  • enforce_invertibility: Steuert, ob das Modell während des Optimierungsprozesses die Invertierbarkeit für die geschätzten Parameter erzwingen soll.

    Wenn enforce_invertibility auf True (Standardeinstellung) festgelegt ist, wird damit angegeben, dass das SARIMAX-Modell die Invertierbarkeit für die geschätzten Parameter erzwingen soll. Die Invertierbarkeit stellt sicher, dass das Modell gut definiert ist und dass die geschätzten AR- und MA-Koeffizienten innerhalb des Bereichs der Stationarität liegen.

    Durch Erzwingen der Invertierbarkeit kann sichergestellt werden, dass das SARIMAX-Modell den theoretischen Anforderungen für ein stabiles Zeitreihenmodell entspricht. Außerdem werden Probleme mit der Modellschätzung und -stabilität verhindert.

Der Standard ist ein AR(1)-Modell. Dies bezieht sich auf (1, 0, 0). Es ist jedoch üblich, verschiedene Kombinationen der Ordnungsparameter und saisonalen Ordnungsparameter auszuprobieren und die Leistung des Modells für ein Dataset zu bewerten. Die entsprechenden Werte können von einer Zeitreihe zu einer anderen variieren.

Die Bestimmung der optimalen Werte umfasst häufig die Analyse der Autokorrelationsfunktion (ACF) und der partiellen Autokorrelationsfunktion (PACF) der Zeitreihendaten. Sie umfasst auch häufig die Verwendung von Modellauswahlkriterien, z. B. das Akaike-Informationskriterium (AIC) oder das Bayes'sche Informationskriterium (BIC).

Optimieren der Hyperparameter:

# Tune the hyperparameters to determine the best model
for param in pdq:
    for param_seasonal in seasonal_pdq:
        try:
            mod = sm.tsa.statespace.SARIMAX(y,
                                            order=param,
                                            seasonal_order=param_seasonal,
                                            enforce_stationarity=False,
                                            enforce_invertibility=False)
            results = mod.fit(disp=False)
            print('ARIMA{}x{}12 - AIC:{}'.format(param, param_seasonal, results.aic))
        except:
            continue

Nach Auswertung der vorangehenden Ergebnisse können Sie die Werte sowohl für die Ordnungsparameter als auch für die saisonalen Ordnungsparameter bestimmen. Die Wahl ist order=(0, 1, 1) und seasonal_order=(0, 1, 1, 12), die niedrigste AIC (z. B. 279,58). Verwenden Sie diese Werte zum Trainieren des Modells.

Modelltraining

# Model training 
mod = sm.tsa.statespace.SARIMAX(y,
                                order=(0, 1, 1),
                                seasonal_order=(0, 1, 1, 12),
                                enforce_stationarity=False,
                                enforce_invertibility=False)
results = mod.fit(disp=False)
print(results.summary().tables[1])

Dieser Code visualisiert eine Zeitreihenprognose für Möbelumsatzdaten. Die dargestellten Ergebnisse zeigen sowohl die beobachteten Daten als auch die Ein-Schritt-Vorhersage mit einem Konfidenzintervall (schattierter Bereich) an.

# Plot the forecasting results
pred = results.get_prediction(start=maximim_date, end=maximim_date+pd.DateOffset(months=6), dynamic=False) # Forecast for the next 6 months (months=6)
pred_ci = pred.conf_int() # Extract the confidence intervals for the predictions
ax = y['2019':].plot(label='observed')
pred.predicted_mean.plot(ax=ax, label='One-step ahead forecast', alpha=.7, figsize=(12, 7))
ax.fill_between(pred_ci.index,
                pred_ci.iloc[:, 0],
                pred_ci.iloc[:, 1], color='k', alpha=.2)
ax.set_xlabel('Date')
ax.set_ylabel('Furniture Sales')
plt.legend()
plt.show()

# Validate the forecasted result
predictions = results.get_prediction(start=maximim_date-pd.DateOffset(months=6-1), dynamic=False)
# Forecast on the unseen future data
predictions_future = results.get_prediction(start=maximim_date+ pd.DateOffset(months=1),end=maximim_date+ pd.DateOffset(months=6),dynamic=False)

Verwenden Sie predictions, um die Leistung des Modells durch Gegenüberstellung mit den tatsächlichen Werten zu bewerten. Der predictions_future-Wert steht für die zukünftige Prognose.

# Log the model and parameters
model_name = f"{EXPERIMENT_NAME}-Sarimax"
with mlflow.start_run(run_name="Sarimax") as run:
    mlflow.statsmodels.log_model(results,model_name,registered_model_name=model_name)
    mlflow.log_params({"order":(0,1,1),"seasonal_order":(0, 1, 1, 12),'enforce_stationarity':False,'enforce_invertibility':False})
    model_uri = f"runs:/{run.info.run_id}/{model_name}"
    print("Model saved in run %s" % run.info.run_id)
    print(f"Model URI: {model_uri}")
mlflow.end_run()

# Load the saved model
loaded_model = mlflow.statsmodels.load_model(model_uri)

Schritt 4: Bewerten des Modells und Speichern der Vorhersageergebnisse

Integrieren Sie die tatsächlichen Werte in die prognostizierten Werte zum Erstellen eines Power BI-Berichts. Speichern Sie diese Ergebnisse in einer Tabelle im Lakehouse.

# Data preparation for Power BI visualization
Future = pd.DataFrame(predictions_future.predicted_mean).reset_index()
Future.columns = ['Date','Forecasted_Sales']
Future['Actual_Sales'] = np.NAN
Actual = pd.DataFrame(predictions.predicted_mean).reset_index()
Actual.columns = ['Date','Forecasted_Sales']
y_truth = y['2023-02-01':]
Actual['Actual_Sales'] = y_truth.values
final_data = pd.concat([Actual,Future])
# Calculate the mean absolute percentage error (MAPE) between 'Actual_Sales' and 'Forecasted_Sales' 
final_data['MAPE'] = mean_absolute_percentage_error(Actual['Actual_Sales'], Actual['Forecasted_Sales']) * 100
final_data['Category'] = "Furniture"
final_data[final_data['Actual_Sales'].isnull()]

input_df = y.reset_index()
input_df.rename(columns = {'Order Date':'Date','Sales':'Actual_Sales'}, inplace=True)
input_df['Category'] = 'Furniture'
input_df['MAPE'] = np.NAN
input_df['Forecasted_Sales'] = np.NAN

# Write back the results into the lakehouse
final_data_2 = pd.concat([input_df,final_data[final_data['Actual_Sales'].isnull()]])
table_name = "Demand_Forecast_New_1"
spark.createDataFrame(final_data_2).write.mode("overwrite").format("delta").save(f"Tables/{table_name}")
print(f"Spark DataFrame saved to delta table: {table_name}")

Schritt 5: Visualisieren in Power BI

Der Power BI-Bericht zeigt einen MAPE-Wert (Mean Absolute Percentage Error) von 16,58 an. Die MAPE-Metrik definiert die Genauigkeit einer Prognosemethode. Sie stellt die Genauigkeit der prognostizierten Mengen im Vergleich zu den tatsächlichen Mengen dar.

MAPE ist eine einfache Metrik. Ein MAPE-Wert von 10 % gibt an, dass die durchschnittliche Abweichung zwischen den prognostizierten Werten und den tatsächlichen Werten 10 % beträgt, unabhängig davon, ob die Abweichung positiv oder negativ ist. Die Standards für erstrebenwerte MAPE-Werte variieren je nach Branche.

Die hellblaue Linie in diesem Diagramm stellt die tatsächlichen Umsatzwerte dar. Die dunkelblaue Linie stellt die prognostizierten Umsatzwerte dar. Der Vergleich des tatsächlichen und prognostizierten Umsatzes zeigt, dass das Modell in den ersten sechs Monaten des Jahres 2023 effektiv den Umsatz für die Kategorie Furniture vorhersagt.

Screenshot of a Power BI report.

Basierend auf dieser Beobachtung können wir auf die Vorhersagefähigkeit des Modells für den Gesamtumsatz in den letzten sechs Monaten des Jahres 2023 und bis ins Jahr 2024 vertrauen. Dieses Vertrauen kann strategische Entscheidungen über Bestandsmanagement, Rohstoffbeschaffung und andere geschäftsbezogene Überlegungen unterstützen.

Zugehöriger Inhalt