Primer módulo del Curso de generación de imágenes. Partimos de cero: no necesitas saber nada de visión por computador, pero ayuda tener claro qué es un modelo de IA (si no, pasa antes por Cómo funciona la IA). La meta del curso completo es que entiendas la IA generativa de imágenes de lo básico a lo avanzado: arrancamos por las redes convolucionales (la base de toda la visión moderna), pasamos por autoencoders y GANs, y llegamos a los modelos de difusión tipo Stable Diffusion y a cómo “ven” los LLM multimodales. Pero antes de generar una sola imagen hay que responder algo más humilde: ¿qué es una imagen para una máquina?

La tesis del módulo

Para un computador una imagen no es una imagen: es una grilla de números. Todo lo que viene después — detectar bordes, reconocer un gato, dibujar un rostro que no existe — son operaciones matemáticas sobre esa grilla. Entender que una foto es un tensor de números es el primer paso para entender cómo la IA la manipula.

Una imagen es una grilla de píxeles

Acércate mucho a cualquier foto en tu pantalla y verás cuadraditos de color: los píxeles (del inglés picture element, el punto más chico de una imagen). Una foto de 1920×1080 tiene poco más de dos millones de esos puntos ordenados en una grilla.

Cada píxel guarda un color, y el color se representa con tres números — el modelo RGB (Red, Green, Blue: rojo, verde, azul). Mezclando esos tres canales en distintas intensidades sale cualquier color. Cada canal es un número entero de 0 a 255:

(255, 0, 0) es rojo puro.
(0, 0, 0) es negro (todo apagado).
(255, 255, 255) es blanco (todo encendido).
(120, 120, 120) es un gris medio.

Entonces una imagen a color no es una grilla de píxeles: son tres grillas apiladas, una por canal. Cada grilla es una tabla de números del mismo alto y ancho que la foto.

De la grilla al tensor

Cuando apilamos esas tres grillas obtenemos un tensor: la palabra que la IA usa para una tabla de números de cualquier cantidad de dimensiones. Un número suelto es un tensor de 0 dimensiones; una lista es de 1D; una tabla (filas × columnas) es de 2D; y una imagen a color es de 3D — alto × ancho × 3 canales.

      una imagen RGB = tensor de 3 dimensiones

              ancho (W)
          ┌───────────────┐
    alto  │   canal  R    │
    (H)   └───────────────┘
          ┌───────────────┐    3 grillas apiladas
          │   canal  G    │    forman el tensor
          └───────────────┘    H x W x 3
          ┌───────────────┐
          │   canal  B    │
          └───────────────┘

Una foto de 224×224 a color es entonces un tensor de forma (224, 224, 3) — o sea 224 × 224 × 3 = 150.528 números. Ese bloque de números es, literalmente, todo lo que el modelo recibe. No ve un perro: ve 150.528 valores entre 0 y 255.

Ojo: el orden de las dimensiones cambia según la librería. Muchas usan (alto, ancho, canales), pero PyTorch —el framework que usaremos— prefiere (canales, alto, ancho), y además suele normalizar los valores de 0–255 a un rango de 0.0–1.0 dividiendo por 255. Es la misma información, reordenada y reescalada.

Veámoslo en código:

import numpy as np
from PIL import Image

# Cargamos una foto cualquiera y la volvemos un arreglo de numpy
img = Image.open("gato.jpg")
tensor = np.array(img)

print(tensor.shape)   # (224, 224, 3)  -> alto, ancho, canales
print(tensor.dtype)   # uint8  -> enteros de 0 a 255
print(tensor.min(), tensor.max())   # 0 255

# El píxel de la esquina superior izquierda, sus 3 canales RGB
print(tensor[0, 0])   # p.ej. [130  98  72]  -> un café claro

# Normalizar a 0.0–1.0, como espera casi cualquier red neuronal
tensor_norm = tensor.astype("float32") / 255.0
print(tensor_norm.max())   # 1.0

Por qué una red totalmente conectada fracasa

En Cómo funciona la IA vimos las redes neuronales clásicas (y el Curso de Redes Neuronales las arma pieza por pieza), donde cada neurona de una capa se conecta con todas las de la siguiente. Se llaman fully-connected (totalmente conectadas) o densas. Funcionan de maravilla con datos chicos… y se rompen con imágenes por dos razones.

