Representaciones visuales generales para muchas tareas.

DINO (self-DIstillation with NO labels) y sus sucesores aprenden representaciones visuales directamente de los píxeles, sin etiquetas humanas, y esas representaciones sirven después para tareas muy distintas.

El aprendizaje autosupervisado permite entrenar modelos de visión con muchas más imágenes de las que nadie podría etiquetar.

El modelo genera sus propias señales de supervisión desde los datos.

▷ Ver animación

DINO entrena una red enseñándole a predecir la salida de su versión más estable, la red maestra (teacher), sobre diferentes vistas de la misma imagen. Así, distintas vistas de una misma imagen acaban con representaciones coherentes.

Red estudiante (student network)

• Aprende activamente y ajusta sus pesos mediante backpropagation.
• Recibe todas las vistas: las globales y los recortes locales pequeños, que solo ve ella.

Red maestra (teacher network)

• Posee la misma arquitectura que la estudiante, pero con pesos estables.
• Sus pesos se actualizan lentamente a través de un promedio móvil (momentum update) de los pesos de la red estudiante.
• Recibe solo las vistas globales de la imagen.

▷ Ver animación

Al entrenar Vision Transformers (ViT) con el algoritmo DINO, el modelo aprende por su cuenta a separar el objeto principal del fondo.

El descubrimiento: segmentación autoaprendida. El modelo aprende a separar objetos sin anotaciones humanas y sin ninguna función de pérdida de segmentación a nivel de píxel.

Por qué funciona: la autoatención (self-attention).

• Visión global: cada parte de la imagen construye su comprensión procesando y relacionándose con otras ubicaciones, incluso las más distantes.
• Comprensión de escena: así cada parche lleva información del resto de la imagen, no solo de su entorno.
• Segmentación por atención: al analizar los mapas de atención internos del modelo, se observa que estos se alinean directamente con regiones semánticas coherentes, es decir, el modelo «separa» los objetos automáticamente.

Desliza para pasar de la imagen al mapa de atención del modelo. Nadie le dijo dónde estaba el objeto: estas máscaras salen de un entrenamiento sin una sola etiqueta.

Jirafas Bicicleta Perro

Atención Foto

Deslizar para comparar

Dos animales del mismo tipo y el mapa los separa a los dos, con más intensidad en cuellos y cabezas.

DINO, acrónimo de «self-DIstillation with NO labels», es la familia de referencia del aprendizaje autosupervisado en visión.

1. 2021 · DINO

   Entrena un ViT sin etiquetas y demuestra que su atención separa objetos sin supervisión explícita.

2. 2023 · DINOv2

   142 millones de imágenes curadas (LVD-142M) y mejoras de entrenamiento. Sus features funcionan sin ajuste en muchas tareas.

3. 2025 · DINOv3

   1.689 millones de imágenes y un modelo de 7.000 millones de parámetros. Gram anchoring evita que las features densas se degraden en entrenamientos largos.

DINOv2 es el backbone de RF-DETR (tema 1) y de Depth Anything (tema 6). Ojo con dos confusiones habituales: SAM no usa DINO, y el DINO de Grounding DINO es un detector que solo comparte el nombre.

▷ Ver animación

Buena parte de la mejora de DINOv2 viene de los datos: un pipeline automático construye LVD-142M mezclando imágenes curadas con imágenes de la web parecidas a ellas.

1. Ingesta de datos

   Imágenes curadas y no curadas (de la web) se combinan para diversidad.

2. Generación de embeddings

   Todas las imágenes se transforman en embeddings de alta dimensión.

3. Eliminar duplicados

   Se eliminan duplicados o imágenes muy similares de los datos no curados usando embeddings.

4. Matching y enriquecimiento

   Imágenes no curadas visualmente similares a las curadas se añaden para enriquecer el dataset.

5. Retrieval autosupervisado

   El sistema expande el dataset añadiendo imágenes relevantes sin etiquetado manual.

DINO usa autodestilación: una red «estudiante» aprende de una red «maestra» en un ciclo iterativo, sin etiquetas. Son cinco pasos.

