> 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/grundlagen/chat-templates.md).

# Chat-Vorlagen

Lernen Sie die Grundlagen und Anpassungsoptionen von Chat-Vorlagen kennen, einschließlich Conversational-, ChatML-, ShareGPT-, Alpaca-Formaten und mehr!

In unserem GitHub haben wir eine Liste aller Chat-Templates, die Unsloth verwendet, einschließlich für Llama, Mistral, Phi-4 usw. Falls du also Hinweise zur Formatierung oder zum Anwendungsfall brauchst, kannst du sie hier ansehen: [github.com/unslothai/unsloth/blob/main/unsloth/chat\_templates.py](https://github.com/unslothai/unsloth/blob/main/unsloth/chat_templates.py)

#### Liste der Colab-Notebooks für Chat-Templates:

* [Konversationell](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Llama3.2_\(1B_and_3B\)-Conversational.ipynb)
* [ChatML](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Llama3_\(8B\)-Ollama.ipynb)
* [Ollama](https://colab.research.google.com/drive/1WZDi7APtQ9VsvOrQSSC5DDtxq159j8iZ?usp=sharing)
* [Textklassifikation](https://github.com/timothelaborie/text_classification_scripts/blob/main/unsloth_classification.ipynb) von Timotheeee
* [Mehrere Datensätze](https://colab.research.google.com/drive/1njCCbE1YVal9xC83hjdo2hiGItpY_D6t?usp=sharing) von Flail

### Neue Tokens hinzufügen

Unsloth hat eine Funktion namens `add_new_tokens` die es dir ermöglicht, deinem Finetuning neue Tokens hinzuzufügen. Wenn du zum Beispiel hinzufügen möchtest `<CHARACTER_1>`, `<THINKING>` und `<SCRATCH_PAD>` können wir Folgendes tun:

```python
model, tokenizer = FastLanguageModel.from_pretrained(...)
from unsloth import add_new_tokens
add_new_tokens(model, tokenizer, new_tokens = ["<CHARACTER_1>", "<THINKING>", "<SCRATCH_PAD>"])
model = FastLanguageModel.get_peft_model(...)
```

{% hint style="warning" %}
Hinweis - du MUSST immer `add_new_tokens` vor `FastLanguageModel.get_peft_model`!
{% endhint %}

## Gespräche mit mehreren Runden

Ein Problem, falls dir das nicht aufgefallen ist: Der Alpaca-Datensatz ist einstufig, während ChatGPT interaktiv war und du in mehreren Runden mit ihm sprechen kannst. Links ist das, was wir wollen, rechts bietet der Alpaca-Datensatz jedoch nur einzelne Konversationen. Wir wollen, dass das feinabgestimmte Sprachmodell irgendwie lernt, Mehrturnus-Konversationen genau wie ChatGPT zu führen.

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

Daher haben wir `conversation_extension` Parameter eingeführt, der im Wesentlichen einige zufällige Zeilen in deinem einstufigen Datensatz auswählt und sie zu 1 Konversation zusammenführt! Wenn du ihn zum Beispiel auf 3 setzt, wählen wir zufällig 3 Zeilen aus und führen sie zu 1 zusammen! Zu lange Einstellungen können das Training verlangsamen, aber deinen Chatbot und das finale Fine-Tuning deutlich verbessern!

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

Dann setze `output_column_name` zur Vorhersage-/Ausgabespalte. Für das Alpaca-Dataset wäre das die Ausgabespalte.

Dann verwenden wir die `standardize_sharegpt` Funktion, um den Datensatz einfach in das richtige Format für das Fine-Tuning zu bringen! Immer aufrufen!

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-7bf83bf802191bda9e417bbe45afa181e7f24f38%2Fimage.png?alt=media" alt=""><figcaption></figcaption></figure>

## Anpassbare Chat-Templates

Wir können nun die Chat-Vorlage für das Fine-Tuning selbst festlegen. Das sehr bekannte Alpaca-Format ist unten zu sehen:

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-59737e6dcb09fed15487d5a57c69f07cb40bb8e7%2Fimage.png?alt=media" alt=""><figcaption></figcaption></figure>

Aber erinnere dich, dass wir gesagt haben, dies sei eine schlechte Idee, weil Fine-Tunings im ChatGPT-Stil nur 1 Prompt benötigen? Da wir mit Unsloth erfolgreich alle Datensatzspalten zu 1 zusammengeführt haben, können wir im Wesentlichen die untenstehende Chat-Vorlage mit 1 Eingabespalte (Anweisung) und 1 Ausgabe erstellen:

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

Wir verlangen lediglich, dass du ein `{INPUT}` Feld für die Anweisung und ein `{OUTPUT}` Feld für das Ausgabefeld des Modells einfügst. Tatsächlich erlauben wir auch ein optionales `{SYSTEM}` Feld, das nützlich ist, um einen System-Prompt genauso wie in ChatGPT anzupassen. Unten sind zum Beispiel einige coole Beispiele, wie du die Chat-Vorlage gestalten kannst:

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

Für das in OpenAI-Modellen verwendete ChatML-Format:

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-15bfca9cfadf10d54b4d3f66e3050044317d62c5%2Fimage.png?alt=media" alt=""><figcaption></figcaption></figure>

Oder du kannst die Llama-3-Vorlage selbst verwenden (die nur mit der Instruct-Version von Llama-3 funktioniert): Tatsächlich erlauben wir auch ein optionales `{SYSTEM}` Feld, das nützlich ist, um einen System-Prompt genauso wie in ChatGPT anzupassen.

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-80a2ed4de2ca323ac192c513cac65e9e8bf475db%2Fimage.png?alt=media" alt=""><figcaption></figcaption></figure>

Oder bei der Titanic-Vorhersageaufgabe, bei der du in diesem Colab-Notebook vorhersagen musstest, ob ein Passagier gestorben ist oder überlebt hat und das das Hochladen von CSV- und Excel-Dateien enthält: <https://colab.research.google.com/drive/1VYkncZMfGFkeCEgN2IzbZIKEDkyQuJAS?usp=sharing>

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-20911ab305c1a10e85859c703157b80175141eb1%2Fimage.png?alt=media" alt=""><figcaption></figcaption></figure>

## Anwenden von Chat-Templates mit Unsloth

Bei Datensätzen, die normalerweise dem gängigen ChatML-Format folgen, besteht der Prozess der Vorbereitung des Datensatzes für das Training oder Finetuning aus vier einfachen Schritten:

* Prüfe die Chat-Templates, die Unsloth derzeit unterstützt:\\

  ```
  from unsloth.chat_templates import CHAT_TEMPLATES
  print(list(CHAT_TEMPLATES.keys()))
  ```

  \
  Dies gibt die Liste der derzeit von Unsloth unterstützten Templates aus. Hier ist ein Beispiel für die Ausgabe:\\

  ```
  ['unsloth', 'zephyr', 'chatml', 'mistral', 'llama', 'vicuna', 'vicuna_old', 'vicuna old', 'alpaca', 'gemma', 'gemma_chatml', 'gemma2', 'gemma2_chatml', 'llama-3', 'llama3', 'phi-3', 'phi-35', 'phi-3.5', 'llama-3.1', 'llama-31', 'llama-3.2', 'llama-3.3', 'llama-32', 'llama-33', 'qwen-2.5', 'qwen-25', 'qwen25', 'qwen2.5', 'phi-4', 'gemma-3', 'gemma3']
  ```

  \\\\
* Verwenden Sie `get_chat_template` um das richtige Chat-Template auf deinen Tokenizer anzuwenden:\\

  ```
  from unsloth.chat_templates import get_chat_template

  tokenizer = get_chat_template(
      tokenizer,
      chat_template = "gemma-3", # ändere dies in den richtigen chat_template-Namen
  )
  ```

  \\\\
* Definiere deine Formatierungsfunktion. Hier ist ein Beispiel:\\

  ```
  def formatting_prompts_func(examples):
     convos = examples["conversations"]
     texts = [tokenizer.apply_chat_template(convo, tokenize = False, add_generation_prompt = False) for convo in convos]
     return { "text" : texts, }
  ```

  \
  \
  Diese Funktion durchläuft deinen Datensatz und wendet das von dir definierte Chat-Template auf jedes Beispiel an.\\
* Schließlich laden wir den Datensatz und wenden die erforderlichen Änderungen auf unseren Datensatz an: \\

  ```
  # Datensatz importieren und laden
  from datasets import load_dataset
  dataset = load_dataset("repo_name/dataset_name", split = "train")

  # Wende die Formatierungsfunktion mit der map-Methode auf deinen Datensatz an
  dataset = dataset.map(formatting_prompts_func, batched = True,)
  ```

  \
  Wenn dein Datensatz das ShareGPT-Format mit "from"/"value"-Schlüsseln statt des ChatML-Formats "role"/"content" verwendet, kannst du die `standardize_sharegpt` Funktion verwenden, um ihn zuerst zu konvertieren. Der überarbeitete Code sieht dann wie folgt aus:\
  \\

  ```
  # Datensatz importieren
  from datasets import load_dataset
  dataset = load_dataset("mlabonne/FineTome-100k", split = "train")

  # Konvertiere deinen Datensatz bei Bedarf in das "role"/"content"-Format
  from unsloth.chat_templates import standardize_sharegpt
  dataset = standardize_sharegpt(dataset)

  # Wende die Formatierungsfunktion mit der map-Methode auf deinen Datensatz an
  dataset = dataset.map(formatting_prompts_func, batched = True,)
  ```

## Weitere Informationen

Angenommen, dein Datensatz ist eine Liste von Listen von Dictionaries wie unten:

```python
[
    [{'from': 'human', 'value': 'Hallo!'},
     {'from': 'gpt', 'value': 'Hallo, wie kann ich helfen?'},
     {'from': 'human', 'value': 'Was ist 2+2?'}],
    [{'from': 'human', 'value': 'Wie heißt du?'},
     {'from': 'gpt', 'value': 'Ich bin Daniel!'},
     {'from': 'human', 'value': 'Ok! Schön!'},
     {'from': 'gpt', 'value': 'Was kann ich für dich tun?'},
     {'from': 'human', 'value': 'Ach nichts :)'}],
]
```

Sie können unser `get_chat_template` um es zu formatieren. Wähle `chat_template` einen von `zephyr, chatml, mistral, llama, alpaca, vicuna, vicuna_old, unsloth`, und `Zuordnung` um die Dictionary-Werte zuzuordnen `von`, `Wert` usw. `map_eos_token` ermöglicht es dir,  `<|im_end|>` auf EOS zuzuordnen, ohne jegliches Training.

```python
from unsloth.chat_templates import get_chat_template

tokenizer = get_chat_template(
    tokenizer,
    chat_template = "chatml", # Unterstützt zephyr, chatml, mistral, llama, alpaca, vicuna, vicuna_old, unsloth
    mapping = {"role" : "from", "content" : "value", "user" : "human", "assistant" : "gpt"}, # ShareGPT-Stil
    map_eos_token = True, # Ordnet <|im_end|> stattdessen </s> zu
)

def formatting_prompts_func(examples):
    convos = examples["conversations"]
    texts = [tokenizer.apply_chat_template(convo, tokenize = False, add_generation_prompt = False) for convo in convos]
    return { "text" : texts, }
pass

from datasets import load_dataset
dataset = load_dataset("philschmid/guanaco-sharegpt-style", split = "train")
dataset = dataset.map(formatting_prompts_func, batched = True,)
```

Du kannst auch deine eigenen benutzerdefinierten Chat-Templates erstellen! Unser internes Chat-Template, das wir verwenden, ist unten gezeigt. Du musst ein `Tupel` aus `(custom_template, eos_token)` angeben, bei dem das `eos_token` im Template verwendet werden muss.

```python
unsloth_template = \
    "{{ bos_token }}"\
    "{{ 'Du bist ein hilfreicher Assistent für den Nutzer\n' }}"\
    "</div>"\
    "<div data-gb-custom-block data-tag=\"for\">"\
        "<div data-gb-custom-block data-tag=\"if\" data-0='role' data-1='role' data-2='] == ' data-3='user'>"\
            "{{ '>>> Nutzer: ' + message['content'] + '\\n' }}"\
        "<div data-gb-custom-block data-tag=\"elif\" data-0='role' data-1='role' data-2='] == ' data-3='assistant'></div>"\
            "{{ '>>> Assistent: ' + message['content'] + eos_token + '\\n' }}"\
        "</div>"\
    "</div>"\
    "<div data-gb-custom-block data-tag=\"if\">"\
        "{{ '>>> Assistent: ' }}"\
    "</div>"
unsloth_eos_token = "eos_token"

tokenizer = get_chat_template(
    tokenizer,
    chat_template = (unsloth_template, unsloth_eos_token,), # Du musst ein Template und ein EOS-Token angeben
    mapping = {"role" : "from", "content" : "value", "user" : "human", "assistant" : "gpt"}, # ShareGPT-Stil
    map_eos_token = True, # Ordnet <|im_end|> stattdessen </s> zu
)
```


---

# 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/de/grundlagen/chat-templates.md?ask=<question>&goal=<user_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.