Zeitreihen Features einfach generiert: Ein praktischer Ansatz für einfache Modelle
- Von Mark Willoughby
Share post:
Von allen Schritten der Zeitreihenanalyse und -prognose ist die Erstellung von Merkmalen (Features) einer der wichtigsten. Zeitreihenmerkmale sind in der Lage, den Trend, die Saisonalität, Lags oder rollierende Statistiken zu erfassen, die dem Modell helfen, die zeitliche Dynamik zu verstehen.
In diesem Beitrag gehen wir darauf ein, welche praktischen Tools und Techniken zur Generierung von Zeitreihenmerkmalen einsetzen werden können. Wir vermeiden Komplikationen beim Deep Learning und konzentrieren uns auf effektive, einfache Ansätze zur Erstellung von Merkmalen, die einfachere Modelle befähigen, robuste, erklärbare Vorhersagen zu liefern.
Wie Features generieren: Feature engineering vs. Deep Learning Methoden?
Während Deep-Learning-Modelle automatisch komplexe Darstellungen aus rohen Zeitreihendaten erlernen können und direkt mit begrenzter oder sogar ohne Merkmalstransformation trainiert werden können, sind klassischere Modelle wie lineare Regression und Entscheidungsbäume in hohem Maße auf gut ausgearbeitete Merkmale angewiesen. Diese Modelle sind am leistungsfähigsten, wenn sie mit aussagekräftigen Merkmalen gefüttert werden, die aus den Rohdaten extrahiert werden; das Feature-Engineering ist dann ein wesentlicher Bestandteil für eine gute Leistung und Erklärbarkeit des Modells.
Die gute Nachricht ist, es ist keine ausgefeilte KI nötig, um aussagekräftige Zeitreihenmerkmale zu erzeugen. Stattdessen ermöglichen Tools und Bibliotheken, die sich auf deterministische funktionale Transformationen konzentrieren, diese mit sehr geringem Aufwand zu extrahieren: effiziente, interpretierbare Methoden sind ideal für einfache maschinelle Lernmodelle.
Python Bibliotheken zur Generierung von Zeitreihen Features
Einige wenige Bibliotheken sind in der Lage, den Prozess der Extraktion von Merkmalen aus Zeitreihendaten zu automatisieren. Zu den bekanntesten gehören Catch22, das 22 sorgfältig kuratierte Zeitreihenmerkmale bereitstellt, und tsfresh, eine umfangreiche Bibliothek für die Extraktion einer breiten Palette von Zeitreihenmerkmalen. Diese Tools sind zwar äußerst leistungsfähig, können aber sehr rechenintensiv sein und eignen sich daher nicht so gut für sehr große Datensätze oder Echtzeitanwendungen, wie sie in der Industrie üblich sind.
In diesem Beitrag werden wir uns auf Functime konzentrieren, eine leichtgewichtige und effiziente Open-Source-Bibliothek für schnelle Feature-Generierung, die auf Rust basiert und nahtlos in Polars integriert ist. Functime bietet ein hervorragendes Gleichgewicht zwischen Rechengeschwindigkeit und Flexibilität und eignet sich daher ideal für Szenarien, in denen Einfachheit und Leistung entscheidend sind. Es ist so optimiert, dass es die mühelose Berechnung statistischer Merkmale, einschließlich Verzögerungen, über eine gewünschte Periodizität ermöglicht. Mit Functime können schnell die Merkmale für einfachere Modelle erzeugt werden, ohne die Komplexität und den Overhead aufwändigerer Tools.
UseCase: Vorhersage der Abschaltung einer Wasserpumpe
In diesem Anwendungsfall geht es um die Vorhersage der Abschaltungen einer Wasserpumpe anhand von Zeitreihendaten. Der Datensatz besteht aus unverarbeiteten Sensormesswerten, die in regelmäßigen Zeitabständen von 52 Sensoren erfasst werden, zusammen mit einem Zeitstempel und einer Statusbezeichnung (
machine_status). Jeder Sensor erfasst einen bestimmten Aspekt des Pumpenbetriebs, z. B. Druck, Temperatur oder Durchflussmenge.
Der Datensatz enthält folgende Spalten:
timestamp # Zeitstempel jeder Beobachtung
sensor_00 # Messwerte von Sensor 00
...
sensor_51 # Messwerte von Sensor 51
maschine_status # Betriebsstatus der Pumpe (NORMAL, WARNUNG oder ABGESCHALTET)
Die Daten für unser Beispiel stammen aus dem gleichnamigen Use Case auf Kaggle
ts_sensor_path = Path(os.path.abspath("")).parents[1] / "data" / "ts_data"/ "ts_sensor_data.csv"
ts_sensor_data = pl.read_csv(source=ts_sensor_path)
ts_sensor_data.head()
Features erstellen mit FUNCTIME
Mit Functime stellen wir uns den Herausforderungen der Modellierung: die Erzeugung von Zeitreihenmerkmale. Das Tool berechnete statistische Merkmale über bestimmte Zeiträume und hilft dabei, die ursprünglichen Daten in eine Reihe von intuitiven Merkmalen umzuwandeln. Für die Zwecke dieser Präsentation haben wir statistische Merkmale wie das absolute Maximum und den quadratischen Mittelwert für alle sechs Stunden der Daten jedes Sensors berechnet. Über 312 Merkmale wurden aus den Daten von 52 Sensoren in nur 73 Millisekunden berechnet, was die Effizienz des Verfahrens zur Merkmalserstellung verdeutlicht. Diese schnelle Berechnung ermöglicht die Verarbeitung von Echtzeit- oder Hochfrequenz-Sensordatenströmen ohne nennenswerten Berechnungsaufwand. Die berechneten Merkmale können direkt als Input für klassische Modelle wie lineare Regression, Random Forests oder Gradient Boosted Trees verwendet werden.
def generate_features_for_timeseries(column_name: str) -> dict:
ts = pl.col(column_name).ts
return {
f"mean_n_absolute_max_{column_name}": ts.mean_n_absolute_max(n_maxima=3),
f"range_over_mean_{column_name}": ts.range_over_mean(),
f"root_mean_square_{column_name}": ts.root_mean_square(),
f"first_location_of_maximum_{column_name}": ts.first_location_of_maximum(),
f"last_location_of_maximum_{column_name}": ts.last_location_of_maximum(),
f"absolute_maximum_{column_name}": ts.absolute_maximum()
}
sensor_columns = [col for col in ts_sensor_data.columns if col not in ['timestamp', 'machine_status', '']]
new_features = {
feature_name: calculation
for sensor_column in sensor_columns
for feature_name, calculation in generate_features_for_timeseries(sensor_column).items()
}
timeseries_features = (
ts_sensor_data.group_by_dynamic(
index_column="timestamp",
every="6h",
group_by="machine_status",
start_by="window"
)
.agg(**new_features)
)
timeseries_features.head()
Die folgende Grafik zeigt, wie gut unsere Merkmale mit unseren Zielen korrelieren. Diese Zeitreihen Features bieten wertvolle Einblicke in das Verhalten der Sensoren und ihre Beziehung zum Pumpenstatus (
NORMAL, BROKEN oder RECOVERING). Wir können zum Beispiel feststellen, dass die Pumpe kaputt ist, wenn der quadratische Mittelwert von Sensor 48 nahe 0 liegt. Wir erwarten auch, dass höhere absolute Maximalwerte für die Sensoren 3, 4 und 11 die Wahrscheinlichkeit erhöhen, dass sich die Pumpe in einem NORMAL-Zustand befindet. 
Modellvorhersagen mit unseren Zeitreihenfeatures
Anhand der berechneten Merkmale erstellen wir ein Vorhersagemodell zur Klassifizierung des Betriebszustands der Wasserpumpe.
Mit Hilfe von
SelectKBest wählen wir die 30 wichtigsten Merkmale auf der Grundlage der ANOVA F-Statistiken aus. Als Basismodell haben wir uns für einen HistGradientBoostingClassifier entschieden, der robust gegenüber unausgewogenen Klassen ist und von Haus gute Vorhersagen liefert.
Dieser schlanke Ansatz, der auf einer leichten Merkmalsgenerierung beruht, zeigt, wie klassische Modelle hochwertige Vorhersagen liefern können, wenn sie mit ausgereiften Zeitreihenmerkmalen kombiniert werden.
Unsere Key Insights für die Modellnutzung und -vorhersagebewertung:
- Die Feature-Generierung nutzt Rust-basierte
functime– undpolars-Datenverarbeitungsbibliotheken, die es ermöglichen, mit großen Datensätzen selbst auf einem einfachen Notebook zu arbeiten. - Das Modell geht effektiv mit Klassenungleichgewichten um und erreicht hohe Werte in allen Kategorien. Dies beweist die Stärke des
HistGradientBoostingClassifierin Kombination mit den gut ausgearbeiteten Zeitreihenmerkmalen. - Geringfügige Leistungseinbrüche bei der Klasse
RECOVERINGdeuten auf mögliche Verbesserungen hin, wie z. B. eine Feinabstimmung des Modells oder die Einbeziehung zusätzlicher Merkmale, die auf Übergangszustände zugeschnitten sind.
X = timeseries_features[timeseries_features.columns[2:]]
y = timeseries_features["machine_status"]
selector = SelectKBest(score_func=f_classif, k=30).set_output(transform="pandas")
X_selected = selector.fit_transform(X, y)
X_train, X_test, y_train, y_test = train_test_split(X_selected, y, test_size=0.3, random_state=42, stratify=y)
model = HistGradientBoostingClassifier(random_state=42, class_weight="balanced")
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
report = classification_report(y_test, y_pred)
print(report)
| PRECISION | recall | F1-SCORE | N (Support) | |
|---|---|---|---|---|
| BROKEN | 1.00 | 1.00 | 1.00 | 2 |
| NORMAL | 0.99 | 1.00 | 1.00 | 346 |
| RECOVERING | 0.96 | 0.92 | 0.94 | 26 |
| accuracy | 0.99 | 374 | ||
| macro avg | 0.98 | 0.97 | 0.98 | 374 |
| weighted avg | 0.99 | 0.99 | 0.99 | 374 |
Dank der optimierten Merkmalsgenerierung zeigt das Modell eine außerordentlich vielversprechende Leistung in allen Klassen
Unsere Interpration der Modellperformance mit den generierten Zeitreihenfeatures:
- BROKEN: Das Modell macht perfekte Vorhersagen mit Precision, Recall und F1-Score von 1,00, ist aber möglicherweise nicht sehr zuverlässig, da es nur zwei Beispiele gibt (Support = 2);
- NORMAL: Das Modell ist mit 99% Präzision und 100% Recall nahezu perfekt, was zeigt, dass fast alle normalen Beispiele korrekt identifiziert wurden;
- RECOVERING: Es gab einen leichten Leistungsabfall (F1-Score = 0,94) aufgrund einiger falsch negativer Ergebnisse, was darauf hindeutet, dass Verbesserungen durch Feature-Engineering oder Hyperparameter-Tuning möglich sind.
Fazit: FuncTime Paket als echte Hilfe für Zeitreihenfeatures
Das Python Paket
Functime kann das Leben wirklich erleichtern, in dem es in sekundenschnell die Zeitreihenfeatures erstellt. Für unser Modell zur Vorhersage der Funktionalität von Wasserpumpen war die Performance schon wirklich vielversprechend, ohne, dass wir aufwändiges Fine Tuning betreiben mussten. Ein weiterer Vorteil von automatisierter Featureerstellung ist natürlich auch, dass kein Feature ausversehen vergessen wird und das Vorgehen auch mit neuen oder erweiterten Daten einfach wiederholen werden kann. 
Mark Willhoughby
Data Scientist