1. Imagen y aumentaciones diferentes

   Una imagen de entrada se somete a diversas transformaciones (aumentaciones) para crear múltiples vistas, incluyendo crops locales y globales.

2. Red estudiante: todas las vistas

   La red estudiante procesa todas las vistas, también los recortes locales pequeños, que solo ve ella.

3. Red maestra: solo vistas globales

   A la vez, la red maestra procesa únicamente las vistas globales, las que muestran casi toda la imagen.

4. Estudiante predice salida de la red maestra

   La estudiante aprende a predecir la salida de la maestra para una vista global incluso a partir de un recorte local pequeño: de un trozo, el todo.

5. Maestra se actualiza por promedio

   Los pesos de la red maestra se actualizan de forma suave, utilizando un promedio móvil exponencial (momentum update) de los pesos de la red estudiante. Eso le da un objetivo estable y evita el colapso.

Descubrimientos importantes

Además de aprender representaciones, DINO hace bien cuatro cosas para las que nunca se entrenó.

El uso más habitual de DINO: convertir cualquier imagen en vectores útiles sin anotar nada.

Uso principal

Backbone para extraer características visuales universales de cualquier imagen, sin anotaciones.

Ventajas

• Generales y transferibles.
• Alto rendimiento en dominios nuevos.
• No sesgado a categorías específicas.

Calidad

• Densas (por patch).
• Semánticamente significativas.
• Altamente discriminativas.

Aplicaciones

• Clasificación (k-NN).
• Detección de anomalías.
• Clustering visual.

Cuatro técnicas para ver qué ha aprendido DINO.

Las imágenes de colores chillones que ilustran DINO no son un filtro ni un mapa de calor. Son las características del modelo pintadas, y el procedimiento cabe en cuatro pasos.

1. Un vector por parche

   La imagen se parte en parches de 16 × 16 píxeles y el modelo devuelve un vector por parche, de 768 números en un ViT base. Una imagen de 224 × 224 da 196 vectores.

2. PCA sobre todos los parches

   Se juntan esos vectores y se buscan las tres direcciones en las que más varían. Es álgebra pura, sin entrenamiento ni etiquetas.

3. Tres números por parche

   Cada parche se proyecta sobre esas tres direcciones. Los 768 números se quedan en tres, que es justo lo que cabe en un color.

4. Los tres números se pintan

   Se reescalan a 0-255 y se usan como rojo, verde y azul. El parche vuelve a su sitio en la rejilla y aparece la imagen de colores.

Por qué el ala de un avión sale del mismo color que el ala de un pájaro. El color no lo decide el píxel, lo decide el vector. Dos parches con vectores parecidos reciben proyecciones parecidas y, por tanto, el mismo color, aunque uno sea metal gris y el otro plumas marrones.

Que el modelo los deje cerca significa que ha aprendido algo sobre ellos sin que nadie se lo dijera: los dos son superficies alargadas que salen de un cuerpo y lo sostienen. Igual caen juntas la rueda de un coche y la de una bicicleta, o el cielo y el mar.

Para qué sirve más allá de la ilustración: es la forma rápida de comprobar si un modelo entiende tus imágenes antes de montar nada encima. Si al pintar el PCA de tus piezas la zona buena y la zona defectuosa salen de colores distintos, merece la pena probar ese backbone; si sale todo del mismo color, mira otro modelo u otra resolución. Es una exploración, no una medida de rendimiento.

DINO no sirve para todo. Estas son las señales a favor y en contra.

Regla empírica: si tienes etiquetas abundantes y un objetivo fijo, entrena supervisado. Si no, empieza con DINO features y ahorra semanas de trabajo.

Cuando los fallos son raros o imprevisibles no hay ejemplos de defecto con los que entrenar. Con DINO y un enfoque tipo PatchCore basta con imágenes buenas.

1. Imágenes de referencia «normales»

   Se recopilan entre 10 y 50 imágenes que representan el estado normal o sin defectos del objeto o proceso a monitorear.

