MiniMind : 2 heures de formation à partir de zéro 26M paramètres GPT outil open source

Introduction générale

MiniMind est un projet open source créé par le développeur jingyaogong. Son objectif principal est de permettre aux gens ordinaires d'entraîner rapidement leurs propres modèles d'intelligence artificielle. La principale caractéristique de MiniMind est qu'il faut deux heures pour entraîner un modèle GPT de 26 millions de paramètres à partir de zéro sur une simple carte graphique NVIDIA 3090, pour un coût d'environ 3 RMB seulement. Le projet fournit un code complet allant du pré-entraînement au réglage fin, y compris le nettoyage des ensembles de données, le pré-entraînement, le réglage fin des commandes, LoRA, DPO et la distillation des modèles, ainsi que le support de l'extension visuelle multimodale MiniMind-V. Tout le code a été refactorisé à partir de la base en se basant sur PyTorch, sans dépendre d'interfaces d'abstraction tierces. En février 2025, MiniMind a été publié en plusieurs versions, avec une taille de modèle minimale de 25,8 millions de paramètres, et a reçu un accueil enthousiaste de la part de la communauté.

Liste des fonctions

• Prise en charge de la formation de modèles GPT à 26 millions de paramètres en moins de 2 heures, avec une seule carte graphique 3090.
• Fournit un code de flux complet pour le pré-entraînement, la mise au point des instructions, LoRA, DPO et la distillation du modèle.
• Inclut l'extension visuelle multimodale MiniMind-V pour le traitement d'images et de textes.
• Prise en charge de la formation à carte unique et à cartes multiples, compatible avec les visualisations DeepSpeed et wandb.
• Fournir un serveur de protocole API OpenAI pour faciliter l'accès à des interfaces de chat tierces.
• Des ensembles de données et des poids de modèles de haute qualité en libre accès pour un téléchargement direct ou un développement secondaire.
• Prise en charge de l'apprentissage du tokeniser et des listes de mots personnalisées afin d'ajuster la structure du modèle de manière flexible.

Utiliser l'aide

L'utilisation de MiniMind se divise en trois étapes : l'installation, la formation et le raisonnement. Vous trouverez ci-dessous un guide détaillé pour aider les utilisateurs à démarrer rapidement.

Processus d'installation

1. Préparation de l'environnement
   • Nécessite Python 3.10 ou une version ultérieure.
   • Vérifiez que la carte graphique prend en charge CUDA en exécutant le code suivant :

     import torch
     print(torch.cuda.is_available())
     

     Si le retour TrueSi ce n'est pas le cas, vous devrez installer la version correspondante de PyTorch.

   • Installer Git pour cloner le code.
2. projet de clonage
   Saisissez-le dans le terminal :

git clone https://github.com/jingyaogong/minimind.git
cd minimind

3. Installation des dépendances
   Installation accélérée à l'aide des miroirs de Tsinghua :

pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple

Si vous rencontrez des problèmes, vous pouvez l'installer manuellement torch peut-être flash_attn.

4. Télécharger la base de données

• Téléchargez le jeu de données sur GitHub README ou https://www.modelscope.cn/datasets/gongjy/minimind_dataset/files.
• établir ./dataset extraire les fichiers dans ce répertoire.
• Téléchargements recommandés pretrain_hq.jsonl(1,6 Go) et sft_mini_512.jsonl(1.2GB).

Modèles de formation

1. préformation

• Exécutez le script pour lancer la préformation :

  python train_pretrain.py
  

• Utilisation par défaut pretrain_hq.jsonlLes poids de sortie sont enregistrés sous la forme pretrain_*.pth.
• Accélération multicartes :

  torchrun --nproc_per_node 2 train_pretrain.py
  

2. réglage fin des commandes

• Exécutez le script de mise au point :

  python train_full_sft.py
  

• Utilisation par défaut sft_mini_512.jsonlLes poids de sortie sont enregistrés sous la forme full_sft_*.pth.
• Il en va de même pour la prise en charge des cartes multiples.

3. Mise au point de la LoRA

