> 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/de/modelle/muse-glimmer/train.md). # Fine-Tuning-Leitfaden für Muse Glimmer Trainiere Metas Modell Muse Glimmer 30B mit Unsloth. Sie können jetzt mit Metas agentischem Modell Muse Glimmer mit 30 Mrd. Parametern Feintuning und Reinforcement Learning (RL) über [Unsloth](https://github.com/unslothai/unsloth). Muse Glimmer unterstützt Vision und trainiert lokal mit 24 GB VRAM über Unsloth mit Unterstützung für Vision, Text, Audio und RL-Training. * Unsloth trainiert Muse Glimmer **ca. 1,5× schneller** mit **ca. 50 % weniger VRAM** als FA2-Setups (kein Genauigkeitsverlust) * Muse Glimmer feinabstimmen über unsere **kostenlosen** **Kaggle-Notebooks**: | [**Vision + Text**](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) | [**Dialog**](https://www.kaggle.com/notebooks/welcome?src=https://github.com/unslothai/notebooks/blob/main/nb/Kaggle-Muse_Glimmer_\(30B\)-Conversational.ipynb\&accelerator=nvidiaTeslaT4) | | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | * Sie können Muse Glimmer auch mit [Reinforcement Learning](#reinforcement-learning-rl) (RL) kostenlos oder auf 24 GB VRAM trainieren. * **30B QLoRA funktioniert mit 24 GB** und LoRA benötigt >40 GB * **Exportieren**/Speichern von Modellen in GGUF usw. und vollständiges Feintuning **(FFT)** funktioniert ebenfalls. Wir haben Muse Glimmer außerdem optimiert, damit sie passt, einschließlich dieser Optimierungen: * `offload_embedding = True` behält `embed_tokens` im CPU-RAM und verschiebt nur die nachgeschlagenen Zeilen auf die GPU. Das Eingabe-Embedding von Muse Glimmer ist 202048 x 6656 in 16 Bit, wodurch beim Laden 2,5 GB zurückgewonnen werden – funktioniert derzeit nur auf einer einzelnen GPU (WIP für Multi-GPU-Setups) * Dynamische 4-Bit-BnB-Quantisierungen, die das Modell von 56 GB auf 21 GB komprimieren und Feintunes auf 24-GB-Karten ermöglichen! Gemessen auf einer einzelnen 180-GiB-Karte bei `max_seq_length = 1024`, Batchgröße 1, LoRA r=16: Gewichte 18,22 GiB nach dem Laden mit aktiviertem Offload (20,72 GiB ohne), und **22,57 GiB maximal reserviert** während des Trainings. Planen Sie eine 24-GiB-Karte als realistische Mindestvoraussetzung ein. ### Schnellstart Muse Glimmer ist ein dichter kausaler Transformer mit einem dedizierten Wahrnehmungs-Encoder, der für autonome Agenten entwickelt wurde, die Planung, Werkzeugausführung, multimodales Verständnis und langkontextuelles Schlussfolgern benötigen. * Wenn Sie die Schlussfolgerungsfähigkeit erhalten möchten, mischen Sie Beispiele im Reasoning-Stil mit direkten Antworten. Vermeiden Sie es, nur auf kurze Antworten zu trainieren, da dies die Leistung beim mehrstufigen Schlussfolgern verringern kann. * Muse Glimmer unterstützt lange Kontexte von bis zu 131K+ Tokens, aber beginnen Sie das Feintuning zunächst mit kürzeren Kontexten. * Nach dem Feintuning können Sie Ihr Modell für lokale Inferenzformate nach NVFP4, FP8 oder GGUF exportieren. ### Kostenlose Feintuning-Notebooks Für kostenloses Muse-Glimmer-Feintuning über [Unsloth](https://github.com/unslothai/unsloth), bieten wir mehrere Kaggle-Notebooks an, die **30 Stunden kostenlose GPU-Nutzung mit 2× Tesla T4-GPUs**. Kaggle ist ein Google-Produkt, ähnlich wie Google Colab, und bietet eine bequeme Möglichkeit, Feintuning-Workflows auszuführen, ohne eigene GPU-Hardware zu benötigen. | [**Vision + Text**](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) | [**Dialog**](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 **Dialog** Kaggle {% embed url="" %} {% endcolumn %} {% endcolumns %}
### Reinforcement Learning RL Wir haben Muse Glimmer auch erfolgreich dazu gebracht, GRPO / RL in einer kostenlosen Tesla-T4-x-2-Kaggle-Umgebung auszuführen – es passt gerade so, funktioniert aber! Auf 2 x 16-GB-T4-GPUs `num_generations = 2`, `max_seq_length = 1536` und einer Obergrenze von 128 Zeilen für den Log-Softmax benötigt 4,10 GiB GPU-VRAM. Derselbe Lauf mit 3072 Tokens benötigt 7,57 GiB und passt daher nicht. Wir haben eine explizite Device-Map mit `unsloth_zoo.device_map_planner`erstellt, die ebenfalls den Logit-Spielraum auf der Haupt-GPU-Karte reserviert. {% embed url="" %} Kaggle-Notebook für Reinforcement Learning, kostenlos, für 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, # Freien Speicher, nicht den gesamten: Der CUDA-Kontext ist bereits resident max_memory = {i: torch.cuda.mem_get_info(i)[0] for i in range(_n)}, rows_per_chunk = 128, # entspricht der unten stehenden Obergrenze für den Log-Softmax retained_rows = BATCH_SIZE * max_seq_length, softcapped = True, temperature_scaled = True, ) ``` {% endcode %} ### 🦥 Unsloth-Leitfaden {% columns %} {% column %} Muse Glimmer kann ausgeführt und feinabgestimmt werden in [Unsloth](/docs/de/neu/studio.md) Desktop, unserer neuen Open-Source-Weboberfläche für lokale KI. Mit Unsloth Studio können Sie Modelle lokal ausführen auf **macOS, Windows**, Linux und NVIDIA-GPUs trainieren. Unterstützung für Intel-, MLX- und AMD-Training kommt noch in diesem Monat. {% endcolumn %} {% column %}
{% endcolumn %} {% endcolumns %} {% stepper %} {% step %} #### Unsloth installieren Der einfachste Einstieg ist der Download der [Unsloth-Desktop-App](/docs/de/desktop.md). Funktioniert auf [macOS](/docs/de/erste-schritte/install/mac.md), [Windows](/docs/de/erste-schritte/install/windows-installation.md), und [Linux](/docs/de/erste-schritte/install/linux.md). Unsloth herunterladen * :apple: [Für macOS herunterladen](https://unsloth.ai/download/mac) * :windows: [Für Windows herunterladen](https://unsloth.ai/download/windows) * :linux: [Für Linux herunterladen](https://unsloth.ai/download/linux) Oder, wenn Sie die manuelle Installation bevorzugen: macOS, Linux, WSL: ```bash curl -fsSL https://unsloth.ai/install.sh | sh ``` Windows PowerShell: ```bash irm https://unsloth.ai/install.ps1 | iex ``` {% endstep %} {% step %} #### Muse Glimmer trainieren Beim ersten Start müssen Sie ein Passwort erstellen, um Ihr Konto zu sichern, und sich später erneut anmelden. Anschließend sehen Sie einen kurzen Einrichtungsassistenten zur Auswahl eines Modells, Datensatzes und der Grundeinstellungen. Sie können ihn jederzeit überspringen. Suchen Sie in der Suchleiste nach Muse Glimmer und wählen Sie das gewünschte Modell und den gewünschten Datensatz aus. Passen Sie anschließend Ihre Hyperparameter und die Kontextlänge nach Wunsch an. {% endstep %} {% step %} #### Trainingsfortschritt überwachen Nachdem Sie auf Training starten geklickt haben, können Sie den Trainingsfortschritt des Modells überwachen und beobachten. Der Trainingsverlust sollte stetig sinken.\ Nach Abschluss wird das Modell automatisch gespeichert.
{% endstep %} {% step %} #### Ihr feinabgestimmtes Modell exportieren Nach Abschluss ermöglicht Ihnen Unsloth Studio, das Modell in Formate wie GGUF, Safetensors usw. zu exportieren.
{% endstep %} {% step %} #### Feinabgestimmtes Modell mit Originalmodell vergleichen Klicken Sie auf `Vergleichsmodus` um den LoRA-Adapter und das Originalmodell zu vergleichen.
{% endstep %} {% endstepper %} ## Überblick über Muse Glimmer-30B | Modellarchitektur | Dichter kausaler Transformer mit Wahrnehmungs-Encoder | | -------------------- | ----------------------------------------------------- | | Parameter | \~29,6 Mrd. | | Schichten | 52 | | Verborgene Dimension | 6656 | | Aufmerksamkeit | Lokale, lokale, lokale, globale Wiederholung | | Gleitfenster | 2048 | | Attention-Köpfe | 32 Query / 2 KV | | FFN | SwiGLU | | Kontextlänge | 131,072+ | | Vision-Encoder | ViT-G/14 (\~1,8 Mrd. Parameter) | | Modalitäten | Text- und Bildeingabe, Textausgabe | | Vokabular | 202.048 Tokens | Muse Glimmer verwendet: * langkontextuelles Schlussfolgern * Planung des Werkzeugeinsatzes * Fehlerbehebung * Multimodales Verständnis * Kompatibilität mit Agenten-Frameworks * Steuerbarer Denkaufwand ## Empfohlene Feintuning-Methode ### LoRA-Feintuning Für die meisten Nutzer ist LoRA der empfohlene Ansatz. Vorteile: * Deutlich geringerer VRAM-Bedarf * Schnelleres Training * Kleinere Adapter-Dateien * Einfaches Teilen des Modells * Erhält die Fähigkeiten des Basismodells Empfohlene Startkonfiguration: ```python r = 16 lora_alpha = 16 lora_dropout = 0 ``` Für schwierigere agentische Aufgaben: ```python r = 32 lora_alpha = 32 ``` Beginnen Sie kleiner und erhöhen Sie nur, wenn erforderlich. ## QLoRA-Feintuning QLoRA wird empfohlen, wenn der GPU-Speicher begrenzt ist. Muse Glimmer wurde für eine effiziente lokale Bereitstellung einschließlich quantisierter Inferenz entwickelt. Dieselben Prinzipien machen QLoRA zu einem praktischen Feintuning-Ansatz. Verwenden Sie QLoRA, wenn: * Training auf Consumer-GPUs * Feinabstimmung größerer Datensätze * Den Speicherverbrauch niedrig halten * Training mehrerer Adapter Beispiel: ```python load_in_4bit = True ``` *** ## Multimodales Feintuning Muse Glimmer enthält einen dedizierten Wahrnehmungs-Encoder für das Bildverständnis. Für Vision-Aufgaben: * Den Wahrnehmungs-Encoder zunächst einfrieren. * Zuerst die Sprachschichten feinabstimmen. * Trainieren Sie die Vision-Komponenten nur, wenn Ihr Datensatz eine visuelle Anpassung erfordert. Gute multimodale Datensätze umfassen: * Screenshot-Verständnis * Dokumenten-Schlussfolgern * Diagramm-Interpretation * GUI-Interaktion * Auf Bildern basierende Agenten-Workflows Beispielformat: ```json { "messages": [ { "role": "user", "content": [ { "type": "image", "image": "example.png" }, { "type": "text", "text": "Erkläre diesen Screenshot." } ] }, { "role": "assistant", "content": "Der Screenshot zeigt..." } ] } ``` ## Agentisches Feintuning Muse Glimmer ist für autonome Agenten-Workflows optimiert. Für Agenten-Datensätze fügen Sie hinzu: * Werkzeugbeschreibungen * Korrekte Funktionsaufrufe * Werkzeugausgaben * Wiederherstellung nach Fehlern * Beispiele für mehrstufige Planung * Umgang mit Berechtigungen * Finale nutzerseitige Antworten Beispiel: ```json { "messages": [ { "role": "user", "content": "Finde meinen neuesten Bericht und fasse ihn zusammen." }, { "role": "assistant", "content": "Ich werde Ihre Dateien durchsuchen.", "tool_calls": [ { "name": "file_search", "arguments": { "query": "neuster Bericht" } } ] } ] } ``` ## Datensatzvorbereitung Muse Glimmer funktioniert am besten mit hochwertigen Instruktionsdatensätzen. Empfohlene Datensätze: * Mehrturn-Gespräche * Werkzeugeinsatz-Verläufe * Programmieraufgaben * Agenten-Trajektorien * Vision-Sprach-Beispiele * Schlussfolgerungsbeispiele Vermeiden Sie: * Doppelte Beispiele * Hochwertig generierte Antworten * Falsche Funktionsaufrufe * Inkonsistente Formatierung Zur Bewahrung des Schlussfolgens: * Halten Sie die Schlussfolgerungsbeispiele vielfältig. * Fügen Sie endgültige Antworten hinzu. * Vermeiden Sie es, ausschließlich auf Chain-of-Thought-Ausgaben zu trainieren. ## Trainings-Einstellungen Eine gute Startkonfiguration: ```python trainer = SFTTrainer( max_seq_length = 4096, packing = True, ) ``` Empfohlen: | Einstellung | Wert | | ---------------------- | --------- | | Batchgröße | 1-8 | | Gradientenakkumulation | 4-16 | | Lernrate | 2e-4 LoRA | | Epochen | 1-3 | | Optimierer | AdamW | | Präzision | BF16 | Für das Training mit langem Kontext: * Erhöhen Sie die Sequenzlänge schrittweise. * Überwachen Sie die VRAM-Nutzung. * Verwenden Sie Gradienten-Checkpointing. ## Feintuning für Schlussfolgerungen Muse Glimmer unterstützt steuerbare Schlussfolgerungsstärke: ``` Schlussfolgerungsstärke: niedrig Schlussfolgerungsstärke: mittel Schlussfolgerungsstärke: hoch Schlussfolgerungsstärke: xhoch ``` Für komplexe Aufgaben: * Programmierung → hoch/xhoch * Agenten-Workflows → hoch/xhoch * Einfache Assistenten → mittel * Schnelle Antworten → niedrig Beim Feintuning von Schlussfolgerungsmodellen: * Nehmen Sie schwierige Beispiele auf. * Nehmen Sie Fehler und Korrekturen auf. * Nehmen Sie mehrstufige Aufgaben auf. * Bewahren Sie die allgemeinen Fähigkeiten. ## Ihr feinabgestimmtes Modell exportieren Exportieren Sie nach dem Training Ihren Adapter: ```python model.save_pretrained("muse-glimmer-lora") tokenizer.save_pretrained("muse-glimmer-lora") ``` Sie können LoRA-Adapter zusammenführen: ```python model.merge_and_unload() ``` Exportformate können Folgendes umfassen: * Hugging-Face-Format * Safetensors * GGUF-kompatible Formate ## Inferenz-Einstellungen Empfohlene Generierungseinstellungen: ```python temperature = 1.0 top_p = 0.95 top_k = 64 ``` Für schwierige Schlussfolgerungsaufgaben: ``` Schlussfolgerungsstärke: hoch ``` Für schnelle Gespräche: ``` Schlussfolgerungsstärke: niedrig ``` ## Hardwareanforderungen Muse Glimmer ist für die lokale Bereitstellung optimiert. Ungefähre Anforderungen: | Trainingsmethode | Hardware | | ------------------------ | ---------------------------------------------------- | | LoRA | GPU mit hohem Speicherbedarf empfohlen | | QLoRA | Consumer-GPUs möglich, abhängig von der Sequenzlänge | | Vollständiges Feintuning | Multi-GPU-Systeme | Das Modell selbst kann effizient mit quantisierten Gewichten ausgeführt werden, wobei veröffentlichte 4-Bit-Varianten auf 24-GB- und 32-GB-Consumer-Hardware abzielen. ## Sicherheits-Feintuning Beim Bereitstellen von Muse Glimmer in agentischen Systemen: * Fügen Sie Prüfungen für Werkzeugberechtigungen hinzu. * Validieren Sie externe Aktionen. * Verlangen Sie eine Bestätigung für irreversible Vorgänge. * Testen Sie die Widerstandsfähigkeit gegen Prompt-Injection. * Bewerten Sie Datenschutzrisiken. Empfohlene Sicherheitsdatensätze: * Beispiele für Werkzeugmissbrauch * Berechtigungsgrenzen * Umgang mit unsicheren Anweisungen * Beispiele zur Datenminimierung ## Fehlerbehebung ### Speicher voll Versuchen Sie: * Sequenzlänge reduzieren * LoRA-Rang verringern * 4-Bit-Laden aktivieren * Batchgröße reduzieren * Gradienten-Checkpointing aktivieren ### Modellqualität sinkt Versuchen Sie: * Lernrate reduzieren * Trainiere über weniger Epochen * Erhöhe die Datensatzqualität * Mische ursprüngliche Instruktionsbeispiele ### Werkzeugaufrufe werden falsch Hinzufügen: * Mehr Beispiele für Werkzeugaufrufe * Korrekte Schemata * Beispiele zur Fehlerbehebung * Mehrturn-Workflows --- # 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/de/modelle/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.