Katz - Rahmen für die Zeitreihenanalyse

Die Zeitreihenanalyse ist ein grundlegender Bereich der Datenwissenschaft und des maschinellen Lernens mit massiven Anwendungen in verschiedenen Bereichen wie E-Commerce, Finanzen, Kapazitätsplanung, Lieferkettenmanagement, Medizin, Wetter, Energie, Astronomie und vielen anderen.

Zeitreihenanalyse

Die Zeitreihenanalyse als statistische Technik wird zur Untersuchung und Modellierung zeitabhängiger Daten verwendet. Zu den gemeinsamen Merkmalen der Tools für die Zeitreihenanalyse gehören:

• Zeitreihenzerlegung: die Fähigkeit, eine Zeitreihe in ihre Bestandteile zu zerlegen, z.B. Trend, Saisonalität und Residuen
• Prognose: die Fähigkeit, zukünftige Werte einer Zeitreihe auf der Grundlage vergangener Daten vorherzusagen
• Anomalie-Erkennung: die Fähigkeit, ungewöhnliches oder unerwartetes Verhalten in einer Zeitreihe zu erkennen
• Multivariate Analyse: die Fähigkeit, mehrere Zeitreihen gleichzeitig zu analysieren und dabei die Beziehungen zwischen ihnen zu berücksichtigen
• Merkmalsextraktion/Einbettung: die Fähigkeit, aussagekräftige Merkmale aus Zeitreihendaten zu extrahieren oder Zeitreihendaten für die weitere Analyse in einem niedrigdimensionalen Raum darzustellen.

Dies sind nur einige Beispiele für die Arten von Funktionen, die in einem Zeitreihenanalyse-Tool enthalten sein können. Schauen wir mal, was Kats uns bieten kann.

Kats ist eine zentrale Anlaufstelle

Kats ist ein leichtgewichtiges, benutzerfreundliches und verallgemeinerbares Framework für die generische Zeitreihenanalyse, einschließlich Vorhersage, Anomalieerkennung, multivariate Analyse und Merkmalsextraktion/-einbettung.

Kats ist die erste umfassende Python-Bibliothek für die generische Zeitreihenanalyse, die sowohl klassische als auch fortgeschrittene Techniken zur Modellierung von Zeitreihendaten bietet.

Kats verbindet verschiedene Bereiche der Zeitreihenanalyse, in denen die Benutzer die grundlegenden Merkmale ihrer Zeitreihendaten erforschen, die zukünftigen Werte vorhersagen, die Anomalien überwachen und sie in ihre ML-Modelle und Pipelines einbauen können.

Was es tut

Kats bietet eine Reihe von Algorithmen und Modellen für vier Bereiche der Zeitreihenanalyse: Vorhersage, Erkennung, Merkmalsextraktion und -einbettung sowie multivariate Analyse.

• Vorhersage: Kats bietet ein komplettes Toolset für die Vorhersage, das 10+ individuelle Vorhersagemodelle, Ensembling, ein Modell für selbstüberwachtes Lernen (Meta-Learning), Backtesting, Hyperparameter-Tuning und empirische Vorhersageintervalle umfasst.

• Erkennung: Kats unterstützt Funktionen zur Erkennung verschiedener Muster in Zeitreihendaten, einschließlich Saisonalität, Ausreißer, Wendepunkte und langsame Trendänderungen.

• Merkmalextraktion und Einbettung: Das Modul zur Extraktion von Zeitreihenmerkmalen (TSFeature) in Kats kann 65 Merkmale mit klaren statistischen Definitionen erzeugen, die in die meisten Modelle für maschinelles Lernen (ML), wie Klassifizierung und Regression, integriert werden können.

• Nützliche Dienstprogramme: Kats bietet auch eine Reihe nützlicher Hilfsprogramme, wie z.B. Zeitreihen-Simulatoren.

Installation in Python

Kats befindet sich auf PyPI, so dass Sie pip verwenden können, um es zu installieren.

1
2

pip install --upgrade pip
pip install kats

Beispiel für eine Vorhersage

Verwendung des Modells Prophet zur Vorhersage des Datensatzes air_passengers.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

from kats.consts import TimeSeriesData
from kats.models.prophet import ProphetModel, ProphetParams

# Nehmen wir als Beispiel die Daten "air_passengers".
air_passengers_df = pd.read_csv("../kats/data/air_passengers.csv")

# in TimeSeriesData-Objekt umwandeln
air_passengers_ts = TimeSeriesData(air_passengers_df)

# Erstellen Sie eine Modell-Param-Instanz
# Beachten Sie, dass der additive Modus schlechtere Ergebnisse liefert.
params = ProphetParams(seasonality_mode='multiplicative')

