Visión moderna: modelos preentrenados, autoaprendizaje y CLIP

1. Solo la cabeza (o una sonda lineal): con 30 fotos por clase, un ajuste completo puede sobreajustar, y calcular las variables una vez es barato sin GPU. Si después quieres un poco más, puedes ajustar solo las últimas capas.
2. Ajuste completo desde una red preentrenada: con muchos datos y GPU, retocar todos los filtros suele dar lo mejor. Entrenar desde cero también sería posible, pero partir de pesos preentrenados casi nunca empeora y converge más rápido.
3. CLIP zero-shot, con plantillas como «a photo of food». Son clases comunes en internet, justo lo que CLIP vio.
4. Ajuste completo de una red preentrenada, probablemente con varias épocas. Las fotos se parecen poco a ImageNet y a internet, así que la cabeza sola y CLIP zero-shot rendirían peor; aun así, los bordes y texturas de las primeras capas sirven. Desde cero también es razonable con 5000 fotos; lo correcto es probar las dos opciones y medir en validación.

modelo = resnet18(weights=pesos)
modelo.fc = nn.Linear(512, 4)


def entrenables(m):
    return sum(p.numel() for p in m.parameters() if p.requires_grad)


total = entrenables(modelo)
print(f"Todo:                  {total:>10,}".replace(",", " "))
for p in modelo.parameters():
    p.requires_grad = False
for p in modelo.fc.parameters():
    p.requires_grad = True
print(f"Solo la cabeza:        {entrenables(modelo):>10,}"
      .replace(",", " "))
for p in modelo.layer4.parameters():
    p.requires_grad = True
n = entrenables(modelo)
print(f"layer4 y la cabeza:    {n:>10,}".replace(",", " "),
      f"({n / total:.0%})")

Todo:                  11 178 564
Solo la cabeza:             2 052
layer4 y la cabeza:     8 395 780 (75%)

La cabeza tiene 512 · 4 + 4 = 2052 parámetros, menos del 0,02 % de la red. El último bloque solo ya tiene cerca de tres cuartos de todos: las capas finales de una CNN tienen muchos canales, y cada filtro de 3 × 3 × 512 tiene 4608 pesos. Ajustar «solo las últimas capas» ahorra cálculo (el gradiente no tiene que bajar hasta el principio), pero no tantos parámetros como podrías pensar.

sel = torch.cat([torch.arange(k * 100, k * 100 + 10) for k in range(4)])
sonda = LogisticRegression(max_iter=2000)
sonda.fit(v_ent[sel].numpy(), y_ent[sel].numpy())
print(f"Solo la cabeza:  {sonda.score(v_val.numpy(), y_val.numpy()):.3f}")

torch.manual_seed(0)
pocas = resnet18(weights=pesos)
pocas.fc = nn.Linear(512, 4)
cargador_pocas = DataLoader(TensorDataset(x_ent[sel], y_ent[sel]),
                            batch_size=8, shuffle=True,
                            generator=torch.Generator().manual_seed(0))
entrenar(pocas, cargador_pocas, cargador_pocas, epocas=5,
         optimizador=torch.optim.Adam(pocas.parameters(), lr=1e-4),
         dispositivo=device, mostrar=False)
cargador_val = DataLoader(TensorDataset(x_val, y_val), batch_size=100)
_, exactitud = evaluar(pocas, cargador_val, nn.CrossEntropyLoss(), device)
print(f"Ajuste completo: {exactitud:.3f}")

Solo la cabeza:  0.833
Ajuste completo: 0.865

Con 10 fotos por clase las dos formas quedan cerca. El ajuste completo gana por poco, pero con 40 fotos y 11 millones de parámetros el resultado depende mucho de la semilla y de la tasa, y cuesta mucho más tiempo. Con pocas fotos, la cabeza sola es la apuesta segura; el ajuste completo rinde más cuando hay más datos (como en la teoría) o cuando las fotos se parecen poco a las del preentrenamiento.

plantillas = ["{}", "a satellite photo of {}", "a satellite photo of {}.",
              "a photo of {}.", "an aerial view of {}."]


def exactitud_zero_shot(t):
    pred = (c_val @ t.T).argmax(dim=1)
    return (pred == y_val).float().mean().item()


vectores = []
for p in plantillas:
    t = codificar_textos([p.format(c) for c in EN])
    vectores.append(t)
    print(f"{p!r:28s} {exactitud_zero_shot(t):.3f}")

promedio = F.normalize(torch.stack(vectores).mean(dim=0), dim=1)
print(f"{'promedio de las cinco':28s} {exactitud_zero_shot(promedio):.3f}")

