# Chat-Vorlagen

In unserem GitHub haben wir eine Liste aller Chat-Vorlagen, die Unsloth verwendet, einschließlich für Llama, Mistral, Phi-4 usw. Wenn Sie also Hinweise zur Formatierung oder zum Anwendungsfall benötigen, können Sie sie hier einsehen: [github.com/unslothai/unsloth/blob/main/unsloth/chat\_templates.py](https://github.com/unslothai/unsloth/blob/main/unsloth/chat_templates.py)

#### Liste der Colab-Chatvorlagen-Notebooks:

* [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 Token hinzufügen

Unsloth hat eine Funktion namens `add_new_tokens` die es Ihnen ermöglicht, neue Token zu Ihrem Finetuning hinzuzufügen. Zum Beispiel, wenn Sie `<CHARACTER_1>`, `<THINKING>` und `<SCRATCH_PAD>` hinzufügen möchten, 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 - Sie MÜSSEN immer `add_new_tokens` vor `FastLanguageModel.get_peft_model`!
{% endhint %}

## Mehrwertige Gespräche

Ein Problem, falls Sie es nicht bemerkt haben: Der Alpaca-Datensatz ist einstufig, während die Nutzung von ChatGPT interaktiv war und Sie mehrmals mit ihm sprechen können. Zum Beispiel ist links das, was wir wollen, aber rechts liefert der Alpaca-Datensatz nur einzelne Gespräche. Wir möchten, dass das feinabgestimmte Sprachmodell irgendwie lernt, mehrstufige Konversationen genau wie ChatGPT zu führen.

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

Deshalb haben wir den `conversation_extension` Parameter eingeführt, der im Wesentlichen einige zufällige Zeilen in Ihrem einstufigen Datensatz auswählt und sie zu einer Konversation zusammenführt! Wenn Sie ihn zum Beispiel auf 3 setzen, wählen wir zufällig 3 Zeilen aus und fügen sie zu einer zusammen! Zu lange Einstellungen können das Training verlangsamen, aber Ihren Chatbot und das endgültige Finetuning erheblich verbessern!

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

Dann setzen Sie `output_column_name` auf die Vorhersage- / Ausgabespalte. Für den Alpaca-Datensatz wäre es die Ausgabespalte.

Wir verwenden dann die `standardize_sharegpt` Funktion, um den Datensatz einfach in ein korrektes Format für das Finetuning zu bringen! Rufen Sie diese Funktion immer auf!

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

## Anpassbare Chatvorlagen

Wir können nun die Chatvorlage für das Finetuning selbst angeben. Das sehr berühmte Alpaca-Format ist unten:

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

Aber denken Sie daran, wir sagten, dies sei eine schlechte Idee, weil ChatGPT‑Stil-Finetunes nur 1 Eingabeaufforderung erfordern? Da wir erfolgreich alle Datensatzspalten mit Unsloth in eine einzige zusammengeführt haben, können wir im Wesentlichen die unten gezeigte Chatvorlage im Stil mit 1 Eingabespalte (instruction) und 1 Ausgabe erstellen:

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

Wir verlangen nur, dass Sie ein `{INPUT}` Feld für die Anweisung und ein `{OUTPUT}` Feld für das Ausgabeergebnis des Modells einfügen. Tatsächlich erlauben wir optional ein `{SYSTEM}` Feld, das nützlich ist, um eine Systemaufforderung wie in ChatGPT anzupassen. Zum Beispiel sind unten einige coole Beispiele, mit denen Sie die Chatvorlage anpassen können:

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

Für das ChatML-Format, das in OpenAI-Modellen verwendet wird:

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

Oder Sie können die Llama-3-Vorlage selbst verwenden (die nur funktioniert, wenn die Instruct-Version von Llama-3 verwendet wird): Tatsächlich erlauben wir optional ein `{SYSTEM}` Feld, das ebenfalls nützlich ist, um eine Systemaufforderung wie in ChatGPT anzupassen.

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

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

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

## Anwenden von Chat-Vorlagen mit Unsloth

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

* Überprüfen Sie die Chatvorlagen, 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 Vorlagen aus. Hier ein 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 Chatvorlage auf Ihren Tokenizer anzuwenden:\\

  ```
  from unsloth.chat_templates import get_chat_template

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

  \\
* Definieren Sie Ihre Formatierungsfunktion. Hier 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 Ihren Datensatz und wendet die von Ihnen definierte Chatvorlage auf jede Probe an.\\
* Laden wir schließlich den Datensatz und wenden die erforderlichen Änderungen auf unseren Datensatz an: \\

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

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

  \
  Wenn Ihr Datensatz das ShareGPT-Format mit "from"/"value" Schlüsseln anstelle des ChatML "role"/"content" Formats verwendet, können Sie zuerst die `standardize_sharegpt` Funktion verwenden, um ihn 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")

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

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

## Weitere Informationen

Vorausgesetzt, Ihr Datensatz ist eine Liste von Listen von Dictionaries wie unten:

```python
[
    [{'from': 'human', 'value': 'Hi there!'},
     {'from': 'gpt', 'value': 'Hi how can I help?'},
     {'from': 'human', 'value': 'What is 2+2?'}],
    [{'from': 'human', 'value': 'What's your name?'},
     {'from': 'gpt', 'value': 'I'm Daniel!'},
     {'from': 'human', 'value': 'Ok! Nice!'},
     {'from': 'gpt', 'value': 'What can I do for you?'},
     {'from': 'human', 'value': 'Oh nothing :)'},],
]
```

Sie können unser `get_chat_template` verwenden, um es zu formatieren. Wählen Sie `chat_template` aus, um eines von `zephyr, chatml, mistral, llama, alpaca, vicuna, vicuna_old, unsloth`zu sein, und verwenden Sie `mapping` um die Wörterbuchwerte abzubilden `von`, `value` usw. `map_eos_token` ermöglicht es Ihnen, `<|im_end|>` ohne weiteres 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 <|im_end|> stattdessen 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,)
```

Sie können auch Ihre eigenen benutzerdefinierten Chatvorlagen erstellen! Zum Beispiel ist unsere interne Chatvorlage, die wir verwenden, unten. Sie müssen ein `Tupel` aus `(custom_template, eos_token)` übergeben, wobei das `eos_token` im Template verwendet werden muss.

```python
unsloth_template = \
    "{{ bos_token }}"\
    "{{ 'You are a helpful assistant to the user\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'>"\
            "{{ '>>> User: ' + message['content'] + '\n' }}"\
        "<div data-gb-custom-block data-tag="elif" data-0='role' data-1='role' data-2='] == ' data-3='assistant'></div>"\
            "{{ '>>> Assistant: ' + message['content'] + eos_token + '\n' }}"\
        "</div>"\
    "</div>"\
    "<div data-gb-custom-block data-tag="if">"\
        "{{ '>>> Assistant: ' }}"\
    "</div>"
unsloth_eos_token = "eos_token"

tokenizer = get_chat_template(
    tokenizer,
    chat_template = (unsloth_template, unsloth_eos_token,), # Sie müssen eine Vorlage und ein EOS-Token bereitstellen
    mapping = {"role" : "from", "content" : "value", "user" : "human", "assistant" : "gpt"}, # ShareGPT-Stil
    map_eos_token = True, # Mappt <|im_end|> stattdessen auf </s>
)
```


---

# Agent Instructions: 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:

```
GET https://unsloth.ai/docs/de/grundlagen/chat-templates.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.