TimesFM für Zeitreihenprognosen

Einführung

Der Zeitreihen Das Basis Mannequin, kurz TimesFM, ist ein vorab trainiertes Zeitreihen-Grundlagenmodell, das von Google Analysis für die Vorhersage univariater Zeitreihen entwickelt wurde. Als vorab trainiertes Basismodell vereinfacht es den oft komplexen Prozess der Zeitreihenanalyse. Google Analysis sagt, dass ihr Zeitreihen-Basismodell Zero-Shot-Prognosefunktionen aufweist, die mit der Genauigkeit führender überwachter Prognosemodelle über mehrere öffentliche Datensätze hinweg mithalten können.

Überblick

• TimesFM ist ein vorab trainiertes Modell, das von Google Analysis für univariate Zeitreihenvorhersagen entwickelt wurde und Zero-Shot-Vorhersagefunktionen bietet, die mit führenden überwachten Modellen mithalten können.
• TimesFM ist ein transformatorbasiertes Modell mit 200 Millionen Parametern, das darauf ausgelegt ist, zukünftige Werte einer einzelnen Variablen auf der Grundlage ihrer historischen Daten vorherzusagen und Kontextlängen von bis zu 512 Punkten zu unterstützen.
• Es weist eine hohe Prognosegenauigkeit für unsichtbare Datensätze auf und nutzt seine Transformatorschichten und einstellbaren Hyperparameter wie Modellabmessungen, Patchlängen und Horizontlängen.
• Die Demo verwendet TimesFM für den Stromproduktionsdatensatz von Kaggle. Es zeigt genaue Prognosen mit minimalen Fehlern (z. B. MAE = 3,34) und schneidet im Vergleich zu tatsächlichen Daten intestine ab.
• TimesFM ist ein fortschrittliches Modell, das die Zeitreihenanalyse vereinfacht und gleichzeitig eine nahezu hochmoderne Genauigkeit bei der Vorhersage zukünftiger Traits in verschiedenen Datensätzen erreicht, ohne dass zusätzliches Coaching erforderlich ist.

Hintergrund

Eine Zeitreihe besteht aus Datenpunkten, die in konsistenten Zeitintervallen erfasst werden, beispielsweise tägliche Aktienkurse oder stündliche Temperaturwerte. Die Vorhersage solcher Daten ist aufgrund von Elementen wie Traits, saisonalen Schwankungen und unregelmäßigen Mustern oft komplex. Diese Herausforderungen können genaue Vorhersagen zukünftiger Werte behindern, Modelle mögen dies jedoch TimesFM sollen diese Aufgabe rationalisieren.

Verständnis der TimesFM-Architektur

Das TimesFM 1.0 enthält einen 200M-Parameter, einen transformatorbasierten, modelltrainierten Decoder, der nur auf einem Pretrain-Datensatz mit über 100 Milliarden realen Zeitpunkten trainiert.

Das TimesFM 1.0 generiert ohne zusätzliche Schulung genaue Prognosen auf unsichtbaren Datensätzen; Es sagt die zukünftigen Werte von voraus eine einzelne Variable basierend auf eigenen historischen Daten. Dabei wird eine Variable (Zeitreihe) verwendet, um zukünftige Zeitpunkte derselben Variablen im Hinblick auf die Zeit vorherzusagen. Es führt univariate Zeitreihenvorhersagen für Kontextlängen von bis zu 512 Zeitpunkten durch und verfügt für alle Horizontlängen über eine optionale Häufigkeitsindikatoreingabe.

Lesen Sie auch: Zeitreihenprognose: Vollständiges Tutorial | Teil 1

Parameter (Hyperparameter)

Dies sind einstellbare Werte, die das Verhalten des Modells steuern und sich auf seine Leistung auswirken:

1. model_dim: Dimensionalität der Eingabe- und Ausgabevektoren.
2. input_patch_len (p): Länge jedes Eingabepatches.
3. Output_patch_len (h): Länge der in jedem Schritt generierten Prognose.
4. Anzahl_Köpfe: Anzahl der Aufmerksamkeitsköpfe im Mehrkopf-Aufmerksamkeitsmechanismus.
5. num_layers (nl): Anzahl der gestapelten Transformatorschichten.
6. Kontextlänge (L): Die Länge der für die Vorhersage verwendeten historischen Daten.
7. Horizontlänge (H): Die Länge des Prognosehorizonts.
8. Anzahl der Eingabe-Tokens (N)berechnet als Gesamtkontextlänge dividiert durch die Eingabe-Patch-Länge: N = L/p. Jeder dieser Token wird zur Verarbeitung in die Transformatorschichten eingespeist.

Komponenten

