Erstellen von Zeitreihenmodellen für maschinelles Lernen mit Sktime in Python

# Einführung

Wenn Sie mit Sensorwerten, Servermetriken oder anderen Daten arbeiten, die im Laufe der Zeit ankommen, kennen Sie diesen Customary bereits scikit-lernen Rohrleitungen passen nicht ganz. Zeitreihendaten haben eine Struktur, die tabellarische Modelle ignorieren: Saisonalität, Pattern, zeitliche Reihenfolge und die Tatsache, dass zukünftige Werte von vergangenen Werten abhängen.

Skizeit ist eine speziell dafür entwickelte Python-Bibliothek. Sie erhalten eine API im Scikit-Study-Stil – anpassen, vorhersagen, transformieren –, die jedoch von Grund auf für Zeitreihen konzipiert ist. Sie können Prognosen, Klassifizierungen, Regressionen und Clustering für Zeitreihen durchführen – und das alles über eine konsistente Schnittstelle.

In diesem Artikel bearbeiten Sie ein Beispielproblem: die Vorhersage von Temperaturmesswerten eines industriellen HVAC-Sensors. Sie erfahren, wie sktime mit Zeitreihendaten umgeht, wie Sie Vorverarbeitungspipelines erstellen, wie Sie Prognostiker anpassen und wie Sie diese auswerten.

Den Code erhalten Sie auf GitHub.

# Voraussetzungen

Du wirst brauchen Python 3.10 oder höher und eine grundlegende Vertrautheit mit Pandas. Installieren Sie alles, was Sie brauchen mit:

pip set up sktime pmdarima statsmodels

Wenn Sie lieber alle optionalen Abhängigkeiten auf einmal haben möchten, pip set up sktime(all_extras) deckt sie ab.

# Was macht Freizeit sinnvoll?

Es hilft zu verstehen, welches Downside Sktime löst. In scikit-learn sind Ihre Daten eine 2D-Tabelle – Zeilen sind Beispiele, Spalten sind Options. Zeitreihendaten widerlegen diese Annahme, da jede „Zeile“ tatsächlich eine Folge von Werten im Zeitverlauf ist und die Reihenfolge dieser Werte von Bedeutung ist.

Die wichtigsten Datencontainer, die Sie verwenden werden, sind:

Für den Zeitindex selbst unterstützt sktime mehrere Zeitindizes: DatetimeIndex, PeriodIndex, Int64IndexUnd RangeIndex auf deinen Pandas-Objekten. Der Index muss monoton sein. Wenn Sie verwenden DatetimeIndexDie freq Das Attribut sollte festgelegt werden.

# Einrichten des Datensatzes

Lassen Sie uns einen realistischen Datensatz erstellen. Stellen Sie sich einen HVAC-Sensor in einer Fabrik vor, der stündlich die Temperatur aufzeichnet. Die Messwerte weisen ein tägliches saisonales Muster auf (höher während der Arbeitszeit), einen leichten Aufwärtstrend aufgrund des Sommers und etwas Lärm.

import numpy as np
import pandas as pd

np.random.seed(42)

# 90 days of hourly readings beginning Jan 1, 2026
n_hours = 90 * 24
timestamps = pd.date_range(begin="2026-01-01", durations=n_hours, freq="h")

# Pattern: gradual 5-degree rise over 90 days
development = np.linspace(0, 5, n_hours)

# Each day seasonality: temperature peaks at 2pm, dips at 4am
hour_of_day = np.arange(n_hours) % 24
daily_cycle = 4 * np.sin(2 * np.pi * (hour_of_day - 4) / 24)

# Noise
noise = np.random.regular(0, 0.8, n_hours)

# Base temperature round 20°C
temperature = 20 + development + daily_cycle + noise

# Introduce just a few lacking values (sensor dropout)
dropout_indices = (300, 301, 302, 1440, 1441)
temperature(dropout_indices) = np.nan

y = pd.Collection(temperature, index=timestamps, identify="temp_celsius")
y.index.freq = pd.tseries.frequencies.to_offset("h")

print(y.head())
print(f"nShape: {y.form}")
print(f"Lacking values: {y.isna().sum()}")
print(f"Index sort: {sort(y.index)}")

Ausgabe:

2026-01-01 00:00:00    16.933270
2026-01-01 01:00:00    17.063277
2026-01-01 02:00:00    18.522783
2026-01-01 03:00:00    20.190095
2026-01-01 04:00:00    19.821941
Freq: h, Title: temp_celsius, dtype: float64

Form: (2160,)
Lacking values: 5
Index sort: 

# Aufteilen von Zeitreihendaten für Coaching und Exams

Das Aufteilen von Zeitreihendaten unterscheidet sich von tabellarischen Daten: Zeilen können nicht gemischt werden. Sie müssen immer chronologisch aufteilen: Trainieren Sie anhand früherer Daten, testen Sie anhand späterer Daten.

Sktime bietet temporal_train_test_split zu diesem Zweck:

from sktime.break up import temporal_train_test_split

# Maintain out the final 7 days (168 hours) because the take a look at set
y_train, y_test = temporal_train_test_split(y, test_size=168)

