> 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 d'affinage Muse Glimmer Entraînez le modèle Muse Glimmer 30B de Meta avec Unsloth. Vous pouvez désormais affiner et effectuer de l’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** avec **\~50 % de VRAM en moins** que les configurations FA2 (sans perte de précision) * Affiner 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 aussi entraîner Muse Glimmer avec [l’apprentissage par renforcement](#reinforcement-learning-rl) (RL) gratuitement ou sur 24 Go de VRAM. * **Le QLoRA 30B fonctionne avec 24 Go** et le LoRA nécessite >40 Go * **Exportation** / sauvegarde des modèles en GGUF, etc. et le fine-tuning complet **(FFT)** fonctionne aussi. Nous avons également optimisé Muse Glimmer pour qu’il tienne en incluant les optimisations suivantes : * `offload_embedding = True` conserve `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, ce qui récupère 2,5 Go au chargement - pour l’instant, cela fonctionne uniquement sur un seul GPU (travail en cours sur 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 carte de 24 Go ! Mesuré sur une carte de 180 GiB avec `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 de mémoire réservée 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 avec un encodeur de perception dédié, conçu pour des agents autonomes nécessitant de la planification, l’exécution d’outils, une compréhension multimodale et un raisonnement à long contexte. * Si vous souhaitez préserver les capacités de raisonnement, mélangez des exemples de type raisonnement avec des réponses directes. Évitez de n’entraîner que des réponses courtes, car cela peut réduire les performances de raisonnement en plusieurs étapes. * Muse Glimmer prend en charge des contextes longs allant jusqu’à 131K+ tokens, mais commencez d’abord le fine-tuning avec des contextes plus courts. * Après le fine-tuning, vous pouvez exporter votre modèle vers des 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 proposons 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 fonctionner GRPO / RL sur Muse Glimmer dans un environnement Kaggle gratuit avec 2 Tesla T4 - ça tient à peine, mais ça marche ! 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écessite 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 carte des périphériques explicite avec `unsloth_zoo.device_map_planner`, qui réserve également la marge de logit 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 Intel, MLX et AMD arrive ce mois-ci. {% endcolumn %} {% column %}
{% endcolumn %} {% endcolumns %} {% stepper %} {% step %} #### Installer Unsloth Le moyen le 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 l’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 les 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 de 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 affiné Une fois terminé, Unsloth Studio vous permet d’exporter le modèle en formats GGUF, safetensor, etc.
{% endstep %} {% step %} #### Comparer le modèle affiné au 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,6 Md | | Couches | 52 | | Dimension cachée | 6656 | | Attention | Répétition locale, locale, locale, globale | | Fenêtre glissante | 2048 | | Têtes d’attention | 32 Query / 2 KV | | FFN | SwiGLU | | Longueur de contexte | 131,072+ | | Encodeur visuel | ViT-G/14 (\~1,8 Md de paramètres) | | Modalités | Entrée texte + image, sortie texte | | Vocabulaire | 202 048 tokens | Muse Glimmer utilise : * Raisonnement à long contexte * Planification de l’utilisation d’outils * Récupération après échec * Compréhension multimodale * Compatibilité avec les architectures d’agents * 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 bien plus faible * Entraînement plus rapide * Fichiers d’adaptateur plus petits * Partage facile du modèle * 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 les tâches agentiques plus difficiles : ```python r = 32 lora_alpha = 32 ``` Commencez plus petit et augmentez uniquement 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 * Fine-tuning de jeux de données plus volumineux * Réduction de l’utilisation 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 gelé. * Affinez d’abord les couches linguistiques. * N’entraînez les composants visuels que si votre jeu de données nécessite une adaptation visuelle. Les 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’agents ancrés dans l’image 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 des flux de travail d’agents autonomes. Pour les jeux de données d’agents, incluez : * Descriptions des outils * Appels de fonction corrects * Résultats 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 chercher dans 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 * Formatage incohérent Pour préserver le raisonnement : * Gardez des exemples de raisonnement variés. * Incluez des réponses finales. * Évitez d’entraîner exclusivement sur des sorties de type 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 des 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 intensité de raisonnement contrôlable : ``` Intensité de raisonnement : faible Intensité de raisonnement : moyenne Intensité de raisonnement : élevée Intensité de raisonnement : très élevée ``` Pour les tâches complexes : * Codage → élevé/très élevé * Flux de travail d’agents → élevé/très élevé * Assistants simples → moyen * Réponses rapides → faible Lors du fine-tuning 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 des 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 temperature = 1.0 top_p = 0.95 top_k = 64 ``` Pour les tâches de raisonnement difficiles : ``` Intensité de raisonnement : élevée ``` Pour des conversations rapides : ``` Intensité 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 | Des GPU grand public sont possibles selon la longueur de séquence | | Fine-tuning complet | Systèmes multi-GPU | Le modèle lui-même peut s’exécuter efficacement avec des poids quantifiés, les 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 des permissions des outils. * Validez les actions externes. * Exigez une confirmation pour les opérations irréversibles. * Testez la résistance à l’injection de prompt. * Évaluez les risques pour la vie privée. Jeux de données de sécurité recommandés : * Exemples de mauvaise utilisation d’outils * Frontières 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 de lot * Activer le gradient checkpointing ### La qualité du modèle diminue Essayez : * Réduire le taux d’apprentissage * Entraîner pendant moins d’époques * Améliorer la qualité du jeu de données * Mélanger des exemples d’instructions originaux ### Les appels d’outils deviennent incorrects Ajouter : * Davantage d’exemples d’appels d’outils * Schémas corrects * Exemples de récupération après échec * Flux de travail à plusieurs 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 dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter: ``` 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 optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. 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.