Dies sind die Grundbausteine ​​der Modellarchitektur:

1. Restblöcke: Neuronale Netzwerkblöcke zur Verarbeitung von Eingabe- und Ausgabepatches.
2. Gestapelter Transformator: Die Kerntransformatorschichten im Modell.
3. tj: Die den Transformatorschichten zugeführten Eingabe-Tokens, abgeleitet von den verarbeiteten Patches.

t_j = InputResidualBlock(ŷ_j ⊙ (1 – m_j)) + PE_j

Dabei ist ỹ_j der j-te Patch der Eingabereihe, m̃_j die entsprechende Maske und PE_j die Positionskodierung.

4. oj: Der Ausgabetoken in Schritt j, generiert von den Transformatorschichten basierend auf den Eingabe-Tokens. Es wird verwendet, um den entsprechenden Ausgabe-Patch vorherzusagen:

o_j = StackedTransformer((t_1, ṁ_1), …, (t_j, ṁ_j))

5. m1:L (Maske): Die Maske, mit der bestimmte Teile der Eingabe während der Verarbeitung ignoriert werden.

Der Verlustfunktion wird während des Trainings verwendet. Im Fall der Punktvorhersage ist dies der Fall Mittlerer quadratischer Fehler (MSE):

TrainLoss = (1 / N) * Σ (MSE(ŷp(j+1):p(j+h), yp(j+1):p(j+h)))

Dabei sind ŷ die Vorhersagen des Modells und y die wahren Zukunftswerte.

Lesen Sie auch: Einführung in die Prognose von Zeitreihendaten

TimesFM 1.0 für Prognosen

Der „Elektrische Produktion“ Datensatz ist auf Kaggle verfügbar und enthält Daten zur Stromproduktion im Zeitverlauf. Es besteht nur aus zwei Spalten: DATUMdas das Datum der aufgezeichneten Werte darstellt, und Wertder die in diesem Monat produzierte Strommenge angibt. Unsere Aufgabe ist es, mit TimesFM Daten für 24 Monate vorherzusagen.

Demo

Bevor wir beginnen, stellen Sie sicher, dass Sie eine GPU verwenden. Ich mache diese Demonstration auf Kaggle und verwende den GPU T4 x 2-Beschleuniger.

Lassen Sie uns „timesfm“ mit pip installieren. „-q“ installiert es einfach, ohne etwas anzuzeigen.

!pip -q set up timesfm

Lassen Sie uns einige notwendige Bibliotheken importieren und den Datensatz lesen.

import timesfm

import pandas as pd
knowledge=pd.read_csv('/kaggle/enter/electric-production/Electric_Production.csv')
knowledge.head()

Es führt univariate Zeitreihenvorhersagen für Kontextlängen von bis zu 512 Zeitpunkten durch und verfügt für beliebige Horizontlängen über einen optionalen Häufigkeitsindikatoreingang.

knowledge('DATE')=pd.to_datetime(knowledge('DATE'))
knowledge.head()

Die DATE-Spalte wurde in datetime konvertiert und liegt jetzt im Format JJJJ-MM-TT vor

#Let's Visualise the Datas
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings('ignore') # Settings the warnings to be ignored
sns.set(model="darkgrid")
plt.determine(figsize=(15, 6))
sns.lineplot(x="DATE", y='Worth', knowledge=knowledge, coloration="inexperienced")
plt.title('Electrical Manufacturing')
plt.xlabel('Date')
plt.ylabel('Worth')
plt.present()

Schauen wir uns die Daten an:

import matplotlib.pyplot as plt
from statsmodels.tsa.seasonal import seasonal_decompose
# Set index to DATE and decompose the information
knowledge.set_index("DATE", inplace=True)
consequence = seasonal_decompose(knowledge('Worth'))
# Create a 2x2 grid for the subplots
fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12, 10))
consequence.noticed.plot(ax=ax1, coloration="darkgreen")
ax1.set_ylabel('Noticed')
consequence.development.plot(ax=ax2, coloration="darkgreen")
ax2.set_ylabel('Pattern')
consequence.seasonal.plot(ax=ax3, coloration="darkgreen")
ax3.set_ylabel('Seasonal')
consequence.resid.plot(ax=ax4, coloration="darkgreen")
ax4.set_ylabel('Residual')
plt.tight_layout()
plt.present()
# Alter structure and present the plots
plt.tight_layout()
plt.present()
# Reset the index after plotting
knowledge.reset_index(inplace=True)

Wir können die Komponenten der Zeitreihe sehen, wie Pattern und Saisonalität, und wir können uns ein Bild von ihrem Verhältnis zur Zeit machen.

