Otro modelo a gran escala revolucionario de Meta AI DINOv2 para la extracción de características de imágenes.

Meta AI DINOv2's revolutionary large-scale model for image feature extraction.

DINOv2 es uno de los mejores modelos de DL basados en ViT auto-supervisados para la extracción de características de imagen

Introducción

Mete AI presenta una nueva versión del modelo de extracción de características de imagen llamado DINOv2 que extrae automáticamente características visuales de la imagen. Este es otro paso revolucionario en el campo de la IA, especialmente en el dominio de la visión por computadora en términos de escalado de datos y modelos.

Motivación – ¿Por qué deberíamos preocuparnos?

DINOv2 es un modelo auto-supervisado que no requiere ajuste fino y tiene un buen rendimiento. Además, puede ser utilizado como columna vertebral para muchas tareas diferentes de visión por computadora, como:

• Clasificación, clasificación de alta precisión – por ejemplo, gato vs perro o por ejemplo, identificador de raza de perro
• Recuperación de imagen – por ejemplo, encontrar una bolsa similar a la tuya a partir de una gran cantidad de imágenes en internet
• Segmentación semántica de imagen – Asocia una etiqueta o categoría con cada píxel en una imagen.
• Comprensión de video – reconoce e interpreta automáticamente varios aspectos de los videos, como objetos, acciones, eventos, escenas e incluso conceptos de nivel superior.
• Estimación de profundidad monocular: predecir si un objeto está en primer plano o en segundo plano en una imagen.
• Agrupación de imágenes: agrupar imágenes en clústeres de manera que las imágenes dentro de los mismos clústeres sean similares entre sí
• Sistema de recomendación basado en contenido: recomendación de elementos a partir de una representación de imagen.

DINOv2 complementa otra investigación reciente de visión por computadora, incluyendo Segment Anything. Segment Anything es un sistema de segmentación que se enfoca en la generalización sin necesidad de entrenamiento para un conjunto diverso de tareas de segmentación.

Puedes echar un vistazo al Modelo Segment Anything (SAM) en mi publicación anterior.

Meta AI presenta un revolucionario modelo de segmentación de imágenes entrenado en 1 mil millones de máscaras

Segment Anything Model (SAM) – Mejor modelo de DL para la segmentación de imágenes

towardsdatascience.com

• ¿Qué hacen realmente los Ingenieros de Datos?
• 5 formas de obtener conjuntos de datos interesantes para tu próximo...
• ¿Demasiadas características? Veamos el Análisis de Componentes Prin...

Metodología

La principal contribución del artículo puede ser la siguiente:

• Crear un conjunto de datos de entrenamiento grande y curado
• Mejorar el algoritmo y la implementación de entrenamiento
• Diseñar un pipeline de destilación funcional.

Crear un conjunto de datos de entrenamiento grande y curado

Los modelos grandes de aprendizaje profundo necesitan grandes cantidades de datos para el entrenamiento. Es por eso que los autores han creado un pipeline automático que se muestra en la figura a continuación para obtener un conjunto de datos de entrenamiento curado.

Seleccionaron un conjunto de imágenes semilla de una colección de alrededor de 25 conjuntos de datos de terceros y su objetivo era aumentar estas imágenes semilla. Así es como funciona. Rasparon una gran cantidad de imágenes no curadas (aproximadamente 1.2 mil millones de imágenes únicas) de internet. Después de eso, crearon incrustaciones de imagen utilizando una red ViT-H/16 auto-supervisada pre-entrenada en ImageNet-22k. En segundo lugar, utilizaron la similaridad del coseno como medida de distancia entre imágenes para filtrar las imágenes duplicadas con el fin de reducir la redundancia y aumentar la diversidad. Como se eliminaron las imágenes duplicadas de los grandes conjuntos de datos no curados, luego realizaron una etapa de recuperación de imágenes, donde se extrajeron las imágenes que eran similares a las imágenes curadas. Al final, este enfoque les permitió crear 142 millones de imágenes curadas de una base de datos no curada de 1.2 mil millones de imágenes.

Algoritmo de entrenamiento mejorado