print(f"Practice: {y_train.index(0)} → {y_train.index(-1)}")
print(f"Check:  {y_test.index(0)} → {y_test.index(-1)}")
print(f"Practice dimension: {len(y_train)}, Check dimension: {len(y_test)}")

Ausgabe:

Practice: 2026-01-01 00:00:00 → 2026-03-24 23:00:00
Check:  2026-03-25 00:00:00 → 2026-03-31 23:00:00
Practice dimension: 1992, Check dimension: 168

Die Funktion stellt sicher, dass die Aufteilung sauber und chronologisch ist – kein Datenleck aus der Zukunft in den Trainingssatz.

# Definieren des Prognosehorizonts

Bevor Sie ein Modell anpassen, müssen Sie sktime mitteilen, welche Zeitschritte Sie vorhersagen möchten. Das ist das ForecastingHorizon.

from sktime.forecasting.base import ForecastingHorizon

# Predict 168 steps forward (7 days of hourly information)
# is_relative=False means we're utilizing absolute timestamps
fh = ForecastingHorizon(y_test.index, is_relative=False)

print(f"Horizon size: {len(fh)}")
print(f"First forecast level: {fh(0)}")
print(f"Final forecast level:  {fh(-1)}")

Das ergibt:

Horizon size: 168
First forecast level: 2026-03-25 00:00:00
Final forecast level:  2026-03-31 23:00:00

Sie können auch verwenden relative Horizonte wie fh = (1, 2, 3, ..., 168)was „1 Schritt voraus, 2 Schritte voraus, …“ bedeutet. Absolute Horizonte sind sauberer, wenn Sie tatsächliche Zeitstempel haben, für die Sie Vorhersagen wünschen.

# Aufbau einer Vorverarbeitungs- und Prognosepipeline

Echte Sensordaten weisen fehlende Werte, saisonale Muster und Traits auf – Sie müssen all dies vor oder während der Prognose berücksichtigen. Sktime’s TransformedTargetForecaster ermöglicht die Verkettung von Transformationen mit einem Prognostiker zu einem einzigen Schätzer. Die Transformationen werden auf die Zielreihe angewendet y vor dem Einpassen und beim Auslaufen während der Vorhersage automatisch umgekehrt.

from sktime.forecasting.exp_smoothing import ExponentialSmoothing
from sktime.forecasting.compose import TransformedTargetForecaster
from sktime.transformations.collection.impute import Imputer
from sktime.transformations.collection.detrend import Deseasonalizer, Detrender

pipeline = TransformedTargetForecaster(
    steps=(
        # Step 1: Fill lacking sensor readings utilizing linear interpolation
        ("imputer", Imputer(technique="linear")),
        # Step 2: Take away the linear development so the forecaster sees a stationary collection
        ("detrender", Detrender()),
        # Step 3: Take away the day by day seasonality (sp=24 for hourly information with 24-hour cycles)
        ("deseasonalizer", Deseasonalizer(mannequin="additive", sp=24)),
        # Step 4: Forecast the cleaned, stationary residuals
        ("forecaster", ExponentialSmoothing(development=None, seasonal=None)),
    )
)

pipeline.match(y_train, fh=fh)
y_pred = pipeline.predict()

print(y_pred.head())

Ausgabe:

2026-03-25 00:00:00    21.210066
2026-03-25 01:00:00    21.788986
2026-03-25 02:00:00    22.615184
2026-03-25 03:00:00    23.688449
2026-03-25 04:00:00    24.621127
Freq: h, Title: temp_celsius, dtype: float64

Hier erfahren Sie, was jeder Schritt bewirkt:

• Imputer(technique="linear") Füllt fehlende Werte durch lineare Interpolation zwischen den umgebenden Messwerten, was für Sensordaten intestine funktioniert.
• Detrender() Passt einen linearen Pattern an die Trainingsreihe an und subtrahiert ihn; Bei der Vorhersage wird der Pattern wieder hinzugefügt.
• Deseasonalizer(sp=24) entfernt den 24-Stunden-Zyklus aus den Resten; sp steht für Saisonperiode.
• Endlich, ExponentialSmoothing prognostiziert die trendbereinigten, desaisonalisierten Residuen.
• Wann predict() aufgerufen wird, werden alle Rücktransformationen automatisch in umgekehrter Reihenfolge angewendet und Sie erhalten Vorhersagen in der ursprünglichen Temperaturskala zurück.

# Auswertung der Prognose

Sktime lässt sich integrieren mit Standardbewertungsmetriken. Für Prognosen werden häufig der mittlere absolute Fehler (MAE) und der mittlere absolute prozentuale Fehler (MAPE) gewählt.

from sktime.performance_metrics.forecasting import (
    mean_absolute_error,
    mean_absolute_percentage_error,
)

mae = mean_absolute_error(y_test, y_pred)
mape = mean_absolute_percentage_error(y_test, y_pred)

print(f"MAE:  {mae:.3f} °C")
print(f"MAPE: {mape*100:.2f}%")

Ausgabe:

MAE:  0.584 °C
MAPE: 2.40%