'{}'                         0.678
'a satellite photo of {}'    0.592
'a satellite photo of {}.'   0.530
'a photo of {}.'             0.637
'an aerial view of {}.'      0.700
promedio de las cinco        0.668

Un detalle tan chico como el punto final cambia mucho la exactitud: CLIP no «entiende» la frase como una persona, la convierte en un vector que depende de cada token. Por eso hay que probar varias plantillas y medir con fotos etiquetadas, aunque sean pocas. Promediar plantillas suele dar un resultado más estable que elegir una sola (los autores de CLIP promediaron 80 plantillas para ImageNet), pero aquí no le gana a la mejor plantilla: tampoco es magia. Ojo: si eliges la plantilla mirando la exactitud de prueba, esa exactitud ya no es una medida honesta; lo correcto es elegirla con un conjunto de validación aparte.

Dividir por τ = 0,1 multiplica por 10: la fila 1 queda (3; 1) y la fila 2, (2; 2,5).

• p₁₁ = e³ / (e³ + e¹) = 1 / (1 + e⁻²) ≈ 1 / 1,135 ≈ 0,881
• p₂₂ = e²·⁵ / (e² + e²·⁵) = 1 / (1 + e⁻⁰·⁵) ≈ 1 / 1,607 ≈ 0,622
• L = −(ln 0,881 + ln 0,622) / 2 ≈ (0,127 + 0,475) / 2 ≈ 0,301

s = torch.tensor([[0.30, 0.10], [0.20, 0.25]])
correctas = torch.tensor([0, 1])
for tau in [0.1, 0.01]:
    p = (s / tau).softmax(dim=1)
    perdida = F.cross_entropy(s / tau, correctas)
    print(f"tau = {tau}: p11 = {p[0, 0]:.3f}, p22 = {p[1, 1]:.3f}, "
          f"pérdida = {perdida:.3f}")

tau = 0.1: p11 = 0.881, p22 = 0.622, pérdida = 0.301
tau = 0.01: p11 = 1.000, p22 = 0.993, pérdida = 0.003

Con τ = 0,01, diferencias de similitud de 0,05 se vuelven diferencias de 5 antes del softmax, y las dos fotos dan casi toda la probabilidad a su texto: la pérdida baja casi a cero sin que cambie ningún vector. Por eso la temperatura se aprende junto con la red, y por eso una pérdida chica solo se puede comparar con otra calculada con la misma τ.

frases_es = ["una foto de una bicicleta sobre el pasto",
             "un frutero sobre una mesa",
             "un gato durmiendo en una silla",
             "el clavijero de una guitarra",
             "montañas nevadas y una laguna",
             "un perro echado junto al mar"]
for idioma, textos in [("inglés", frases), ("español", frases_es)]:
    t = codificar_textos(textos)
    s6 = codificar_fotos(list(fotos6.values())) @ t.T
    diagonal = s6.diagonal()
    # El mayor valor de cada fila fuera de la diagonal
    otros = (s6 - 9 * torch.eye(6)).max(dim=1).values
    print(f"{idioma:8s} elige {s6.argmax(dim=1).tolist()}  "
          f"diagonal {diagonal.mean():.3f}  "
          f"margen medio {(diagonal - otros).mean():.3f}")

ES = ["un bosque", "una autopista", "una zona residencial", "un río"]
t = codificar_textos([f"una foto satelital de {c}" for c in ES])
pred = (c_val @ t.T).argmax(dim=1)
print(f"EuroSAT en español: {(pred == y_val).float().mean():.3f}")

inglés   elige [0, 1, 2, 3, 4, 5]  diagonal 0.297  margen medio 0.122
español  elige [0, 1, 2, 3, 4, 5]  diagonal 0.270  margen medio 0.083
EuroSAT en español: 0.598

Con estas seis fotos tan distintas, CLIP todavía acierta las seis en español, pero con similitudes más bajas y menos margen sobre la segunda frase: muchas palabras («bicicleta», «guitarra», «gato») comparten pedazos con el inglés o aparecieron en textos de internet. En EuroSAT, la plantilla en español dio casi lo mismo que la de la teoría en inglés (0,598 frente a 0,592): con estas clases, CLIP se equivoca por otras razones. Que acierte en estos casos no quiere decir que entienda español; con frases que no se parecen al inglés le puede ir mucho peor. Para otro idioma conviene traducir las frases al inglés o usar un CLIP multilingüe, y siempre medir.

for nombre, a, b in [("DINOv2", d_ent, d_val), ("ResNet-18", v_ent, v_val)]:
    fila = []
    for k in [1, 5, 15]:
        knn = KNeighborsClassifier(n_neighbors=k, metric="cosine")
        knn.fit(a.numpy(), y_ent.numpy())
        fila.append(f"k = {k:2d}: {knn.score(b.numpy(), y_val.numpy()):.3f}")
    print(f"{nombre:10s}", "   ".join(fila))

