Introduction

The warning Found untraced functions such as lstm_cell_6_layer_call_and_return_conditional_losses appears when saving a TensorFlow/Keras model that contains LSTM layers (or other RNN layers). It means TensorFlow's tracing mechanism could not capture certain internal functions of the LSTM cell during the tf.saved_model.save() or model.save() process. These untraced functions are typically internal loss-computation and call methods. The warning is usually harmless for inference but can affect model serving if those code paths are needed.

The Warning

1WARNING:tensorflow:Found untraced functions such as
2lstm_cell_6_layer_call_fn, lstm_cell_6_layer_call_and_return_conditional_losses,
3lstm_cell_7_layer_call_fn, lstm_cell_7_layer_call_and_return_conditional_losses.
4These functions will not be directly callable after loading.

This appears during:

• model.save("model_path") with SavedModel format
• tf.saved_model.save(model, "model_path")
• model.save("model.keras") in some TensorFlow versions

Why This Happens

When TensorFlow saves a model in SavedModel format, it traces all functions to convert them to a computation graph. LSTM cells have multiple internal methods (call, return conditional losses, etc.) that TensorFlow's tracer may not visit during normal forward-pass tracing:

1import tensorflow as tf
2
3model = tf.keras.Sequential([
4    tf.keras.layers.LSTM(64, return_sequences=True, input_shape=(10, 32)),
5    tf.keras.layers.LSTM(32),
6    tf.keras.layers.Dense(1)
7])
8
9model.compile(optimizer='adam', loss='mse')
10
11# This triggers the warning
12model.save("my_lstm_model")

The LSTM cell internally has methods like layer_call_and_return_conditional_losses that handle regularization losses. If the model does not use regularization, these paths are never executed during tracing and remain untraced.

Fix 1: Call the Model Before Saving

Ensure the model has been called with sample input before saving so TensorFlow traces all execution paths:

1import numpy as np
2import tensorflow as tf
3
4model = tf.keras.Sequential([
5    tf.keras.layers.LSTM(64, return_sequences=True, input_shape=(10, 32)),
6    tf.keras.layers.LSTM(32),
7    tf.keras.layers.Dense(1)
8])
9
10model.compile(optimizer='adam', loss='mse')
11
12# Run a forward pass with sample data to trigger tracing
13sample_input = np.random.randn(1, 10, 32).astype(np.float32)
14_ = model(sample_input)
15
16# Now save — warning may still appear but model is fully traced for inference
17model.save("my_lstm_model")

Fix 2: Save in Keras Format Instead

The .keras format (or legacy .h5) saves model weights and config without graph tracing, avoiding the warning entirely:

1# Keras native format (recommended for TF 2.16+)
2model.save("my_model.keras")
3
4# Load it back
5loaded = tf.keras.models.load_model("my_model.keras")
6
7# Legacy HDF5 format
8model.save("my_model.h5")
9loaded = tf.keras.models.load_model("my_model.h5")

Use the Keras format when you plan to load the model in Python/Keras. Use SavedModel format when you need to serve with TensorFlow Serving or convert to TFLite.

Fix 3: Suppress the Warning

If the warning does not affect your use case (inference-only deployment), suppress it:

1import tensorflow as tf
2import logging
3
4# Suppress TensorFlow warnings
5tf.get_logger().setLevel(logging.ERROR)
6
7# Or suppress specific warnings
8import warnings
9warnings.filterwarnings('ignore', message='Found untraced functions')
10
11model.save("my_lstm_model")

This does not fix the underlying issue — it hides the message. Only do this after confirming your saved model loads and produces correct predictions.

Fix 4: Use input_signature for Custom Models

For custom models or subclassed models, providing an explicit input_signature helps TensorFlow trace all paths:

1import tensorflow as tf
2
3class MyLSTMModel(tf.keras.Model):
4    def __init__(self):
5        super().__init__()
6        self.lstm = tf.keras.layers.LSTM(64)
7        self.dense = tf.keras.layers.Dense(1)
8
9    @tf.function(input_signature=[tf.TensorSpec(shape=[None, 10, 32], dtype=tf.float32)])
10    def call(self, inputs):
11        x = self.lstm(inputs)
12        return self.dense(x)
13
14model = MyLSTMModel()
15sample = tf.random.normal([1, 10, 32])
16_ = model(sample)
17
18tf.saved_model.save(model, "my_custom_model")

The input_signature decorator tells TensorFlow the exact shape and type, enabling complete tracing.

Verifying the Saved Model Works

1import tensorflow as tf
2import numpy as np
3
4# Load and test
5loaded_model = tf.keras.models.load_model("my_lstm_model")
6
7# Verify predictions match
8test_input = np.random.randn(5, 10, 32).astype(np.float32)
9original_pred = model.predict(test_input)
10loaded_pred = loaded_model.predict(test_input)
11
12print(np.allclose(original_pred, loaded_pred, atol=1e-6))  # True

If predictions match, the untraced functions were not needed for inference.

Which Layers Trigger This Warning

Common Pitfalls

• Ignoring the warning for TF Serving: If you deploy with TensorFlow Serving and your serving signature calls one of the untraced functions (e.g., for loss computation during fine-tuning), loading will fail. Always test the saved model in your deployment environment.
• Saving before training: Saving an untrained model may produce more untraced functions because some code paths are only exercised during training. Train (or at least call model.fit for one step) before saving.
• Version-specific behavior: The warning message and which functions are untraced change between TensorFlow versions. Upgrading TensorFlow (especially to 2.13+) reduces the number of untraced functions as Keras tracing has improved.
• Confusing warning with error: This is a warning, not an error. The model is still saved and typically works correctly for inference. Do not restructure your model architecture solely to eliminate this warning.
• Multiple LSTM layers amplify the warning: Each LSTM layer generates its own set of untraced functions (lstm_cell_0, lstm_cell_1, etc.). The warning lists them all, which looks alarming but follows the same pattern for each layer.

Summary

• The warning occurs when saving models with LSTM/GRU layers in SavedModel format
• TensorFlow cannot trace internal cell methods that are not exercised during the save process
• The warning is usually harmless for inference — verify by loading and testing predictions
• Save in .keras format instead of SavedModel to avoid the warning entirely
• Call the model with sample input before saving to maximize traced function coverage
• For production deployment with TF Serving, test the saved model end-to-end