DINOv2 utiliza un mecanismo estudiante-profesor que es una técnica de entrenamiento donde una red neuronal más pequeña, conocida como el estudiante, aprende a imitar el comportamiento de una red neuronal más grande o más compleja, conocida como el profesor. Estudiante y profesor se basan en la arquitectura Vision Tranformer (ViT) [2]. En cuanto a la pérdida, utilizan una pérdida de entropía cruzada para la similitud de características estudiante-profesor. Para aprender características locales y globales en la imagen, utilizaron diferentes niveles de aprendizaje. Para el aprendizaje global, utilizaron el aprendizaje de nivel de imagen: recorte de datos de manera aleatoria en la misma imagen. En cuanto al aprendizaje de características locales, utilizaron el aprendizaje de nivel de parche: aplicar aleatoriamente una máscara a los parches de entrada del estudiante, pero no al del profesor. Además, realizaron diferentes técnicas de normalización como la normalización por lotes Sinkhorn-knop, etc. Puedes encontrar más detalles en el artículo.

Pipeline de destilación.

Se requiere hardware potente para hacer predicciones (inferencia) utilizando modelos grandes. Para superar esta limitación, también se comprime un modelo grande en uno más pequeño. La destilación de conocimiento [5] tiene como objetivo reproducir la salida de un modelo grande con un modelo más pequeño minimizando alguna distancia entre ambas salidas para un conjunto de entradas dadas. El algoritmo de entrenamiento se basa en la auto destilación, lo que hace que sea sencillo comprimir nuestros modelos grandes en modelos más pequeños.

Resultado

Se ha evaluado el rendimiento del modelo en ocho tareas diferentes de visión por computadora y se ha comparado con otros métodos.

En el gráfico a continuación, el resultado de los modelos DINOv2 son de color azul oscuro, otros métodos auto-supervisados son de color naranja pálido y los métodos débilmente supervisados se destacan en rosa oscuro. La línea horizontal discontinua es el modelo débilmente supervisado de mejor rendimiento.

Como muestra el resultado, los modelos DINOv2 mejoran drásticamente el estado del arte anterior en el aprendizaje auto-supervisado y alcanzan un rendimiento comparable con características débilmente supervisadas.

Conclusión

En resumen, DINOv2 es otro modelo revolucionario del equipo de Meta AI. No requiere ajuste fino y se puede utilizar como columna vertebral para muchos modelos de visión por computadora diferentes. DINOv2 utiliza un mecanismo de auto-supervisión y puede aprender de cualquier colección de imágenes.

Demostración de DINOv2 – clasificación de imágenes de grano fino

En esta parte, intentaré demostrar cómo funciona DINOv2 en un escenario real. Crearé una tarea de clasificación de imágenes de grano fino.

Flujo de trabajo de clasificación:

• Descargar el conjunto de datos Food101 de los conjuntos de datos PyTorch.
• Extraer características de los conjuntos de datos de entrenamiento y prueba utilizando DINOv2 pequeño
• Entrenar modelos clasificadores de ML (SVM, XGBoost y KNN) utilizando características extraídas del conjunto de datos de entrenamiento.
• Hacer una predicción en las características extraídas del conjunto de datos de prueba.
• Evaluar la precisión y la puntuación F1 de cada modelo de ML.

Datos : Food 101 es un conjunto de datos desafiante de 101 categorías de alimentos con 101.000 imágenes. Para cada clase, se proporcionan 250 imágenes de prueba revisadas manualmente y 750 imágenes de entrenamiento.

Modelo : modelo DINOv2 pequeño (ViT-S/14 destilado)

Modelos de ML : SVM, XGBoost, KNN.

Paso 1 – Configuración (Puede usar Google Colab para ejecutar el código y activar la GPU)

import torchimport numpy as npimport torchvisionfrom torchvision import transformsfrom torch.utils.data import Subset, DataLoaderimport matplotlib.pyplot as pltimport timeimport osimport randomfrom tqdm import tqdmfrom xgboost import XGBClassifierfrom sklearn.svm import SVCfrom sklearn.neighbors import KNeighborsClassifierfrom sklearn.metrics import accuracy_score, f1_scoreimport pandas as pddef set_seed(no):    torch.manual_seed(no)    random.seed(no)    np.random.seed(no)    os.environ['PYTHONHASHSEED'] = str()    torch.backends.cudnn.benchmark = False    torch.backends.cudnn.deterministic = Trueset_seed(100)

