Instalación de TensorFlow con soporte CPU y GPU

Requisitos previos del sistema

Antes de instalar TensorFlow es imprescindible disponer de un entorno Python correcto. TensorFlow 2.18.x (la versión estable a marzo 2026) es compatible con Python 3.9 a 3.12. Se recomienda Python 3.12 por su rendimiento y soporte activo.

python --version   # debe devolver 3.9, 3.10, 3.11 o 3.12
pip --version

Para proyectos de deep learning se recomienda siempre trabajar en un entorno virtual que aísle las dependencias:

python -m venv tf-env
source tf-env/bin/activate        # Linux/macOS
tf-env\Scripts\activate           # Windows
pip install --upgrade pip

Instalación de TensorFlow en CPU

La instalación estándar de TensorFlow incluye soporte completo de CPU y es la opción recomendada para comenzar a experimentar:

pip install tensorflow

Para fijar una versión concreta (útil en entornos de producción reproducibles):

pip install tensorflow==2.18.0

Verifica que la instalación se completó correctamente:

import tensorflow as tf

print(f"Versión de TensorFlow: {tf.__version__}")
print(f"Versión de Keras: {tf.keras.__version__}")

# Comprobar dispositivos disponibles
dispositivos = tf.config.list_physical_devices()
print("Dispositivos físicos:", dispositivos)

Instalación con soporte GPU (NVIDIA CUDA)

Para aprovechar la aceleración por GPU se necesitan componentes adicionales del ecosistema NVIDIA. La tabla de compatibilidad oficial para TensorFlow 2.18 es:

| TensorFlow | Python | CUDA | cuDNN | |---|---|---|---| | 2.18.x | 3.9–3.12 | 12.3 | 8.9 | | 2.17.x | 3.9–3.12 | 12.3 | 8.9 | | 2.16.x | 3.9–3.12 | 12.3 | 8.9 |

Pasos para configurar GPU:

1. Instala los drivers NVIDIA actualizados para tu tarjeta.
2. Instala CUDA Toolkit 12.3.
3. Instala cuDNN 8.9 compatible con CUDA 12.3.
4. Instala TensorFlow normalmente:

pip install tensorflow[and-cuda]

Esta variante instala automáticamente las dependencias de CUDA desde PyPI cuando es posible.

Verificación del soporte GPU

Una vez instalados los componentes, verifica que TensorFlow detecta tu GPU:

import tensorflow as tf

# Listar GPUs físicas disponibles
gpus = tf.config.list_physical_devices('GPU')
cpus = tf.config.list_physical_devices('CPU')

print(f"GPUs disponibles: {len(gpus)}")
for gpu in gpus:
    print(f"  - {gpu.name} ({gpu.device_type})")

print(f"CPUs disponibles: {len(cpus)}")

# Verificar si CUDA está disponible
print(f"CUDA disponible: {tf.test.is_built_with_cuda()}")
print(f"GPU disponible para TF: {len(tf.config.list_physical_devices('GPU')) > 0}")

Control de la memoria GPU

Por defecto TensorFlow reserva toda la memoria disponible de la GPU. Para un uso más eficiente es conveniente activar el crecimiento de memoria (memory growth), que asigna memoria de forma incremental:

import tensorflow as tf

gpus = tf.config.list_physical_devices('GPU')
if gpus:
    try:
        # Habilitar asignación incremental de memoria en todas las GPUs
        for gpu in gpus:
            tf.config.experimental.set_memory_growth(gpu, True)
        print("Memory growth habilitado")
    except RuntimeError as e:
        # Debe configurarse antes de que se inicialice el grafo
        print(f"Error: {e}")

También es posible limitar la memoria disponible mediante dispositivos virtuales:

import tensorflow as tf

gpus = tf.config.list_physical_devices('GPU')
if gpus:
    try:
        # Limitar a 4 GB la primera GPU
        tf.config.set_logical_device_configuration(
            gpus[0],
            [tf.config.LogicalDeviceConfiguration(memory_limit=4096)]
        )
        logical_gpus = tf.config.list_logical_devices('GPU')
        print(f"GPUs físicas: {len(gpus)}, lógicas: {len(logical_gpus)}")
    except RuntimeError as e:
        print(f"Error: {e}")

Selección explícita de dispositivo con tf.device

TensorFlow asigna operaciones automáticamente al dispositivo más adecuado. Con tf.device se puede forzar la ejecución en un dispositivo concreto:

import tensorflow as tf