• Préparer les données du domaine (par exemple lora_medical.jsonl), courir :

  python train_lora.py
  

• Les poids de sortie sont enregistrés sous la forme lora_xxx_*.pth.

4. DPD Apprentissage renforcé

• utiliser dpo.jsonl Les données, la course :

  python train_dpo.py
  

• Les poids de sortie sont enregistrés sous la forme rlhf_*.pth.

5. Formation à la visualisation

• Ajouter des paramètres --use_wandbComme :

  python train_pretrain.py --use_wandb
  

• Consultez les courbes d'entraînement sur le site officiel de wandb.

Raisonner avec des modèles

1. raisonnement en ligne de commande

• Télécharger les poids des modèles (par exemple MiniMind2) :

  git clone https://huggingface.co/jingyaogong/MiniMind2
  

• Raisonnement en cours d'exécution :

  python eval_model.py --load 1 --model_mode 2
  

• Paramètre Description :--load 1 Au format transformateur, le--model_mode 2 Avec MiniMind2.

2. webchat

• Installer Streamlit :

  pip install streamlit
  

• Interface de démarrage :

  cd scripts
  streamlit run web_demo.py
  

• Accès par un navigateur localhost:8501Vous pouvez dialoguer.

3. Services API

• Démarrer le serveur :

  python serve_openai_api.py
  

• Tester l'interface :

  curl http://localhost:8000/v1/chat/completions -H "Content-Type: application/json" -d '{"model": "MiniMind2", "messages": [{"role": "user", "content": "你好"}], "max_tokens": 512}'
  

Fonction en vedette Fonctionnement

• Multimodalité visuelle (MiniMind-V)
• Télécharger le modèle MiniMind-V :

git clone https://huggingface.co/jingyaogong/MiniMind2-V

• Télécharger le modèle de visualisation CLIP pour ./model/vision_model: :

git clone https://huggingface.co/openai/clip-vit-base-patch16

• La course à pied :

python eval_vlm.py --load 1

• Saisissez du texte et des images et le modèle génère une description.
• Formation sur mesure
• Organiser les données comme suit .jsonl dans le format ./dataset.
• modifications ./model/LMConfig.py paramètres (par exemple d_model peut-être n_layers).
• S'entraîner en suivant les étapes ci-dessus.

mise en garde

• S'il n'y a pas assez de mémoire vidéo, réglez le paramètre batch_size ou augmenter accumulation_steps.
• Lorsque les ensembles de données sont volumineux, il convient de les traiter par lots afin d'éviter les débordements de mémoire.
• Les contextes ultra-longs permettent d'ajuster les paramètres RoPE jusqu'à 2048.

scénario d'application

1. Apprentissage de l'IA
   MiniMind fournit un ensemble complet de codes et de données permettant aux débutants d'étudier le processus d'apprentissage des grands modèles.
2. Personnalisation du domaine
   Entraîner des modèles avec des données privées, telles que des questions-réponses médicales ou des dialogues avec le service clientèle.
3. Déploiement à faible coût
   Le modèle paramétrique 26M est adapté aux dispositifs embarqués tels que les maisons intelligentes.
4. Démonstration d'enseignement
   Les enseignants peuvent l'utiliser pour démontrer le processus de formation à l'IA et les étudiants peuvent s'exercer.

QA

1. De quelle quantité de matériel MiniMind a-t-il besoin ?
   Une simple carte graphique NVIDIA 3090 est suffisante pour la formation, un CPU peut l'exécuter mais il est lent.
2. Les 2 heures de formation sont-elles fiables ?
   Oui, sur la base du test 3090 carte unique, le modèle paramétrique 26M ne prend qu'environ 2 heures pour s'entraîner à partir de zéro.
3. Est-il disponible dans le commerce ?
   Oui, le projet est soumis à la licence Apache 2.0, qui permet une utilisation et une modification libres.
4. Comment prolonger la durée du contexte ?
   Ajustez les paramètres RoPE ou affinez avec des données plus longues pour prendre en charge jusqu'à 2048.