GPU local o en la nube: cuándo y cómo

No necesitas comprar una GPU para aprender, pero sí saber cuándo alquilarla.

Qué vas a aprender

• Comprobar si tienes GPU local con nvidia-smi y con la API de CUDA de PyTorch
• Configurar Google Colab con una GPU T4 para experimentar gratis en la nube
• Medir una multiplicación de matrices en CPU frente a GPU y calcular la aceleración
• Estimar el modelo más grande que cabe en tu VRAM con la regla rápida de fp16

Por qué importa

La mayoría de las lecciones de los módulos 1 a 3 funcionan bien en CPU. Pero en cuanto empieces a entrenar redes neuronales, Transformers o LLMs (del módulo 4 en adelante), necesitarás aceleración por GPU. Un entrenamiento que tarda 8 horas en CPU puede tardar 10 minutos en GPU.

Tienes tres opciones: GPU local, GPU en la nube o Google Colab (gratis).

La idea clave

Tus opciones:

1. GPU NVIDIA local
   Coste: 0 € (ya la tienes)
   Configuración: instalar CUDA + cuDNN
   Ideal para: uso habitual, datasets grandes

2. Google Colab (plan gratuito)
   Coste: 0 €
   Configuración: ninguna
   Ideal para: experimentos rápidos, si no tienes GPU en casa

3. GPU en la nube (Lambda, RunPod, Vast.ai…)
   Coste: aprox. 0,20-2 $/hora (varía según modelo de GPU y proveedor)
   Configuración: SSH + instalación
   Ideal para: entrenamientos serios, modelos grandes

¿Por qué una GPU es tan rápida? Una CPU tiene unos pocos núcleos muy potentes, pensados para tareas secuenciales. Una GPU tiene miles de núcleos más sencillos que hacen la misma operación a la vez sobre datos distintos. Y entrenar redes neuronales es, sobre todo, multiplicar matrices enormes: exactamente lo que se paraleliza bien.

Paso a paso

Opción 1: GPU NVIDIA local

Comprueba si tienes una:

nvidia-smi

Con PyTorch instalado con soporte CUDA (lo hiciste en «Tu puesto de trabajo de IA, desde cero»), comprueba qué ve:

import torch

print(f"CUDA disponible: {torch.cuda.is_available()}")
print(f"Versión de CUDA: {torch.version.cuda}")
if torch.cuda.is_available():
    print(f"GPU: {torch.cuda.get_device_name(0)}")
    print(f"Memoria: {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB")

Opción 2: Google Colab

1. Entra en colab.research.google.com
2. Menú Entorno de ejecución › Cambiar tipo de entorno de ejecución › GPU T4
3. Ejecuta !nvidia-smi en una celda para comprobarlo

Puedes subir a Colab directamente los notebooks del curso.

Ojo con Colab gratis: la sesión se desconecta tras un rato de inactividad y tiene límites de uso. Guarda tus checkpoints en Google Drive para no perder un entrenamiento a medias.

Opción 3: GPU en la nube

Con Lambda Labs, RunPod, Vast.ai u otro proveedor:

ssh usuario@tu-instancia-gpu

pip install torch torchvision torchaudio
python -c "import torch; print(torch.cuda.get_device_name(0))"

Apaga la máquina al terminar. Las GPUs en la nube cobran por hora aunque no las estés usando. Es el error más caro (y más común) de quien empieza.

¿Sin GPU? Sin problema

La mayoría de lecciones funcionan en CPU. Las que necesitan GPU lo indican. Escribe tu código para que funcione en ambos casos:

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"Usando: {device}")

Paso a paso: comparativa GPU frente a CPU

import torch
import time

size = 5000

a_cpu = torch.randn(size, size)
b_cpu = torch.randn(size, size)

start = time.time()
c_cpu = a_cpu @ b_cpu
cpu_time = time.time() - start
print(f"CPU: {cpu_time:.3f}s")