# eine Prophetenmodell-Instanz erstellen
m = ProphetModel(air_passengers_ts, params)

# Modell einfach durch Aufruf von m.fit() anpassen
m.fit()

# Vorhersage für die nächsten 30 Monate treffen
fcst = m.predict(steps=30, freq="MS")

Beispiele für die Erkennung

Die folgenden Schlüsse können mit Kats gezogen werden:

• Ausreißer-Erkennung: Es erkennt eine anomale Zunahme oder Abnahme innerhalb der Zeitreihe.
• Erkennung von Veränderungspunkten: Er erkennt plötzliche Veränderungen in der Zeitreihe. Für diesen Prozess gibt es in Kats 3 verschiedene Algorithmen:
  • CUSUM-Erkennung
  • Bayes’sche Online-Erkennung von Änderungspunkten (BOCPD)
  • Stat Sig-Erkennung
• Trend Change Detection: Er erkennt die Trendänderungen der Zeitreihen mit Hilfe des Mann-Kendall Detection Algorithmus.

Ausreißer-Erkennung

Für die Erkennung von Ausreißern sind mindestens 24 Zeilen an Daten erforderlich.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

from kats.detectors.outlier import OutlierDetector

fake_df = df[df["Product"] == "Product E"].drop(["VisitsCount", "Product"], axis=1)
fake_df = fake_df.append(pd.DataFrame({"time":["2021-12-31"], "SalesCount":[round(fake_df["SalesCount"][-3:].mean())]})).reset_index(drop=True)
fake_df["time"] = pd.to_datetime(fake_df["time"])

outlier_ts = TimeSeriesData(fake_df)
ts_outlierDetection = OutlierDetector(outlier_ts, 'multiplicative')
ts_outlierDetection.detector()

ts_outlierDetection.outliers[0]

Mit Kats erkannte Ausreißer können auch mit Hilfe von Kats bereinigt werden. Kats bietet hierfür 2 Methoden:

• Keine Interpolation: Füllt Ausreißer mit NaN auf, ohne die Interpolationsoperation anzuwenden.
• Mit Interpolation: Füllt Ausreißer durch Anwendung einer linearen Interpolation auf.

Erkennung von Änderungspunkten

Mit Kats ist es möglich, die Änderungspunkte in den Zeitreihen zu erkennen. Für diesen Prozess gibt es in Kats 3 verschiedene Algorithmen:

• CUSUMDetector
• BOCPDetector
• RobustStatDetector

Verwendung des Erkennungsalgorithmus CUSUM auf einem simulierten Datensatz.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

from kats.consts import TimeSeriesData
from kats.detectors.cusum_detection import CUSUMDetector

# Zeitreihen mit Anstieg simulieren
np.random.seed(10)
df_increase = pd.DataFrame(
    {
        'time': pd.date_range('2019-01-01', '2019-03-01'),
        'increase':np.concatenate([np.random.normal(1,0.2,30), np.random.normal(2,0.2,30)]),
    }
)

# in TimeSeriesData-Objekt umwandeln
timeseries = TimeSeriesData(df_increase)

# Detektor ausführen und Änderungspunkte finden
change_points = CUSUMDetector(timeseries).detector()

Erkennung von Trendänderungen

Mit Kats ist es auch möglich, die Trendrichtung einer Serie zu erkennen. Kats verwendet dafür den MKDetector-Algorithmus. Die Grundlage dieses Algorithmus ist der Mann-Kendall-Test, ein nicht-parametrischer Test.

1
2
3
4
5

from kats.detectors.trend_mk import MKDetector

detector = MKDetector(data=cpd_ts, threshold=.8)
detected_time_points = detector.detector(direction='up', window_size=10)
detector.plot(detected_time_points)

Nützliche Links

• Homepage: https://facebookresearch.github.io/Kats/
• Kats Python package: https://pypi.org/project/kats/0.1.0/
• Facebook Engineering: https://engineering.fb.com/2021/06/21/open-source/kats/
• Source code repository: https://github.com/facebookresearch/kats
• Contributing: https://github.com/facebookresearch/Kats/blob/master/CONTRIBUTING.md
• Tutorials: https://github.com/facebookresearch/Kats/tree/master/tutorials

Fazit

Kats ist ein Tool für die Analyse von Zeitreihen, das eine Metalearning-Methode verwendet, um das am besten geeignete Modell und die entsprechenden Parameter für eine bestimmte Zeitreihe zu ermitteln. Dazu verwendet es die mit TSFeatures gewonnenen Metadaten und wendet den Random Forest-Algorithmus an, um das beste Modell auf der Grundlage dieser Metadaten zu ermitteln. Mit dieser Funktion von Kats können Benutzer ihr eigenes Tool für automatisches maschinelles Lernen (autoML) erstellen.