> 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

In unserem GitHub haben wir eine Liste jeder Chat-Vorlage, die Unsloth verwendet, einschließlich für Llama, Mistral, Phi-4 usw. Wenn ihr also Hinweise zur Formatierung oder zum Anwendungsfall braucht, könnt ihr 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-Vorlagen:

* [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` mit der ihr neue Tokens zu eurem Finetuning hinzufügen könnt. Wenn ihr zum Beispiel hinzufügen wollt `<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 - ihr MÜSST immer `add_new_tokens` vor `FastLanguageModel.get_peft_model`!
{% endhint %}

## Mehrturn-Konversationen

Ein Problem, falls du es nicht bemerkt hast, ist, dass der Alpaca-Datensatz nur eine einzelne Gesprächsrunde hat, während die Verwendung von ChatGPT interaktiv war und du in mehreren Runden mit ihm sprechen kannst. Zum Beispiel ist links das, was wir wollen, aber rechts, der Alpaca-Datensatz, bietet nur einzelne Gespräche. Wir wollen, dass das feinabgestimmte Sprachmodell irgendwie lernt, wie man mehrrundige Gespräche führt, genau wie ChatGPT.

<figure><img src="/files/2efae6d26a0d21ca860759680cf822bea5693430" alt=""><figcaption></figcaption></figure>

Also haben wir den `conversation_extension` Parameter eingeführt, der im Wesentlichen einige zufällige Zeilen in deinem Ein-Runden-Datensatz auswählt und sie zu 1 Gespräch 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! Wenn du ihn zu lang setzt, kann das Training langsamer machen, aber deinen Chatbot und die finale Feinabstimmung deutlich verbessern!

<figure><img src="/files/ae03a02a6047abaec1bbcfc6b0b65b08ed2998f6" alt=""><figcaption></figcaption></figure>

Dann setze `output_column_name` an die Vorhersage-/Ausgabespalte. Für den Alpaca-Datensatz wäre es die Ausgabespalte.

Dann verwenden wir die `standardize_sharegpt` Funktion, um das Datenset einfach in ein korrektes Format für die Feinabstimmung zu bringen! Immer aufrufen!

<figure><img src="/files/149e3fd52e5659b662d60406b82bf70f929285fa" alt=""><figcaption></figcaption></figure>

## Anpassbare Chat-Vorlagen

Wir können nun die Chat-Vorlage für die Feinabstimmung selbst festlegen. Das sehr berühmte Alpaca-Format ist unten:

<figure><img src="/files/36f49701e7212973776a13f747383559eb04a418" alt=""><figcaption></figcaption></figure>

Aber erinnere dich, wir sagten, das sei eine schlechte Idee, weil ChatGPT-ähnliche Feinabstimmungen nur 1 Prompt erfordern? Da wir mit Unsloth erfolgreich alle Datensatzspalten in 1 zusammengeführt haben, können wir im Wesentlichen die unten stehende Chat-Vorlage mit 1 Eingabespalte (Anweisung) und 1 Ausgabe erstellen:

<figure><img src="/files/f276b92dea2d56161f6c8a8e6dcb228cb9bc2967" 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. Wir erlauben tatsächlich auch ein optionales `{SYSTEM}` Feld, das nützlich ist, um einen System-Prompt ähnlich wie in ChatGPT anzupassen. Unten sind zum Beispiel einige coole Beispiele, wie du die Chat-Vorlage anpassen kannst:

<figure><img src="/files/6194a7bb2a593f34d7f7728154bc48c9b565a34f" alt=""><figcaption></figcaption></figure>

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

<figure><img src="/files/0974379c0dd0e80210540d7027de17591aeabfae" alt=""><figcaption></figcaption></figure>

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

<figure><img src="/files/305c197f681fcb9c389a681830746f491216334d" alt=""><figcaption></figcaption></figure>

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

<figure><img src="/files/b0686f0a6604e5e54d6421734690a5d1fc413ef4" alt=""><figcaption></figcaption></figure>

## Chat-Vorlagen mit Unsloth anwenden

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

* Prüft die Chat-Vorlagen, die Unsloth derzeit unterstützt:\\

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

  \
  Dies gibt die Liste der Vorlagen aus, die derzeit von Unsloth unterstützt werden. Hier ist eine Beispielausgabe:\\

  ```
  ['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 die richtige Chat-Vorlage auf euren Tokenizer anzuwenden:\\

  ```
  from unsloth.chat_templates import get_chat_template

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

  \\
* Definiert eure 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 läuft durch euren Datensatz und wendet die von euch definierte Chat-Vorlage auf jedes Beispiel an.\\
* Lassen wir nun den Datensatz laden und die erforderlichen Änderungen an unserem Datensatz vornehmen: \\

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

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

  \
  Wenn euer Datensatz das ShareGPT-Format mit "from"/"value"-Schlüsseln anstelle des ChatML-Formats "role"/"content" verwendet, könnt ihr die `standardize_sharegpt` Funktion verwenden, um ihn zuerst zu konvertieren. Der überarbeitete Code sieht dann so aus:\
  \\

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

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

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

## Weitere Informationen

Angenommen, euer 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': 'Okay! Schön!'},
     {'from': 'gpt', 'value': 'Was kann ich für dich tun?'},
     {'from': 'human', 'value': 'Ach nichts :)'},],
]
```

Ihr könnt unser `get_chat_template` verwenden, um es zu formatieren. Wählt `chat_template` als eines von `zephyr, chatml, mistral, llama, alpaca, vicuna, vicuna_old, unsloth`, und verwendet `mapping` um die Dictionary-Werte zuzuordnen `from`, `value` usw. `map_eos_token` ermöglicht es euch, `<|im_end|>` ohne jegliches Training auf EOS abzubilden.

```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, # Mappt stattdessen <|im_end|> auf </s>
)

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

Ihr könnt auch eure eigenen benutzerdefinierten Chat-Vorlagen erstellen! Zum Beispiel ist unsere interne Chat-Vorlage, die wir verwenden, unten zu sehen. Ihr müsst ein `Tupel` von `(custom_template, eos_token)` übergeben, wobei das `eos_token` innerhalb der Vorlage verwendet werden muss.

```python
unsloth_template = \
    "{{ bos_token }}"\
    "{{ 'Ihr seid ein hilfreicher Assistent für den Benutzer\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'>"\
            "{{ '>>> Benutzer: ' + 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,), # Ihr müsst eine Vorlage und ein EOS-Token angeben
    mapping = {"role" : "from", "content" : "value", "user" : "human", "assistant" : "gpt"}, # ShareGPT-Stil
    map_eos_token = True, # Mappt stattdessen <|im_end|> auf </s>
)
```


---

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

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