如何向有状态LSTM批量输入数据？以比特币价格预测为例

Alright, let's walk through exactly how to prepare and batch data for a stateful LSTM using your Bitcoin daily price prediction scenario. Stateful LSTMs are tricky because they retain memory across batches—so getting the data structure right is make-or-break for your model's performance.

First: What Makes Stateful LSTMs Different? #

Unlike regular LSTMs, which reset their internal state after every batch, stateful LSTMs keep their state between batches. That means the sequence of data you feed in must be chronologically continuous across batches. If you mess this up, the model will learn garbage because it's connecting unrelated time steps.

Your Dataset Breakdown #

You have 101 days of closing prices: [p1, p2, ..., p101]. Your goal is to use each day's price to predict the next day's, so your input is [p1, p2, ..., p100] and labels are [p2, p3, ..., p101]. This is a simple single-step time series prediction task, perfect for demonstrating stateful LSTM batching.

The Golden Rules for Batching Stateful LSTMs #

Before we dive into code, let's lock in the non-negotiables:

• No shuffling: Ever. Shuffling would break the chronological continuity the model relies on.
• Fixed batch size: The model's input shape is tied to your batch size—you can't change it mid-training/prediction.
• Reset state after epochs: After each full pass through your data, reset the model's state so the next epoch starts fresh.
• Batch continuity: The first sample in batch N must directly follow the last sample in batch N-1.

Step-by-Step Implementation #

Let's use Keras for this example (it's the most common framework for stateful LSTMs).

1. Prepare Your Data #

First, reshape your data to fit the LSTM input format: (number_of_samples, time_steps, number_of_features). Since we're using 1 day to predict the next, time_steps=1 and number_of_features=1 (just the closing price).

import numpy as np

# Simulate your 101-day price data (replace with real values)
prices = np.arange(1, 102)  # [1,2,...,101] for example

# Input: first 100 days, reshaped to (100, 1, 1)
X = prices[:-1].reshape(-1, 1, 1)
# Labels: last 100 days (shifted 1 day forward), reshaped to (100, 1)
y = prices[1:].reshape(-1, 1)

2. Define the Stateful LSTM Model #

Notice we set stateful=True and explicitly define the batch_input_shape—this is required for stateful LSTMs.

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense

# Pick a batch size (we'll use 2 for this example)
batch_size = 2

model = Sequential()
# LSTM layer with 32 units, stateful=True, fixed batch input shape
model.add(LSTM(32, stateful=True, batch_input_shape=(batch_size, 1, 1)))
# Output layer for single price prediction
model.add(Dense(1))

# Compile with Adam optimizer and MSE loss (standard for regression tasks)
model.compile(optimizer='adam', loss='mean_squared_error')

3. Train the Model #

Since we're using stateful mode, we can't just run model.fit() for multiple epochs directly—we need to loop through epochs manually and reset the state after each one.

epochs = 10

for epoch in range(epochs):
    print(f"Epoch {epoch + 1}/{epochs}")
    # Train for 1 epoch, no shuffling, fixed batch size
    model.fit(X, y, epochs=1, batch_size=batch_size, shuffle=False)
    # Reset state after each epoch to avoid carryover between training cycles
    model.reset_states()

4. Bonus: Continuous Prediction #

One of the big benefits of stateful LSTMs is making sequential predictions (e.g., predicting 5 days ahead after your training data). To do this, don't reset the state—feed each prediction back into the model as the next input.

Note: For easier continuous prediction, it's often better to train with batch_size=1 (since you'll be predicting one step at a time). Here's how that looks:

# Re-define model with batch_size=1
model = Sequential()
model.add(LSTM(32, stateful=True, batch_input_shape=(1, 1, 1)))
model.add(Dense(1))
model.compile(optimizer='adam', loss='mean_squared_error')

# Train with batch_size=1
for epoch in range(epochs):
    model.fit(X, y, epochs=1, batch_size=1, shuffle=False)
    model.reset_states()

# Predict 5 days beyond p101
current_price = prices[-1].reshape(1, 1, 1)
predicted_prices = []

for _ in range(5):
    next_price = model.predict(current_price, batch_size=1)
    predicted_prices.append(next_price[0][0])
    # Use the prediction as input for the next step
    current_price = next_price.reshape(1, 1, 1)

print("Predicted prices for the next 5 days:", predicted_prices)

Key Gotchas to Remember #

• If you use a larger time_steps value (e.g., using 3 days to predict the 4th), your data reshaping changes: X would be (98, 3, 1) (since you need 3 consecutive days for each sample, leaving 98 total samples). The batching rule still applies—each batch's samples must be consecutive in the timeline.
• Never change the batch size after training. If you trained with batch_size=2, you must predict with batches of 2 (or re-train the model with a new batch size).
• If you need to evaluate the model, use model.evaluate() with the same batch size and no shuffling, then reset the state afterward.

内容的提问来源于stack exchange，提问作者KOB