Problema 1: demasiados parámetros. Para meter nuestra imagen de 150.528 números a una red densa hay que estirarla en una fila larga (aplanarla). Si la primera capa oculta tiene apenas 1.000 neuronas, cada una necesita un peso por cada entrada:

   150.528 entradas  x  1.000 neuronas  =  150 millones
   de parámetros SOLO en la primera capa

Ciento cincuenta millones de números que ajustar, para una imagen pequeña y una sola capa modesta. Es inviable: necesitaría muchísimos datos, muchísima memoria y se sobreajustaría al instante.

Problema 2: ignora la estructura espacial. Al aplanar la imagen en una fila, dos píxeles vecinos —que forman juntos un borde, una textura— quedan tan lejos entre sí como dos píxeles de esquinas opuestas. La red pierde la noción de que la imagen es 2D, de que hay cercanía. Y un gato en la esquina superior no activa las mismas neuronas que el mismo gato en la esquina inferior: la red tendría que reaprender el gato en cada posición.

Enfoque	Parámetros (1ª capa)	¿Usa la vecindad?	¿Reconoce un patrón en cualquier posición?
Fully-connected	~150 millones	No, aplana todo	No, cada posición se aprende aparte
Convolucional (módulo 2)	unos cientos	Sí, mira parches	Sí, el mismo filtro recorre toda la imagen

La solución a estos dos problemas es la convolución, el corazón del próximo módulo. Por ahora quédate con la intuición: hay que mirar la imagen por parches locales y reutilizar el mismo detector en toda ella.

El panorama: las tareas de visión por computador

“Ver” no es una sola cosa. La visión por computador se divide en tareas, y conviene tener el mapa completo antes de empezar:

Tarea	Qué pregunta responde	Salida típica
Clasificación	¿Qué hay en la imagen?	Una etiqueta: “gato”
Detección (detection)	¿Qué hay y dónde?	Cajas alrededor de cada objeto
Segmentación (segmentation)	¿Qué píxeles son qué?	Un contorno preciso por objeto
Generación (generation)	Crear una imagen que no existía	Una imagen nueva

Las tres primeras son de análisis: reciben una imagen y la resumen. La cuarta invierte el flujo: recibe una idea (un texto, un ruido) y produce píxeles. Ese es el foco final del curso.

   ANÁLISIS  (entender lo que existe)
   ┌─────────┐      ┌──────────────┐
   │  imagen │ ───► │  clase / caja│
   └─────────┘      └──────────────┘

   GENERACIÓN  (crear lo que no existe)
   ┌─────────┐      ┌──────────────┐
   │  idea o │ ───► │    imagen    │
   │  ruido  │      │    nueva     │
   └─────────┘      └──────────────┘

Lo interesante: para generar buenas imágenes, un modelo primero tiene que entenderlas. Por eso el curso arranca por las CNN de clasificación (módulos 1–4), sube a los autoencoders y GANs (5–7) y remata en difusión y multimodal (8–12). Cada peldaño se apoya en el anterior.

Errores comunes

Creer que el modelo “ve” la foto como tú. No la ve: recibe un tensor de números y aprende relaciones entre ellos. No hay ojos ni intuición, solo álgebra.
Pensar que color = un número. Un píxel a color son tres números (RGB). Confundir esto lleva a formas de tensor equivocadas y errores al cargar datos.
Olvidar normalizar. Meter valores 0–255 a una red que espera 0.0–1.0 (o viceversa) es una de las causas más comunes de que un modelo “no aprenda nada”.
Intentar resolver imágenes con una red densa. Técnicamente se puede con imágenes minúsculas, pero no escala. Para imágenes de verdad, la convolución no es opcional.
Confundir alto×ancho con ancho×alto. El orden de las dimensiones importa y varía entre librerías; siempre imprime el .shape para confirmar.

La frase para llevarse

“Una máquina no ve gatos ni atardeceres: ve grillas de números. Toda la magia de la visión por computador es matemática cuidadosa sobre esas grillas.”

Qué viene

Módulo 2: la convolución. El truco que resuelve de un golpe los dos problemas de la red densa — mirar la imagen por parches locales y reutilizar el mismo detector en toda ella. Veremos qué es un filtro, cómo se desliza sobre la imagen y cómo aprende solo a detectar bordes y texturas.

Generación de imágenes — Módulo 1: cómo ve una máquina — de píxeles a tensores