Présentation détaillée du cours LLMs-from-scratch

Aperçu du projet

LLMs-from-scratch est une ressource d'apprentissage complète créée par Sebastian Raschka, conçue pour enseigner comment construire des grands modèles linguistiques (LLM) à partir de zéro. Ce projet est le dépôt de code officiel du livre « Build a Large Language Model (From Scratch) ».

Caractéristiques principales

📚 Objectifs d'apprentissage

• Comprendre le fonctionnement interne des grands modèles linguistiques
• Construire son propre LLM étape par étape par le codage
• Apprendre les méthodes d'entraînement et de développement des modèles fondamentaux derrière des outils comme ChatGPT
• Maîtriser les techniques de chargement et de réglage fin (fine-tuning) des poids de modèles pré-entraînés

🎯 Méthodologie d'enseignement

• Codage à partir de zéro: Implémentation complète avec PyTorch, sans dépendance à des bibliothèques LLM externes
• Approche progressive: Chaque étape est clairement expliquée avec du texte, des diagrammes et des exemples
• Fortement pratique: Création de modèles éducatifs petits mais entièrement fonctionnels
• Ressources complémentaires abondantes: Inclut 17 heures et 15 minutes de cours vidéo

Structure du cours

Contenu des chapitres

Chapitre 1: Comprendre les grands modèles linguistiques (Understanding large language models)

• Introduction aux concepts fondamentaux des LLM
• Aperçu de l'architecture des modèles

Chapitre 2: Travailler avec des données textuelles (Working with text data)

• Code principal: ch02.ipynb, dataloader.ipynb
• Prétraitement du texte et chargement des données
• Solutions d'exercices: exercise-solutions.ipynb

Chapitre 3: Coder les mécanismes d'attention (Coding attention mechanisms)

• Code principal: ch03.ipynb, multihead-attention.ipynb
• Implémentation du mécanisme d'auto-attention
• Explication détaillée du mécanisme d'attention multi-têtes

Chapitre 4: Implémenter un modèle GPT à partir de zéro (Implementing a GPT model from scratch)

• Code principal: ch04.ipynb, gpt.py
• Implémentation complète de l'architecture GPT
• Explication détaillée des composants du modèle

Chapitre 5: Pré-entraînement sur des données non étiquetées (Pretraining on unlabeled data)

• Code principal: ch05.ipynb, gpt_train.py, gpt_generate.py
• Processus de pré-entraînement
• Implémentation de la génération de texte

Chapitre 6: Réglage fin pour les tâches de classification (Finetuning for classification)

• Code principal: ch06.ipynb, gpt_class_finetune.py
• Ajustement du modèle pour des tâches de classification spécifiques
• Techniques et stratégies de réglage fin

Chapitre 7: Réglage fin pour suivre les instructions (Finetuning to follow instructions)

• Code principal: ch07.ipynb, gpt_instruction_finetuning.py
• Méthodes de réglage fin par instruction
• Évaluation du modèle: ollama_evaluate.py

Contenu des annexes

Annexe A: Introduction à PyTorch

• Code: code-part1.ipynb, code-part2.ipynb
• Entraînement parallèle distribué des données: DDP-script.py
• Démarrage rapide des bases de PyTorch

Annexes B-E

• Annexe B: Références et lectures complémentaires
• Annexe C: Récapitulatif des solutions d'exercices
• Annexe D: Ajout de fonctionnalités supplémentaires
• Annexe E: Réglage fin efficace en paramètres

Contenu bonus (Bonus Materials)

Ressources supplémentaires du Chapitre 5

• Méthodes alternatives de chargement des poids: Différentes techniques de chargement des poids de modèle
• Pré-entraînement sur le jeu de données Project Gutenberg: Entraînement sur de grands corpus de texte
• Optimisation de la boucle d'entraînement: Ajout de diverses fonctionnalités d'amélioration
• Planificateurs de taux d'apprentissage (Learning Rate Schedulers): Optimisation du processus d'entraînement
• Optimisation des hyperparamètres: Optimisation des hyperparamètres de pré-entraînement
• Construction d'une interface utilisateur: UI pour interagir avec les LLM pré-entraînés
• Conversion de modèles:
  • Conversion de GPT en Llama
  • Implémentation de Llama 3.2 à partir de zéro
  • Modèles Qwen3 denses et à mélange d'experts (MoE)
  • Implémentation de Gemma 3 à partir de zéro
• Chargement des poids économe en mémoire: Optimisation du chargement du modèle
• Extension du tokenizer Tiktoken BPE: Ajout de nouveaux tokens
• Conseils d'optimisation des performances PyTorch: Accélérer l'entraînement des LLM

Ressources supplémentaires du Chapitre 6

• Techniques avancées de réglage fin pour la classification

Ressources supplémentaires du Chapitre 7

• Outils de jeu de données: Trouver les doublons approximatifs et créer des entrées au passif
• Évaluation des réponses: Évaluer les réponses aux instructions avec l'API OpenAI et Ollama
• Génération de jeux de données: Générer des jeux de données pour le réglage fin par instruction
• Amélioration des jeux de données: Améliorer la qualité des jeux de données pour le réglage fin par instruction
• Génération de jeux de données de préférences: Utilisation de Llama 3.1 70B et Ollama
• Alignement DPO: Implémentation de l'Optimisation par Préférence Directe (Direct Preference Optimization)
• Interface utilisateur: Interagir avec les modèles GPT réglés finement par instruction

Ressources pour les modèles d'inférence (du dépôt reasoning-from-scratch)

• Bases de Qwen3
• Méthodes d'évaluation des modèles

Exigences techniques

