When you train multiple models in a loop or run many experiments sequentially, memory usage can grow steadily. Keras provides keras.backend.clear_session() to reset the state and free resources. A common question is whether this function affects only the current process or clears sessions across all running processes. The short answer is that clear_session() is process-scoped. It resets the Keras/TensorFlow state within the process that calls it and has no effect on other processes. This article explains what the function does, when to use it, and how to combine it with other memory management techniques.

What clear_session() Actually Does

When you create a Keras model, TensorFlow allocates GPU memory, builds a computation graph (in TF1-style code), and registers various internal objects like layers, optimizers, and metrics. Over time, especially in a loop that builds and discards models, these objects accumulate.

keras.backend.clear_session() performs the following cleanup.

1. Destroys the current TensorFlow graph and creates a new one.
2. Resets the Keras global state, including layer name counters and the UID counter.
3. Releases references to models, layers, and other Keras objects so that Python's garbage collector can reclaim their memory.

1import tensorflow as tf
2from tensorflow import keras
3
4for i in range(10):
5    model = keras.Sequential([
6        keras.layers.Dense(128, activation='relu', input_shape=(784,)),
7        keras.layers.Dense(10, activation='softmax')
8    ])
9    model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
10    # ... train the model ...
11
12    # Clean up before building the next model
13    keras.backend.clear_session()

Without the clear_session() call, each iteration would leave behind graph nodes and layer references, causing memory usage to climb.

Process-Level Scope, Not Global

Each Python process maintains its own TensorFlow session and Keras backend state. When you call clear_session(), only the state in the calling process is affected.

1# Process A
2keras.backend.clear_session()  # Only clears Process A's session
3
4# Process B (a separate Python process)
5# Its session, models, and graph are completely unaffected

This design makes sense because operating system processes have isolated memory spaces. There is no mechanism for a function call in one process to reach into another process's memory and release TensorFlow resources.

If you are using Python's multiprocessing module to run parallel training jobs, each worker process has its own independent Keras session. Calling clear_session() in one worker does not touch the others.

When to Use clear_session()

Hyperparameter Search Loops

When you iterate over many hyperparameter combinations, each iteration creates a new model. Without cleanup, the accumulated graph nodes and layer objects consume increasing amounts of memory.

1for lr in [0.001, 0.01, 0.1]:
2    for units in [64, 128, 256]:
3        model = build_model(lr=lr, units=units)
4        model.fit(x_train, y_train, epochs=5, verbose=0)
5        score = model.evaluate(x_test, y_test, verbose=0)
6        print(f"lr={lr}, units={units}, score={score[1]:.4f}")
7
8        del model
9        keras.backend.clear_session()

Cross-Validation

Similar to hyperparameter search, k-fold cross-validation builds a fresh model for each fold.

1from sklearn.model_selection import KFold
2
3kf = KFold(n_splits=5)
4for fold, (train_idx, val_idx) in enumerate(kf.split(x_data)):
5    model = build_model()
6    model.fit(x_data[train_idx], y_data[train_idx], epochs=10, verbose=0)
7    val_score = model.evaluate(x_data[val_idx], y_data[val_idx], verbose=0)
8    print(f"Fold {fold}: {val_score[1]:.4f}")
9
10    del model
11    keras.backend.clear_session()

Jupyter Notebooks

Notebooks are long-lived processes. If you redefine and retrain models many times in the same kernel, memory will grow. Calling clear_session() between experiments helps keep memory usage stable.

Combining with Other Memory Techniques

clear_session() alone may not free all memory, especially GPU memory that TensorFlow pre-allocates. Here are complementary techniques.

Python garbage collection. After deleting the model and clearing the session, explicitly invoke the garbage collector.

1import gc
2
3del model
4keras.backend.clear_session()
5gc.collect()

Limiting GPU memory growth. By default, TensorFlow allocates all available GPU memory. You can configure it to allocate incrementally instead.

gpus = tf.config.experimental.list_physical_devices('GPU')
for gpu in gpus:
    tf.config.experimental.set_memory_growth(gpu, True)

This does not release memory after clear_session(), but it prevents TensorFlow from grabbing all GPU memory upfront, which reduces waste when running smaller models.

Common Pitfalls

Expecting GPU memory to be fully released. TensorFlow's GPU memory allocator does not always return memory to the OS after clear_session(). The memory may be reused by subsequent TensorFlow operations within the same process, but it will not appear as free in nvidia-smi. If you need to truly free GPU memory, you must terminate the process.

Calling clear_session() while a model is still in use. If you clear the session and then try to call model.predict() on a previously built model, you will get errors because the underlying graph has been destroyed. Always finish all work with a model before clearing.

Forgetting to delete the Python model object. clear_session() resets the Keras global state, but the Python variable still holds a reference to the model object. Use del model before calling clear_session() so the garbage collector can actually reclaim the memory.

Assuming thread safety. In a multi-threaded program where threads share the same process, calling clear_session() from one thread can destroy the graph that another thread is actively using. In multi-threaded setups, either give each thread its own tf.Graph and tf.Session, or coordinate access carefully.

Summary

keras.backend.clear_session() is a process-level function. It resets the Keras backend state, destroys the current TensorFlow graph, and releases internal references within the calling process. It has no effect on other processes. Use it between model-building iterations, such as in hyperparameter search, cross-validation, or notebook experiments, to prevent memory from growing unchecked. Pair it with del model and gc.collect() for more thorough cleanup, and be aware that GPU memory may not be fully returned to the OS until the process exits.