# Operación forzada en CPU
with tf.device('/CPU:0'):
    a = tf.constant([[1.0, 2.0], [3.0, 4.0]])
    b = tf.constant([[5.0, 6.0], [7.0, 8.0]])
    resultado_cpu = tf.matmul(a, b)
    print(f"Resultado en CPU:\n{resultado_cpu}")

# Operación forzada en GPU (si está disponible)
if tf.config.list_physical_devices('GPU'):
    with tf.device('/GPU:0'):
        c = tf.constant([[1.0, 2.0], [3.0, 4.0]])
        d = tf.constant([[5.0, 6.0], [7.0, 8.0]])
        resultado_gpu = tf.matmul(c, d)
        print(f"Resultado en GPU:\n{resultado_gpu}")

Verificación de la ubicación de los tensores

Para confirmar en qué dispositivo se está ejecutando cada tensor se puede usar el atributo device:

import tensorflow as tf

tensor = tf.constant([1.0, 2.0, 3.0])
print(f"Tensor creado en: {tensor.device}")

with tf.device('/CPU:0'):
    tensor_cpu = tf.constant([1.0, 2.0])
    print(f"Tensor CPU: {tensor_cpu.device}")

Mixed Precisión para mayor rendimiento

En GPUs NVIDIA con capacidad de cómputo 7.0 o superior (Volta, Turing, Ampere, Ada Lovelace) se puede activar mixed precisión para usar float16 en las operaciones de cómputo y float32 para el acumulador, duplicando aproximadamente el rendimiento:

import tensorflow as tf
from tensorflow.keras import mixed_precision

# Activar mixed precision float16
policy = mixed_precision.Policy('mixed_float16')
mixed_precision.set_global_policy(policy)

print(f"Dtype compute: {policy.compute_dtype}")
print(f"Dtype variable: {policy.variable_dtype}")

# Al construir el modelo, la capa de salida debe ser float32
modelo = tf.keras.Sequential([
    tf.keras.layers.Dense(128, activation='relu', input_shape=(784,)),
    tf.keras.layers.Dense(64, activation='relu'),
    # La capa de salida necesita float32 para estabilidad numérica
    tf.keras.layers.Dense(10, activation='softmax', dtype='float32')
])

Entornos alternativos: Google Colab y Kaggle Notebooks

Si no dispones de una GPU local, las plataformas en la nube ofrecen acceso gratuito:

• Google Colab: selecciona Entorno de ejecución → Cambiar tipo de entorno de ejecución → GPU (T4 o A100 según disponibilidad). TensorFlow ya viene preinstalado.
• Kaggle Notebooks: habilita la GPU en Settings → Accelerator → GPU T4 x2. TensorFlow también está disponible por defecto.

# Verificar entorno en Colab
import tensorflow as tf
import subprocess

resultado = subprocess.run(['nvidia-smi'], capture_output=True, text=True)
print(resultado.stdout)
print(f"TensorFlow {tf.__version__}")
print(f"GPU: {tf.config.list_physical_devices('GPU')}")

Resolución de problemas habituales

| Problema | Causa probable | Solución | |---|---|---| | No module named 'tensorflow' | TF no instalado o entorno virtual inactivo | Activar el entorno virtual y ejecutar pip install tensorflow | | Could not load dynamic library 'libcudart.so' | CUDA no instalado o ruta incorrecta | Instalar CUDA 12.3 y añadir al PATH | | ResourceExhaustedError | Memoria GPU agotada | Reducir batch size o habilitar memory growth | | La GPU no aparece | Driver o cuDNN incompatible | Consultar la matriz de compatibilidad oficial y actualizar drivers | | TF usa CPU aunque hay GPU | Memory growth mal configurado | Configurar memory growth antes de importar Keras |

Comprobación completa del entorno

Este script resume todos los pasos de verificación en un único bloque:

import tensorflow as tf
import sys

print("=" * 50)
print(f"Python:        {sys.version}")
print(f"TensorFlow:    {tf.__version__}")
print(f"Keras:         {tf.keras.__version__}")
print(f"CUDA built:    {tf.test.is_built_with_cuda()}")
print("-" * 50)
print("Dispositivos físicos:")
for d in tf.config.list_physical_devices():
    print(f"  {d.device_type}: {d.name}")
print("=" * 50)

# Test rápido con un modelo pequeño
modelo = tf.keras.Sequential([
    tf.keras.layers.Dense(8, activation='relu', input_shape=(4,)),
    tf.keras.layers.Dense(3, activation='softmax')
])
modelo.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
print("Modelo de prueba compilado correctamente.")