Introduction

Yes, a stateful LSTM can be used inside a Keras Functional model. The important constraint is not the API style, but the stateful LSTM requirements: fixed batch size, stable batch ordering, and explicit state resets between unrelated sequences. Most confusion comes from treating stateful recurrent layers like ordinary dense layers when their execution rules are stricter.

Functional API and Stateful LSTM Are Compatible

The Functional API supports any layer that works with symbolic tensors, including tf.keras.layers.LSTM(stateful=True). The key difference is that a stateful recurrent layer needs a fixed batch_shape, not just a variable input shape.

1import numpy as np
2import tensorflow as tf
3
4batch_size = 2
5timesteps = 3
6features = 1
7
8inputs = tf.keras.Input(batch_shape=(batch_size, timesteps, features))
9x = tf.keras.layers.LSTM(4, stateful=True)(inputs)
10outputs = tf.keras.layers.Dense(1)(x)
11
12model = tf.keras.Model(inputs, outputs)
13model.compile(optimizer="adam", loss="mse")
14model.summary()

This is a real Functional model. The presence of stateful=True does not force you back to Sequential.

Why Fixed Batch Size Matters

State is stored per batch slot. That means sample zero in one batch is assumed to be the continuation of sample zero in the next batch, sample one continues sample one, and so on. If batch size changes or sample ordering shifts, the carried state becomes meaningless.

For that reason, stateful training usually requires:

1. a fixed batch size
2. deterministic ordering between batches
3. shuffle=False during training

A minimal training example looks like this:

1x_train = np.array([
2    [[1.0], [2.0], [3.0]],
3    [[4.0], [5.0], [6.0]],
4    [[7.0], [8.0], [9.0]],
5    [[10.0], [11.0], [12.0]],
6], dtype="float32")
7
8y_train = np.array([[1.0], [2.0], [3.0], [4.0]], dtype="float32")
9
10model.fit(
11    x_train,
12    y_train,
13    epochs=2,
14    batch_size=batch_size,
15    shuffle=False,
16    verbose=0
17)

If you shuffle batches, you destroy the continuity the stateful model is trying to preserve.

Reset State at Sequence Boundaries

Stateful does not mean "keep state forever". It means "reuse state until you explicitly reset it". When one logical sequence ends and another unrelated sequence begins, call reset_states.

model.reset_states()
pred = model.predict(x_train[:2], batch_size=batch_size, verbose=0)
print(pred)

Without resets, information from previous samples leaks into later predictions and training batches.

Functional Composition Still Works

The Functional API remains valuable because you can combine recurrent layers with other components such as embeddings, multiple inputs, or dense branches.

1inputs = tf.keras.Input(batch_shape=(batch_size, timesteps, features))
2lstm_out = tf.keras.layers.LSTM(8, stateful=True, return_sequences=False)(inputs)
3norm = tf.keras.layers.LayerNormalization()(lstm_out)
4outputs = tf.keras.layers.Dense(1, activation="sigmoid")(norm)
5
6classifier = tf.keras.Model(inputs, outputs)
7classifier.compile(optimizer="adam", loss="binary_crossentropy")

So the real question is not "can I call it as a Functional model". The real question is whether your data pipeline respects the stateful assumptions.

When Not to Use Stateful LSTM

Stateful models are useful only when batches truly represent consecutive fragments of longer sequences. If your sequences are independent and already fully contained in each sample, a stateless LSTM is usually simpler and safer.

Stateful models complicate:

• training pipeline design
• evaluation
• distributed execution
• inference resets

If you do not need cross-batch temporal continuity, do not pay that complexity cost.

Common Pitfalls

• Using input_shape instead of a fixed batch_shape for a stateful layer.
• Training with shuffle=True and breaking batch-to-batch state continuity.
• Forgetting to call reset_states between unrelated sequences.
• Changing batch size between training and inference for the same stateful model.
• Choosing a stateful LSTM when the problem does not require cross-batch memory.

Summary

• A stateful LSTM works fine inside a Keras Functional model.
• The real constraints are fixed batch size, stable ordering, and manual state resets.
• Use batch_shape, not only input_shape, when building the input tensor.
• Keep shuffle=False if batches represent consecutive sequence fragments.
• Use stateful recurrence only when cross-batch continuity is truly part of the problem.