if torch.cuda.is_available():
    a_gpu = a_cpu.to("cuda")
    b_gpu = b_cpu.to("cuda")

    torch.cuda.synchronize()
    start = time.time()
    c_gpu = a_gpu @ b_gpu
    torch.cuda.synchronize()
    gpu_time = time.time() - start
    print(f"GPU: {gpu_time:.3f}s")
    print(f"Aceleración: {cpu_time / gpu_time:.0f}x")

¿Por qué torch.cuda.synchronize()? Las operaciones en GPU son asíncronas: Python lanza el cálculo y sigue adelante sin esperar. Si paras el cronómetro sin sincronizar, medirás lo que tarda en encargar el trabajo, no en hacerlo.

Tienes este mismo test, ampliado, en comprobar_gpu.py («Archivos de la lección»): detecta tu GPU (NVIDIA o Apple), mide la aceleración frente a la CPU y te dice qué tamaño de modelo te cabe. Ejecútalo en tu ordenador con python comprobar_gpu.py.

Pruébalo aquí: por qué el hardware paralelo es tan rápido

En el navegador no hay GPU, pero puedes ver la misma idea a pequeña escala. Un bucle de Python hace las multiplicaciones de una en una; NumPy las lanza en bloque sobre código optimizado que aprovecha las instrucciones vectoriales de la CPU. Una GPU lleva esa idea al extremo, con miles de núcleos trabajando a la vez:

import time
import numpy as np

n = 120
a = np.random.rand(n, n)
b = np.random.rand(n, n)

inicio = time.perf_counter()
c = [[sum(a[i, k] * b[k, j] for k in range(n)) for j in range(n)] for i in range(n)]
t_bucle = time.perf_counter() - inicio

inicio = time.perf_counter()
c_np = a @ b
t_numpy = time.perf_counter() - inicio

print(f"Bucle de Python: {t_bucle:.3f} s")
print(f"NumPy (a @ b):   {t_numpy:.5f} s")
print(f"Aceleración:     {t_bucle / t_numpy:.0f}x")
print("¿Mismo resultado?", np.allclose(c, c_np))

Extra: ¿cuánta memoria necesita un modelo?

La cuenta rápida: memoria de los pesos = número de parámetros × bytes por parámetro.

Calcúlalo para cualquier modelo: cambia parametros (en miles de millones) y vram_gb (la memoria de tu GPU) y ejecútalo:

parametros = 8      # miles de millones de parámetros (8B)
vram_gb = 16        # memoria de tu GPU en GB

bytes_por_parametro = {"fp32": 4, "fp16 / bf16": 2, "int8": 1, "int4": 0.5}
margen = 1.2        # +20 % para activaciones y caché de atención

print(f"Modelo de {parametros}B en una GPU de {vram_gb} GB (inferencia):\n")
for precision, b in bytes_por_parametro.items():
    necesaria = parametros * b * margen
    veredicto = "cabe" if necesaria <= vram_gb else "NO cabe"
    print(f"  {precision:<12} {necesaria:6.1f} GB  → {veredicto}")

print(f"\nPara entrenarlo entero (~16 bytes/parámetro): {parametros * 16} GB")

Eso es solo para usar el modelo (inferencia), y aun así necesitarás algo de margen para las activaciones y la caché de atención. Entrenarlo cuesta mucho más: con el optimizador Adam y precisión mixta, una regla habitual es de unos 16 bytes por parámetro (pesos, gradientes, estados del optimizador y una copia en fp32). Por eso para ajustar modelos grandes se usan técnicas como LoRA, que verás en el módulo 9 (Ajuste fino y preferencias).

Retos para tu ordenador

1. Ejecuta la comparativa anterior y compara los tiempos de CPU y GPU
2. Si no tienes GPU, ejecútala en Google Colab y compara
3. Mira cuánta memoria tiene tu GPU y estima el modelo más grande que te cabe (regla rápida: 2 bytes por parámetro en fp16)

Glosario de la lección