> 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/notions-de-base/inference-and-deployment/deploy-llms-phone.md).
# Comment exécuter et déployer des LLM sur votre iPhone ou téléphone Android
Tutoriel pour fine-tuner votre propre LLM et le déployer sur votre Android ou iPhone avec ExecuTorch.
Nous sommes ravis de montrer comment vous pouvez entraîner des LLM puis **les déployer localement** à **Téléphones Android** et **iPhones**. Nous avons collaboré avec [ExecuTorch](https://github.com/pytorch/executorch/) de PyTorch et Meta pour créer un flux de travail simplifié utilisant l’entraînement tenant compte de la quantification ([QAT](/docs/fr/blog/quantization-aware-training-qat.md)) puis les déployer directement sur des appareils en périphérie. Avec [Unsloth](https://github.com/unslothai/unsloth), TorchAO et ExecuTorch, nous montrons comment vous pouvez :
* Utiliser la même technologie (ExecuTorch) que Meta emploie pour alimenter des milliards d’utilisateurs sur Instagram, WhatsApp
* Déployer Qwen3-0.6B localement sur **Pixel 8** et **un iPhone 15 Pro à \~40 tokens/s**
* Appliquer QAT via TorchAO pour récupérer 70 % de la précision
* Obtenez la confidentialité d'abord, des réponses instantanées et des capacités hors ligne
* Utilisez notre [notebook Colab gratuit](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_\(0_6B\)-Phone_Deployment.ipynb) pour affiner Qwen3 0.6B et l’exporter pour le déploiement sur téléphone
Tutoriel iOSTutoriel Android
{% columns %}
{% column %}
**Qwen3-4B** déployé sur un iPhone 15 Pro
{% endcolumn %}
{% endcolumns %}
### 🦥 Entraîner votre modèle
Nous prenons en charge Qwen3, Gemma3, Llama3, Qwen2.5, Phi4 et bien d’autres modèles pour le déploiement sur téléphone ! Suivez le [**notebook Colab gratuit**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_\(0_6B\)-Phone_Deployment.ipynb) **pour le déploiement de Qwen3-0.6B :**
{% embed url="" %}
Commencez par mettre à jour Unsloth et installer TorchAO et Executorch.
```bash
pip install --upgrade unsloth unsloth_zoo
pip install torchao==0.14.0 executorch pytorch_tokenizers
```
Ensuite, utilisez simplement `qat_scheme = "phone-deployment"` pour indiquer que nous voulons le déployer sur un téléphone. Notez que nous définissons aussi `full_finetuning = True` pour un finetuning complet !
```python
from unsloth import FastLanguageModel
import torch
model, tokenizer = FastLanguageModel.from_pretrained(
model_name = "unsloth/Qwen3-0.6B",
max_seq_length = 1024,
full_finetuning = True,
qat_scheme = "phone-deployment", # Indicateur de déploiement sur téléphone
)
```
Nous utilisons `qat_scheme = "phone-deployment"` nous utilisons en fait `qat_scheme = "int8-int4"` en interne pour activer le QAT Unsloth/TorchAO qui *simule* une quantification dynamique des activations en INT8 avec une quantification des poids en INT4 pour les couches linéaires pendant l’entraînement (via des opérations de fausse quantification) tout en conservant les calculs en 16 bits. Après l’entraînement, le modèle est converti en une véritable version quantifiée afin que le modèle sur l’appareil soit plus petit et généralement **conserve mieux la précision qu’un PTQ naïf**.
Après l’affinage comme décrit dans le [notebook Colab](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_\(0_6B\)-Phone_Deployment.ipynb), nous l’enregistrons ensuite dans un fichier `.pte` via Executorch :
{% code expandable="true" %}
```bash
# Convertir les clés du state dict du checkpoint des poids vers le format attendu par ExecuTorch
python -m executorch.examples.models.qwen3.convert_weights "phone_model" pytorch_model_converted.bin
# Télécharger la configuration du modèle depuis le dépôt ExecuTorch
curl -L -o 0.6B_config.json https://raw.githubusercontent.com/pytorch/executorch/main/examples/models/qwen3/config/0_6b_config.json
# Exporter vers le fichier pte ExecuTorch
python -m executorch.examples.models.llama.export_llama \
--model "qwen3_0_6b" \
--checkpoint pytorch_model_converted.bin \
--params 0.6B_config.json \
--output_name qwen3_0.6B_model.pte \
-kv --use_sdpa_with_kv_cache -X --xnnpack-extended-ops \
--max_context_length 1024 --max_seq_length 128 --dtype fp32 \
--metadata '{"get_bos_id":199999, "get_eos_ids":[200020,199999]}'
```
{% endcode %}
### 🏁 Déploiement après l’entraînement
Et maintenant, avec votre `qwen3_0.6B_model.pte` fichier d’environ 472 Mo, nous pouvons le déployer ! Choisissez votre appareil et lancez-vous directement :
* [#ios-deployment](#ios-deployment "mention") – voie Xcode, simulateur ou appareil
* [#android-deployment](#android-deployment "mention") – voie ligne de commande, sans Unsloth requis
## :apple: Déploiement iOS
Tutoriel pour faire fonctionner votre modèle sur iOS (testé sur un iPhone 16 Pro, mais fonctionnera aussi sur d’autres iPhones). Vous aurez besoin d’un appareil physique basé sur macOS capable d’exécuter XCode 15.
### Configuration de l’environnement de développement macOS
**Installer Xcode et les outils en ligne de commande**
1. Installez Xcode depuis le Mac App Store (doit être la version 15 ou ultérieure)
2. Ouvrez le Terminal et vérifiez votre installation : `xcode-select -p`
3. Installez les outils en ligne de commande et acceptez la licence :
1. `xcode-select --install`
2. `sudo xcodebuild -license accept`
4. Lancez Xcode pour la première fois et installez les composants supplémentaires lorsqu’on vous le demande
5. Si l’on vous demande de sélectionner des plateformes, choisissez iOS 18 et téléchargez-le pour l’accès au simulateur
{% hint style="warning" %}
Important : le premier lancement d’Xcode est crucial ! Ne sautez pas ces installations de composants supplémentaires ! Consultez [ici](https://developer.apple.com/documentation/xcode/downloading-and-installing-additional-xcode-components) et [ici](https://developer.apple.com/documentation/safari-developer-tools/adding-additional-simulators) pour une aide supplémentaire.
{% endhint %}
**Vérifiez que tout fonctionne :** `xcode-select -p`
Vous devriez voir un chemin affiché. Sinon, répétez l’étape 3.
### Configuration du compte Apple Developer
**Pour les appareils physiques uniquement !**
{% hint style="info" %}
Ignorez toute cette section si vous utilisez uniquement le simulateur iOS. Vous n’avez besoin d’un compte développeur payant que pour le déploiement sur un iPhone physique.
{% endhint %}
{% columns %}
{% column %}
**Créez votre identifiant Apple**
Vous n’avez pas d’identifiant Apple ?[ Inscrivez-vous ici](https://support.apple.com/en-us/108647?device-type=iphone).
#### **Ajoutez votre compte à Xcode**
1. Ouvrez Xcode
2. Allez dans Xcode → Réglages → Comptes
3. Cliquez sur le bouton + et sélectionnez Apple ID
4. Connectez-vous avec votre identifiant Apple habituel
{% endcolumn %}
{% column %}
{% endcolumn %}
{% endcolumns %}
#### **Inscrivez-vous au programme Apple Developer**
ExecuTorch nécessite la `capacité d’augmentation de la limite mémoire`, qui nécessite un compte développeur payant :
1. Visitez[ developer.apple.com](https://developer.apple.com)
2. Connectez-vous avec votre identifiant Apple
3. Inscrivez-vous au programme Apple Developer
### Configurer l’application de démonstration ExecuTorch
**Récupérez le code d’exemple :**
```bash
# Téléchargez directement l’application d’exemple LLM
curl -L https://github.com/meta-pytorch/executorch-examples/archive/main.tar.gz | \
tar -xz --strip-components=2 executorch-examples-main/llm/apple
```
{% columns %}
{% column %}
**Ouvrir dans Xcode**
1. Ouvrez `apple/etLLM.xcodeproj` dans Xcode
2. Dans la barre d’outils supérieure, sélectionnez `iPhone 16 Pro` Simulateur comme appareil cible
3. Appuyez sur Lecture (▶️) pour compiler et exécuter
🎉 Succès ! L’application devrait maintenant se lancer dans le simulateur. Elle ne fonctionnera pas encore, nous devons ajouter votre modèle.
{% endcolumn %}
{% column %}
{% endcolumn %}
{% endcolumns %}
### Déploiement sur le simulateur
**Aucun compte développeur n’est nécessaire.**
**Préparez vos fichiers de modèle**
1. Arrêtez le simulateur dans Xcode (appuyez sur le bouton d’arrêt)
2. Allez dans le dépôt de votre Hub HuggingFace (si ce n’est pas enregistré localement)
3. Téléchargez ces deux fichiers :
1. `qwen3_0.6B_model.pte` (votre modèle exporté)
2. tokenizer.json (le tokenizer)
**Créez un dossier partagé sur le simulateur**
1. Cliquez sur le bouton virtuel Accueil sur le simulateur
2. Ouvrez l’application Fichiers → Parcourir → Sur mon iPhone
3. Appuyez sur le bouton avec les points de suspension (•••) et créez un nouveau dossier nommé `Qwen3test`
**Transférer des fichiers via le terminal**
```bash
# Trouver le dossier caché du simulateur
find ~/Library/Developer/CoreSimulator/Devices/ -type d -iname "*Qwen3test*"
```
Quand vous voyez le dossier, exécutez ce qui suit :
```bash
cp tokenizer.json /path/to/Qwen3test/tokenizer.json
cp qwen3_0.6B_model.pte /path/to/Qwen3test/qwen3_model.pte
```
**Charger et discuter**
{% columns %}
{% column %}
1. Retournez à l’application etLLM dans le simulateur. Touchez-la pour la lancer.
{% endcolumn %}
{% column %}
2\. Chargez le modèle et le tokenizer depuis le dossier Qwen3test
{% endcolumn %}
{% column %}
3\. Commencez à discuter avec votre modèle affiné ! 🎉
{% endcolumn %}
{% endcolumns %}
### Déploiement sur votre iPhone physique
**Configuration initiale de l’appareil**
1. Connectez votre iPhone à votre Mac via USB
2. Déverrouillez votre iPhone et touchez « Faire confiance à cet appareil »
3. Dans Xcode, allez dans Fenêtre → Appareils et simulateurs
4. Attendez que votre appareil apparaisse à gauche (il peut afficher « Préparation » pendant un moment)
**Configurer la signature Xcode**
{% columns %}
{% column %}
1. Ajoutez votre compte Apple : Xcode → Réglages → Comptes → `+`
2. Dans le navigateur de projet, cliquez sur le projet etLLM (icône bleue)
3. Sélectionnez etLLM sous TARGETS
4. Allez dans l’onglet Signing & Capabilities
5. Cochez « Automatically manage signing »
6. Sélectionnez votre équipe dans le menu déroulant
{% endcolumn %}
{% column %}
{% endcolumn %}
{% endcolumns %}
{% hint style="warning" %}
Changez l’identifiant du bundle pour un identifiant unique (par ex. : com.votrenom.etLLM). Cela corrige 99 % des erreurs de profil de provisionnement
{% endhint %}
**Ajoutez la capacité requise**
1. Toujours dans Signing & Capabilities, cliquez sur + Capability
2. Recherchez « Increased Memory Limit » et ajoutez-le
**Compiler et exécuter**
1. Dans la barre d’outils supérieure, sélectionnez votre iPhone physique dans le sélecteur d’appareil
2. Appuyez sur Lecture (▶️) ou sur Cmd + R
**Faire confiance au certificat du développeur**
Votre première compilation échouera — c’est normal !
1. Sur votre iPhone, allez dans Réglages → Confidentialité et sécurité → Mode développeur
2. Activez
3. Acceptez et confirmez les notifications
4. Redémarrez l’appareil, retournez dans Xcode et appuyez à nouveau sur Lecture
{% hint style="warning" %}
Le mode développeur permet à XCode d’exécuter et d’installer des apps sur votre iPhone
{% endhint %}
**Transférer les fichiers du modèle vers votre iPhone**
1. Une fois l’application en cours d’exécution, ouvrez le Finder sur votre Mac
2. Sélectionnez votre iPhone dans la barre latérale
3. Cliquez sur l’onglet Fichiers
4. Développez etLLM
5. Glissez-déposez vos fichiers .pte et tokenizer.json directement dans ce dossier
6. Soyez patient ! Ces fichiers sont volumineux et peuvent prendre quelques minutes
**Charger et discuter**
{% columns %}
{% column %}
1. Sur votre iPhone, revenez à l’application etLLM
2. Chargez le modèle et le tokenizer depuis l’interface de l’application
{% endcolumn %}
{% column %}
3\. Votre Qwen3 affiné fonctionne maintenant nativement sur votre iPhone !
{% endcolumn %}
{% endcolumns %}
## :android: Déploiement Android
Ce guide explique comment construire et installer l’application de démonstration ExecuTorch Llama sur un appareil Android (testé avec un Pixel 8, mais fonctionnera aussi sur d’autres téléphones Android) à l’aide d’un environnement en ligne de commande Linux/Mac. Cette approche minimise les dépendances (aucun Android Studio requis) et décharge le processus de compilation lourd sur votre ordinateur.
### Exigences
Assurez-vous que votre machine de développement a les éléments suivants installés :
* Java 17 (Java 21 est souvent la valeur par défaut mais peut causer des problèmes de compilation)
* Git
* Wget / Curl
* Outils en ligne de commande Android
* [Guide d’installation](https://www.xda-developers.com/install-adb-windows-macos-linux/) et configuration `adb` sur votre Android et votre ordinateur
#### Vérification
Vérifiez que votre version de Java correspond à 17.x :
```bash
# La sortie devrait ressembler à : openjdk version "17.0.x"
java -version
```
Si ce n’est pas le cas, installez-la via Ubuntu/Debian :
```bash
sudo apt install openjdk-17-jdk
```
Puis définissez-la comme valeur par défaut ou exportez `JAVA_HOME`:
```bash
export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64
export PATH=$JAVA_HOME/bin:$PATH
```
Si vous êtes sur un autre OS ou une autre distribution, vous pouvez vouloir suivre [ce guide](https://docs.oracle.com/en/java/javase/25/install/overview-jdk-installation.html) ou simplement demander à votre LLM préféré de vous guider.
### Étape 1 : installer Android SDK et NDK
Configurez un environnement Android SDK minimal sans le plein Android Studio.
1\. Créez le répertoire SDK :
```bash
mkdir -p ~/android-sdk/cmdline-tools
cd ~/android-sdk
```
2. Installer les outils en ligne de commande Android
```bash
wget https://dl.google.com/android/repository/commandlinetools-linux-11076708_latest.zip
unzip commandlinetools-linux-*.zip -d cmdline-tools
# Important : réorganisez pour respecter la structure du SDK
mv cmdline-tools/cmdline-tools cmdline-tools/latest
```
### Étape 2 : configurer les variables d’environnement
Ajoutez ceci à votre `~/.bashrc` ou `~/.zshrc`:
```bash
export ANDROID_HOME=$HOME/android-sdk
export PATH=$ANDROID_HOME/cmdline-tools/latest/bin:$PATH
export PATH=$ANDROID_HOME/platform-tools:$PATH
```
Rechargez-les :
```bash
source ~/.zshrc # ou ~/.bashrc selon votre shell
```
### Étape 3 : installer les composants SDK
ExecuTorch nécessite des versions NDK spécifiques.
```bash
# Accepter les licences
yes | sdkmanager --licenses
# Installer API 34 et NDK 25
sdkmanager "platforms;android-34" "platform-tools" "build-tools;34.0.0" "ndk;25.0.8775105"
```
Définissez la variable NDK :
```bash
export ANDROID_NDK=$ANDROID_HOME/ndk/25.0.8775105
```
### Étape 4 : obtenir le code
Nous utilisons le `dépôt executorch-examples` qui contient la démo Llama mise à jour.
```bash
cd ~
git clone https://github.com/meta-pytorch/executorch-examples.git
cd executorch-examples
```
### Étape 5 : corriger les problèmes de compilation courants
Notez que le code actuel n’a pas ces problèmes, mais nous les avons déjà rencontrés et cela pourrait vous aider :
**Corriger « SDK Location not found » :**
Créez un `fichier local.properties` pour indiquer explicitement à Gradle où se trouve le SDK :
```bash
echo "sdk.dir=$HOME/android-sdk" > llm/android/LlamaDemo/local.properties
```
**Corriger `cannot find symbol` erreur :**
Le code actuel utilise une méthode obsolète `getDetailedError()`. Corrigez-la avec cette commande :
```bash
sed -i 's/e.getDetailedError()/e.getMessage()/g' llm/android/LlamaDemo/app/src/main/java/com/example/executorchllamademo/MainActivity.java
```
### Étape 6 : compiler l’APK
Cette étape compile l’application et les bibliothèques natives.
1. Accédez au projet Android :
```bash
cd llm/android/LlamaDemo
```
2. Compilez avec Gradle (définissez explicitement `JAVA_HOME` sur 17 pour éviter les erreurs de toolchain) :
Remarque : la première exécution prendra quelques minutes.
```bash
export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64
./gradlew :app:assembleDebug
```
3. L’apk final généré se trouve à :
```
app/build/outputs/apk/debug/app-debug.apk
```
### Étape 7 : installer sur votre appareil Android
Vous avez deux options pour installer l’application.
#### Option A : utiliser ADB (avec fil/sans fil)
Si vous avez `adb` accès à votre téléphone :
```bash
adb install -r app/build/outputs/apk/debug/app-debug.apk
```
#### Option B : transfert direct de fichier
Si vous êtes sur une VM distante ou n’avez pas de câble :
1. Téléversez app-debug.apk à un endroit d’où vous pourrez le télécharger sur le téléphone
2. Téléchargez-le sur votre téléphone
3. Touchez pour installer (activez « Installer à partir de sources inconnues » si demandé).
### Étape 8 : transférer les fichiers du modèle
L’application a besoin des fichiers .pte du modèle et du tokenizer.
1. Transférer les fichiers : déplacez votre model.pte et tokenizer.bin (ou tokenizer.model) vers le stockage de votre téléphone (par ex. : dossier Téléchargements).
2. Ouvrez l’application LlamaDemo : lancez l’application sur votre téléphone.
3. Sélectionner un modèle
4. Touchez Réglages (icône d’engrenage) ou le sélecteur de fichiers.
5. Accédez à votre dossier Téléchargements.
6. Sélectionnez votre fichier .pte.
7. Sélectionnez votre fichier tokenizer.
C’est terminé ! Vous pouvez maintenant discuter avec le LLM directement sur votre appareil.
### Dépannage
* Échec de la compilation ? Vérifiez java -version. Il DOIT être 17.
* Le modèle ne se charge pas ? Assurez-vous d’avoir sélectionné à la fois le `.pte` ET le `tokenizer`.
* L’application plante ? Des `.pte` fichiers valides doivent être exportés spécifiquement pour ExecuTorch (généralement le backend XNNPACK pour le CPU).
### Transférer le modèle sur votre téléphone
Actuellement, `executorchllama` l’application que nous avons construite ne prend en charge le chargement du modèle que depuis un répertoire spécifique sur Android, malheureusement inaccessible via les gestionnaires de fichiers classiques. Mais nous pouvons enregistrer les fichiers du modèle dans ledit répertoire à l’aide d’adb.
#### Assurez-vous qu’adb fonctionne correctement et est connecté
```shellscript
adb devices
```
{% columns %}
{% column %}
1. Si vous vous êtes connecté via le débogage sans fil, vous verrez quelque chose comme ceci :
Ou si vous vous êtes connecté avec un câble :
Si vous n’avez pas donné les autorisations à l’ordinateur pour accéder à votre téléphone :
{% endcolumn %}
{% column %}
2\. Vous devez alors vérifier sur votre téléphone une boîte de dialogue contextuelle semblable à ceci (que vous voudrez peut-être autoriser)
{% endcolumn %}
{% endcolumns %}
Une fois cela fait, il est temps de créer le dossier où nous devons placer le `.pte` et `tokenizer.json` fichiers.
Créez ledit répertoire sur le chemin du téléphone.
```shellscript
adb shell mkdir -p /data/local/tmp/llama
adb shell chmod 777 /data/local/tmp/llama
```
Vérifiez que le répertoire est correctement créé.
```shellscript
adb shell ls -l /data/local/tmp/llama
total 0
```
Poussez le contenu dans ledit répertoire. Cela peut prendre quelques minutes ou plus selon votre ordinateur, la connexion et le téléphone. Merci d’être patient.
```shellscript
adb push /data/local/tmp/llama
adb push /data/local/tmp/llama
```
{% columns %}
{% column %}
1. Ouvrez le `executorchllamademo` application que vous avez installée à l’étape 5, puis appuyez sur l’icône d’engrenage en haut à droite pour ouvrir les Réglages.
2. Appuyez sur la flèche à côté de Model pour ouvrir le sélecteur et choisir un modèle.\
Si vous voyez une boîte de dialogue blanche vide sans nom de fichier, il est probable que le push de votre modèle via ADB ait échoué — recommencez cette étape. Notez aussi qu’il peut d’abord afficher « aucun modèle sélectionné ».
3. Après avoir चयनné un modèle, l’application devrait afficher le nom du fichier du modèle.
{% endcolumn %}
{% column %}
{% endcolumn %}
{% endcolumns %}
{% columns %}
{% column %}
5\. Répétez maintenant la même opération pour le tokenizer. Cliquez sur la flèche à côté du champ du tokenizer et sélectionnez le fichier correspondant.
{% endcolumn %}
{% column %}
6\. Vous devrez peut-être sélectionner le type de modèle en fonction du modèle que vous téléversez. Qwen3 est sélectionné ici.
{% endcolumn %}
{% column %}
7\. Une fois les deux fichiers sélectionnés, cliquez sur le bouton « Load Model ».
{% endcolumn %}
{% endcolumns %}
{% columns %}
{% column %}
8\. Vous serez ramené à l’écran d’origine avec la fenêtre de discussion, et il peut afficher « chargement du modèle ». Le chargement peut prendre quelques secondes selon la RAM et la vitesse de stockage de votre téléphone.
{% endcolumn %}
{% column %}
9\. Une fois qu’il indique « modèle chargé avec succès », vous pouvez commencer à discuter avec le modèle.\
\
Et voilà, vous avez maintenant un LLM qui s’exécute nativement sur votre téléphone Android !
{% endcolumn %}
{% endcolumns %}
### :mobile\_phone:ExecuTorch alimente des milliards
ExecuTorch [alimente les expériences de ML sur appareil pour des milliards de personnes](https://engineering.fb.com/2025/07/28/android/executorch-on-device-ml-meta-family-of-apps/) sur Instagram, WhatsApp, Messenger et Facebook. Instagram Cutouts utilise ExecuTorch pour extraire des autocollants modifiables à partir de photos. Dans des applications chiffrées comme Messenger, ExecuTorch permet une identification et une traduction linguistiques tenant compte de la vie privée, directement sur l’appareil. ExecuTorch prend en charge plus d’une douzaine de backends matériels sur Apple, Qualcomm, ARM et [Quest 3 et Ray Bans de Meta](https://ai.meta.com/blog/executorch-reality-labs-on-device-ai/).
## Autre prise en charge de modèles
* Tous les modèles denses Qwen 3 ([Qwen3-0.6B](https://huggingface.co/unsloth/Qwen3-0.6B), [Qwen3-4B](https://huggingface.co/unsloth/Qwen3-4B), [Qwen3-32B](https://huggingface.co/unsloth/Qwen3-32B) etc)
* Tous les modèles Gemma 3 ([Gemma3-270M](https://huggingface.co/unsloth/gemma-3-270m-it), [Gemma3-4B](https://huggingface.co/unsloth/gemma-3-4b-it), [Gemma3-27B](https://huggingface.co/unsloth/gemma-3-27b-it) etc)
* Tous les modèles Llama 3 ([Llama 3.1 8B](https://huggingface.co/unsloth/Llama-3.1-8B-Instruct), [Llama 3.3 70B Instruct](https://huggingface.co/unsloth/Llama-3.3-70B-Instruct) etc)
* Qwen 2.5, les modèles Phi 4 Mini, et bien plus encore !
Vous pouvez personnaliser le [**notebook Colab gratuit**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_\(0_6B\)-Phone_Deployment.ipynb) pour Qwen3-0.6B afin de permettre le déploiement sur téléphone pour l’un quelconque des modèles ci-dessus !
{% columns %}
{% column %}
**Notebook principal de déploiement sur téléphone pour Qwen3 0.6B**
{% embed url="" %}
{% endcolumn %}
{% column %}
Fonctionne avec Gemma 3
{% embed url="" %}
{% endcolumn %}
{% column %}
Fonctionne avec Llama 3
{% embed url="" %}
{% endcolumn %}
{% endcolumns %}
Allez sur notre [Notebooks Unsloth](/docs/fr/commencer/unsloth-notebooks.md) page pour tous les autres notebooks.
---
# 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/notions-de-base/inference-and-deployment/deploy-llms-phone.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.
