NVIDIA vient de lâcher une bombe : son nouveau modèle d'IA multimodale NVLM 1.0 72B est ouvert, massif et prêt à rivaliser avec GPT-4

Le modèle est à poids ouvert avec une licence non commerciale cc-by-nc-4.0

Nvidia vient de lâcher une bombe : son nouveau modèle d'IA multimodale NVLM 1.0 72B est ouvert, massif et prêt à rivaliser avec GPT-4, le modèle est à poids ouvert avec une licence non commerciale cc-by-nc-4.0

NVIDIA a publié son puissant modèle d'intelligence artificielle (IA) open-source qui pourrait surpasser le GPT-4 d'OpenAI. La nouvelle famille NVLM 1.0 de grands modèles de langage (LLM) multimodaux open-source de la société, dont le modèle phare, NVLM-D-72B, compte environ 72 milliards de paramètres.

Selon l'équipe de recherche de NVIDIA, le nouveau modèle d'IA excelle dans les tâches de vision-langage tout en maintenant et même en améliorant les performances en texte seul par rapport à leurs LLM de base. Dans leur article, les chercheurs déclarent : « Nous présentons le NVLM 1.0, une famille de grands modèles de langage multimodaux d'avant garde qui obtiennent des résultats de pointe dans les tâches de vision-langage, rivalisant avec les principaux modèles propriétaires (par exemple, GPT-4o) et les modèles en libre accès. »


Contrairement à d'autres modèles propriétaires dont les performances textuelles diminuent considérablement avec le temps, le modèle NVLM-D-72B a augmenté sa précision de 4,3 points en moyenne sur les principaux benchmarks textuels.

Le LLM a également été capable d'interpréter des graphiques et des tableaux, d'analyser des images, de comprendre des mèmes, de coder des logiciels et de résoudre des problèmes mathématiques. Les poids du modèle sont accessibles au public sur Hugging Face et NVIDIA indique qu'elle publiera ultérieurement le code d'entraînement.


Détails du modèle

Le 17 septembre 2024, NVIDIA a présenté le NVLM 1.0, une famille de grands modèles de langage (LLM) multimodaux d'avant-garde qui obtiennent des résultats de pointe sur les tâches vision-langage, rivalisant avec les principaux modèles propriétaires (par exemple, GPT-4o) et les modèles en accès libre (par exemple, Llama 3-V 405B et InternVL 2). Fait remarquable, le NVLM 1.0 présente des performances améliorées pour le texte seul par rapport à son homologue LLM après une formation multimodale.

En termes de conception de modèle, NVIDIA a effectué une comparaison complète entre les LLM multimodaux à décodeur uniquement (par exemple, LLaVA) et les modèles basés sur l'attention croisée (par exemple, Flamingo). En se basant sur les forces et les faiblesses des deux approches, NVIDIA a proposé une nouvelle architecture qui améliore à la fois l'efficacité de l'entraînement et les capacités de raisonnement multimodal.


En outre, NVIDIA a introduit une conception 1-D tile-tagging pour les images à haute résolution dynamique à base de tuiles, ce qui améliore considérablement les performances sur le raisonnement multimodal et les tâches liées à la reconnaissance optique des caractères (OCR).

En ce qui concerne les données d'entraînement, NVIDIA a méticuleusement préparé et fourni des informations détaillées sur ses ensembles de données multimodales de pré-entraînement et de mise au point supervisée. Leurs conclusions indiquent que la qualité des ensembles de données et la diversité des tâches sont plus importantes que l'échelle, même pendant la phase de pré-entraînement, sur toutes les architectures. Ils ont notamment développé une multimodalité de niveau production pour les modèles NVLM-1.0, leur permettant d'exceller dans les tâches de vision et de langage tout en maintenant et même en améliorant les performances pour le texte seul par rapport à leurs modèles LLM.


Pour y parvenir, NVIDIA a conçu et intégré un ensemble de données textuelles de haute qualité dans la formation multimodale, ainsi qu'une quantité substantielle de données mathématiques et de raisonnement multimodales, ce qui a permis d'améliorer les capacités mathématiques et de codage dans les différents modes.

Pour faire avancer la recherche dans ce domaine, NVIDIA a publié les poids du modèle et ouvrira le code à la communauté : https://nvlm-project.github.io/. Le modèle NVLM-1.0-D-72B (architecture à décodeur uniquement), les poids du modèle à décodeur uniquement et le code sont également mis à la disposition de la communauté sur Hugging Face.