2. Extracción de features DINO

   Se utiliza DINOv2 (ViT-B/14 para un buen balance) o DINOv3 (para mayor robustez) como extractor de características.

3. Embeddings por parche

   Se extraen los tokens de parche (no solo el CLS) y se normalizan con L2, capturando representaciones detalladas para cada parche de la imagen.

4. Generación del banco de normalidad (CoreSet)

   A partir de los embeddings de las imágenes normales, se construye un CoreSet (un subconjunto representativo del 1-10 %) para almacenar la normalidad.

5. Imagen de test

   Una nueva imagen, que podría contener anomalías, se procesa de la misma manera para extraer sus embeddings por parche.

6. Predicción de anomalías (kNN)

   Se calcula la distancia kNN (L2 o coseno) de cada parche de la imagen de test a su vecino más cercano en el CoreSet. Esto genera un heatmap de anomalías y un score global.

Se rechaza

Celdas marcadas13

Puntuación más alta1,89

Qué pieza pasa por la cámara

Pieza con defecto Pieza buena

El defecto queda marcado con 13 celdas, y la más alta llega a 1,89. La pieza sale de la línea.

Umbral de rechazo 1,30

0,90 · desconfiado1,90 · permisivo

Así se monta una inspección real: el banco se llena con piezas buenas de la propia línea, el umbral se fija con un lote de validación mirando cuántas falsas alarmas aguanta el proceso, y el mapa sirve para enseñar al operario dónde está el problema, no solo que existe.

import torch
from PIL import Image
from transformers import AutoImageProcessor, AutoModel

model_id = "facebook/dinov2-base"
processor = AutoImageProcessor.from_pretrained(model_id)
model = AutoModel.from_pretrained(model_id).eval()

def embedding(ruta):
    image = Image.open(ruta).convert("RGB")
    inputs = processor(images=image, return_tensors="pt")
    with torch.no_grad():
        salida = model(**inputs).last_hidden_state
    cls = salida[:, 0]                      # resumen global de la imagen
    return torch.nn.functional.normalize(cls, dim=-1)

a, b = embedding("pieza_1.jpg"), embedding("pieza_2.jpg")
print("similitud:", float(a @ b.T))

1. Reúne entre 10 y 50 imágenes normales

   De la misma cámara, la misma distancia y la misma luz que vas a tener en producción. La variabilidad que no esté aquí se marcará como anomalía.

2. Extrae embeddings por parche y normaliza

   Usa los tokens de parche, no solo el CLS, y normaliza con L2. Sácalos de una capa intermedia: en la última, cada vector mezcla información de toda la imagen y un defecto altera también los parches sanos, de modo que el umbral deja de separar.

3. Construye el banco con un CoreSet del 1 al 10 %

   No guardes todos los vectores: quédate con un subconjunto que cubra el espacio. Reduce memoria y acelera la búsqueda sin perder cobertura.

4. Fija el umbral con imágenes normales de validación

   Puntúa unas cuantas imágenes buenas que no estén en el banco y coloca el umbral por encima de su distancia máxima, con margen. No lo adivines.

5. Puntúa y revisa el heatmap, no solo el número

   El máximo por parche da el score de la imagen; el mapa completo te dice si el modelo mira donde tú mirarías.

Señal de alarma: si el heatmap se enciende en el fondo o en los bordes en vez de en la pieza, el problema es el encuadre o la iluminación, no el modelo.

1. Las imágenes normales cubren la variación realTurnos, lotes, luz de mañana y de tarde. Lo que falte se marcará como anomalía.
2. Encuadre estableSi la pieza cambia de posición entre fotos, la distancia sube sin que haya defecto.
3. Umbral fijado con validaciónCon imágenes buenas apartadas, no con las del propio banco.
4. Heatmap revisado a ojoQue se encienda donde está el defecto y no en el fondo.
5. Falsos positivos contadosCuántas piezas buenas estás parando. Ese es el coste que notará producción.
6. Plan de actualizaciónQué haces cuando cambie el proveedor, el lote o la iluminación.

1. Guarda una copia en Drive.
2. Compara dos imágenes.
3. Interpreta patches y PCA.