> 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/loslegen/install/intel.md).

# LLMs auf Intel-GPUs mit Unsloth feinabstimmen

Erfahre, wie du große Sprachmodelle auf Intel-GPUs trainierst und feinabstimmst.

Sie können jetzt LLMs mit Unsloth auf Ihrem lokalen Intel-Gerät feinabstimmen! Lesen Sie unseren Leitfaden, wie Sie genau mit dem Training Ihres eigenen benutzerdefinierten Modells beginnen.

Bevor Sie beginnen, stellen Sie sicher, dass Sie Folgendes haben:

* **Intel-GPU:** Data Center GPU Max Series, Arc Series oder Intel Ultra AIPC
* **Betriebssystem:** Linux (Ubuntu 22.04+ empfohlen) oder Windows 11 (empfohlen)
* **Nur Windows:** Installieren Sie das Intel oneAPI Base Toolkit 2025.2.1 (Version 2025.2.1 auswählen)
* **Intel-Grafiktreiber:** Neuester empfohlener Treiber für Windows/Linux
* **Python:** 3.10+

{% hint style="info" %}
Unsloth Studio auf einer Intel-GPU installieren? Siehe [Intel-GPUs im Installationsleitfaden für Studio](/docs/de/neu/studio/install.md#intel-gpus) wenn der Installer XPU PyTorch selbst auswählt und wie man es festlegt.
{% endhint %}

### Unsloth mit Intel-Unterstützung erstellen

{% stepper %}
{% step %}

#### Neue conda-Umgebung erstellen (optional)

```bash
conda create -n unsloth-xpu python==3.10
conda activate unsloth-xpu
```

{% endstep %}

{% step %}

#### Unsloth installieren

```bash
git clone https://github.com/unslothai/unsloth.git
cd unsloth
pip install .[intel-gpu-torch290]
```

{% hint style="info" %}
Nur unter Linux: Installieren [vLLM](/docs/de/grundlagen/inference-and-deployment/vllm-guide.md) (Optional)\
Sie können auch vLLM für [Inferenz](/docs/de/grundlagen/inference-and-deployment.md) und [RL](/docs/de/loslegen/reinforcement-learning-rl-guide.md). Bitte folgen Sie [der vLLM-Anleitung](https://docs.vllm.ai/en/latest/getting_started/installation/gpu/#intel-xpu).
{% endhint %}
{% endstep %}

{% step %}

#### Überprüfen Sie Ihre Umgebungen

```python
import torch
print(f"PyTorch-Version: {torch.__version__}")
print(f"XPU verfügbar: {torch.xpu.is_available()}")
print(f"XPU-Geräteanzahl: {torch.xpu.device_count()}")
print(f"XPU-Gerätename: {torch.xpu.get_device_name(0)}")
```

{% endstep %}

{% step %}

#### Beginnen Sie mit dem Fine-Tuning.

Sie können direkt unser Unsloth [Notebooks](/docs/de/loslegen/unsloth-notebooks.md) oder sehen Sie sich unsere speziellen [Fine-Tuning](/docs/de/loslegen/fine-tuning-llms-guide.md) oder [Reinforcement Learning](/docs/de/loslegen/reinforcement-learning-rl-guide.md) Anleitungen an.
{% endstep %}
{% endstepper %}

### Nur unter Windows - Laufzeitkonfigurationen

Aktivieren Sie in der Eingabeaufforderung mit Administratorrechten die Unterstützung langer Pfade in der Windows-Registrierung:

```bash
powershell -Command "Set-ItemProperty -Path "HKLM:\\SYSTEM\\CurrentControlSet\\Control\\FileSystem" -Name "LongPathsEnabled" -Value 1
```

Dieser Befehl muss auf einem einzelnen Rechner nur einmal gesetzt werden. Er muss nicht vor jedem Lauf konfiguriert werden. Dann:

1. Laden Sie level-zero-win-sdk-1.20.2.zip von [GitHub](https://github.com/oneapi-src/level-zero/releases/tag/v1.20.2)
2. Entpacken Sie die level-zero-win-sdk-1.20.2.zip
3. In der Eingabeaufforderung, unter der conda-Umgebung unsloth-xpu:

```bash
call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat" -
set ZE_PATH=path\to\the\unzipped\level-zero-win-sdk-1.20.2
```

### Beispiel 1: QLoRA-Fine-Tuning mit SFT

Dieses Beispiel zeigt, wie man ein Qwen3-32B-Modell mit 4-Bit-QLoRA auf einer Intel-GPU feinabstimmt. QLoRA reduziert den Speicherbedarf erheblich und macht es möglich, große Modelle auf Consumer-Hardware feinabzustimmen.

{% code expandable="true" %}

```python
from unsloth import FastLanguageModel, FastModel
from trl import SFTTrainer, SFTConfig
from datasets import load_dataset
max_seq_length = 2048 # Unterstützt intern RoPE Scaling, also wählen Sie irgendeinen Wert!
# LAION-Datensatz abrufen
url = "https://huggingface.co/datasets/laion/OIG/resolve/main/unified_chip2.jsonl"
dataset = load_dataset("json", data_files = {"train" :
url}, split = "train")

# Vorquantisierte 4-Bit-Modelle, die wir für schnelles Herunterladen + keine OOMs unterstützen.
fourbit_models = [
"unsloth/Qwen3-32B-bnb-4bit",
"unsloth/Qwen3-14B-bnb-4bit",
"unsloth/Qwen3-8B-bnb-4bit",
"unsloth/Qwen3-4B-bnb-4bit",
"unsloth/Qwen3-1.7B-bnb-4bit",
"unsloth/Qwen3-0.6B-bnb-4bit",
# "unsloth/Qwen2.5-32B-bnb-4bit",
# "unsloth/Qwen2.5-14B-bnb-4bit",
# "unsloth/Qwen2.5-7B-bnb-4bit",
# "unsloth/Qwen2.5-3B-bnb-4bit",
# "unsloth/Qwen2.5-1.5B-bnb-4bit",
# "unsloth/Qwen2.5-0.5B-bnb-4bit",
# "unsloth/Llama-3.2-3B-bnb-4bit",
# "unsloth/Llama-3.2-1B-bnb-4bit",
# "unsloth/Llama-3.1-8B-bnb-4bit",
# "unsloth/Llama-3.1-70B-bnb-4bit",
# "unsloth/mistral-7b-bnb-4bit",
# "unsloth/Phi-4",
# "unsloth/Phi-3.5-mini-instruct",
# "unsloth/Phi-3-medium-4k-instruct",
# "unsloth/Phi-3-mini-4k-instruct",
# "unsloth/gemma-2-9b-bnb-4bit",
# "unsloth/gemma-2-27b-bnb-4bit",
] # Weitere Modelle unter https://huggingface.co/unsloth

model, tokenizer = FastLanguageModel.from_pretrained(
model_name = "unsloth/Qwen3-32B-bnb-4bit",
max_seq_length = max_seq_length,
load_in_4bit = True,
# token = "hf_...", # Verwenden Sie einen, wenn Sie abgesicherte Modelle wie meta-llama/Llama-2-7b-hf verwenden
)

model = FastLanguageModel.get_peft_model(
model,
r = 16, # Wähle irgendeine Zahl > 0 ! Empfohlen: 8, 16, 32, 64, 128
target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
"gate_proj", "up_proj", "down_proj",
],
lora_alpha = 16,
lora_dropout = 0, # Unterstützt alles, aber = 0 ist optimiert
bias = "none", # Unterstützt beliebige, aber = "none" ist optimiert
use_gradient_checkpointing = "unsloth", # True oder "unsloth" für sehr lange Kontexte
random_state = 3407,
use_rslora = False, # Wir unterstützen rankstabilisiertes LoRA
loftq_config = None, # Und LoftQ
)

trainer = SFTTrainer(
model = model,
tokenizer = tokenizer,
train_dataset = dataset,
dataset_text_field = "text",
max_seq_length = max_seq_length,
dataset_num_proc = 1, # Empfohlen unter Windows
packing = False, # Kann das Training für kurze Sequenzen 5x schneller machen.
args = SFTConfig(
per_device_train_batch_size = 2,
gradient_accumulation_steps = 4,
warmup_steps = 5,
max_steps = 60,
learning_rate = 2e-4,
logging_steps = 1,
optim = "adamw_8bit",
weight_decay = 0.01,
lr_scheduler_type = "linear",
seed = 3407,
dataset_num_proc=1, # Empfohlen unter Windows
),
)

trainer.train()
```

{% endcode %}

### Beispiel 2: Reinforcement Learning GRPO

GRPO ist eine [Reinforcement Learning](/docs/de/loslegen/reinforcement-learning-rl-guide.md) Technik zur Ausrichtung von Sprachmodellen an menschlichen Präferenzen. Dieses Beispiel zeigt, wie man ein Modell darauf trainiert, ein bestimmtes XML-Ausgabeformat mithilfe mehrerer Belohnungsfunktionen zu befolgen.

#### Was ist GRPO?

GRPO verbessert das traditionelle RLHF durch:

* Verwendung einer gruppenbasierten Normalisierung für stabileres Training
* Unterstützung mehrerer Belohnungsfunktionen für die Multi-Ziel-Optimierung
* Speichereffizienter als PPO

{% code expandable="true" %}

```python
from unsloth import FastLanguageModel
import re
from trl import GRPOConfig, GRPOTrainer
from datasets import load_dataset, Dataset

max_seq_length = 1024  # Kann für längere Reasoning-Traces erhöht werden
lora_rank = 32  # Größerer Rang = intelligenter, aber langsamer
max_prompt_length = 256

# Datensatz laden und vorbereiten
SYSTEM_PROMPT = """
Antworten Sie im folgenden Format:
<reasoning>
...
</reasoning>
<answer>
...
</answer>
"""

XML_COT_FORMAT = """\
<reasoning>
{reasoning}
</reasoning>
<answer>
{answer}
</answer>
"""


def extract_xml_answer(text: str) -> str:
    answer = text.split("<answer>")[-1]
    answer = answer.split("</answer>")[0]
    return answer.strip()


def extract_hash_answer(text: str) -> str | None:
    if "####" not in text:
        return None
    return text.split("####")[1].strip()


# mittlere Nachrichten für 1-Shot-Prompting auskommentieren
def get_gsm8k_questions(split: str = "train") -> Dataset:
    data = load_dataset("openai/gsm8k", "main")[split]  # type: ignore
    data = data.map(
        lambda x: {  # type: ignore
            "prompt": [
                {"role": "system", "content": SYSTEM_PROMPT},
                {"role": "user", "content": x["question"]},
            ],
            "answer": extract_hash_answer(x["answer"]),
        }
    )  # type: ignore
    return data  # type: ignore


# Belohnungsfunktionen
def correctness_reward_func(prompts, completions, answer, **kwargs) -> list[float]:
    responses = [completion[0]["content"] for completion in completions]
    q = prompts[0][-1]["content"]
    extracted_responses = [extract_xml_answer(r) for r in responses]
    print(
        "-" * 20,
        f"Frage:\n{q}",
        f"\nAntwort:\n{answer[0]}",
        f"\nAntwort:\n{responses[0]}",
        f"\nExtrahiert:\n{extracted_responses[0]}",
    )
    return [2.0 if r == a else 0.0 for r, a in zip(extracted_responses, answer)]


def int_reward_func(completions, **kwargs) -> list[float]:
    responses = [completion[0]["content"] for completion in completions]
    extracted_responses = [extract_xml_answer(r) for r in responses]
    return [0.5 if r.isdigit() else 0.0 for r in extracted_responses]


def strict_format_reward_func(completions, **kwargs) -> list[float]:
    """Belohnungsfunktion, die prüft, ob die Ausgabe ein bestimmtes Format hat."""
    pattern = r"^<reasoning>\n.*?\n</reasoning>\n<answer>\n.*?\n</answer>\n$"
    responses = [completion[0]["content"] for completion in completions]
    matches = [re.match(pattern, r) for r in responses]
    return [0.5 if match else 0.0 for match in matches]


def soft_format_reward_func(completions, **kwargs) -> list[float]:
    """Belohnungsfunktion, die prüft, ob die Ausgabe ein bestimmtes Format hat."""
    pattern = r"<reasoning>.*?</reasoning>\s*<answer>.*?</answer>"
    responses = [completion[0]["content"] for completion in completions]
    matches = [re.match(pattern, r) for r in responses]
    return [0.5 if match else 0.0 for match in matches]


def count_xml(text: str) -> float:
    count = 0.0
    if text.count("<reasoning>\n") == 1:
        count += 0.125
    if text.count("\n</reasoning>\n") == 1:
        count += 0.125
    if text.count("\n<answer>\n") == 1:
        count += 0.125
    count -= len(text.split("\n</answer>\n")[-1]) * 0.001
    if text.count("\n</answer>") == 1:
        count += 0.125
    count -= (len(text.split("\n</answer>")[-1]) - 1) * 0.001
    return count


def xmlcount_reward_func(completions, **kwargs) -> list[float]:
    contents = [completion[0]["content"] for completion in completions]
    return [count_xml(c) for c in contents]


if __name__ == "__main__":
    model, tokenizer = FastLanguageModel.from_pretrained(
        model_name="unsloth/Qwen3-0.6B",
        max_seq_length=max_seq_length,
        load_in_4bit=False,  # False für LoRA 16-Bit
        fast_inference=False,  # vLLM-Schnellinferenz aktivieren
        max_lora_rank=lora_rank,
        gpu_memory_utilization=0.7,  # Verringern, wenn der Speicher ausgeht
        device_map="xpu:0",
    )

    model = FastLanguageModel.get_peft_model(
        model,
        r=lora_rank,  # Wählen Sie eine beliebige Zahl > 0! Empfohlen: 8, 16, 32, 64, 128
        target_modules=[
            "q_proj",
            "k_proj",
            "v_proj",
            "o_proj",
            "gate_proj",
            "up_proj",
            "down_proj",
        ],  # Entfernen Sie QKVO, wenn der Speicher ausgeht
        lora_alpha=lora_rank,
        use_gradient_checkpointing="unsloth",  # Long-Context-Fine-Tuning aktivieren
        random_state=3407,
    )

    dataset = get_gsm8k_questions()

    training_args = GRPOConfig(
        learning_rate=5e-6,
        adam_beta1=0.9,
        adam_beta2=0.99,
        weight_decay=0.1,
        warmup_ratio=0.1,
        lr_scheduler_type="cosine",
        optim="adamw_torch",
        logging_steps=1,
        per_device_train_batch_size=1,
        gradient_accumulation_steps=1,  # Für reibungsloseres Training auf 4 erhöhen
        num_generations=4,  # Verringern, wenn der Speicher ausgeht
        max_prompt_length=max_prompt_length,
        max_completion_length=max_seq_length - max_prompt_length,
        # num_train_epochs=1,  # Für einen vollständigen Trainingslauf auf 1 setzen
        max_steps=20,
        save_steps=250,
        max_grad_norm=0.1,
        report_to="none",  # Kann Weights & Biases verwenden
        output_dir="outputs",
    )

    trainer = GRPOTrainer(
        model=model,
        processing_class=tokenizer,
        reward_funcs=[
            xmlcount_reward_func,
            soft_format_reward_func,
            strict_format_reward_func,
            int_reward_func,
            correctness_reward_func,
        ],
        args=training_args,
        train_dataset=dataset,
        dataset_num_proc=1,  # Empfohlen unter Windows
    )

    trainer.train()

```

{% endcode %}

## Fehlerbehebung

### Out-of-Memory-Fehler (OOM)

Wenn Ihnen der Speicher ausgeht, probieren Sie diese Lösungen aus:

1. **Batch-Größe reduzieren:** Verringern `per_device_train_batch_size`.
2. **Ein kleineres Modell verwenden:** Beginnen Sie mit einem kleineren Modell, um den Speicherbedarf zu reduzieren.
3. **Sequenzlänge reduzieren:** Verringern `max_seq_length`.
4. **LoRA-Rang reduzieren:** Verwenden Sie `r=8` anstatt `r=16` oder `r=32`.
5. **Für GRPO die Anzahl der Generierungen reduzieren:** Verringern `num_generations`.

### (Nur unter Windows) Intel Ultra AIPC iGPU Shared Memory

Bei Intel Ultra AIPC mit aktuellen GPU-Treibern unter Windows ist der gemeinsam genutzte GPU-Speicher für die integrierte GPU normalerweise standardmäßig auf **57%** des Systemspeichers festgelegt. Für größere Modelle (z. B. **Qwen3-32B**), oder wenn Sie eine längere maximale Sequenzlänge, eine größere Batch-Größe, LoRA-Adapter mit höherem LoRA-Rang usw. verwenden, können Sie während des Fine-Tunings den verfügbaren VRAM erhöhen, indem Sie den Prozentsatz des dem iGPU zugewiesenen Systemspeichers anheben.

Sie können dies anpassen, indem Sie die Registrierung ändern:

* Pfad: `Computer\HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\GraphicsDrivers\MemoryManager`
* Zu ändernder Schlüssel:\
  `SystemPartitionCommitLimitPercentage` (auf einen höheren Prozentsatz setzen)


---

# 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/loslegen/install/intel.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.