# Austausch eines anderen Forecasters

Einer der größten Vorteile der Sktime-Schnittstelle besteht darin, dass zum Austausch des zugrunde liegenden Algorithmus nur eine Zeile geändert werden muss. Versuchen wir es mit einem ARIMA-Modell anstelle der exponentiellen Glättung und vergleichen wir es.

from sktime.forecasting.arima import ARIMA

pipeline_arima = TransformedTargetForecaster(
    steps=(
        ("imputer", Imputer(technique="linear")),
        ("detrender", Detrender()),
        ("deseasonalizer", Deseasonalizer(mannequin="additive", sp=24)),
        # ARIMA(1,1,1) on the cleaned residuals
        ("forecaster", ARIMA(order=(1, 1, 1), suppress_warnings=True)),
    )
)

pipeline_arima.match(y_train, fh=fh)
y_pred_arima = pipeline_arima.predict()

mae_arima = mean_absolute_error(y_test, y_pred_arima)
mape_arima = mean_absolute_percentage_error(y_test, y_pred_arima)

print(f"ARIMA MAE:  {mae_arima:.3f} °C")
print(f"ARIMA MAPE: {mape_arima*100:.2f}%")

Ausgabe:

ARIMA MAE:  0.586 °C
ARIMA MAPE: 2.41%

Der entscheidende Punkt ist, dass die Vorverarbeitungsschritte – Imputation, Trendberechnung, Desaisonalisierung – identisch geblieben sind. Sie haben nur den endgültigen Prognostiker geändert und alles andere sauber darum herum angeordnet.

# Kreuzvalidierung im Zeitverlauf

Das Verschweigen eines einzelnen Testfensters kann irreführend sein. sktime bietet eine Kreuzvalidierung von Zeitreihen durch Splitter, die die zeitliche Reihenfolge berücksichtigen.

SlidingWindowSplitter verwendet ein rollierendes Fenster: Das Trainingsfenster verschiebt sich zeitlich nach vorne und bleibt immer gleich lang. ExpandingWindowSplitter Der Trainingssatz wächst im Laufe der Zeit kumulativ. Dies ist besser geeignet, wenn Sie den gesamten verfügbaren Verlauf nutzen möchten.

from sktime.break up import ExpandingWindowSplitter
from sktime.forecasting.model_evaluation import consider

# Increasing window: begin with 1800-hour practice set, consider on 168-hour home windows
cv = ExpandingWindowSplitter(
    initial_window=1800,
    fh=record(vary(1, 169)),
    step_length=168,
)

outcomes = consider(
    forecaster=pipeline,
    y=y,
    cv=cv,
    scoring=mean_absolute_error,
    return_data=False,
)

print(outcomes(("test__DynamicForecastingErrorMetric", "fit_time")).spherical(3))
print(f"nMean CV MAE: {outcomes('test__DynamicForecastingErrorMetric').imply():.3f} °C")

Ausgabe:

   test__DynamicForecastingErrorMetric  fit_time
0                                0.627     0.274
1                                0.585     0.100

Imply CV MAE: 0.606 °C

consider gibt einen DataFrame mit Professional-Fold-Metriken und Timing zurück. Die Kreuzvalidierung MAE bestätigt, dass das Modell über verschiedene Zeitfenster in den Daten konsistent verallgemeinert.

# Nächste Schritte

In diesem Artikel wurde der Kern-Prognose-Workflow in Sktime behandelt, aber die Bibliothek geht weit über grundlegende Vorhersageaufgaben hinaus.

Es unterstützt auch Zeitreihenklassifizierung, probabilistische Prognose mit Unsicherheitsschätzungen, Coaching gemeinsamer Modelle über mehrere verwandte Zeitreihen hinweg, Anpassung herkömmlicher Algorithmen für maschinelles Lernen für sequentielle Prognosen und Automatisierung der Arbeitsabläufe bei der Modellauswahl und -optimierung.

Eine der größten Stärken von sktime ist seine konsistente API und Integration in das breitere Python-Ökosystem für maschinelles Lernen, was das Experimentieren sowohl für Anfänger als auch für erfahrene Praktiker erleichtert. Der Sktime-Dokumente Und Beispiel-Notizbücher sind besonders intestine geschrieben und es lohnt sich, sie als Lesezeichen zu speichern, wenn Sie regelmäßig mit Prognosen oder zeitlichen Datenproblemen arbeiten.

Bala Priya C ist ein Entwickler und technischer Redakteur aus Indien. Sie arbeitet gerne an der Schnittstelle von Mathematik, Programmierung, Datenwissenschaft und Inhaltserstellung. Zu ihren Interessen- und Fachgebieten gehören DevOps, Datenwissenschaft und Verarbeitung natürlicher Sprache. Sie liebt es zu lesen, zu schreiben, zu programmieren und Kaffee zu trinken! Derzeit arbeitet sie daran, zu lernen und ihr Wissen mit der Entwickler-Neighborhood zu teilen, indem sie Tutorials, Anleitungen, Meinungsbeiträge und mehr verfasst. Bala erstellt außerdem ansprechende Ressourcenübersichten und Programmier-Tutorials.