Introduction

When Keras does not use GPU, training is often dramatically slower and developers assume model code is wrong. In most cases, the model is fine and the issue is environment mismatch: missing CUDA/cuDNN compatibility, incorrect TensorFlow build, unavailable GPU drivers, or runtime configuration forcing CPU execution. GPU troubleshooting is mainly a dependency and runtime verification task.

This guide gives a practical sequence to diagnose and fix GPU detection issues in TensorFlow/Keras environments.

Core Sections

1. Confirm TensorFlow sees GPU devices

import tensorflow as tf
print(tf.__version__)
print(tf.config.list_physical_devices("GPU"))

If this returns an empty list, fix environment before touching model code.

2. Verify driver and CUDA stack

System-level checks (Linux):

nvidia-smi
nvcc --version

nvidia-smi confirms driver and GPU visibility. CUDA toolkit and cuDNN versions must match TensorFlow compatibility requirements.

3. Install compatible TensorFlow package

Recent TensorFlow releases include GPU support in standard package on many platforms.

pip install --upgrade tensorflow

Use official compatibility matrix for your version; mismatched CUDA/cuDNN is a common root cause.

4. Check environment isolation and interpreter

Many failures are due to installing TensorFlow in one environment but running code from another.

which python
python -c "import tensorflow as tf; print(tf.__file__)"

Ensure Jupyter kernel/interpreter matches the environment where GPU-enabled TensorFlow is installed.

5. Configure memory growth and runtime logs

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

Memory-growth setup prevents TensorFlow from pre-allocating all GPU memory, which can appear as startup crashes on shared machines.

6. Detect accidental CPU-only constraints

Check for environment variables or config forcing CPU.

echo $CUDA_VISIBLE_DEVICES

If set to empty or invalid value, TensorFlow may not see GPU.

7. Profile actual device placement

tf.debugging.set_log_device_placement(True)

This prints whether ops execute on GPU:0 or CPU, useful when GPU appears available but workload still runs on CPU.

Common Pitfalls

• Installing incompatible CUDA/cuDNN versions for current TensorFlow build.
• Running code in a different Python environment than the one configured for GPU.
• Assuming pip install tensorflow-gpu is always required on newer versions.
• Leaving CUDA_VISIBLE_DEVICES misconfigured and hiding all GPUs.
• Debugging model architecture before validating system-level GPU detection.

Summary

Keras not using GPU is usually an environment compatibility issue, not a modeling issue. Start with device detection, validate driver/CUDA/cuDNN compatibility, confirm the active Python environment, and inspect runtime device placement. Once the stack is aligned, most Keras models automatically execute GPU-supported operations without code changes.

For teams maintaining keras does not use gpu - how to troubleshoot in long-lived codebases, reliability improves when implementation guidance is paired with a lightweight verification routine. A practical pattern is to define three test categories up front. First, happy-path tests that validate normal expected inputs. Second, boundary tests that include empty values, minimum and maximum limits, and malformed records from real logs. Third, operational tests that simulate production-like behavior under retries, parallel execution, and partial failure. This combination catches both obvious logic defects and the subtle integration issues that usually appear after deployment.

It is also useful to encode assumptions close to the code rather than leaving them in scattered documentation. Add short comments where invariants matter, keep helper utilities centralized, and avoid repeating slightly different logic in multiple modules. In CI, run a small deterministic suite on every commit and a broader dataset suite on schedule. When incidents occur, convert the failing scenario into a permanent regression test before patching. Over time this creates a strong feedback loop where keras does not use gpu - how to troubleshoot behavior remains stable even as dependencies, framework versions, and team ownership change. The result is less firefighting and faster review cycles.