Paso 2 – Crear transformación, descargar y crear conjuntos de datos Pytorch de Food101, crear objetos de cargador de datos de entrenamiento y prueba.

tamaño_del_lote = 8transformación = transforms.Compose([        transforms.Resize(256),        transforms.CenterCrop(224),        transforms.ToTensor(),        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])    ])trainset = torchvision.datasets.Food101(root='./data', split='train',                                        download=True, transform=transformation)testset = torchvision.datasets.Food101(root='./data', split='test',                                       download=True, transform=transformation)# train_indices = random.sample(range(len(trainset)), 20000)# test_indices = random.sample(range(len(testset)), 5000)# trainset = Subset(trainset, train_indices)# testset  = Subset(testset, test_indices)trainloader = torch.utils.data.DataLoader(trainset, batch_size=tamaño_del_lote,                                          shuffle=True)testloader = torch.utils.data.DataLoader(testset, batch_size=tamaño_del_lote,                                         shuffle=False)classes = trainset.classesprint(len(trainset), len(testset))print(len(trainloader), len(testloader))

[out] 75750 25250

[out] 9469 3157

Paso 3 (Opcional) — Visualizar lote de entrenamiento de dataloader

# Obtener un lote de imágenesdataiter = iter(trainloader)imágenes, etiquetas = next(dataiter)# Graficar las imágenesfig, ejes = plt.subplots(1, len(imágenes),figsize=(12,12))for i, ax in enumerate(axes):    # Convertir la imagen tensor a formato numpy    imagen = imágenes[i].numpy()    imagen = imagen.transpose((1, 2, 0))  # Transponer a (alto, ancho, canales)    # Normalizar la imagen    media = [0.485, 0.456, 0.406]    std = [0.229, 0.224, 0.225]    imagen_normalizada = (imagen * std) + media    # Mostrar la imagen    ax.imshow(imagen_normalizada)    ax.axis('off')    ax.set_title(f'Etiqueta: {etiquetas[i]}')# Mostrar la gráficaplt.show()

Paso 4 — Cargar modelo DINOv2 pequeño y extraer características de dataloaders de entrenamiento y prueba.

dispositivo = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")dinov2_vits14 = torch.hub.load('facebookresearch/dinov2', 'dinov2_vits14').to(dispositivo)#entrenamientoembeddings_entrenamiento = []etiquetas_entrenamiento = []dinov2_vits14.eval()with torch.no_grad():  for datos, etiquetas in tqdm(trainloader):    lote_de_incrustaciones_de_imágenes = dinov2_vits14(datos.to(dispositivo))    embeddings_entrenamiento.append(lote_de_incrustaciones_de_imágenes.detach().cpu().numpy())    etiquetas_entrenamiento.append(etiquetas.detach().cpu().numpy())#pruebaincrustaciones_prueba = []etiquetas_prueba = []dinov2_vits14.eval()with torch.no_grad():  for datos, etiquetas in tqdm(testloader):    lote_de_incrustaciones_de_imágenes = dinov2_vits14(datos.to(dispositivo))    incrustaciones_prueba.append(lote_de_incrustaciones_de_imágenes.detach().cpu().numpy())    etiquetas_prueba.append(etiquetas.detach().cpu().numpy())#concatenar resultadosembeddings_entrenamiento_f = np.vstack(embeddings_entrenamiento)etiquetas_entrenamiento_f = np.concatenate(etiquetas_entrenamiento).flatten()incrustaciones_prueba_f = np.vstack(incrustaciones_prueba)etiquetas_prueba_f = np.concatenate(etiquetas_prueba).flatten()embeddings_entrenamiento_f.shape, etiquetas_entrenamiento_f.shape, incrustaciones_prueba_f.shape, etiquetas_prueba_f.shape

[out] ((75750, 384), (75750,), (25250, 384), (25250,))

Paso 5 — Construir una función para los clasificadores SVM, XGBoost y KNN.

