Entraînez un VLM de 65M à partir de zéro en 2 heures : Plongée en profondeur dans MiniMind-V

Construire un modèle de vision-langage (VLM) à partir de zéro semble être une tâche ardue réservée aux grandes équipes disposant de budgets de calcul massifs. Mais que diriez-vous si vous pouviez en entraîner un en seulement deux heures, pour moins que le prix d'un café ? C'est exactement ce que propose le projet MiniMind-V : un VLM entièrement fonctionnel de 65 millions de paramètres que vous pouvez entraîner sur un seul GPU NVIDIA 3090.

Ce n'est pas un simple jouet. MiniMind-V est une implémentation complète et open source qui couvre l'ensemble du pipeline : préparation des données, pré-entraînement, ajustement fin supervisé (SFT) et inférence. Il est conçu comme une ressource d'apprentissage pour quiconque souhaite comprendre comment fonctionnent réellement les VLM modernes comme LLaVA et Qwen-VL.

Pourquoi MiniMind-V est important

Le slogan du projet — « 大道至简 » (Les grandes vérités sont simples) — capture sa philosophie. La plupart des tutoriels sur les VLM soit survolent les détails d'implémentation, soit nécessitent des ressources que les développeurs individuels ne possèdent pas. MiniMind-V élimine la complexité, montrant que le cœur d'un VLM est étonnamment simple.

Avec seulement 65 millions de paramètres (environ 1/2600e de la taille de GPT-3), MiniMind-V est suffisamment petit pour fonctionner sur du matériel grand public. L'ensemble de la phase SFT prend environ 2 heures sur un seul RTX 3090, avec des coûts de location de GPU d'environ 3 $. Cela le rend accessible pour l'expérimentation, l'apprentissage et même des applications pratiques où un petit modèle est suffisant.

Architecture : Le VLM minimal

MiniMind-V suit la même architecture que LLaVA-1.5, avec trois composants principaux :

Encodeur visuel : SigLIP2 (siglip2-base-p32-256-ve) — un modèle ViT-B/32 avec environ 95 millions de paramètres, maintenu gelé pendant l'entraînement.
Module de projection : Un MLP à 2 couches (Linear → GELU → Linear) avec LayerNorm, mappant les caractéristiques visuelles à la dimension cachée du LLM.
Modèle de langage : Le LLM de 64 millions de paramètres de MiniMind (taille cachée 768, 8 couches), avec seulement les première et dernière couches ajustées.

L'idée clé est que l'encodeur visuel agit comme un « dictionnaire de langue étrangère » pour les images. Il traduit les données de pixels en tokens que le LLM peut comprendre. Le module de projection aligne ensuite ces tokens visuels avec l'espace d'embedding des tokens de texte.

Flux de tokens

Lorsque vous entrez une image, l'encodeur SigLIP2 traite une image de 256×256 en 64 tokens de patch (grille 8×8 avec patch_size=32). Ceux-ci passent par le projecteur MLP pour devenir 64 tokens visuels, qui remplacent les espaces réservés <|image_pad|> dans l'invite de texte. La séquence combinée traverse ensuite le LLM comme d'habitude.

# Exemple de structure d'invite
"<|image_pad|>" * 64 + "\nQu'y a-t-il dans cette image ?"

Pipeline d'entraînement

MiniMind-V utilise un processus d'entraînement en deux étapes, bien que vous puissiez sauter la première étape si vous manquez de temps.

Étape 1 : Pré-entraînement (Optionnel)

Données : Environ 1,27 million de paires image-légende provenant de ALLaVA-4V (sous-ensembles LAION + VFLAN)
Objectif : Aligner les tokens visuels avec les tokens de langage
Stratégie de gel : Geler à la fois le LLM et l'encodeur visuel, entraîner uniquement le projecteur (--freeze_llm 2)
Taux d'apprentissage : 4e-4
Longueur maximale de séquence : 450 tokens

Cette étape est optionnelle car le jeu de données SFT inclut déjà tous les échantillons de pré-entraînement. Cependant, l'exécuter d'abord aide le projecteur à converger plus proprement avant d'ajuster finement le LLM.

Étape 2 : Ajustement fin supervisé (SFT)