Résultats des tests de référence

NVIDIA a formé son modèle avec l'ancien Megatron-LM et a adapté la base de code à Huggingface pour l'hébergement du modèle, la reproductibilité et l'inférence. NVIDIA a observé des différences numériques entre les bases de code Megatron et Huggingface, qui se situent dans la fourchette de variation attendue. Les résultats de la base de code Huggingface et de la base de code Megatron sont fournis à des fins de reproductibilité et de comparaison avec d'autres modèles.

Les résultats (au 17 septembre 2024) dans les benchmarks multimodaux sont les suivants :


Comment l'utiliser

Lors de la conversion du point de contrôle Megatron en Huggingface, la base de code InternVL est adaptée pour supporter le chargement du modèle et l'inférence multi-GPU dans HF. Pour la formation, il faut se référer à Megatron-LM (bientôt disponible).

Préparer l'environnement

Un fichier de construction Docker est fourni dans le Dockerfile pour la reproduction.

L'image docker est basée sur nvcr.io/nvidia/pytorch:23.09-py3.

Note : Nous observons que différentes versions de transformateur / versions CUDA / versions de docker peuvent conduire à de légères différences dans les numéros de référence. Il est recommandé d'utiliser le Dockerfile ci-dessus pour une reproduction précise.


Chargement du modèle


Plusieurs GPU

Le modèle peut être chargé sur plusieurs GPU comme suit :


Inférence

[CODE]import torch
from transformers import AutoTokenizer, AutoModel
import math
from PIL import Image
import torchvision.transforms as T
from torchvision.transforms.functional import InterpolationMode

def split_model():
device_map = {}
world_size = torch.cuda.device_count()
num_layers = 80
# Since the first GPU will be used for ViT, treat it as half a GPU.
num_layers_per_gpu = math.ceil(num_layers / (world_size - 0.5))
num_layers_per_gpu = [num_layers_per_gpu] * world_size
num_layers_per_gpu[0] = math.ceil(num_layers_per_gpu[0] * 0.5)
layer_cnt = 0
for i, num_layer in enumerate(num_layers_per_gpu):
for j in range(num_layer):
device_map[f'language_model.model.layers.{layer_cnt}'] = i
layer_cnt += 1
device_map['vision_model'] = 0
device_map['mlp1'] = 0
device_map['language_model.model.tok_embeddings'] = 0
device_map['language_model.model.embed_tokens'] = 0
device_map['language_model.output'] = 0
device_map['language_model.model.norm'] = 0
device_map['language_model.lm_head'] = 0
device_map[f'language_model.model.layers.{num_layers - 1}'] = 0

return device_map

IMAGENET_MEAN = (0.485, 0.456, 0.406)
IMAGENET_STD = (0.229, 0.224, 0.225)

def build_transform(input_size):
MEAN, STD = IMAGENET_MEAN, IMAGENET_STD
transform = T.Compose([
T.Lambda(lambda img: img.convert('RGB') if img.mode != 'RGB' else img),
T.Resize((input_size, input_size), interpolation=InterpolationMode.BICUBIC),
T.ToTensor(),
T.Normalize(mean=MEAN, std=STD)
])
return transform

def find_closest_aspect_ratio(aspect_ratio, target_ratios, width, height, image_size):
best_ratio_diff = float('inf')
best_ratio = (1, 1)
area = width * height
for ratio in target_ratios:
target_aspect_ratio = ratio[0] / ratio[1]
ratio_diff = abs(aspect_ratio - target_aspect_ratio)
if ratio_diff < best_ratio_diff:
best_ratio_diff = ratio_diff
best_ratio = ratio
elif ratio_diff == best_ratio_diff:
if area > 0.5 * image_size * image_size * ratio[0] * ratio[1]:
best_ratio = ratio
return best_ratio

def dynamic_preprocess(image, min_num=1, max_num=12, image_size=448, use_thumbnail=False):
orig_width, orig_height = image.size
aspect_ratio = orig_width / orig_height

# calculate the existing image aspect ratio
target_ratios = set(
(i, j) for n in range(min_num, max_num + 1) for i in range(1, n + 1) for j in range(1, n + 1) if
i * j <= max_num and i * j >= min_num)
target_ratios = sorted(target_ratios, key=lambda x: x[0] * x[1])

# find the closest aspect ratio to the target[/1]...