> 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/fr/commencer/install/intel.md).
# Fine-tuning de LLM sur GPU Intel avec Unsloth
Découvrez comment entraîner et fine-tuner de grands modèles de langage sur GPU Intel.
Vous pouvez désormais ajuster finement des LLM sur votre appareil Intel local avec Unsloth ! Lisez notre guide qui explique précisément comment commencer à entraîner votre propre modèle personnalisé.
Avant de commencer, assurez-vous d’avoir :
* **GPU Intel :** Série Data Center GPU Max, série Arc, ou Intel Ultra AIPC
* **OS :** Linux (Ubuntu 22.04+ recommandé) ou Windows 11 (recommandé)
* **Windows uniquement :** Installez Intel oneAPI Base Toolkit 2025.2.1 (sélectionnez la version 2025.2.1)
* **Pilote graphique Intel :** Dernier pilote recommandé pour Windows/Linux
* **Python :** 3.10+
{% hint style="info" %}
Vous installez Unsloth Studio sur un GPU Intel ? Voir [GPU Intel dans le guide d’installation de Studio](/docs/fr/nouveau/studio/install.md#intel-gpus) pour savoir quand l’installateur choisit lui-même XPU PyTorch et comment le verrouiller.
{% endhint %}
### Compiler Unsloth avec la prise en charge Intel
{% stepper %}
{% step %}
#### Créer un nouvel environnement conda (facultatif)
```bash
conda create -n unsloth-xpu python==3.10
conda activate unsloth-xpu
```
{% endstep %}
{% step %}
#### Installer Unsloth
```bash
git clone https://github.com/unslothai/unsloth.git
cd unsloth
pip install .[intel-gpu-torch290]
```
{% hint style="info" %}
Linux uniquement : installer [vLLM](/docs/fr/notions-de-base/inference-and-deployment/vllm-guide.md) (Facultatif)\
Vous pouvez également installer vLLM pour [l’inférence](/docs/fr/notions-de-base/inference-and-deployment.md) et [RL](/docs/fr/commencer/reinforcement-learning-rl-guide.md). Veuillez suivre [le guide de vLLM](https://docs.vllm.ai/en/latest/getting_started/installation/gpu/#intel-xpu).
{% endhint %}
{% endstep %}
{% step %}
#### Vérifiez vos environnements
```python
import torch
print(f"Version de PyTorch : {torch.__version__}")
print(f"XPU disponible : {torch.xpu.is_available()}")
print(f"Nombre de périphériques XPU : {torch.xpu.device_count()}")
print(f"Nom du périphérique XPU : {torch.xpu.get_device_name(0)}")
```
{% endstep %}
{% step %}
#### Commencez l’ajustement fin.
Vous pouvez utiliser directement notre Unsloth [notebooks](/docs/fr/commencer/unsloth-notebooks.md) ou consulter nos guides dédiés [d’ajustement fin](/docs/fr/commencer/fine-tuning-llms-guide.md) ou [l’apprentissage par renforcement](/docs/fr/commencer/reinforcement-learning-rl-guide.md) .
{% endstep %}
{% endstepper %}
### Windows uniquement - Configurations d’exécution
Dans l’invite de commandes avec privilèges administrateur, activez la prise en charge des chemins longs dans le registre Windows :
```bash
powershell -Command "Set-ItemProperty -Path "HKLM:\\SYSTEM\\CurrentControlSet\\Control\\FileSystem" -Name "LongPathsEnabled" -Value 1
```
Cette commande n’a besoin d’être définie qu’une seule fois sur une seule machine. Elle n’a pas besoin d’être configurée avant chaque exécution. Ensuite :
1. Téléchargez level-zero-win-sdk-1.20.2.zip depuis [GitHub](https://github.com/oneapi-src/level-zero/releases/tag/v1.20.2)
2. Décompressez le fichier level-zero-win-sdk-1.20.2.zip
3. Dans l’invite de commandes, dans l’environnement conda 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
```
### Exemple 1 : ajustement fin QLoRA avec SFT
Cet exemple montre comment ajuster finement un modèle Qwen3-32B en utilisant QLoRA 4 bits sur un GPU Intel. QLoRA réduit considérablement les besoins en mémoire, ce qui rend possible l’ajustement fin de grands modèles sur du matériel grand public.
{% code expandable="true" %}
```python
from unsloth import FastLanguageModel, FastModel
from trl import SFTTrainer, SFTConfig
from datasets import load_dataset
max_seq_length = 2048 # Prend en charge le RoPE Scaling en interne, donc choisissez n’importe quelle valeur !
# Obtenir le jeu de données LAION
url = "https://huggingface.co/datasets/laion/OIG/resolve/main/unified_chip2.jsonl"
dataset = load_dataset("json", data_files = {"train" :
url}, split = "train")
# Modèles pré-quantifiés en 4 bits que nous prenons en charge pour un téléchargement rapide et sans OOM.
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",
] # Plus de modèles sur 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_...", # utilisez-en un si vous utilisez des modèles protégés comme meta-llama/Llama-2-7b-hf
)
model = FastLanguageModel.get_peft_model(
model,
r = 16, # Choisissez n’importe quel nombre > 0 ! Suggestion : 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, # Prend en charge n’importe quelle valeur, mais = 0 est optimisé
bias = "none", # Prend en charge n’importe quelle valeur, mais = "none" est optimisé
use_gradient_checkpointing = "unsloth", # True ou "unsloth" pour un contexte très long
random_state = 3407,
use_rslora = False, # Nous prenons en charge le LoRA à rang stabilisé
loftq_config = None, # Et LoftQ
)
trainer = SFTTrainer(
model = model,
tokenizer = tokenizer,
train_dataset = dataset,
dataset_text_field = "text",
max_seq_length = max_seq_length,
dataset_num_proc = 1, # Recommandé sous Windows
packing = False, # Peut rendre l’entraînement 5x plus rapide pour les séquences courtes.
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, # Recommandé sous Windows
),
)
trainer.train()
```
{% endcode %}
### Exemple 2 : apprentissage par renforcement GRPO
GRPO est une [l’apprentissage par renforcement](/docs/fr/commencer/reinforcement-learning-rl-guide.md) technique permettant d’aligner les modèles de langage avec les préférences humaines. Cet exemple montre comment entraîner un modèle à suivre un format de sortie XML spécifique à l’aide de plusieurs fonctions de récompense.
#### Qu’est-ce que GRPO ?
GRPO améliore le RLHF traditionnel en :
* Utilisant une normalisation par groupes pour un entraînement plus stable
* Prenant en charge plusieurs fonctions de récompense pour une optimisation multi-objectifs
* Étant plus économe en mémoire que 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 # Peut être augmenté pour des traces de raisonnement plus longues
lora_rank = 32 # Rang plus élevé = plus intelligent, mais plus lent
max_prompt_length = 256
# Charger et préparer le jeu de données
SYSTEM_PROMPT = """
Répondez dans le format suivant :
...
...
"""
XML_COT_FORMAT = """\
{reasoning}
{answer}
"""
def extract_xml_answer(text: str) -> str:
answer = text.split("")[-1]
answer = answer.split("")[0]
return answer.strip()
def extract_hash_answer(text: str) -> str | None:
if "####" not in text:
return None
return text.split("####")[1].strip()
# décommentez les messages intermédiaires pour un prompting en 1 tir
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
# Fonctions de récompense
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"Question :\n{q}",
f"\nRéponse :\n{answer[0]}",
f"\nRéponse générée :\n{responses[0]}",
f"\nExtrait :\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]:
"""Fonction de récompense qui vérifie si la complétion a un format spécifique."""
pattern = r"^\n.*?\n\n\n.*?\n\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]:
"""Fonction de récompense qui vérifie si la complétion a un format spécifique."""
pattern = r".*?\s*.*?"
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("\n") == 1:
count += 0.125
if text.count("\n\n") == 1:
count += 0.125
if text.count("\n\n") == 1:
count += 0.125
count -= len(text.split("\n\n")[-1]) * 0.001
if text.count("\n") == 1:
count += 0.125
count -= (len(text.split("\n")[-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 pour LoRA 16 bits
fast_inference=False, # Activer l’inférence rapide vLLM
max_lora_rank=lora_rank,
gpu_memory_utilization=0.7, # Réduisez si la mémoire est insuffisante
device_map="xpu:0",
)
model = FastLanguageModel.get_peft_model(
model,
r=lora_rank, # Choisissez n’importe quel nombre > 0 ! Suggestions : 8, 16, 32, 64, 128
target_modules=[
"q_proj",
"k_proj",
"v_proj",
"o_proj",
"gate_proj",
"up_proj",
"down_proj",
], # Supprimez QKVO en cas de manque de mémoire
lora_alpha=lora_rank,
use_gradient_checkpointing="unsloth", # Activer l’ajustement fin sur long contexte
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, # Augmentez à 4 pour un entraînement plus fluide
num_generations=4, # Réduisez en cas de manque de mémoire
max_prompt_length=max_prompt_length,
max_completion_length=max_seq_length - max_prompt_length,
# num_train_epochs=1, # Définissez à 1 pour un entraînement complet
max_steps=20,
save_steps=250,
max_grad_norm=0.1,
report_to="none", # Peut utiliser Weights & Biases
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, # Recommandé sous Windows
)
trainer.train()
```
{% endcode %}
## Dépannage
### Erreurs de mémoire insuffisante (OOM)
Si vous manquez de mémoire, essayez ces solutions :
1. **Réduire la taille du lot :** Réduire `per_device_train_batch_size`.
2. **Utiliser un modèle plus petit :** Commencez avec un modèle plus petit pour réduire les besoins en mémoire.
3. **Réduire la longueur de séquence :** Réduire `max_seq_length`.
4. **Réduire le rang LoRA :** Utilisez `r=8` au lieu de `r=16` ou `r=32`.
5. **Pour GRPO, réduisez le nombre de générations :** Réduire `num_generations`.
### (Windows uniquement) Mémoire partagée iGPU Intel Ultra AIPC
Pour Intel Ultra AIPC avec des pilotes graphiques récents sous Windows, la mémoire GPU partagée pour le GPU intégré est généralement définie par défaut sur **57%** de la mémoire système. Pour des modèles plus grands (par exemple, **Qwen3-32B**), ou lors de l’utilisation d’une longueur de séquence maximale plus grande, d’une taille de lot plus importante, d’adaptateurs LoRA avec un rang LoRA plus élevé, etc., pendant l’ajustement fin, vous pouvez augmenter la VRAM disponible en augmentant le pourcentage de mémoire système alloué à l’iGPU.
Vous pouvez ajuster cela en modifiant le registre :
* Chemin : `Computer\HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\GraphicsDrivers\MemoryManager`
* Clé à modifier :\
`SystemPartitionCommitLimitPercentage` (définir sur un pourcentage plus élevé)
---
# 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/fr/commencer/install/intel.md?ask=&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.