> For the complete documentation index, see [llms.txt](https://unsloth.ai/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://unsloth.ai/docs/fr/modeles/muse-glimmer/train.md). # Guide de fine-tuning de Muse Glimmer Entraînez le modèle Muse Glimmer 30B de Meta avec Unsloth. Vous pouvez désormais affiner et effectuer un apprentissage par renforcement (RL) avec le modèle agentique Muse Glimmer 30B de Meta via [Unsloth](https://github.com/unslothai/unsloth). Muse Glimmer prend en charge la vision et s'entraîne localement sur 24 Go de VRAM via Unsloth avec prise en charge de la vision, du texte, de l'audio et de l'entraînement RL. * Unsloth entraîne Muse Glimmer **\~1,5x plus vite** par **\~50 % de VRAM en moins** que les configurations FA2 (sans perte de précision) * Ajuster finement Muse Glimmer via nos **gratuits** **Notebooks Kaggle**: | [**Vision + texte**](https://www.kaggle.com/notebooks/welcome?src=https://github.com/unslothai/notebooks/blob/main/nb/Kaggle-Muse_Glimmer_\(30B\)-Vision.ipynb\&accelerator=nvidiaTeslaT4) | [**RL GRPO**](https://www.kaggle.com/notebooks/welcome?src=https://github.com/unslothai/notebooks/blob/main/nb/Kaggle-Muse_Glimmer_\(30B\)-GRPO.ipynb\&accelerator=nvidiaTeslaT4) | [**Conversationnel**](https://www.kaggle.com/notebooks/welcome?src=https://github.com/unslothai/notebooks/blob/main/nb/Kaggle-Muse_Glimmer_\(30B\)-Conversational.ipynb\&accelerator=nvidiaTeslaT4) | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | * Vous pouvez également entraîner Muse Glimmer avec [l’apprentissage par renforcement](#reinforcement-learning-rl) (RL) gratuitement ou sur 24 Go de VRAM. * **QLoRA 30B fonctionne avec 24 Go** et LoRA nécessite >40 Go * **Exportation**/enregistrement des modèles au format GGUF, etc. et l'ajustement fin complet **(FFT)** fonctionne également. Nous avons également optimisé Muse Glimmer pour les faire tenir, notamment grâce à ces optimisations : * `offload_embedding = True` garde `embed_tokens` dans la RAM CPU et ne déplace vers le GPU que les lignes récupérées. L'embedding d'entrée de Muse Glimmer est de 202048 x 6656 en 16 bits, donc cela récupère 2,5 Go au chargement - pour l'instant, cela ne fonctionne que sur un seul GPU (en cours pour les configurations multi-GPU) * Des quantifications BnB dynamiques en 4 bits qui compressent le modèle de 56 Go à 21 Go, permettant des fine-tunings sur une carte de 24 Go ! Mesuré sur une carte de 180 GiB à `max_seq_length = 1024`, taille de lot 1, LoRA r=16 : poids 18,22 GiB après chargement avec le déchargement activé (20,72 GiB sans), et **22,57 GiB réservés au pic** pendant l'entraînement. Prévoyez une carte de 24 GiB comme minimum réaliste. ### Démarrage rapide Muse Glimmer est un Transformer causal dense doté d'un encodeur de perception dédié, conçu pour les agents autonomes nécessitant la planification, l'exécution d'outils, la compréhension multimodale et un raisonnement à long contexte. * Si vous souhaitez préserver les capacités de raisonnement, mélangez des exemples de style raisonnement avec des réponses directes. Évitez d'entraîner uniquement des réponses courtes, car cela peut réduire les performances de raisonnement en plusieurs étapes. * Muse Glimmer prend en charge des contextes longs jusqu'à 131K+ tokens, mais commencez d'abord à l'affiner avec des contextes plus courts. * Après l'affinage, vous pouvez exporter votre modèle vers les formats NVFP4, FP8 ou GGUF pour l'inférence locale. ### Notebooks de fine-tuning gratuits Pour un fine-tuning gratuit de Muse Glimmer via [Unsloth](https://github.com/unslothai/unsloth), nous fournissons plusieurs notebooks Kaggle qui offrent **30 heures d'utilisation gratuite du GPU avec 2× GPU Tesla T4**. Kaggle est un produit Google, similaire à Google Colab, et fournit un moyen pratique d'exécuter des workflows de fine-tuning sans avoir besoin de votre propre matériel GPU. | [**Vision + texte**](https://www.kaggle.com/notebooks/welcome?src=https://github.com/unslothai/notebooks/blob/main/nb/Kaggle-Muse_Glimmer_\(30B\)-Vision.ipynb\&accelerator=nvidiaTeslaT4) | [**RL GRPO**](https://www.kaggle.com/notebooks/welcome?src=https://github.com/unslothai/notebooks/blob/main/nb/Kaggle-Muse_Glimmer_\(30B\)-GRPO.ipynb\&accelerator=nvidiaTeslaT4) | [**Conversationnel**](https://www.kaggle.com/notebooks/welcome?src=https://github.com/unslothai/notebooks/blob/main/nb/Kaggle-Muse_Glimmer_\(30B\)-Conversational.ipynb\&accelerator=nvidiaTeslaT4) | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | {% columns %} {% column %} Muse Glimmer **Vision** Kaggle {% embed url="" %} {% endcolumn %} {% column %} Muse Glimmer **Conversationnel** Kaggle {% embed url="" %} {% endcolumn %} {% endcolumns %}
### Apprentissage par renforcement RL Nous avons également réussi à faire faire du GRPO / RL à Muse Glimmer dans un environnement Kaggle gratuit Tesla T4 x 2 - ça tient à peine mais ça fonctionne ! Sur 2 GPU T4 de 16 Go `num_generations = 2`, `max_seq_length = 1536` et une limite de 128 lignes sur le log-softmax nécessitent 4,10 GiB de VRAM GPU. La même exécution à 3072 tokens nécessite 7,57 GiB, donc cela ne tient pas. Nous avons créé une cartographie explicite des appareils avec `unsloth_zoo.device_map_planner`, qui réserve également la marge de manœuvre des logits sur la carte GPU principale. {% embed url="" %} Notebook Kaggle gratuit d'apprentissage par renforcement pour Muse Glimmer {% endembed %} {% code overflow="wrap" %} ```python from unsloth_zoo.device_map_planner import plan_device_map_for_pretrained _plan = plan_device_map_for_pretrained( MODEL_NAME, # Mémoire libre, pas totale : le contexte CUDA est déjà résident max_memory = {i: torch.cuda.mem_get_info(i)[0] for i in range(_n)}, rows_per_chunk = 128, # correspond à la limite de log-softmax ci-dessous retained_rows = BATCH_SIZE * max_seq_length, softcapped = True, temperature_scaled = True, ) ``` {% endcode %} ### 🦥 Guide Unsloth {% columns %} {% column %} Muse Glimmer peut être exécuté et affiné dans [Unsloth](/docs/fr/nouveau/studio.md) Desktop, notre nouvelle interface web open source pour l'IA locale. Avec Unsloth Studio, vous pouvez exécuter des modèles localement sur **macOS, Windows**, Linux et entraîner des GPU NVIDIA. La prise en charge de l'entraînement sur Intel, MLX et AMD arrive ce mois-ci. {% endcolumn %} {% column %}
{% endcolumn %} {% endcolumns %} {% stepper %} {% step %} #### Installer Unsloth La façon la plus simple de commencer est de télécharger l' [application Unsloth Desktop](/docs/fr/desktop.md). Fonctionne sur [macOS](/docs/fr/commencer/install/mac.md), [Windows](/docs/fr/commencer/install/windows-installation.md)et [Linux](/docs/fr/commencer/install/linux.md). Télécharger Unsloth * :apple: [Télécharger pour macOS](https://unsloth.ai/download/mac) * :windows: [Télécharger pour Windows](https://unsloth.ai/download/windows) * :linux: [Télécharger pour Linux](https://unsloth.ai/download/linux) Ou, si vous préférez installer manuellement : MacOS, Linux, WSL : ```bash curl -fsSL https://unsloth.ai/install.sh | sh ``` Windows PowerShell : ```bash irm https://unsloth.ai/install.ps1 | iex ``` {% endstep %} {% step %} #### Entraîner Muse Glimmer Au premier lancement, vous devrez créer un mot de passe pour sécuriser votre compte et vous reconnecter plus tard. Vous verrez ensuite un bref assistant d'intégration pour choisir un modèle, un jeu de données et des paramètres de base. Vous pouvez le passer à tout moment. Recherchez Muse Glimmer dans la barre de recherche et sélectionnez le modèle et le jeu de données souhaités. Ensuite, ajustez vos hyperparamètres et la longueur du contexte selon vos besoins. {% endstep %} {% step %} #### Surveiller la progression de l'entraînement Après avoir cliqué sur démarrer l'entraînement, vous pourrez surveiller et observer la progression de l'entraînement du modèle. La perte d'entraînement devrait diminuer régulièrement.\ Une fois terminé, le modèle sera automatiquement enregistré.
{% endstep %} {% step %} #### Exporter votre modèle ajusté finement Une fois terminé, Unsloth Studio vous permet d'exporter le modèle aux formats GGUF, safetensor, etc.
{% endstep %} {% step %} #### Comparer le modèle ajusté finement avec le modèle original Cliquez sur `Mode comparaison` pour comparer l'adaptateur LoRA et le modèle original.
{% endstep %} {% endstepper %} ## Aperçu de Muse Glimmer-30B | Architecture du modèle | Transformer causal dense avec encodeur de perception | | ---------------------- | ---------------------------------------------------- | | Paramètres | \~29,6B | | Couches | 52 | | Dimension cachée | 6656 | | Attention | Local, local, local, global en répétition | | Fenêtre glissante | 2048 | | Têtes d'attention | 32 requêtes / 2 KV | | FFN | SwiGLU | | Longueur de contexte | 131,072+ | | Encodeur de vision | ViT-G/14 (\~1,8B paramètres) | | Modalités | Entrée texte + image, sortie texte | | Vocabulaire | 202 048 jetons | Muse Glimmer utilise : * Raisonnement à long contexte * Planification de l'utilisation d'outils * Récupération après échec * Compréhension multimodale * Compatibilité avec l'ossature d'agent * Effort de raisonnement contrôlable ## Méthode de fine-tuning recommandée ### Fine-tuning LoRA Pour la plupart des utilisateurs, LoRA est l'approche recommandée. Avantages : * Utilisation de VRAM beaucoup plus faible * Entraînement plus rapide * Fichiers d'adaptateur plus petits * Partage du modèle facile * Préserve les capacités du modèle de base Configuration de départ recommandée : ```python r = 16 lora_alpha = 16 lora_dropout = 0 ``` Pour des tâches agentiques plus difficiles : ```python r = 32 lora_alpha = 32 ``` Commencez plus petit et n'augmentez que si nécessaire. ## Fine-tuning QLoRA QLoRA est recommandé lorsque la mémoire GPU est limitée. Muse Glimmer a été conçu pour un déploiement local efficace, y compris l'inférence quantifiée. Les mêmes principes font de QLoRA une approche de fine-tuning pratique. Utilisez QLoRA lorsque : * Entraînement sur des GPU grand public * Affinage de jeux de données plus volumineux * Maintien d'une faible utilisation de la mémoire * Entraînement de plusieurs adaptateurs Exemple : ```python load_in_4bit = True ``` *** ## Fine-tuning multimodal Muse Glimmer inclut un encodeur de perception dédié pour la compréhension des images. Pour les tâches de vision : * Gardez d'abord l'encodeur de perception figé. * Ajustez d'abord les couches de langage. * N'entraînez les composants de vision que si votre jeu de données nécessite une adaptation visuelle. De bons jeux de données multimodaux incluent : * Compréhension de captures d'écran * Raisonnement sur des documents * Interprétation de graphiques * Interaction avec l'interface graphique * Flux de travail d'agent fondés sur les images Format d'exemple : ```json { "messages": [ { "role": "user", "content": [ { "type": "image", "image": "example.png" }, { "type": "text", "text": "Expliquez cette capture d'écran." } ] }, { "role": "assistant", "content": "La capture d'écran montre..." } ] } ``` ## Fine-tuning agentique Muse Glimmer est optimisé pour les flux de travail d'agents autonomes. Pour les jeux de données d'agents, incluez : * Descriptions des outils * Appels de fonction corrects * Sorties des outils * Récupération après des échecs * Exemples de planification en plusieurs étapes * Gestion des permissions * Réponses finales destinées à l'utilisateur Exemple : ```json { "messages": [ { "role": "user", "content": "Trouvez mon dernier rapport et résumez-le." }, { "role": "assistant", "content": "Je vais rechercher vos fichiers.", "tool_calls": [ { "name": "file_search", "arguments": { "query": "dernier rapport" } } ] } ] } ``` ## Préparation du jeu de données Muse Glimmer fonctionne mieux avec des jeux de données d'instructions de haute qualité. Jeux de données recommandés : * Conversations à plusieurs tours * Traces d'utilisation d'outils * Tâches de codage * Trajectoires d'agents * Exemples vision-langage * Exemples de raisonnement À éviter : * Exemples dupliqués * Réponses générées de faible qualité * Appels d'outils incorrects * Mise en forme incohérente Pour préserver le raisonnement : * Gardez des exemples de raisonnement variés. * Incluez les réponses finales. * Évitez d'entraîner exclusivement sur des sorties de chaîne de pensée. ## Paramètres d'entraînement Une bonne configuration de départ : ```python trainer = SFTTrainer( max_seq_length = 4096, packing = True, ) ``` Recommandé : | Paramètre | Valeur | | ------------------------- | --------- | | Taille de lot | 1-8 | | Accumulation de gradients | 4-16 | | Taux d'apprentissage | 2e-4 LoRA | | Époques | 1-3 | | Optimiseur | AdamW | | Précision | BF16 | Pour l'entraînement à long contexte : * Augmentez progressivement la longueur de séquence. * Surveillez l'utilisation de la VRAM. * Utilisez le gradient checkpointing. ## Fine-tuning du raisonnement Muse Glimmer prend en charge une force de raisonnement contrôlable : ``` Force de raisonnement : faible Force de raisonnement : moyenne Force de raisonnement : élevée Force de raisonnement : très élevée ``` Pour les tâches complexes : * Codage → élevée/très élevée * Flux de travail d'agent → élevée/très élevée * Assistants simples → moyenne * Réponses rapides → faible Lors de l'affinage de modèles de raisonnement : * Incluez des exemples difficiles. * Incluez les échecs et les corrections. * Incluez des tâches en plusieurs étapes. * Préservez les capacités générales. ## Exporter votre modèle affiné Après l'entraînement, exportez votre adaptateur : ```python model.save_pretrained("muse-glimmer-lora") tokenizer.save_pretrained("muse-glimmer-lora") ``` Vous pouvez fusionner les adaptateurs LoRA : ```python model.merge_and_unload() ``` Les formats d'exportation peuvent inclure : * Format Hugging Face * Safetensors * Formats compatibles GGUF ## Paramètres d'inférence Paramètres de génération recommandés : ```python température = 1.0 top_p = 0.95 top_k = 64 ``` Pour les tâches de raisonnement difficiles : ``` Force de raisonnement : élevée ``` Pour les conversations rapides : ``` Force de raisonnement : faible ``` ## Exigences matérielles Muse Glimmer est optimisé pour le déploiement local. Exigences approximatives : | Méthode d'entraînement | Matériel | | ---------------------- | -------------------------------------------------------- | | LoRA | GPU à grande mémoire recommandé | | QLoRA | GPU grand public possibles selon la longueur de séquence | | Fine-tuning complet | Systèmes multi-GPU | Le modèle lui-même peut fonctionner efficacement à l'aide de poids quantifiés, avec des variantes 4 bits publiées ciblant du matériel grand public de 24 Go et 32 Go. ## Fine-tuning de sécurité Lors du déploiement de Muse Glimmer dans des systèmes agentiques : * Ajoutez des vérifications d'autorisation des outils. * Validez les actions externes. * Exigez une confirmation pour les opérations irréversibles. * Testez la résistance aux injections de prompt. * Évaluez les risques liés à la confidentialité. Jeux de données de sécurité recommandés : * Exemples de mauvaise utilisation des outils * Limites des permissions * Gestion des instructions dangereuses * Exemples de minimisation des données ## Dépannage ### Mémoire insuffisante Essayez : * Réduire la longueur de séquence * Réduire le rang LoRA * Activer le chargement en 4 bits * Réduire la taille du lot * Activer le gradient checkpointing ### La qualité du modèle diminue Essayez : * Réduire le taux d'apprentissage * Entraîner moins d'époques * Augmenter la qualité du jeu de données * Mélanger des exemples d'instructions d'origine ### Les appels d'outils deviennent incorrects Ajoutez : * Davantage d'exemples d'appels d'outils * Schémas corrects * Exemples de récupération après échec * Flux de travail multi-tours --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation by asking a question. Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters: ``` GET https://unsloth.ai/docs/fr/modeles/muse-glimmer/train.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.