> 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/bases/inference-and-deployment/deploy-llms-phone.md).
# Comment exécuter et déployer des LLM sur votre téléphone iOS ou Android
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 utilise pour alimenter des milliards de comptes sur Instagram, WhatsApp
* Déployer Qwen3-0.6B localement sur **Pixel 8** et **iPhone 15 Pro à \~40 jetons/s**
* Appliquer le QAT via TorchAO pour récupérer 70 % de la précision
* Bénéficier d'une confidentialité prioritaire, de réponses instantanées et de capacités hors ligne
* Utilisez notre [carnet 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 un 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 un déploiement sur téléphone ! Suivez le [**carnet 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 affinement 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 pour le déploiement sur téléphone
)
```
Nous utilisons `qat_scheme = "phone-deployment"` en réalité, nous utilisons `qat_scheme = "int8-int4"` sous le capot pour activer le QAT Unsloth/TorchAO qui *simule* la quantification dynamique des activations en INT8 avec la quantification des poids en INT4 pour les couches Linear 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 vraie version quantifiée afin que le modèle embarqué soit plus petit et généralement **conserve mieux la précision que le PTQ naïf**.
Après l'affinage tel que décrit dans le [carnet 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
# Convertissez les clés du state dict du point de contrôle des poids en un format attendu par ExecuTorch
python -m executorch.examples.models.qwen3.convert_weights "phone_model" pytorch_model_converted.bin
# Téléchargez 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 un 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 en ligne de commande, sans besoin d'Unsloth
## :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 sous 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 en 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 tous les composants supplémentaires lorsqu'ils vous y invitent
5. Si l'on vous demande de sélectionner des plateformes, choisissez iOS 18 et téléchargez-le pour accéder 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" %}
Sautez toute cette section si vous n'utilisez que 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 Identifiant Apple
4. Connectez-vous avec votre identifiant Apple habituel
{% endcolumn %}
{% column %}
{% endcolumn %}
{% endcolumns %}
#### **Inscrivez-vous au programme Apple Developer**
ExecuTorch nécessite la `capacité de limite de mémoire augmentée`, 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` le simulateur comme appareil cible
3. Appuyez sur Play (▶️) 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. Accédez à votre dépôt HuggingFace Hub (s'il 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 Accueil virtuel du simulateur
2. Ouvrez l'application Fichiers → Parcourir → Sur mon iPhone
3. Touchez le bouton points de suspension (•••) et créez un nouveau dossier nommé `Qwen3test`
**Transférez les fichiers à l'aide du Terminal**
```bash
# Trouvez 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 dans Xcode**
{% columns %}
{% column %}
1. Ajoutez votre compte Apple : Xcode → Réglages → Comptes → `+`
2. Dans le navigateur du projet, cliquez sur le projet etLLM (icône bleue)
3. Sélectionnez etLLM sous TARGETS
4. Allez dans l'onglet Signing & Capabilities
5. Cochez « Gérer automatiquement la signature »
6. Sélectionnez votre équipe dans le menu déroulant
{% endcolumn %}
{% column %}
{% endcolumn %}
{% endcolumns %}
{% hint style="warning" %}
Modifiez le Bundle Identifier pour quelque chose d'unique (par ex., com.votrenom.etLLM). Cela corrige 99 % des erreurs de profil d'approvisionnement
{% endhint %}
**Ajouter 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 Play (▶️) ou sur Cmd + R
**Faire confiance au certificat de développement**
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 validez les notifications
4. Redémarrez l'appareil, revenez dans Xcode et appuyez à nouveau sur Play
{% hint style="warning" %}
Le mode développeur permet à Xcode d'exécuter et d'installer des applications sur votre iPhone
{% endhint %}
**Transférer les fichiers du modèle sur 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. Faites glisser et 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 désormais nativement sur votre iPhone !
{% endcolumn %}
{% endcolumns %}
## :android: Déploiement Android
Ce guide explique comment compiler et installer l'application de démonstration Llama d'ExecuTorch 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 (pas besoin d'Android Studio) et déporte le processus de compilation lourd sur votre ordinateur.
### Exigences
Assurez-vous que votre machine de développement dispose des é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 de configuration `adb` sur votre Android et votre ordinateur
#### Vérification
Vérifiez que votre version de Java correspond à la version 17.x :
```bash
# La sortie devrait ressembler à : openjdk version "17.0.x"
java -version
```
Si ce n'est pas le cas, installez-le via Ubuntu/Debian :
```bash
sudo apt install openjdk-17-jdk
```
Puis définissez-le 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 système d'exploitation ou une autre distribution, vous voudrez peut-être 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 l'Android Studio complet.
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 satisfaire la structure du SDK
mv cmdline-tools/cmdline-tools cmdline-tools/latest
```
### Étape 2 : Configurer les variables d'environnement
Ajoutez-les à 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 spécifiques du NDK.
```bash
# Acceptez les licences
yes | sdkmanager --licenses
# Installez 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 : Récupérer le code
Nous utilisons le `référentiel 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 auparavant et cela pourrait vous être utile :
**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 chaîne d'outils) :
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 ici :
```
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 fichiers
Si vous êtes sur une VM distante ou que vous n'avez pas de câble :
1. Téléversez app-debug.apk à un endroit d'où vous pouvez le télécharger depuis le téléphone
2. Téléchargez-le sur votre téléphone
3. Touchez pour installer (activez « Installer depuis des sources inconnues » si demandé).
### Étape 8 : Transférer les fichiers du modèle
L'application a besoin des fichiers modèle .pte et tokenizer.
1. Transférez les fichiers : déplacez votre model.pte et tokenizer.bin (ou tokenizer.model) vers le stockage de votre téléphone (par ex., le 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 les Paramètres (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.
Terminé ! Vous pouvez maintenant discuter directement avec le LLM sur votre appareil.
### Dépannage
* La compilation échoue ? Vérifiez java -version. Il DOIT être en 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 fichiers valides `.pte` 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 ce 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 verriez quelque chose comme ceci :
Ou si vous êtes connecté via un câble :
Si vous n'avez pas donné d'autorisation à l'ordinateur pour accéder à votre téléphone :
{% endcolumn %}
{% column %}
2\. Alors vous devez vérifier votre téléphone pour une boîte de dialogue contextuelle ressemblant à ceci (que vous pouvez 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 le répertoire en question 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 vers le répertoire indiqué. Cela peut prendre quelques minutes, voire plus, selon votre ordinateur, la connexion et le téléphone. Veuillez être patient.
```shellscript
adb push /data/local/tmp/llama
adb push /data/local/tmp/llama
```
{% columns %}
{% column %}
1. Ouvrez l’ `executorchllamademo` application que vous avez installée à l’étape 5, puis appuyez sur l’icône en forme d’engrenage en haut à droite pour ouvrir les Paramètres.
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, l’envoi du modèle via ADB a probablement échoué — refaites cette étape. Notez aussi qu’au départ, il peut afficher « aucun modèle sélectionné ».
3. Après avoir sélectionné 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 tokenizer et sélectionnez le fichier correspondant.
{% endcolumn %}
{% column %}
6\. Vous devrez peut-être sélectionner le type de modèle selon celui 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 chat, et il peut afficher « model loading ». 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 affiche « successfully loaded model », 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 des expériences de ML sur l’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 respectueuses de la confidentialité, directement sur l’appareil. ExecuTorch prend en charge plus d’une douzaine de backends matériels sur Apple, Qualcomm, ARM et [les Quest 3 et les lunettes Ray-Ban de Meta](https://ai.meta.com/blog/executorch-reality-labs-on-device-ai/).
## Autres modèles pris en charge
* 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.)
* les modèles Qwen 2.5, Phi 4 Mini, et bien plus encore !
Vous pouvez personnaliser le [**carnet 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 n’importe lequel des modèles ci-dessus !
{% columns %}
{% column %}
**carnet de déploiement principal sur téléphone Qwen3 0.6B**
{% embed url="" %}
{% endcolumn %}
{% column %}
Fonctionne avec Gemma 3
{% embed url="" %}
{% endcolumn %}
{% column %}
Fonctionne avec Llama 3
{% embed url="" %}
{% endcolumn %}
{% endcolumns %}
Rendez-vous sur notre [Notebooks Unsloth](/docs/fr/commencer/unsloth-notebooks.md) page pour tous les autres carnets.
---
# 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 dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:
```
GET https://unsloth.ai/docs/fr/bases/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 optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.
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.