df = pd.DataFrame({'unique_id':(1)*len(knowledge),'ds': knowledge("DATE"), 
"y":knowledge('Worth')})

# Spliting into 94% and 6%
split_idx = int(len(df) * 0.94)
# Break up the dataframe into prepare and check units
train_df = df(:split_idx)
test_df = df(split_idx:)
print(train_df.form, test_df.form)

(373, 3) (24, 3)

Lassen Sie uns die Daten für 24 Monate oder 2 Jahre prognostizieren, indem wir die verbleibenden Daten als Vergangenheitsdaten verwenden.

# Initialize the TimesFM mannequin with specified parameters
tfm = timesfm.TimesFm(
   context_len=128,       # Size of the context window for the mannequin
   horizon_len=24,        # Forecasting horizon size
   input_patch_len=32,    # Size of enter patches
   output_patch_len=128,  # Size of output patches
   num_layers=20,        
   model_dims=1280,      
)
# Load the pretrained mannequin checkpoint
tfm.load_from_checkpoint(repo_id="google/timesfm-1.0-200m")
# Forecasting the values utilizing the TimesFM mannequin
timesfm_forecast = tfm.forecast_on_df(
   inputs=train_df,       # Enter coaching knowledge for coaching
   freq="MS",             # Frequency of the time-series knowledge
   value_name="y",        # Title of the column containing the values to be forecasted
   num_jobs=-1,           # Set to -1 to make use of all obtainable cores
)
timesfm_forecast = timesfm_forecast(("ds","timesfm"))

Die Vorhersagen sind fertig. Schauen wir uns sowohl die tatsächlichen als auch die vorhergesagten Werte an

timesfm_forecast.head()

test_df.head()

import numpy as np
actuals = test_df('y')
predicted_values = timesfm_forecast('timesfm')
# Convert to numpy arrays
actual_values = np.array(actuals)
predicted_values = np.array(predicted_values)
# Calculate error metrics
MAE = np.imply(np.abs(actual_values - predicted_values))  # Imply Absolute Error
MSE = np.imply((actual_values - predicted_values)**2)     # Imply Squared Error
RMSE = np.sqrt(np.imply((actual_values - predicted_values)**2))  # Root Imply Squared Error
# Print the error metrics
print(f"Imply Absolute Error (MAE): {MAE}")
print(f"Imply Squared Error (MSE): {MSE}")
print(f"Root Imply Squared Error (RMSE): {RMSE}")

Imply Absolute Error (MAE): 3.3446476043701163
Imply Squared Error (MSE): 22.60650784076036
Root Imply Squared Error (RMSE): 4.754630147630872

# Let's Visualise the Knowledge
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings('ignore')  # Setting the warnings to be ignored
# Set the model for seaborn
sns.set(model="darkgrid")
# Plot measurement
plt.determine(figsize=(15, 6))
# Plot precise timeseries knowledge
sns.lineplot(x="ds", y='timesfm', knowledge=timesfm_forecast, coloration="pink", label="Forecast")
# Plot forecasted values
sns.lineplot(x="DATE", y='Worth', knowledge=knowledge, coloration="inexperienced", label="Precise Time Collection")
# Set plot title and labels
plt.title('Electrical Manufacturing: Precise vs Forecast')
plt.xlabel('Date')
plt.ylabel('Worth')
# Present the legend
plt.legend()
# Show the plot
plt.present()

Die Vorhersagen liegen nahe an den tatsächlichen Werten. Auch bei den Fehlermetriken (MSE, RMSE, MAE) schneidet das Modell intestine ab, obwohl es die Werte im Zero-Shot vorhersagt.

Lesen Sie auch: Ein umfassender Leitfaden zur Zeitreihenanalyse und -prognose

Abschluss

Zusammenfassend lässt sich sagen, dass TimesFM, ein transformatorbasiertes vorab trainiertes Modell von Google Analysis, beeindruckende Zero-Shot-Prognosefunktionen für univariate Zeitreihendaten demonstriert. Seine Architektur und das Coaching anhand umfangreicher Datensätze ermöglichen genaue Vorhersagen und zeigen das Potenzial zur Optimierung der Zeitreihenanalyse bei gleichzeitiger Annäherung an die Genauigkeit modernster Modelle in verschiedenen Anwendungen.

Suchen Sie nach weiteren Artikeln zu ähnlichen Themen wie diesem? Schauen Sie sich unsere an Zeitreihen Artikel.

Häufig gestellte Fragen

Ich bin ein Technik-Fanatic und habe meinen Abschluss am Vellore Institute of Know-how gemacht. Ich arbeite gerade als Knowledge Science Trainee. Ich interessiere mich sehr für Deep Studying und generative KI.