def evaluar_clasificadores(X_entrenamiento, y_entrenamiento, X_prueba, y_prueba):    # Clasificador de Máquina de Soporte Vectorial (SVM)    clasificador_svm = SVC()    clasificador_svm.fit(X_entrenamiento, y_entrenamiento)    predicciones_svm = clasificador_svm.predict(X_prueba)    # Clasificador XGBoost    clasificador_xgb = XGBClassifier(tree_method='gpu_hist')    clasificador_xgb.fit(X_entrenamiento, y_entrenamiento)    predicciones_xgb = clasificador_xgb.predict(X_prueba)    # Clasificador de Vecinos Más Cercanos (KNN)    clasificador_knn = KNeighborsClassifier()    clasificador_knn.fit(X_entrenamiento, y_entrenamiento)    predicciones_knn = clasificador_knn.predict(X_prueba)    # Calculando Top-1    top1_svm = accuracy_score(y_prueba, predicciones_svm)    top1_xgb = accuracy_score(y_prueba, predicciones_xgb)    top1_knn = accuracy_score(y_prueba, predicciones_knn)    # Calculando el puntaje F1    f1_svm = f1_score(y_prueba, predicciones_svm, average='weighted')    f1_xgb = f1_score(y_prueba, predicciones_xgb, average='weighted')    f1_knn = f1_score(y_prueba, predicciones_knn, average='weighted')    return pd.DataFrame({        'SVM': {'Top-1 Accuracy': top1_svm, 'Puntuación F1': f1_svm},        'XGBoost': {'Top-1 Accuracy': top1_xgb,'Puntuación F1': f1_xgb},        'KNN': {'Top-1 Accuracy': top1_knn, 'Puntuación F1': f1_knn}    })X_entrenamiento = embeddings_entrenamiento_f  # Características de los datos de entrenamientoy_entrenamiento = etiquetas_entrenamiento_f  # Etiquetas de los datos de entrenamientoX_prueba = incrustaciones_prueba_f   # Características de los datos de pruebay_prueba = etiquetas_prueba_f   # Etiquetas de los datos de pruebarecursos = evaluar_clasificadores(X_entrenamiento, y_entrenamiento, X_prueba, y_prueba)print(recursos)

Resultados

¡Guau, los resultados son geniales! Como se demostró, el modelo SVM entrenado en el pequeño modelo DINOv2 extrajo características que superaron a otros modelos de ML y alcanzó una precisión de casi el 90%.

Conclusión

Aunque usamos un modelo DINOv2 pequeño para extraer características, los modelos de ML (especialmente SVM) entrenados en características extraídas demostraron un gran rendimiento en la tarea de clasificación de detalles. El modelo puede clasificar objetos con una precisión de casi el 90% de 101 clases diferentes.

La precisión mejoraría si se usaran modelos DINOv2 grandes, gigantes o enormes. Solo tienes que cambiar dinov2_vits14 en el paso 4 por dinov2_vitb14, dinov2_vitl14 o dinov2_vitg14. Puedes probar y compartir los resultados de precisión en la sección de comentarios 🙂

Espero que lo hayas disfrutado. Si tienes alguna pregunta o te gustaría compartir tus pensamientos sobre este artículo, no dudes en comentar, estaré encantado de responder.

Si quieres apoyar mi trabajo directamente y también obtener acceso ilimitado a los artículos de Zepes, conviértete en miembro de Zepes usando mi enlace de referencia aquí. ¡Gracias un millón de veces y que tengas un buen día!

Únete a Zepes con mi enlace de referencia – Gurami Keretchashvili

Como miembro de Zepes, una parte de tu tarifa de membresía va a los escritores que lees, y tienes acceso completo a todas las historias…

Zepes.com

Referencias

[1] Oquab, M., Darcet, T., Moutakanni, T., Vo, H., Szafraniec, M., Khalidov, V., … & Bojanowski, P. (2023). Dinov2: aprendizaje de características visuales robustas sin supervisión. documento previo de arXiv arXiv:2304.07193.

[2] Dosovitskiy, A., Beyer, L., Kolesnikov, A., Weissenborn, D., Zhai, X., Unterthiner, T., … & Houlsby, N. (2020). Una imagen vale 16×16 palabras: Transformadores para el reconocimiento de imágenes a escala. documento previo de arXiv arXiv:2010.11929.

[3] El equipo DINOv2, DINOv2: modelos de visión por computadora de última generación con aprendizaje auto-supervisado

[4] DINOv2 Github

[5] Hinton, G., Vinyals, O., & Dean, J. (2015). Destilando el conocimiento en una red neuronal. documento previo de arXiv arXiv:1503.02531.

• AI
• Computer Vision
• data science
• Editors Pick
• Python