DINOv2     k =  1: 0.887   k =  5: 0.907   k = 15: 0.890
ResNet-18  k =  1: 0.877   k =  5: 0.890   k = 15: 0.880

DINOv2 gana con los tres valores de k, aunque nunca vio una etiqueta: el autoaprendizaje con muchísimas fotos dio variables por lo menos tan útiles como las de una red entrenada con etiquetas. Con k = 1 una sola vecina equivocada decide; con k = 5 la votación corrige algunos errores; con k más grande se empiezan a colar vecinas de otras clases. Elegir k mirando la prueba tiene el mismo problema que en el ejercicio 4: para elegirlo bien hace falta validación (tema 7).

ocho = [fotos_val[i] for i in range(0, 400, 50)]
x = proc_vit(images=ocho, return_tensors="pt")
with torch.no_grad():
    elegidas = vit(**x.to(device)).logits.argmax(dim=1).tolist()
for i, k in zip(range(0, 400, 50), elegidas):
    etiqueta = vit.config.id2label[k].split(",")[0]
    print(f"{NOMBRES[y_val[i]]:12s} -> {etiqueta}")

bosque       -> nematode
bosque       -> gar
autopista    -> nematode
autopista    -> tile roof
residencial  -> sidewinder
residencial  -> hen-of-the-woods
río          -> nematode
río          -> oboe

Las respuestas son absurdas (gusanos, peces, instrumentos), pero tienen lógica: DeiT-tiny tiene que elegir una de sus 1000 clases de ImageNet, y ninguna es «río visto desde un satélite». Elige la clase cuyas texturas se parecen más: un río serpenteante se parece a un gusano; un tejido de techos, a un tejado. Para usarlo con EuroSAT, hay que cambiarle la cabeza por una de 4 clases y entrenarla (o ajustar toda la red), exactamente como hiciste con ResNet-18.

Este código hace los pasos 3 a 5. Con tus fotos, cambia las frases de DESCRIPCION por las de tus objetos.

from sklearn.metrics import confusion_matrix

# Paso 3: ResNet-18 congelada y sonda lineal, validación cruzada
x = torch.stack([preparar(f) for f in mis_fotos])
mis_v = variables(red, x).numpy()
puntajes = cross_val_score(LogisticRegression(max_iter=2000), mis_v,
                           mis_y, cv=5)
print(f"Transfer (5 pliegues): {puntajes.mean():.3f} "
      f"(de {puntajes.min():.3f} a {puntajes.max():.3f})")

# Paso 4: CLIP zero-shot, una frase en inglés por carpeta
DESCRIPCION = {"autopista": "a satellite photo of a highway",
               "bosque": "a satellite photo of a forest",
               "residencial": "a satellite photo of a residential area",
               "río": "a satellite photo of a river"}
t = codificar_textos([DESCRIPCION[c] for c in clases])
pred = (codificar_fotos(mis_fotos) @ t.T).argmax(dim=1).numpy()
print(f"CLIP zero-shot: {(pred == mis_y).mean():.3f}")

# Paso 5: dónde se equivoca CLIP
print(clases)
print(confusion_matrix(mis_y, pred))
fallas = np.flatnonzero(pred != mis_y)
print("Fotos que fallan:", [f"{clases[mis_y[i]]}->{clases[pred[i]]}"
                            for i in fallas[:4]])

Transfer (5 pliegues): 0.812 (de 0.750 a 0.938)
CLIP zero-shot: 0.525
['autopista', 'bosque', 'residencial', 'río']
[[18  0  2  0]
 [18  0  0  2]
 [ 0  1 19  0]
 [12  0  3  5]]
Fotos que fallan: ['autopista->residencial', 'autopista->residencial', 'bosque->autopista', 'bosque->autopista']

• Con 20 fotos por clase, la sonda lineal sobre ResNet-18 acierta el 81 % en la validación cruzada (con 16 fotos por clase para entrenar en cada pliegue), y CLIP zero-shot apenas la mitad: con fotos satelitales, que CLIP vio poco, el transfer gana con claridad. Con fotos de objetos cotidianos, que abundan en internet, la distancia suele ser mucho menor.
• CLIP reconoce bien las autopistas y las zonas residenciales, pero manda casi todos los bosques y muchos ríos a «autopista»: la misma confusión de la teoría. Una plantilla mejor (ejercicio 4) ayudaría.
• Con tus fotos, la exactitud puede ser alta por una mala razón: si cada objeto se fotografió siempre sobre el mismo fondo. Una prueba honesta: saca 10 fotos nuevas de cada objeto en otro lugar y mide con ellas.