Soup CLI
Soup CLI est une pile de post-entraînement open-source, axée sur la CLI, qui diagnostique automatiquement vos données, choisit une méthode d'entraînement, génère des configurations, dérive des évaluations, protège chaque point de contrôle, et peut diffuser en continu + quantifier NF4 les couches de base gelées afin que même les réglages fins 8B puissent fonctionner sur des GPU d'environ 4 Go.
https://trysoup.dev/?ref=producthunt&utm_source=aipure
Informations sur le produit
Mis à jour:Aug 11, 2026
Qu'est-ce que Soup CLI
Soup CLI est un outil de ligne de commande gratuit, sous licence Apache-2.0, qui transforme le post-entraînement LLM (SFT et alignement des préférences) en un flux de travail unique et reproductible : décider de l'exécution, entraîner, évaluer et livrer. Au lieu de vous faire ajuster manuellement d'innombrables paramètres YAML, Soup se concentre sur les "règles, pas la recherche", sélectionnant automatiquement des valeurs par défaut sensées (par exemple, configuration de la tâche, quantification, taux d'apprentissage, époques, taille de lot, optimiseur/ordonnanceur) et validant vos données avant l'entraînement. Il s'intègre aux outils courants de l'écosystème (Hugging Face, Unsloth, DeepSpeed, MLX, W&B, chemins d'exportation vLLM/Ollama/llama.cpp) tout en restant utilisable hors ligne et en évitant le verrouillage propriétaire.
Caractéristiques principales de Soup CLI
Soup CLI est une boîte à outils de post-entraînement open-source, axée sur la ligne de commande (CLI), qui transforme le "fine-tuning" et l'alignement des LLM en un flux de travail à une seule commande : il pré-vérifie et "répare" votre ensemble de données, sélectionne une méthode d'entraînement appropriée, rédige automatiquement une configuration à l'aide de règles (sans recherche d'hyperparamètres), dérive des évaluations à partir de vos propres données, et valide les points de contrôle avec un verdict "à livrer/à ne pas livrer". Sa capacité phare est le "streaming" exact des couches : il peut maintenir le modèle de base gelé dans la RAM du CPU ou le NVMe et le diffuser dans la VRAM une couche à la fois tout en le quantifiant à 4 bits (par exemple, NF4), permettant le LoRA SFT et les méthodes de préférence (DPO/ORPO/SimPO/KTO) sur de très petits GPU (rapporté : Llama-3.1-8B sur un GPU d'ordinateur portable de 4 Go). Il s'intègre également aux outils courants de l'écosystème ML pour l'ingestion de traces de production, l'évaluation, l'exportation et le déploiement.
Flux de travail de post-entraînement à une seule commande: Exécute la boucle de bout en bout (vérifications des données → sélection de la méthode → génération de la configuration → entraînement → évaluation → sauvegardes validées) à partir d'une seule CLI, réduisant le câblage manuel entre les outils.
Auto-configuration basée sur des règles (moins d'enfer de configuration): Rédige automatiquement les configurations d'entraînement et choisit les valeurs par défaut clés (tâche, quantification, taux d'apprentissage, époques, taille de lot/optimiseur/ordonnanceur/modules cibles) en utilisant des règles intégrées plutôt que de nécessiter des recherches de paramètres.
Streaming exact des couches + quantification 4 bits: Diffuse le modèle de base gelé de la RAM du CPU/NVMe vers la VRAM couche par couche sur un flux CUDA dédié et quantifie à 4 bits (par exemple, NF4), limitant la VRAM de pointe à une seule couche et permettant l'entraînement de modèles plus grands sur de petits GPU.
Prend en charge plusieurs méthodes de post-entraînement: Fournit le "fine-tuning" supervisé (SFT) et les méthodes de préférence/alignement, y compris DPO, ORPO, SimPO et KTO (avec prise en charge du "streaming" pour ces méthodes également).
Évaluation et validation des sauvegardes liées à vos données: Dérive les évaluations de votre propre ensemble de données et valide chaque sauvegarde avec un seul verdict "À LIVRER ou À NE PAS LIVRER", visant à empêcher la sauvegarde/publication aveugle de points de contrôle dégradés.
Migration + intégrations d'écosystème: Comprend `soup migrate` pour convertir les configurations existantes d'autres piles de "fine-tuning" (par exemple, LLaMA-Factory, Axolotl, Unsloth) et s'intègre aux outils courants pour l'accélération de l'entraînement, le suivi, l'exportation et le déploiement (par exemple, Unsloth, DeepSpeed, W&B, vLLM, Ollama, llama.cpp, ONNX, TensorRT).
Cas d'utilisation de Soup CLI
Fine-tuning sur appareil pour les applications "edge": Les équipes développant des assistants qui doivent fonctionner localement (confidentialité/hors ligne) peuvent affiner un modèle de classe 8B sur du matériel contraint en utilisant le "streaming" + la quantification 4 bits, puis l'exporter/le déployer via des runtimes locaux.
Assistants de support client et de connaissances d'entreprise: Affiner et aligner un modèle de base sur des questions-réponses internes et des transcriptions de chat, en utilisant des vérifications préalables des données et des sauvegardes validées pour réduire les régressions avant le déploiement vers les outils de "helpdesk" ou de chat interne.
Itération de produit à partir de traces de production: Ingérer les journaux/traces des plateformes d'observabilité et de LLM (par exemple, exportations Langfuse/LangSmith/Helicone/OpenTelemetry) pour créer des données d'entraînement, exécuter l'optimisation SFT ou de préférence, et évaluer les améliorations dans un pipeline CLI reproductible.
Laboratoires universitaires et petites équipes avec des budgets GPU limités: Les chercheurs peuvent exécuter des expériences reproductibles de "fine-tuning"/alignement sur des GPU modestes sans avoir besoin d'une infrastructure multi-GPU, tout en utilisant des flux d'évaluation et des exportations standard.
Industries réglementées nécessitant des flux de travail hors ligne: Les équipes des secteurs de la santé/finance/public peuvent conserver les données localement, exécuter l'entraînement et l'évaluation hors ligne, et utiliser une validation explicite "à livrer/à ne pas livrer" pour soutenir les processus de publication internes.
Conditionnement du déploiement de modèles pour divers runtimes: Après l'entraînement, les équipes peuvent cibler différentes piles de service (développement local avec Ollama, haut débit avec vLLM/SGLang, "edge" avec llama.cpp/GGUF, ou piles d'inférence via ONNX/TensorRT) à partir du même flux de travail de projet.
Avantages
Permet le "fine-tuning" de LLM plus grands sur de très petits GPU via le "streaming" exact des couches et la quantification 4 bits (par exemple, 8B sur 4 Go rapporté).
L'automatisation basée sur des règles et axée sur la CLI réduit la charge de configuration et accélère l'itération (auto-configuration + sélection de méthode + pré-vérification).
Le flux de travail de bout en bout comprend l'évaluation et la sauvegarde validée des points de contrôle, encourageant des publications plus sûres.
L'intégration étendue de l'écosystème et la migration de configuration réduisent les coûts de changement par rapport à d'autres outils.
Inconvénients
Le "streaming" de couches est explicitement étiqueté BETA avec des limitations déclarées (par exemple, focus transformers/texte/LoRA simple), donc les cas limites peuvent nécessiter de la prudence.
Le "streaming" limite les poids mais pas tous les pilotes de mémoire (par exemple, les logits/vocabulaire peuvent dominer la VRAM), de sorte que certaines charges de travail peuvent toujours ne pas tenir sur de petits GPU.
Des problèmes d'exactitude historique ont été divulgués (par exemple, l'adaptateur "streamé" précédent sans opération en dehors du chemin de "streaming" ; défaut de gradient NF4 au-dessus de 32B avant correction), suggérant que les utilisateurs devraient épingler les versions et valider les résultats.
Les affirmations de performance pour certaines pertes de préférence n'ont pas été entièrement évaluées dans les sources fournies, de sorte que les attentes de débit peuvent nécessiter une mesure locale.
Comment utiliser Soup CLI
1) Installer Soup CLI (noyau léger): Installez les outils de base CLI + config + données (pas de pile PyTorch) :
pip install soup-cli
Utilisez ceci si vous souhaitez uniquement initialiser des projets, gérer des configurations ou exécuter des outils de données sans dépendances d'entraînement.
2) Installer Soup avec le support d'entraînement (recommandé pour le réglage fin): Installez Soup plus la pile d'entraînement (torch, transformers, peft, trl, datasets, etc.) :
pip install \"soup-cli[train]\"
C'est l'installation typique pour les flux de travail SFT et d'entraînement des préférences.
3) (Facultatif) Installer le bundle complet de fonctionnalités: Si vous voulez l'entraînement + le service + l'interface utilisateur + les outils de données en une seule installation :
pip install \"soup-cli[all]\"
4) (Facultatif) Installer la dernière version de développement depuis GitHub: Si vous voulez les changements les plus récents (peut être moins stable) :
pip install git+https://github.com/MakazhanAlpamys/Soup.git
5) Initialiser un nouveau projet à partir d'un modèle: Créez un projet/une configuration de démarrage en utilisant un modèle intégré (exemple : chat) :
soup init --template chat
Cela met en place une structure exécutable afin que vous puissiez vous entraîner avec une configuration manuelle minimale.
6) Préparer vos données d'entraînement (pointer Soup vers votre jeu de données): Placez votre jeu de données localement (généralement JSONL). Dans une configuration Soup, vous ferez référence à des chemins comme :
train: ./data/train.jsonl
Soup prend en charge les formats de jeu de données tels que les données de style Alpaca (comme indiqué dans les sources).
7) Configurer l'exécution (exemple de configuration manuelle): Vous pouvez fournir une configuration qui spécifie le modèle de base, la tâche/étape, les paramètres LoRA, la quantification et le répertoire de sortie. Les champs d'exemple présentés dans les sources incluent :
- base/model_name_or_path: meta-llama/Llama-3.1-8B (ou -Instruct)
- task/stage: sft
- finetuning_type: lora
- lora_rank (r), lora_alpha, lora_dropout, lora_target
- cutoff_len
- learning_rate, epochs
- quantization_bit: 4
- output_dir
Soup peut également détecter/choisir automatiquement de nombreux paramètres (optimiseur, ordonnanceur, modules cibles, taille de lot) en fonction du flux de travail.
8) Entraîner en une seule commande: Exécutez l'entraînement à partir de votre projet/configuration initialisé :
soup train
Selon les sources, Soup effectue des vérifications pré-vol sur les données, sélectionne/dérive les paramètres d'entraînement via des règles (pas de recherche manuelle d'hyperparamètres), dérive les évaluations de vos propres données et gère les sauvegardes.
9) Utiliser la quantification 4 bits pour le réglage fin à faible VRAM (exemple): Pour réduire l'utilisation de la VRAM, configurez la quantification 4 bits (par exemple, quantization_bit: 4). Les sources décrivent la diffusion en continu du modèle de base gelé couche par couche à partir de la RAM du CPU ou du NVMe et la quantification en NF4 afin qu'un modèle 8B puisse être ajusté sur un GPU de 4 Go.
10) Exécuter des méthodes de préférence/alignement (DPO/ORPO/SimPO/KTO) si nécessaire: Soup prend en charge les méthodes d'alignement, y compris DPO, ORPO, SimPO et KTO, et les sources indiquent que celles-ci peuvent également fonctionner avec la même approche de diffusion en continu de couches lorsque le modèle est plus grand que la VRAM du GPU.
11) Migrer depuis un autre outil de réglage fin (conversion de configuration): Si vous avez déjà des configurations d'autres outils, utilisez :
soup migrate
Les sources indiquent que cela convertit les configurations existantes (par exemple, de LLaMA-Factory, Axolotl, Unsloth) sans réécriture, puis vous pouvez vous entraîner normalement.
12) Ingestion de traces/journaux de production pour les données d'entraînement hors ligne (facultatif): Pour créer des jeux de données à partir de journaux/exports existants, utilisez le modèle de commande d'ingestion présenté dans les sources :
soup ingest --source <vendor> --logs <export.jsonl>
Les sources prises en charge mentionnées incluent Langfuse, LangSmith, Helicone, OpenPipe, OpenTelemetry et OpenAI Stored Completions.
FAQ de Soup CLI
Soup CLI est une boîte à outils post-entraînement CLI-first gratuite et open-source (Apache-2.0) qui couvre la boucle complète : elle valide et "répare" vos données avant le vol, choisit une méthode d'entraînement, écrit automatiquement la configuration d'entraînement (y compris la tâche, la quantification, le taux d'apprentissage et les époques à partir de règles plutôt que de la recherche d'hyperparamètres), dérive les évaluations de vos propres données, contrôle chaque sauvegarde, et peut auto-corriger le "reward hacking" en cours d'exécution au lieu de seulement l'arrêter. Elle s'intègre également avec les outils ML courants (Hugging Face, Ollama, vLLM, DeepSpeed, Unsloth, ONNX/TensorRT, W&B, etc.).
Vidéo de Soup CLI
Articles populaires
Atoms : Une plateforme d'IA multi-agents qui transforme les idées en produits prêts à être lancés
May 22, 2026
Nano Banana SBTI : Qu'est-ce que c'est, comment ça marche et comment l'utiliser en 2026
Apr 15, 2026
Atoms : L'outil de création de produits IA qui redéfinit la création numérique en 2026
Apr 10, 2026
Kilo Claw : Comment déployer et utiliser un véritable agent d'IA "Faites-le pour vous" (Mise à jour 2026)
Apr 3, 2026
Derniers outils d'IA similaires à Soup CLI
Gait
Gait est un outil de collaboration qui intègre la génération de code assistée par l'IA avec le contrôle de version, permettant aux équipes de suivre, comprendre et partager efficacement le contexte du code généré par l'IA.
invoices.dev
invoices.dev est une plateforme de facturation automatisée qui génère des factures directement à partir des commits Git des développeurs, avec des capacités d'intégration pour GitHub, Slack, Linear et les services Google.
EasyRFP
EasyRFP est un outil de calcul en périphérie alimenté par l'IA qui rationalise les réponses aux RFP (demande de proposition) et permet le phénotypage des champs en temps réel grâce à la technologie d'apprentissage profond.
Cart.ai
Cart.ai is an AI-powered service platform that provides comprehensive business automation solutions including coding, customer relations management, video editing, e-commerce setup, and custom AI development with 24/7 support.
Outils d'IA populaires comme Soup CLI
GitHub Copilot Chat
GitHub Copilot Chat est un assistant de codage alimenté par l'IA qui fournit des interactions en langage naturel, des suggestions de code en temps réel et un soutien contextuel directement dans les IDE pris en charge et sur GitHub.com.
CopilotForXcode
CopilotForXcode est une extension d'Éditeur de Source Xcode qui intègre GitHub Copilot, Codeium et ChatGPT pour fournir des suggestions de code alimentées par l'IA, une assistance par chat et une fonctionnalité de prompt-à-code au sein de Xcode.
BrowserAI
BrowserAI est une bibliothèque open source qui permet d'exécuter des grands modèles de langage (LLM) locaux directement dans les navigateurs Web avec l'accélération WebGPU, offrant des capacités d'IA axées sur la confidentialité sans nécessiter d'infrastructure de serveur.
OpenAI Codex CLI
OpenAI Codex CLI est un agent de codage open source léger qui s'exécute dans votre terminal, permettant aux développeurs de traduire le langage naturel en exécution de code tout en fournissant un raisonnement de niveau ChatGPT avec la possibilité d'exécuter du code, de manipuler des fichiers et d'itérer sous contrôle de version.