Connaissances préalables

• ✅ Obligatoire: Solides bases en programmation Python
• ✅ Utile: Connaissances fondamentales en réseaux de neurones profonds
• ✅ Utile: Bases de PyTorch (un démarrage rapide est fourni en Annexe A)

Exigences matérielles

• 💻 Un ordinateur portable standard suffit: Le code des chapitres principaux est conçu pour fonctionner sur un ordinateur portable classique
• 🚀 Accélération GPU automatique: Le code utilisera automatiquement le GPU s'il est disponible
• ⚡ Pas de matériel spécialisé requis: Pour garantir l'accessibilité à un large public

Environnement logiciel

• Python 3.x
• PyTorch
• Autres dépendances détaillées dans le répertoire setup

Ressources complémentaires

Cours vidéo

• 📹 Cours vidéo complet de 17 heures et 15 minutes
• Démonstrations de codage chapitre par chapitre
• Peut être utilisé comme ressource d'apprentissage autonome ou en complément du livre
• Plateforme Manning: Master and Build Large Language Models

Livre de suivi

« Build A Reasoning Model (From Scratch) »

• Peut être considéré comme une suite
• Commence avec des modèles pré-entraînés
• Implémente différentes méthodes de raisonnement:
  • Extension du temps d'inférence
  • Apprentissage par renforcement
  • Techniques de distillation
• Améliore les capacités de raisonnement du modèle
• Dépôt GitHub: reasoning-from-scratch

Ressources de test

PDF gratuit de 170 pages: « Test Yourself On Build a Large Language Model (From Scratch) »

• Environ 30 questions de quiz par chapitre avec leurs réponses
• Aide à évaluer le niveau de compréhension
• Téléchargement gratuit sur le site de Manning

Solutions d'exercices

• Chaque chapitre contient plusieurs exercices
• Les solutions sont regroupées dans l'Annexe C
• Les notebooks de code correspondants se trouvent dans les dossiers de chaque chapitre
  • Exemple: ./ch02/01_main-chapter-code/exercise-solutions.ipynb

Acquisition du projet

Méthodes de téléchargement

Méthode 1: Téléchargement direct du ZIP

# Cliquez sur le bouton Download ZIP de la page GitHub

Méthode 2: Clonage Git

git clone --depth 1 https://github.com/rasbt/LLMs-from-scratch.git

Organisation du code

• Chaque chapitre a son propre dossier: ch02/, ch03/, etc.
• Le code principal se trouve dans le sous-dossier 01_main-chapter-code/
• Les ressources supplémentaires se trouvent dans les dossiers numérotés correspondants

Suggestions de parcours d'apprentissage

Modèle mental

Le livre fournit une carte mentale claire qui résume tout le contenu couvert:

1. Comprendre les bases des LLM
2. Traitement des données textuelles
3. Mécanismes d'attention
4. Implémentation de l'architecture GPT
5. Techniques de pré-entraînement
6. Méthodes de réglage fin
7. Déploiement d'applications pratiques

Conseils d'apprentissage

1. Débutants: Commencez par le Chapitre 1, étudiez dans l'ordre et complétez les exercices de chaque chapitre
2. Apprenants expérimentés: Vous pouvez sauter les chapitres familiers et vous concentrer sur des sujets spécifiques
3. Praticiens: Utilisez le contenu bonus pour explorer des sujets avancés
4. Chercheurs: Référez-vous au format de citation pour citer cette ressource dans vos recherches

Communauté et support

Canaux de feedback

• 💬 Forum Manning: Forum officiel
• 💭 Discussions GitHub: Section de discussion
• 🤝 Tous les types de feedback, questions et échanges d'idées sont les bienvenus

Notes sur les contributions

• En raison de la correspondance avec le livre imprimé, le code des chapitres principaux est maintenu cohérent
• Les contributions visant à étendre le contenu des chapitres principaux ne sont actuellement pas acceptées
• Pour garantir la cohérence avec le contenu du livre physique et offrir une expérience d'apprentissage fluide

Informations de citation

Format Chicago

Raschka, Sebastian. Build A Large Language Model (From Scratch). Manning, 2024. ISBN: 978-1633437166.

Format BibTeX

@book{build-llms-from-scratch-book,
  author = {Sebastian Raschka},
  title = {Build A Large Language Model (From Scratch)},
  publisher = {Manning},
  year = {2024},
  isbn = {978-1633437166},
  url = {https://www.manning.com/books/build-a-large-language-model-from-scratch},
  github = {https://github.com/rasbt/LLMs-from-scratch}
}

Liens clés

• 📖 Dépôt GitHub: https://github.com/rasbt/LLMs-from-scratch
• 🛒 Éditeur Manning: http://mng.bz/orYv
• 🛒 Achat sur Amazon: https://www.amazon.com/gp/product/1633437167
• 📹 Cours vidéo: https://www.manning.com/livevideo/master-and-build-large-language-models
• 🧠 Suite sur les modèles de raisonnement: https://github.com/rasbt/reasoning-from-scratch
• 📄 Documentation de configuration: setup/README.md

Résumé

Ceci est une ressource d'apprentissage complète et systématique sur les LLM, adaptée pour:

• 🎓 Les apprenants souhaitant comprendre en profondeur le fonctionnement des LLM
• 👨‍💻 Les développeurs désireux d'implémenter des modèles de type GPT
• 🔬 Les chercheurs en PNL et en apprentissage profond
• 🚀 Les passionnés de technologie intéressés par l'IA et l'apprentissage automatique

Grâce à ce projet, vous acquerrez la capacité complète de construire, entraîner et affiner des grands modèles linguistiques à partir de zéro.