>_ DevTrendsfr

Langue

Accueil

Langages

Sections

Frontend Backend Mobile DevOps AI / ML GameDev Blockchain Embarqué Sécurité
Python

Comment affiner un réseau neuronal 8B sur un ordinateur portable avec un GPU de 4 Go

Soup

Quiconque a déjà essayé d'affiner un LLM par soi-même connaît ce rituel : vous configurez l'environnement, luttez avec les versions CUDA, ajustez la taille des lots, attrapez d'innombrables erreurs CUDA out of memory, et finissez par louer un H100 dans le cloud juste pour exécuter quelques époques sur un petit jeu de données. À un moment donné, la configuration des scripts et la gestion des serveurs commencent à prendre plus de temps que la préparation des données et l'analyse des résultats.

Récemment, je suis tombé sur le dépôt Soup d'Alpamis Makazhan. L'auteur s'est fixé un objectif ambitieux : réduire l'ensemble du pipeline de tuning à une seule commande console et un simple fichier YAML. La chose la plus intéressante à propos de ce projet est la capacité d'affiner un modèle Llama 3.1 avec 8 milliards de paramètres sur un RTX 30 mobile avec seulement 4 Go de mémoire vidéo.

Cela ressemble à une astuce marketing, mais sous le capot il y a de l'ingénierie intéressante et une prépublication ouverte avec des benchmarks. Décomposons comment cela fonctionne et comment cela fonctionne en pratique.

soup train demo

Ce que Soup peut faire

Essentiellement, Soup est un wrapper CLI autour d'une pile ML populaire (PyTorch, Transformers, PEFT, TRL). L'idée principale est de prendre en charge la routine : détection du matériel disponible, quantification, ajustement automatique de la taille des lots et formatage des jeux de données.

L'utilitaire couvre le flux de travail complet du modèle :

  • initialise des modèles pour différentes tâches (chat, code, appel d'outils, classification) ;
  • détecte automatiquement les formats de données (Alpaca, ShareGPT, ChatML) depuis JSONL, Parquet ou CSV ;
  • exécute l'entraînement avec les méthodes SFT, DPO, ORPO, SimPO ou KTO ;
  • teste le résultat pour les régressions et fusionne les adaptateurs LoRA dans les poids du modèle ;
  • exporte le modèle au format GGUF pour l'exécuter dans Ollama ou llama.cpp.

Pour une utilisation basique, vous n'avez même pas besoin de PyTorch : une version CLI légère s'installe en quelques secondes et aide à inspecter les données. Et si vous avez besoin de l'entraînement lui-même, la pile complète est installée.

# Установка пакета с зависимостями для обучения
pip install "soup-cli[train]"

# Создание конфига через мастер или из готового шаблона
soup init --template chat

# Запуск процесса
soup train

Comment un modèle 8B tient dans 4 Go de mémoire vidéo

Habituellement, un modèle à 8 milliards de paramètres même sous forme quantifiée 4 bits (NF4) nécessite environ 5-6 Go de VRAM juste pour être chargé en mémoire. Si vous ajoutez le contexte, les activations et les adaptateurs LoRA, une carte avec 4 Go va inévitablement générer une erreur de mémoire insuffisante.

L'auteur de Soup a utilisé une technique de streaming de couches.

Le modèle de base n'est pas conservé entièrement dans la mémoire vidéo. Il est stocké dans la RAM de l'ordinateur (ou même lu directement depuis un disque NVMe rapide) et transmis au GPU couche par couche. Seuls les adaptateurs LoRA entraînables et la couche décodeur actuelle sont conservés en permanence dans la VRAM.

Dans les tests sur un ordinateur portable RTX 3050 avec 4 Go de VRAM, le modèle Llama-3.1-8B-Instruct avec quantification NF4 a montré une consommation de mémoire maximale de seulement 3,32 Go à une vitesse d'environ 119 tokens par seconde. Les calculs produisent des résultats bit-à-bit identiques à l'entraînement résident conventionnel.

Le streaming de couches est activé littéralement avec une seule ligne dans la configuration soup.yaml :

base: meta-llama/Llama-3.1-8B-Instruct
task: sft

data:
  train: ./data/train.jsonl
  format: alpaca

training:
  stream_layers: true      # стриминг слоев из RAM
  quantization: 4bit       # NF4 квантование
  batch_size: 4
  stream_source: auto      # RAM или NVMe
  lora:
    r: 64
    alpha: 16

output: ./output

Dans les versions 0.72+, le streaming de couches a été étendu non seulement au SFT classique mais aussi aux méthodes d'alignement comme DPO et ORPO. Avec DPO, vous avez besoin du modèle de base pour la comparaison, ce qui double généralement l'utilisation de la mémoire. Ici l'utilitaire utilise la même couche de streaming avec l'adaptateur désactivé, sans créer de doublon en mémoire.

Contrôles de qualité et protection contre les erreurs cachées

Un problème courant lors de l'affinage : le modèle semble avoir appris à répondre à vos questions spécifiques, mais a complètement oublié comment appeler des fonctions ou a commencé à produire du JSON invalide.

Soup dispose d'un outil de vérification intégré soup ship. C'est une porte de qualité interne avec un ensemble de tests (arithmétique, respect du schéma JSON, appel d'outils, sécurité) qui exécute à la fois les modèles original et affiné.

soup ship --base ./base --adapter ./my-lora --task-eval my_task.jsonl

La commande retourne un verdict spécifique : SHIP ou DON'T SHIP. Par exemple, si l'adaptateur a amélioré les réponses sur la tâche cible mais a cassé la syntaxe d'appel d'outils, l'utilitaire sortira avec un code non nul et montrera où la régression s'est produite.

Export et utilisation

Une fois l'adaptateur entraîné et vérifié, vous pouvez le conditionner dans le format souhaité immédiatement :

# Проверить ответы в интерактивном режиме
soup chat --model ./output

# Влить LoRA в базовые веса
soup merge --adapter ./output

# Сконвертировать в GGUF для Ollama
soup export --model ./output --format gguf --quant q4_k_m

# Или поднять локальный API-сервер с OpenAI-совместимыми ручками
soup serve --model ./output

Si vous avez besoin d'exécuter l'entraînement sur une machine distante ou en isolation sans installer manuellement les pilotes, le projet dispose d'une image Docker prête à l'emploi sur GitHub Packages (GHCR).

Qui trouvera ce projet utile

Soup s'adresse aux développeurs qui ont besoin d'un cycle d'expérimentation rapide sans plonger dans les profondeurs de l'entraînement distribué.

Le projet mérite définitivement d'être essayé si vous :

  1. Voulez expérimenter avec de petits modèles (Qwen 2.5, Llama 3.1, Gemma) sur un PC ou un ordinateur portable domestique.
  2. Cherchez un pipeline prêt à l'emploi : du jeu de données brut à un fichier GGUF pour une utilisation locale.
  3. Êtes fatigué d'écrire les mêmes scripts basés sur HuggingFace TRL pour les tâches SFT typiques.

Limitations : Python 3.10–3.12 est strictement requis (les builds PyTorch pour 3.13 sont actuellement instables). Le pré-entraînement complet from scratch sur de grands clusters via Soup n'est pas recommandé—utilisez directement Megatron ou DeepSpeed pour cela. Mais pour l'affinage appliqué et le prototypage sur des GPU grand public, c'est un outil pratique et bien pensé.

Projets similaires