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 de l’apprentissage par renforcement (RL) avec le modèle agentique Muse Glimmer 30B de Meta via 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

RL GRPO

Conversationnel

Vous pouvez aussi entraîner Muse Glimmer avec l’apprentissage par renforcement (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, 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

RL GRPO

Conversationnel

Muse Glimmer Vision Kaggle

Kaggle: Your Home for Data ScienceKaggle

Muse Glimmer Conversationnel Kaggle

Kaggle: Your Home for Data ScienceKaggle

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.

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,
)

🦥 Guide Unsloth

Muse Glimmer peut être exécuté et affiné dans Unsloth 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.

Installer Unsloth

Le moyen le plus simple de commencer est de télécharger l’application Unsloth Desktop. Fonctionne sur macOS, Windows, et Linux.

Télécharger Unsloth

Ou, si vous préférez l’installer manuellement :

MacOS, Linux, WSL :

curl -fsSL https://unsloth.ai/install.sh | sh

Windows PowerShell :

irm https://unsloth.ai/install.ps1 | iex

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.

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é.

Exporter votre modèle affiné

Une fois terminé, Unsloth Studio vous permet d’exporter le modèle en formats GGUF, safetensor, etc.

Comparer le modèle affiné au modèle original

Cliquez sur Mode comparaison pour comparer l’adaptateur LoRA et le modèle original.

Aperçu de Muse Glimmer-30B

Architecture du modèle

Transformer causal dense avec encodeur de perception

Paramètres

~29,6 Md

Couches

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 :

r = 16
lora_alpha = 16
lora_dropout = 0

Pour les tâches agentiques plus difficiles :

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 :

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 :

{
  "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 :

{
  "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 :

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 :

model.save_pretrained("muse-glimmer-lora")
tokenizer.save_pretrained("muse-glimmer-lora")

Vous pouvez fusionner des adaptateurs LoRA :

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 :

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

PrécédentMeta Muse Glimmer

SuivantQwen3.6

Mis à jour il y a 20 jours

Ce contenu vous a-t-il été utile ?