Données : Environ 2,9 millions d'échantillons mélangés (instructions d'image, légendes, texte pur)
Objectif : Apprendre au modèle à répondre à des questions sur les images
Stratégie de gel : Entraîner le projecteur + les première et dernière couches du LLM (--freeze_llm 1)
Taux d'apprentissage : 5e-6
Longueur maximale de séquence : 768 tokens

La stratégie de gel est cruciale. Avec seulement 64 millions de paramètres, dégeler complètement le LLM entraînerait un oubli catastrophique des capacités linguistiques. En maintenant les couches intermédiaires gelées, le modèle conserve ses connaissances pré-entraînées tout en s'adaptant aux entrées multimodales.

# Démarrer l'entraînement SFT
python train_sft_vlm.py --epochs 2 --from_weight llm

Détails du jeu de données

Toutes les données d'entraînement proviennent de la collection ALLaVA-4V, qui fournit des paires image-texte de haute qualité, bilingues (chinois + anglais). Le jeu de données SFT comprend :

Instructions d'image : Environ 1,4 million de paires QA de raisonnement
Légendes d'image : Environ 1,27 million (fusionnées du pré-entraînement)
Texte pur : Environ 230 000 dialogues (avec des images d'espace réservé noires pour maintenir la capacité linguistique)

Les images sont redimensionnées à 256×256 et stockées au format JPEG dans un fichier Parquet pour un chargement efficace. Le format Parquet élimine le besoin d'extraction lente de fichiers image — tout est dans un seul fichier compressé.

# Format du jeu de données (parquet)
# colonnes : conversations (chaîne json), image_bytes (binaire)

Résultats d'évaluation

Le modèle a été testé sur 6 images diverses (chien, parapluie, vélo, voiture, super-héros, voiture de course). Les versions dense (65M) et MoE (200M-A65M) ont correctement identifié le sujet principal dans les 6 cas. La version MoE a produit des descriptions de scène plus riches, tandis que la version dense était plus concise avec moins de répétitions.

Cependant, les deux modèles présentent des problèmes courants des petits modèles : répétition occasionnelle et hallucination de détails. L'auteur note que cela est attendu — le signal visuel est comme une « langue étrangère » pour le LLM, et la qualité de la compréhension est fondamentalement limitée par la capacité du LLM. Augmenter le backbone à quelques milliards de paramètres améliorerait considérablement la précision.

Pour commencer

Pour exécuter MiniMind-V vous-même :

# Cloner le dépôt
git clone --depth 1 https://github.com/jingyaogong/minimind-v
cd minimind-v

# Installer les dépendances
pip install -r requirements.txt

# Télécharger l'encodeur visuel et les poids du LLM
modelscope download --model gongjy/siglip2-base-p32-256-ve --local_dir ./model/siglip2-base-p32-256-ve
modelscope download --model gongjy/minimind-3v-pytorch llm_768.pth --local_dir ./out

# Télécharger les données SFT
wget https://hf-mirror.com/datasets/jingyaogong/minimind-v_dataset/resolve/main/sft_i2t.parquet -P ./dataset

# Entraînement (SFT uniquement, ~2 heures sur RTX 3090)
python train_sft_vlm.py --epochs 2 --from_weight llm

Améliorations futures

Le projet décrit plusieurs directions prometteuses :

Résolution dynamique et encodage basé sur les tuiles (comme LLaVA-NeXT)
Encodeurs visuels plus puissants pour des caractéristiques plus fines
Compréhension multi-image, compréhension vidéo et ancrage visuel

Conclusion

MiniMind-V est une réalisation remarquable dans la démocratisation de la recherche sur les VLM. Il prouve que vous n'avez pas besoin d'un cluster massif ou d'un énorme budget pour construire un modèle multimodal fonctionnel. Le code est propre, bien documenté et constitue un excellent point de départ pour quiconque souhaite comprendre ou expérimenter avec les modèles de vision-langage.

Que vous soyez étudiant, chercheur ou amateur, ce projet vous donne les outils pour rejoindre la révolution des VLM. Comme le dit l'auteur : « Construire un avion avec des LEGOs est bien plus excitant que de voyager en première classe. »

Source

jingyaogong/minimind-v: 👀「大模型」2小时从0训练65M参数的视觉多模态VLM！Train a 65M-parameter VLM from scratch in just 2h!