# Gemma 3n: So führst du es aus und feinstimmst es

Das multimodale Modell Gemma 3n von Google verarbeitet Bild-, Audio-, Video- und Texteingaben. Verfügbar in den Größen 2B und 4B, unterstützt es 140 Sprachen für Text- und multimodale Aufgaben. Sie können jetzt lokal ausführen und feinabstimmen **Gemma-3n-E4B** und **E2B** lokal mit [Unsloth](https://github.com/unslothai/unsloth).

> **Feinabstimmung von Gemma 3n mit unserem** [**kostenlosen Colab-Notebook**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma3N_\(4B\)-Conversational.ipynb)

Gemma 3n hat **32K Kontextlänge**, 30s Audioeingang, OCR, automatische Spracherkennung (ASR) und Sprachübersetzung über Prompts.

<a href="#running-gemma-3n" class="button primary">Ausführungs-Tutorial</a><a href="#fine-tuning-gemma-3n-with-unsloth" class="button secondary">Feinabstimmungs-Tutorial</a><a href="#fixes-for-gemma-3n" class="button secondary">Fehlerbehebungen + technische Analyse</a>

**Unsloth Gemma 3n (Instruct) Uploads mit optimalen Konfigurationen:**

<table><thead><tr><th width="249">Dynamisches 2.0 GGUF (nur Text)</th><th width="285">Dynamisches 4-Bit Instruct (zum Feinabstimmen)</th><th>16-Bit Instruct</th></tr></thead><tbody><tr><td><ul><li><a href="https://huggingface.co/unsloth/gemma-3n-E2B-it-GGUF">2B</a></li><li><a href="https://huggingface.co/unsloth/gemma-3n-E4B-it-GGUF">4B</a></li></ul></td><td><ul><li><a href="https://huggingface.co/unsloth/gemma-3n-E2B-it-unsloth-bnb-4bit">2B</a></li><li><a href="https://huggingface.co/unsloth/gemma-3n-E4B-it-unsloth-bnb-4bit">4B</a></li></ul></td><td><ul><li><a href="https://huggingface.co/unsloth/gemma-3n-E2B-it">2B</a></li><li><a href="https://huggingface.co/unsloth/gemma-3n-E4B-it">4B</a></li></ul></td></tr></tbody></table>

**Siehe alle unsere Gemma 3n Uploads einschließlich Basis und weiteren Formaten in** [**unserer Sammlung hier**](https://huggingface.co/collections/unsloth/gemma-3n-685d3874830e49e1c93f9339)**.**

## 🖥️ Gemma 3n ausführen

Derzeit wird Gemma 3n nur im **Textformat** für Inferenz unterstützt.

{% hint style="info" %}
Wir haben [Probleme behoben](#fixes-for-gemma-3n) mit GGUFs, die in Ollama nicht richtig funktionierten. Bitte laden Sie sie erneut herunter, wenn Sie Ollama verwenden.
{% endhint %}

### :gear: Offiziell empfohlene Einstellungen

Laut dem Gemma-Team sind die offiziell empfohlenen Einstellungen für die Inferenz:

`temperature = 1.0, top_k = 64, top_p = 0.95, min_p = 0.0`

* Temperatur von 1.0
* Top\_K von 64
* Min\_P von 0.00 (optional, aber 0.01 funktioniert gut, der llama.cpp-Standard ist 0.1)
* Top\_P von 0.95
* Repetitionsstrafe von 1.0. (1.0 bedeutet deaktiviert in llama.cpp und Transformers)
* Chat-Vorlage:

  <pre data-overflow="wrap"><code><strong>&#x3C;bos>&#x3C;start_of_turn>user\nHello!&#x3C;end_of_turn>\n&#x3C;start_of_turn>model\nHey there!&#x3C;end_of_turn>\n&#x3C;start_of_turn>user\nWhat is 1+1?&#x3C;end_of_turn>\n&#x3C;start_of_turn>model\n
  </strong></code></pre>
* Chat-Vorlage mit `\n`Zeilenumbrüchen gerendert (außer dem letzten)

{% code overflow="wrap" %}

```
<bos><start_of_turn>user
Hello!<end_of_turn>
<start_of_turn>model
Hey there!<end_of_turn>
<start_of_turn>user
What is 1+1?<end_of_turn>
<start_of_turn>model\n
```

{% endcode %}

{% hint style="danger" %}
llama.cpp und andere Inferenz-Engines fügen automatisch ein \<bos> hinzu - FÜGEN SIE NICHT ZWEI \<bos>-Tokens HINZU! Sie sollten das \<bos> beim Prompten des Modells ignorieren!
{% endhint %}

### :llama: Tutorial: Wie man Gemma 3n in Ollama ausführt

{% hint style="success" %}
Bitte laden Sie die Gemma 3N-Quants erneut herunter oder entfernen Sie die alten über Ollama, da es einige Fehlerbehebungen gibt. Sie können untenstehendes tun, um die alte Datei zu löschen und zu aktualisieren:

```
ollama rm hf.co/unsloth/gemma-3n-E4B-it-GGUF:UD-Q4_K_XL

ollama run hf.co/unsloth/gemma-3n-E4B-it-GGUF:UD-Q4_K_XL
```

{% endhint %}

1. Installieren Sie `ollama` wenn Sie es noch nicht getan haben!

```bash
apt-get update
apt-get install pciutils -y
curl -fsSL https://ollama.com/install.sh | sh
```

2. Führen Sie das Modell aus! Beachten Sie, dass Sie `ollama serve`in einem anderen Terminal aufrufen können, wenn es fehlschlägt! Wir fügen alle unsere Fehlerbehebungen und empfohlenen Parameter (Temperatur usw.) in `params` in unserem Hugging Face Upload hinzu!

```bash
ollama run hf.co/unsloth/gemma-3n-E4B-it-GGUF:UD-Q4_K_XL
```

### 📖 Tutorial: Wie man Gemma 3n in llama.cpp ausführt

{% hint style="info" %}
Wir möchten zunächst danken [Xuan-Son Nguyen](https://x.com/ngxson) von Hugging Face, [Georgi Gerganov](https://x.com/ggerganov) vom llama.cpp-Team dafür, dass Gemma 3N in llama.cpp funktioniert!
{% endhint %}

1. Beschaffen Sie sich das neueste `llama.cpp` auf [GitHub hier](https://github.com/ggml-org/llama.cpp). Sie können auch den Build-Anweisungen unten folgen. Ändern Sie `-DGGML_CUDA=ON` zu `-DGGML_CUDA=OFF` wenn Sie keine GPU haben oder nur CPU-Inferenz wünschen. **Für Apple Mac / Metal-Geräte**, setzen Sie `-DGGML_CUDA=OFF` und fahren Sie dann wie gewohnt fort - Metal-Unterstützung ist standardmäßig aktiviert.

```bash
apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
git clone https://github.com/ggml-org/llama.cpp
cmake llama.cpp -B llama.cpp/build \
    -DBUILD_SHARED_LIBS=ON -DGGML_CUDA=ON -DLLAMA_CURL=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-quantize llama-cli llama-gguf-split llama-mtmd-cli
cp llama.cpp/build/bin/llama-* llama.cpp
```

2. Wenn Sie `llama.cpp` direkt zum Laden von Modellen verwenden möchten, können Sie Folgendes tun: (:Q4\_K\_XL) ist der Quantisierungstyp. Sie können auch über Hugging Face herunterladen (Punkt 3). Dies ist ähnlich zu `ollama run`

```bash
./llama.cpp/llama-cli -hf unsloth/gemma-3n-E4B-it-GGUF:UD-Q4_K_XL -ngl 99 --jinja
```

3. **ODER** laden Sie das Modell herunter via (nach Installation von `pip install huggingface_hub hf_transfer` ). Sie können Q4\_K\_M oder andere quantisierte Versionen wählen (wie BF16 Vollpräzision).

```python
# !pip install huggingface_hub hf_transfer
import os
os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
from huggingface_hub import snapshot_download
snapshot_download(
    repo_id = "unsloth/gemma-3n-E4B-it-GGUF",
    local_dir = "unsloth/gemma-3n-E4B-it-GGUF",
    allow_patterns = ["*UD-Q4_K_XL*", "mmproj-BF16.gguf"], # Für Q4_K_XL
)
```

4. Führen Sie das Modell aus.
5. Bearbeiten Sie `--threads 32` für die Anzahl der CPU-Threads, `--ctx-size 32768` für die Kontextlänge (Gemma 3 unterstützt 32K Kontextlänge!), `--n-gpu-layers 99` für GPU-Offloading, also wie viele Schichten. Versuchen Sie, dies anzupassen, wenn Ihre GPU keinen Speicher mehr hat. Entfernen Sie es auch, wenn Sie nur CPU-Inferenz haben.
6. Für den Konversationsmodus:

```bash
./llama.cpp/llama-cli \
    --model unsloth/gemma-3n-E4B-it-GGUF/gemma-3n-E4B-it-UD-Q4_K_XL.gguf \
    --mmproj unsloth/gemma-3n-E4B-it-GGUF/mmproj-BF16.gguf \
    --ctx-size 32768 \
    --n-gpu-layers 99 \
    --seed 3407 \
    --prio 2 \
    --temp 1.0 \
    --repeat-penalty 1.0 \
    --min-p 0.00 \
    --top-k 64 \
    --top-p 0.95
```

7. Für den Nicht-Konversationsmodus zum Testen von Flappy Bird:

```bash
./llama.cpp/llama-cli \
    --model unsloth/gemma-3n-E4B-it-GGUF/gemma-3n-E4B-it-UD-Q4_K_XL.gguf \
    --mmproj unsloth/gemma-3n-E4B-it-GGUF/mmproj-BF16.gguf \
    --ctx-size 32768 \
    --n-gpu-layers 99 \
    --seed 3407 \
    --prio 2 \
    --temp 1.0 \
    --repeat-penalty 1.0 \
    --min-p 0.00 \
    --top-k 64 \
    --top-p 0.95 \
    -no-cnv \
    --prompt "<start_of_turn>user\nCreate a Flappy Bird game in Python. You must include these things:\n1. You must use pygame.\n2. The background color should be randomly chosen and is a light shade. Start with a light blue color.\n3. Pressing SPACE multiple times will accelerate the bird.\n4. The bird's shape should be randomly chosen as a square, circle or triangle. The color should be randomly chosen as a dark color.\n5. Place on the bottom some land colored as dark brown or yellow chosen randomly.\n6. Make a score shown on the top right side. Increment if you pass pipes and don't hit them.\n7. Make randomly spaced pipes with enough space. Color them randomly as dark green or light brown or a dark gray shade.\n8. When you lose, show the best score. Make the text inside the screen. Pressing q or Esc will quit the game. Restarting is pressing SPACE again.\nThe final game should be inside a markdown section in Python. Check your code for errors and fix them before the final markdown section.<end_of_turn>\n<start_of_turn>model\n"
```

{% hint style="danger" %}
Denken Sie daran, \<bos> zu entfernen, da Gemma 3N automatisch ein \<bos> hinzufügt!
{% endhint %}

## 🦥 Feinabstimmung von Gemma 3n mit Unsloth

Gemma 3n, wie [Gemma 3](https://unsloth.ai/docs/de/modelle/tutorials/gemma-3-how-to-run-and-fine-tune/..#unsloth-fine-tuning-fixes-for-gemma-3), hatte Probleme beim Ausführen auf <mark style="background-color:yellow;">**Float16-GPUs wie Tesla T4s in Colab**</mark>. Sie werden auf NaNs und Unendlichkeiten stoßen, wenn Sie Gemma 3n nicht für Inferenz oder Feinabstimmung patchen. [Weitere Informationen unten](#infinities-and-nan-gradients-and-activations).

* Feinabstimmung von Gemma 3n-E4B mit unserem [kostenlosen Colab-Notebook](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma3N_\(4B\)-Conversational.ipynb)
* **Audio:** Feinabstimmung von Gemma 3n-E4B mit unserem [**Nur-Audio-Notebook**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma3N_\(4B\)-Audio.ipynb)
* **Vision**: Feinabstimmung von Gemma 3n-E4B mit unserem [**Nur-Vision-Notebook**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma3N_\(4B\)-Vision.ipynb)

Wir stellten auch fest, dass Gemma 3n durch seine einzigartige Architektur die versteckten Zustände im Vision-Encoder wiederverwendet, was eine weitere interessante Eigenart im Zusammenhang mit [Gradient Checkpointing, das unten beschrieben wird,](#gradient-checkpointing-issues)

<mark style="background-color:purple;">**darstellt. Unsloth ist das einzige Framework, das auf float16-Maschinen für Gemma 3n Inferenz und Training funktioniert.**</mark> Das bedeutet, Colab-Notebooks mit kostenlosen Tesla T4-GPUs funktionieren ebenfalls! Insgesamt macht Unsloth das Training von Gemma 3n 1,5x schneller, benötigt 50% weniger VRAM und ermöglicht 4x längere Kontextlängen.

Unsere kostenlosen Gemma 3n Colab-Notebooks sind standardmäßig auf Feinabstimmung der Textschichten eingestellt. Wenn Sie auch Vision- oder Audioschichten feinabstimmen möchten, beachten Sie, dass dies viel mehr VRAM erfordert - über die 15 GB hinaus, die das kostenlose Colab oder Kaggle bereitstellt. Sie *können* immer noch alle Schichten feinabstimmen, einschließlich Audio und Vision, und Unsloth ermöglicht es Ihnen auch, nur bestimmte Bereiche feinabzustimmen, z. B. nur Vision. Passen Sie es einfach nach Bedarf an:

```python
model = FastVisionModel.get_peft_model(
    model,
    finetune_vision_layers     = False, # False, wenn Vision-Schichten nicht feinabgestimmt werden
    finetune_language_layers   = True,  # False, wenn Sprach-Schichten nicht feinabgestimmt werden
    finetune_attention_modules = True,  # False, wenn Attention-Schichten nicht feinabgestimmt werden
    finetune_mlp_modules       = True,  # False, wenn MLP-Schichten nicht feinabgestimmt werden
)
```

#### :trophy:Bonus-Inhalte

Wir haben auch gehört, dass ihr euch ein <mark style="background-color:blue;">**Vision-Notebook für Gemma 3 (4B)**</mark> gewünscht habt, also hier ist es:

* Feinabstimmung von Gemma 3 (4B) mit Vision-Unterstützung mithilfe unseres [kostenlosen Colab-Notebook](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma3_\(4B\)-Vision.ipynb)

{% hint style="info" %}
Wenn Sie Kaggle lieben: Google veranstaltet einen Wettbewerb, bei dem das beste mit Gemma 3n und Unsloth feinabgestimmte Modell einen Preis von 10.000 $ gewinnt! [Siehe mehr hier](https://www.kaggle.com/competitions/google-gemma-3n-hackathon).
{% endhint %}

## 🐛 Fehlerbehebungen für Gemma 3n

### :sparkles:GGUF-Probleme & Fixes

Dank Diskussionen von [Michael](https://github.com/mxyng) vom Ollama-Team und auch [Xuan](https://x.com/ngxson) von Hugging Face gab es zwei Probleme, die wir speziell für GGUFs beheben mussten:

1. Der `add_shared_kv_layers` Parameter wurde versehentlich in `float32` kodiert, `was in Ordnung ist, aber das Decodieren auf Ollamas Seite etwas komplizierter macht - eine einfache Änderung zu` uint32 [löst das Problem.](https://github.com/ggml-org/llama.cpp/pull/14450) Pull Request
2. Der `zur Behebung dieses Problems.` per\_layer\_token\_embd
   1. Die Schicht sollte in Q8\_0 Präzision sein. Alles niedrigere funktioniert nicht richtig und führt in der Ollama-Engine zu Fehlern - um Probleme für unsere Community zu reduzieren, haben wir dies in allen Quants auf Q8\_0 gesetzt - leider verwendet dies mehr Speicher. [Als eine](https://huggingface.co/unsloth/gemma-3n-E4B-it-GGUF/discussions/4), [Aktualisierung](https://huggingface.co/WBB2500) erwähnte Matt, dass wir auch Q4\_0, Q4\_1, Q5\_0, Q5\_1 für die Embeddings verwenden können - und wir haben bestätigt, dass es auch in Ollama funktioniert! Das bedeutet erneut, dass die kleineren 2-, 3- und 4-Bit-Quants kleiner in der Größe sind und kein Q8\_0 benötigen!

## :infinity:Unendlichkeiten und NaN-Gradienten und -Aktivierungen

{% columns %}
{% column %}
Gemma 3n hat, genau wie Gemma 3, Probleme auf FP16-GPUs (z. B. Tesla T4s in Colab).

Unsere vorherigen Fixes für Gemma 3 werden [hier diskutiert](https://unsloth.ai/docs/de/modelle/tutorials/gemma-3-how-to-run-and-fine-tune). Für Gemma 3 stellten wir fest, dass Aktivierungen den maximalen Bereich von float16 von **65504.**

**Gemma 3N hat dieses Aktivierungsproblem nicht, aber wir sind dennoch auf Unendlichkeiten gestoßen!**
{% endcolumn %}

{% column %}

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-3f1aa0661c7919f8ad830fcbdf85a074d6a54bdf%2FGemma%203%20activation.webp?alt=media" alt=""><figcaption></figcaption></figure>
{% endcolumn %}
{% endcolumns %}

Um diesen Unendlichkeiten auf den Grund zu gehen, haben wir die absolut größten Gewichtseinträge für Gemma 3N geplottet und folgendes beobachtet:

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-e9b01a20a0a1cfcc41ef47cb29c5188d52d6a79d%2Foutput2.webp?alt=media" alt="" width="563"><figcaption></figcaption></figure>

Wir stellen fest, dass die grünen Kreuze die Conv2D-Faltungsgewichte sind. Wir können sehen, dass die Magnitude der Conv2D-Schichten im Durchschnitt deutlich größer ist.

Nachfolgend eine Tabelle für Conv2D-Gewichte mit großen Magnituden. Unsere Hypothese ist, dass während einer Conv2D-Operation große Gewichte multipliziert und aufsummiert werden und **zufällig den maximalen Bereich von float16 von 65504 überschreiten.** Bfloat16 ist in Ordnung, da sein maximaler Bereich 10^38 ist.

| Name                                   | Max       |
| -------------------------------------- | --------- |
| msfa.ffn.pw\_proj.conv.weight          | 98.000000 |
| blocks.2.21.attn.key.down\_conv.weight | 37.000000 |
| blocks.2.32.pw\_exp.conv.weight        | 34.750000 |
| blocks.2.30.pw\_exp.conv.weight        | 33.750000 |
| blocks.2.34.pw\_exp.conv.weight        | 33.750000 |

### :sparkler:Lösung für Unendlichkeiten

Die naive Lösung ist, alle Conv2D-Gewichte auf float32 `hochzucasten` (falls bfloat16 nicht verfügbar ist). Aber das würde den VRAM-Verbrauch erhöhen. Um dies zu bewältigen, nutzen wir stattdessen `autocast` on-the-fly, um die Gewichte und Eingaben auf float32 hochzucasten, und führen so die Akkumulation in float32 als Teil der Matrixmultiplikation selbst durch, ohne die Gewichte dauerhaft hochzucasten.

{% hint style="success" %}
Unsloth ist das einzige Framework, das Gemma 3n Inferenz und Training auf float16-GPUs ermöglicht, sodass Colab-Notebooks mit kostenlosen Tesla T4s funktionieren!
{% endhint %}

### :checkered\_flag:Probleme mit Gradient Checkpointing

Wir fanden, dass Gemma 3N's Vision-Encoder ebenfalls ziemlich einzigartig ist, da er versteckte Zustände wiederverwendet. Das schränkt leider die Verwendung von [Unsloth's Gradient Checkpointing](https://unsloth.ai/blog/long-context)ein, welches den VRAM-Verbrauch erheblich hätte reduzieren können, da es nicht auf den Vision-Encoder angewendet werden kann.

Wir haben es jedoch trotzdem geschafft, **Unsloth's automatischen Compiler** zu nutzen,

### :cactus:um Gemma 3N zu optimieren!

Hohe Verluste während der Feinabstimmung

1. Wir stellten auch fest, dass die Verluste zu Beginn der Feinabstimmung bemerkenswert hoch sind - im Bereich von 6 bis 7 -, aber sie sinken schnell im Laufe der Zeit. Wir vermuten, dass dies an zwei Möglichkeiten liegen könnte:
2. <mark style="background-color:blue;">**Es könnte ein Implementierungsproblem geben, aber das ist unwahrscheinlich, da die Inferenz zu funktionieren scheint.**</mark> Multimodale Modelle zeigen dieses Verhalten scheinbar immer

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-a37a8ce8ff2cfc3873a9f78acee3744c778692dc%2Foutput(3).png?alt=media" alt="" width="375"><figcaption></figcaption></figure>

{% hint style="success" %}
**Feinabstimmung von Gemma 3n mit unserem** [**kostenlosen Colab-Notebook**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma3N_\(4B\)-Conversational.ipynb)
{% endhint %}

## - wir fanden, dass Llama 3.2 Vision's Verlust bei 3 oder 4 beginnt, Pixtral bei etwa 8, und Qwen 2.5 VL ebenfalls bei \~4. Da Gemma 3N auch Audio einschließt, könnte es den Anfangsverlust verstärken. Aber das ist nur eine Hypothese. Wir fanden auch, dass das Quantisieren von Qwen 2.5 VL 72B Instruct extrem hohe Perplexity-Werte von etwa 30 ergab, aber das Modell funktioniert überraschenderweise gut.

### 🛠️ Technische Analyse

Gemma 3n : MatFormer [Was ist also so besonders an Gemma 3n, fragen Sie? Es basiert auf der](https://arxiv.org/abs/2310.07707) Matryoshka Transformer oder MatFormer

Architektur, was bedeutet, dass jede Transformer-Schicht/-Block FFNs von progressiv kleineren Größen einbettet/verschachtelt. Stellen Sie sich das vor wie progressiv kleinere Becher, die ineinander gesteckt werden. Das Training erfolgt so, dass Sie zur Inferenzzeit die gewünschte Größe wählen können und die beste Leistung der größeren Modelle erhalten.

Es gibt auch Per-Layer-Embedding, das zwischengespeichert werden kann, um den Speicherbedarf bei der Inferenz zu reduzieren. Das 2B-Modell (E2B) ist also ein Subnetzwerk innerhalb des 4B (auch bekannt als 5.44B) Modells, das durch Per-Layer-Embedding-Caching und das Überspringen von Audio- und Vision-Komponenten erreicht wird und sich ausschließlich auf Text konzentriert. `Die MatFormer-Architektur wird typischerweise mit exponentiell gestaffelten Sub-Modellen trainiert, d. h. mit Größen`, `S` S/2, S/4, S/8 `usw. in jeder der Schichten. Während des Trainings werden Eingaben zufällig durch einen der genannten Unterblöcke weitergeleitet, sodass jeder Unterblock die gleiche Chance zum Lernen erhält. Der Vorteil ist, dass Sie zur Inferenzzeit, wenn Sie möchten, dass das Modell 1/4 der ursprünglichen Größe hat,` S/4

große Unterblöcke in jeder Schicht auswählen können. **Sie können auch** Mix and Match `usw. in jeder der Schichten. Während des Trainings werden Eingaben zufällig durch einen der genannten Unterblöcke weitergeleitet, sodass jeder Unterblock die gleiche Chance zum Lernen erhält. Der Vorteil ist, dass Sie zur Inferenzzeit, wenn Sie möchten, dass das Modell 1/4 der ursprünglichen Größe hat,` wählen, `einen Unterblock einer Schicht mit der Größe` S/2 `eines anderen Layers und` S/8

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-0f2e2a7a9d652391166798dec37319252b399f8e%2Fimage.png?alt=media" alt="" width="563"><figcaption><p>eines weiteren Layers auswählen. Tatsächlich können Sie die Untermodelle, die Sie wählen, basierend auf der Eingabe selbst ändern, wenn Sie möchten. Im Grunde ist es so, als würden Sie auf jeder Schicht Ihre eigene Struktur wählen. Durch das Training eines Modells einer bestimmten Größe erstellen Sie exponentiell viele Modelle kleinerer Größen. Kein Lernen geht verloren. Ziemlich clever, oder? <a href="https://ai.google.dev/gemma/docs/gemma-3n">Bild von</a></p></figcaption></figure>

{% hint style="info" %}
**Gemma 3n Modellübersicht** [**kostenlosen Colab-Notebook**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma3N_\(4B\)-Conversational.ipynb)
{% endhint %}