# Hackathon de données synthétiques Unsloth AMD PyTorch
Une fois que vous avez accès à une machine MI300, vous verrez une interface Jupyter Notebook :
**Tout d'abord, mettez à jour Unsloth** et confirmez que tout fonctionne comme prévu - cliquez sur **Terminal**
Ensuite, exécutez ce qui suit dans le **Terminal** pour mettre à jour Unsloth - assurez-vous que la version est **2025.10.5** ou supérieure.
```
pip install --upgrade -qqq --no-cache-dir --force-reinstall --no-deps unsloth unsloth_zoo
python -c "import unsloth; print(unsloth.__version__)"
```
Pour créer un nouveau Notebook ou Terminal, cliquez sur le bouton PLUS
{% hint style="success" %}
**Ouvrez le fichier README.ipynb pour lire les instructions et les critères de notation**
{% endhint %}
### :butterfly:TUTORIEL 1 : Confirmation du bon fonctionnement d'Unsloth
Confirmez que notre simple notebook conversationnel Llama 3.2 1B / 3B s'exécute comme prévu dans un nouveau **Terminal**.
{% code overflow="wrap" %}
```bash
wget "https://raw.githubusercontent.com/unslothai/notebooks/refs/heads/main/python_scripts/Llama3.2_(1B_and_3B)-Conversational.py" -O llama_basic.py
python llama_basic.py
```
{% endcode %}
Vous devriez voir ce qui suit (cela prendra 2 minutes). Si quelque chose casse, essayez d'abord de mettre à jour Unsloth via
{% code overflow="wrap" %}
```bash
pip install --upgrade -qqq --no-cache-dir --force-reinstall --no-deps unsloth unsloth_zoo
python -c "import unsloth; print(unsloth.__version__)"
```
{% endcode %}
### :sloth:TUTORIEL 2 : Exécution de la génération de données synthétiques
{% hint style="success" %}
**Vous pouvez aussi exécuter le tutorial.ipynb qui devrait être sur notre machine immédiatement sans regarder ci-dessous :**
{% endhint %}
Maintenant, essayons l'exemple à et aussi
Tout d'abord, créez un nouveau **Terminal** à nouveau - le bouton PLUS permettra un nouveau **Terminal**.
Exécutez vLLM pour charger Llama 3.3 70B Instruct dans un nouveau **Terminal** (utilisez le bouton PLUS pour un nouveau Terminal)
{% code overflow="wrap" %}
```
vllm serve Unsloth/Llama-3.3-70B-Instruct --port 8001 --max-model-len 48000 --gpu-memory-utilization 0.85
```
{% endcode %}
Vous verrez :
Attendez jusqu'à ce que vous voyiez `INFO: Application startup complete.` puis cliquez sur le bouton PLUS pour ouvrir un nouvel onglet
Installez **synthetic-data-kit** dans un nouveau **Terminal** fenêtre.
```
pip install --upgrade synthetic-data-kit
```
Obtenez `config.yaml` soit depuis , ou ci-dessous :
{% file src="/files/7aa2edb9a2b5789ec3dbfe90bcb3807b1bab91a7" %}
{% code overflow="wrap" %}
```bash
wget https://raw.githubusercontent.com/edamamez/Unsloth-AMD-Fine-Tuning-Synthetic-Data/refs/heads/main/config.yaml -O config.yaml
```
{% endcode %}
Vérifiez si synthetic data kit a fonctionné via. Si vous voyez des erreurs, confirmez que vLLM s'exécute dans la 1ʳᵉ cellule.
{% code overflow="wrap" %}
```bash
synthetic-data-kit -c config.yaml system-check
```
{% endcode %}
Maintenant, récupérez quelques fichiers que nous utiliserons pour le traitement :
{% code overflow="wrap" %}
```bash
# Créez les dépôts où nous utiliserons le PDF et sauvegarderons les exemples dans
mkdir -p logical_reasoning/{sources,data/{input,parsed,generated,curated,final}}
wget -P logical_reasoning/sources/ -q --show-progress "https://www.csus.edu/indiv/d/dowdenb/4/logical-reasoning-archives/logical-reasoning-2017-12-02.pdf" "https://people.cs.umass.edu/~pthomas/solutions/Liar_Truth.pdf"
cp logical_reasoning/sources/* logical_reasoning/data/input/
cp config.yaml logical_reasoning
```
{% endcode %}
Maintenant, ingérons les données et traitons-les :
{% code overflow="wrap" %}
```bash
cd logical_reasoning
synthetic-data-kit ingest ./data/input/ --verbose
```
{% endcode %}
Maintenant, créez soit des Q\&R (paires question & réponse) soit des CoT (paires chaîne de pensée) (cela peut prendre 3 minutes)
{% code overflow="wrap" %}
```bash
synthetic-data-kit -c ../config.yaml create ./data/parsed/ --type qa --num-pairs 15 --verbose
##### OU #####
synthetic-data-kit -c ../config.yaml create ./data/parsed/ --type cot --num-pairs 15 --verbose
```
{% endcode %}
Maintenant, demandons à un LLM de curer les données et d'appeler le LLM comme juge pour supprimer les lignes de données synthétiques moins désirables, puis nous enregistrons la sortie - cela peut prendre 3 minutes
{% code overflow="wrap" %}
```bash
synthetic-data-kit -c ../config.yaml curate ./data/generated/ --threshold 7.0 --verbose
synthetic-data-kit save-as ./data/curated/ --format ft --verbose
```
{% endcode %}
Encore une fois, **ARRÊTEZ le service vLLM pour économiser la VRAM !!! Retournez à l'onglet précédent, et faites CTRL+C 3 fois. Ou voyez** [#how-do-i-free-amd-gpu-memory](#how-do-i-free-amd-gpu-memory "mention")
Maintenant récupérez le notebook que nous allons exécuter à :
{% code overflow="wrap" %}
```bash
wget "https://github.com/unslothai/notebooks/raw/refs/heads/main/nb/Synthetic_Data_Hackathon.ipynb" -O "Synthetic_Data_Hackathon.ipynb"
```
{% endcode %}
{% hint style="info" %}
Si vous obtenez des erreurs Out of Memory, arrêtez votre instance vLLM - voir [#how-do-i-free-amd-gpu-memory](#how-do-i-free-amd-gpu-memory "mention")
{% endhint %}
Cliquez sur le bouton dossier à gauche et ouvrez "Synthetic\_Data\_Hackathon.ipynb" (double-cliquez)
Ensuite, exécutez tout !
Vous verrez au milieu du notebook :
Voir pour plus de détails
### :dolphin:TUTORIEL 3 : GPT-OSS Création automatique de kernels par apprentissage par renforcement
Vous pouvez exécuter ceci en tant que notebook ou via un script Python !
Script Python :
Notebook :
{% code overflow="wrap" %}
```bash
wget "https://raw.githubusercontent.com/unslothai/notebooks/refs/heads/main/nb/gpt_oss_(20B)_GRPO_BF16.ipynb" -O "Auto_Kernels_RL.ipynb"
```
{% endcode %}
Ensuite, comme dans le Tutoriel 2, ouvrez le fichier "Auto\_Kernels\_RL.ipynb", redémarrez et exécutez tout !
Si vous l'exécutez et faites défiler vers le bas, vous verrez le jeu 2048 être exécuté via des stratégies auto-générées par RL :
### :diamonds:TUTORIEL 4 : GPT-OSS Apprentissage par renforcement Jeu 2048
Vous pouvez exécuter ceci en tant que notebook ou via un script Python !
Script Python :
Notebook :
{% code overflow="wrap" %}
```bash
wget "https://github.com/unslothai/notebooks/raw/refs/heads/main/nb/gpt_oss_(20B)_Reinforcement_Learning_2048_Game_BF16.ipynb" -O "RL_2048_Game.ipynb"
```
{% endcode %}
Ensuite, comme pour le Tutoriel 3, ouvrez le fichier "Auto\_Kernels\_RL.ipynb", redémarrez et exécutez tout !
Lorsque vous faites défiler vers le bas, vous verrez l'algorithme RL créer automatiquement des stratégies pour gagner à 2048 !
### :sunflower:Commandes vLLM optimales sur AMD
Pour servir des modèles sur des GPU AMD, veuillez utiliser les commandes suivantes qui amélioreront les performances. Confirmez qu'aiter et flash-attention sont installés ou voyez [#updating-vllm-to-the-latest-on-amd](#updating-vllm-to-the-latest-on-amd "mention")
Pour MI300X, MI325X et GPU Radeon :
```bash
export VLLM_ROCM_USE_AITER=1
# VLLM_USE_AITER_UNIFIED_ATTENTION ne fonctionne que si Flash Attention est installé
export VLLM_USE_AITER_UNIFIED_ATTENTION=0
export VLLM_ROCM_USE_AITER_MHA=0
vllm serve unsloth/gpt-oss-20b \
--no-enable-prefix-caching \
--compilation-config '{"full_cuda_graph": true}'
```
Pour MI355X, faites ce qui suit :
```bash
export VLLM_ROCM_USE_AITER=1
# VLLM_USE_AITER_UNIFIED_ATTENTION ne fonctionne que si Flash Attention est installé
export VLLM_USE_AITER_UNIFIED_ATTENTION=0
export VLLM_ROCM_USE_AITER_MHA=0
export VLLM_USE_AITER_TRITON_FUSED_SPLIT_QKV_ROPE=1
export VLLM_USE_AITER_TRITON_FUSED_ADD_RMSNORM_PAD=1
export TRITON_HIP_PRESHUFFLE_SCALES=1
export VLLM_USE_AITER_TRITON_GEMM=1
vllm serve unsloth/gpt-oss-120b \
--no-enable-prefix-caching \
--compilation-config '{"compile_sizes": [1, 2, 4, 8, 16, 24, 32, 64, 128, 256, 4096, 8192], "full_cuda_graph": true}' \
--block-size 64
```
## :tools:Dépannage et FAQ
### :free:Comment libérer la mémoire GPU AMD ?
Si vous êtes sur une image Docker (comme le hackathon) exécutez ce qui suit dans un nouveau **Terminal** `rocm-smi -d 0 --showpids` si sur une machine locale
```bash
# Lister les PIDs locaux qui ont /dev/kfd ou /dev/dri/render* ouverts
for p in /proc/[0-9]*; do
readlink -f "$p/fd"/* 2>/dev/null | grep -qE '/dev/(kfd|dri/render)' || continue
cmd=$(tr -d '\0' < "$p/cmdline" 2>/dev/null | sed 's/ \+/ /g')
printf "%-8s %s\n" "${p##*/}" "${cmd:-[unknown]}"
done | sort -n
```
Si sur une machine locale, faites simplement `rocm-smi -d 0 --showpids` et exécutez `sudo kill -9 XXXX` où `XXXX` est le PID répertorié pour ce processus spécifique qui utilise le plus de VRAM.
Pour l'image Docker comme dans le hackathon, après avoir exécuté la première cellule, vous pourriez voir quelque chose comme ci-dessous :
Puis recherchez le processus qui utilise la VRAM (comme vLLM), et tapez `sudo kill -9 XXXX` où `XXXX` est le PID répertorié dans la colonne de gauche comme ci-dessous :
Confirmez que toute la mémoire GPU est libérée via `rocm-smi -d 0 --showpids` Par exemple ci-dessous montre 0 d'utilisation mémoire :
Si d'autre part vous voyez ce qui suit, relancez la première cellule Docker pour tuer à nouveau le processus.
### :pencil:torch.OutOfMemoryError: HIP out of memory RuntimeError: Engine process failed to start.
Veuillez consulter [#how-do-i-free-amd-gpu-memory](#how-do-i-free-amd-gpu-memory "mention") pour vérifier si votre GPU utilise la mémoire d'un autre processus et essayez de supprimer ce processus qui utilise la mémoire.
Essayez aussi `amd-smi process --gpu 0` pour lister tous les processus et l'utilisation de la VRAM pour tous les processus utilisant le GPU :
### :arrow\_forward:Aucune plateforme détectée pour vLLM, mise à niveau de vLLM, gpt-oss sur vLLM
Si vous exécutez `vllm serve Unsloth/gpt-oss-20b` vous pourriez utiliser une ancienne version de vLLM. `python -c "import vllm; print(vllm.__version__)"` pour obtenir la version de vLLM.
Dans le docker pré-construit du hackathon, vous obtiendrez `0.7.4` , qui malheureusement ne prend pas en charge les modèles plus récents comme GPT-OSS, cependant, d'autres modèles fonctionnent comme `vllm serve Unsloth/Llama-3.3-70B-Instruct --port 8001 --max-model-len 48000 --gpu-memory-utilization 0.85`
### :cupcake:Mise à jour de vLLM vers la dernière version sur AMD
{% hint style="warning" %}
**GPT-OSS ne peut pas encore s'exécuter dans vLLM après compilation depuis la source - pour l'instant veuillez voir** [**https://rocm.blogs.amd.com/ecosystems-and-partners/openai-day-0/README.html**](https://rocm.blogs.amd.com/ecosystems-and-partners/openai-day-0/README.html) **pour Docker exécutant gpt-oss - le hackathon ne peut malheureusement pas utiliser Docker dans Docker. Vous pourriez obtenir l'erreur :**
{% code overflow="wrap" %}
```
ImportError: cannot import name 'GFX950MXScaleLayout' from 'triton_kernels.tensor_details.layout' (/usr/local/lib/python3.12/dist-packages/triton_kernels/tensor_details/layout.py)
(EngineCore_DP0 pid=44662) Process EngineCore_DP0 :
```
{% endcode %}
{% endhint %}
Pour obtenir la dernière version de vLLM, veuillez voir , exécutez spécifiquement ce qui suit, après avoir fermé tous les processus utilisant le GPU AMD via [#how-do-i-free-amd-gpu-memory](#how-do-i-free-amd-gpu-memory "mention")
{% code overflow="wrap" %}
```bash
# Installer PyTorch
pip uninstall torch -y
pip uninstall pytorch-triton-rocm -y
pip uninstall triton -y
pip install --upgrade torch==2.8.0 pytorch-triton-rocm torchvision torchaudio torchao==0.13.0 xformers --index-url https://download.pytorch.org/whl/rocm6.4
# Installer les kernels Triton OpenAI
pip install git+https://github.com/triton-lang/triton.git@05b2c186c1b6c9a08375389d5efe9cb4c401c075#subdirectory=python/triton_kernels
```
{% endcode %}
L'exécution de ce qui précède produira (rappel : arrêtez d'abord tous les processus utilisant le GPU ! Voir [#how-do-i-free-amd-gpu-memory](#how-do-i-free-amd-gpu-memory "mention"))
(Code réductible OPTIONNEL) Pour construire Flash Attention via (cela prendra 30 minutes à 1 heure) Donc ceci est optionnel si vous ne voulez pas attendre 30 minutes à 1 heure ! Je sauterais généralement ce processus. Développez cette cellule si vous souhaitez installer Flash Attention.
{% code overflow="wrap" %}
```bash
# ********OPTIONNEL********* Vous pourriez devoir attendre 1 heure !!
# ********OPTIONNEL********* Vous pourriez devoir attendre 1 heure !!
git clone https://github.com/Dao-AILab/flash-attention.git
cd flash-attention
git checkout 1a7f4dfa
git submodule update --init
# ********OPTIONNEL********* Vous pourriez devoir attendre 1 heure !!
# ********OPTIONNEL********* Vous pourriez devoir attendre 1 heure !!
ARCH=$(rocminfo | grep -m1 -oE 'gfx[0-9]+[a-z]*')
echo "GPU arch détectée : $ARCH"
GPU_ARCHS="$ARCH" python3 setup.py install
cd ..
# ********OPTIONNEL********* Vous pourriez devoir attendre 1 heure !!
```
{% endcode %}
Vous verrez :
Pour surveiller la progression de Flash-Attention (qui peut être très longue), surveillez la progression \[296/2206].
**(NON OPTIONNEL)** Puis construisez aiter [AI Tensor Engine pour ROCm](https://github.com/ROCm/aiter) (cela prendra 5 minutes)
{% code overflow="wrap" %}
```bash
python3 -m pip uninstall -y aiter
git clone --recursive https://github.com/ROCm/aiter.git
cd aiter
git checkout $AITER_BRANCH_OR_COMMIT
git submodule sync; git submodule update --init --recursive
python3 setup.py develop
cd ..
```
{% endcode %}
**(NON OPTIONNEL)** Ensuite, construisez vLLM :
```bash
pip install --upgrade pip
pip uninstall vllm -y
pip install --upgrade -qqq --no-cache-dir --force-reinstall --no-deps unsloth unsloth_zoo
pip uninstall bitsandbytes -y
pip install "unsloth[amd] @ git+https://github.com/unslothai/unsloth"
# Construire & installer AMD SMI
pip install /opt/rocm/share/amd_smi
# Installer les dépendances
pip install --upgrade numba \
scipy \
huggingface-hub[cli,hf_transfer] \
setuptools_scm
git clone --depth 1 --branch "v0.11.0" https://github.com/vllm-project/vllm.git vllm_build
cd vllm_build
pip install -r requirements/rocm.txt
# Construire vLLM pour MI210/MI250/MI300.
export PYTORCH_ROCM_ARCH="$(rocminfo | grep -m1 -oE 'gfx[0-9]+[a-z]*')"
python3 setup.py develop
cd ..
```
Vous verrez ce qui suit (**veuillez patienter 5 à 10 minutes !**)
Confirmez que vLLM, torch ont été mis à jour via
{% code overflow="wrap" %}
```bash
python -c "import vllm, torch, unsloth; print(vllm.__version__); print(torch.__version__); print(unsloth.__version__);"
vllm
```
{% endcode %}
qui devrait indiquer que vLLM est 0.11.0 ou supérieur, et torch DOIT être 2.8.0 à partir d'octobre 2025. Le type `vllm` pour confirmer que vLLM fonctionne comme prévu.
```
🦥 Unsloth Zoo va maintenant tout patcher pour accélérer l'entraînement !
0.11.0
2.8.0+rocm6.4
2025.10.6
```
### :book:Exécution de unsloth/gpt-oss-20b dans vLLM
{% hint style="warning" %}
**GPT-OSS ne peut pas encore s'exécuter dans vLLM après compilation depuis la source - pour l'instant veuillez voir** [**https://rocm.blogs.amd.com/ecosystems-and-partners/openai-day-0/README.html**](https://rocm.blogs.amd.com/ecosystems-and-partners/openai-day-0/README.html) **pour Docker exécutant gpt-oss - le hackathon ne peut malheureusement pas utiliser Docker dans Docker. Vous pourriez obtenir l'erreur :**
{% code overflow="wrap" %}
```
ImportError: cannot import name 'GFX950MXScaleLayout' from 'triton_kernels.tensor_details.layout' (/usr/local/lib/python3.12/dist-packages/triton_kernels/tensor_details/layout.py)
(EngineCore_DP0 pid=44662) Process EngineCore_DP0 :
```
{% endcode %}
{% endhint %}
Après avoir mis à jour vLLM via [#updating-vllm-to-the-latest-on-amd](#updating-vllm-to-the-latest-on-amd "mention"), vous pouvez exécuter [gpt-oss-20b](https://huggingface.co/unsloth/gpt-oss-20b)! Voir [#optimal-vllm-commands-on-amd](#optimal-vllm-commands-on-amd "mention") pour de meilleures commandes optimales pour exécuter vllm sur GPU AMD (vous pourriez obtenir une inférence plus rapide !)
{% code overflow="wrap" %}
```bash
export VLLM_ROCM_USE_AITER=1
export VLLM_ROCM_USE_AITER_MHA=0
vllm serve unsloth/gpt-oss-20b \
--no-enable-prefix-caching \
--compilation-config '{"full_cuda_graph": true}' \
--port 8001 \
--max-model-len 48000 \
--gpu-memory-utilization 0.85
```
{% endcode %}
### :interrobang:RuntimeError: User specified an unsupported autocast device\_type 'hip'
**Veuillez mettre à jour Unsloth !** Voir ci-dessous [#updating-unsloth](#updating-unsloth "mention")
### :bug:NotImplementedError: Unsloth actuellement ok
### :new:Mise à jour d'Unsloth
**Tout d'abord, mettez à jour Unsloth** et confirmez que tout fonctionne comme prévu - cliquez sur **Terminal**
Ensuite, exécutez ce qui suit dans le **Terminal** pour mettre à jour Unsloth - **assurez-vous que la version est 2025.10.5 ou supérieure.**
```
pip install --upgrade -qqq --no-cache-dir --force-reinstall --no-deps unsloth unsloth_zoo
pip uninstall bitsandbytes -y
pip install "unsloth[amd] @ git+https://github.com/unslothai/unsloth"
python -c "import unsloth; print(unsloth.__version__)"
```
**Vous devez également REDÉMARRER l'environnement d'exécution**
### :interrobang:terminate called after throwing an instance of 'std::logic\_error' what()
Veuillez vérifier que vous êtes sur `torch==2.8.0`. Relancez ce qui suit :
{% code overflow="wrap" %}
```bash
pip install --upgrade torch==2.8.0 pytorch-triton-rocm torchvision torchaudio torchao==0.13.0 xformers --index-url https://download.pytorch.org/whl/rocm6.4
```
{% endcode %}
### :question:System has not been booted, Failed to connect to bus
Vous pourriez voir ce qui suit :
```
root@270fa7fa9157:/jupyter-tutorial/AIAC_129_212_183_103/assets# reboot
Le système n'a pas été démarré avec systemd comme système init (PID 1). Impossible d'opérer.
Failed to connect to bus: Host is down
Impossible de communiquer avec le démon init.
```
Veuillez nous contacter afin que nous puissions redémarrer la machine !
### :bug:Binaire ROCm configuré introuvable - get\_native\_library()
Cela indique que bitsandbytes n'est pas installé correctement comme ci-dessous :
{% code overflow="wrap" %}
```
Traceback (most recent call last):
File "/usr/local/lib/python3.12/dist-packages/bitsandbytes/cextension.py", line 313, in
lib = get_native_library()
^^^^^^^^^^^^^^^^^^^^
File "/usr/local/lib/python3.12/dist-packages/bitsandbytes/cextension.py", line 282, in get_native_library
raise RuntimeError(f"Configured {BNB_BACKEND} binary not found at {cuda_binary_path}")
RuntimeError: Configured ROCm binary not found at /usr/local/lib/python3.12/dist-packages/bitsandbytes/libbitsandbytes_rocm64.so
```
{% endcode %}
Veuillez consulter [#updating-unsloth](#updating-unsloth "mention")pour mettre à jour bitsandbytes et Unsloth !
### :exclamation:NotImplementedError: Cannot copy out of meta tensor; no data!
Ceci signifie que vous êtes à court de mémoire. Voir [#how-do-i-free-amd-gpu-memory](#how-do-i-free-amd-gpu-memory "mention") pour libérer la mémoire GPU.
{% code overflow="wrap" %}
```
--------------------------------------------------------------------------
NotImplementedError Traceback (most recent call last)
Cell In[18], line 8
5 tokenizer.pad_token_id = tokenizer.eos_token_id
7 # Configuration du trainer avec des paramètres compatibles ROCm et une gestion correcte des données
----> 8 trainer = SFTTrainer(
9 model=model,
...
--> 235 lm_head_bad = lm_head_bad.cpu().float().numpy().round(3)
236 from collections import Counter
237 counter = Counter()
NotImplementedError: Cannot copy out of meta tensor; no data!
```
{% endcode %}
### :thought\_balloon:Échec d'importation depuis vllm.\_C avec ModuleNotFoundError("No module named 'vllm.\_C'")
Veuillez réinstaller vLLM. Utilisez `vllm_build` comme dossier dans lequel vous clonez le dépôt et non `vllm`. [#updating-vllm-to-the-latest-on-amd](#updating-vllm-to-the-latest-on-amd "mention")
### :hushed:ModuleNotFoundError: No module named 'vllm'
Veuillez ne pas `rm -rf vllm_build` le dossier que vous avez construit. Ou réinstallez vllm via [#updating-vllm-to-the-latest-on-amd](#updating-vllm-to-the-latest-on-amd "mention")
### :ledger:ipykernel>6.30.1 casse les barres de progression.
Si vous voyez ce qui suit :
{% code overflow="wrap" %}
```
🦥 Unsloth : Va patcher votre ordinateur pour permettre un fine-tuning gratuit 2x plus rapide.
#### Unsloth : `hf_xet==1.1.10` et `ipykernel>6.30.1` cassent les barres de progression. Désactivation pour l'instant dans XET.
#### Unsloth : Pour réactiver les barres de progression, veuillez rétrograder vers `ipykernel==6.30.1` ou attendre une correction à
https://github.com/huggingface/xet-core/issues/526
```
{% endcode %}
Pour l'instant ignorez-le - vous ne verrez simplement pas les barres de progression pour le téléchargement et l'upload des modèles.
### :bug:AssertionError: No MXFP4 MoE backend
Si vous exécutez gpt-oss-20b et voyez ceci pendant vLLM, veuillez réinstaller vLLM via [#updating-vllm-to-the-latest-on-amd](#updating-vllm-to-the-latest-on-amd "mention")
### :head\_bandage:NotImplementedError: Could not run \`aten::empty\_strided\`
Veuillez utiliser `.to("cuda")` et non `.to("hip")` Mettez aussi à jour Unsloth [#updating-unsloth](#updating-unsloth "mention")
### :bug:NotImplementedError: Could not run 'aten::empty.memory\_format'
Veuillez consulter [#updating-unsloth](#updating-unsloth "mention")pour mettre à jour bitsandbytes et Unsloth !
---
# 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/fr/blog/unsloth-amd-pytorch-synthetic-data-hackathon.md?ask=
```
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.