📱Comment exécuter et déployer des LLM sur votre téléphone iOS ou Android

Tutoriel pour affiner votre propre LLM et le déployer sur votre appareil Android ou iPhone avec ExecuTorch.

Nous sommes ravis de montrer comment vous pouvez entraîner des LLM puis les déployer localement en Téléphones Android et iPhones. Nous avons collaboré avec ExecuTorch de PyTorch & Meta pour créer un flux de travail simplifié utilisant l'entraînement conscient de la quantification (QAT) puis les déployer directement sur des appareils périphériques. Avec Unsloth, TorchAO et ExecuTorch, nous montrons comment vous pouvez :

• Utiliser la même technologie (ExecuTorch) que Meta utilise pour alimenter des milliards d'utilisateurs sur Instagram, WhatsApp

• Déployer Qwen3-0.6B localement sur Pixel 8 et iPhone 15 Pro à ~40 tokens/s

• Appliquer le QAT via TorchAO pour récupérer 70 % de l'exactitude

• Obtenir la confidentialité d'abord, des réponses instantanées et des capacités hors ligne

• Utilisez notre notebook Colab gratuit pour affiner Qwen3 0.6B et l'exporter pour le déploiement sur téléphone

Tutoriel iOSTutoriel Android

Qwen3-4B déployé sur un iPhone 15 Pro

Qwen3-0.6B fonctionnant à ~40 tokens/s

🦥 Entraîner votre modèle

Nous prenons en charge Qwen3, Gemma3, Llama3, Qwen2.5, Phi4 et de nombreux autres modèles pour le déploiement sur téléphone ! Suivez le notebook Colab gratuit pour le déploiement de Qwen3-0.6B :

Google Colabcolab.research.google.com

Mettez d'abord à jour Unsloth et installez TorchAO et Executorch.

pip install --upgrade unsloth unsloth_zoo
pip install torchao==0.14.0 executorch pytorch_tokenizers

Ensuite, utilisez simplement qat_scheme = "phone-deployment" pour signifier que nous voulons le déployer sur un téléphone. Notez que nous définissons aussi full_finetuning = True pour un affinage complet !

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" nous utilisons en fait qat_scheme = "int8-int4" en coulisses pour activer le QAT Unsloth/TorchAO qui simule la quantification dynamique d'activation INT8 avec quantification des poids INT4 pour les couches Linear pendant l'entraînement (via des opérations de fausse quantification) tout en gardant les calculs en 16 bits. Après l'entraînement, le modèle est converti en une version réellement quantifiée afin que le modèle sur l'appareil soit plus petit et typiquement conserve mieux la précision que la PTQ naïve.

Après l'affinage tel que décrit dans le notebook Colab, nous l'enregistrons ensuite dans un .pte fichier via Executorch :

# Convertir les clés du dictionnaire d'état du checkpoint des poids vers celles attendues 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 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]}'

🏁 Déploiement après l'entraînement

Et maintenant, avec votre qwen3_0.6B_model.pte fichier qui pèse environ 472 Mo, nous pouvons le déployer ! Choisissez votre appareil et lancez-vous :

• Run LLMs on your Phone – Route Xcode, simulateur ou appareil

• Run LLMs on your Phone – route en ligne de commande, aucun Studio requis

Déploiement iOS

Tutoriel pour faire fonctionner votre modèle sur iOS (testé sur un iPhone 16 Pro mais fonctionnera également 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 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'on vous le demande

5. Si on vous demande de sélectionner des plateformes, choisissez iOS 18 et téléchargez-le pour l'accès au simulateur

Important : Le premier lancement de Xcode est crucial ! Ne sautez pas ces installations de composants supplémentaires ! Consultez ici et ici pour une aide supplémentaire.

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 !

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.

Créez votre identifiant Apple

Vous n'avez pas d'identifiant Apple ? Inscrivez-vous ici.

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

Inscrivez-vous au programme Apple Developer

ExecuTorch requiert la capacité increased-memory-limit, qui nécessite un compte développeur payant :

1. Visitez developer.apple.com

2. Connectez-vous avec votre identifiant Apple

3. Inscrivez-vous au programme Apple Developer

Configurer l'application démo ExecuTorch

Récupérez le code d'exemple :

# Télécharger 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

Ouvrir dans Xcode

1. Ouvrir 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 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.

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 stop)

2. Accédez à votre dépôt HuggingFace Hub (si non 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. Appuyez sur le bouton ellipsis (•••) et créez un nouveau dossier nommé Qwen3test

Transférer des fichiers en utilisant le Terminal

# Trouver le dossier caché du simulateur
find ~/Library/Developer/CoreSimulator/Devices/ -type d -iname "*Qwen3test*"

Lorsque vous voyez le dossier, exécutez ce qui suit :

cp tokenizer.json /path/to/Qwen3test/tokenizer.json
cp qwen3_0.6B_model.pte /path/to/Qwen3test/qwen3_model.pte

Charger et discuter

1. Retournez à l'application etLLM dans le simulateur. Appuyez dessus pour la lancer.

1. Chargez le modèle et le tokenizer depuis le dossier Qwen3test

1. Commencez à discuter avec votre modèle affiné ! 🎉

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 appuyez sur « Se fier à cet appareil »

3. Dans Xcode, allez à Fenêtre → Appareils et Simulateurs

4. Attendez que votre appareil apparaisse à gauche (il peut afficher « Préparation » pendant un moment)

Configurer la signature Xcode

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 à l'onglet Signing & Capabilities

5. Cochez « Gérer automatiquement la signature »

6. Sélectionnez votre équipe dans le menu déroulant

Changez l'identifiant de bundle pour quelque chose d'unique (par ex., com.votrenom.etLLM). Cela corrige 99 % des erreurs de profil de provisioning

Ajouter la capacité requise

1. Toujours dans Signing & Capabilities, cliquez sur + Capability

2. Recherchez « Increased Memory Limit » et ajoutez-la

Compiler et exécuter

1. Dans la barre d'outils supérieure, sélectionnez votre iPhone physique dans le sélecteur d'appareils

2. Appuyez sur Play (▶️) ou pressez Cmd + R

Faire confiance au certificat développeur

Votre première compilation échouera — c'est normal !

1. Sur votre iPhone, allez dans Réglages → Confidentialité & Sécurité → Mode Développeur

2. Activez l'option

3. Acceptez et validez les avis

4. Redémarrez l'appareil, retournez à Xcode et appuyez de nouveau sur Play

Le Mode Développeur permet à XCode d'exécuter et d'installer des applications sur votre iPhone

Transférer les fichiers du modèle vers votre iPhone

1. Une fois l'application en cours d'exécution, ouvrez 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

1. Sur votre iPhone, revenez à l'application etLLM

1. Chargez le modèle et le tokenizer depuis l'interface de l'application

1. Votre Qwen3 affiné fonctionne maintenant nativement sur votre iPhone !

Déploiement Android

Ce guide couvre comment construire et installer l'application démo ExecuTorch Llama sur un appareil Android (testé avec Pixel 8 mais fonctionnera aussi sur d'autres téléphones Android) en utilisant un environnement en ligne de commande Linux/Mac. Cette approche minimise les dépendances (pas besoin d'Android Studio) et déleste le processus de build intensif sur votre ordinateur.

Exigences

Assurez-vous que votre machine de développement ait les éléments suivants installés :

• Java 17 (Java 21 est souvent par défaut mais peut causer des problèmes de build)

• Git

• Wget / Curl

• Outils en ligne de commande Android

• Guide d'installation et configuration adb sur votre Android et votre ordinateur

Vérification

Vérifiez que votre version de Java correspond à 17.x :

# La sortie devrait ressembler à : openjdk version "17.0.x"
java -version

Si ce n'est pas le cas, installez-le via Ubuntu/Debian :

sudo apt install openjdk-17-jdk

Puis définissez-le par défaut ou exportez JAVA_HOME:

export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64
export PATH=$JAVA_HOME/bin:$PATH

Si vous êtes sur un autre OS ou distribution, vous pouvez suivre ce guide ou simplement demander à votre LLM préféré de vous guider.

Étape 1 : Installer Android SDK & NDK

Configurez un environnement SDK Android minimal sans l'intégralité d'Android Studio.

1. Créez le répertoire SDK :

mkdir -p ~/android-sdk/cmdline-tools
cd ~/android-sdk

1. Installer les outils en ligne de commande Android

wget https://dl.google.com/android/repository/commandlinetools-linux-11076708_latest.zip
unzip commandlinetools-linux-*.zip -d cmdline-tools

# Important : Réorganiser 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:

export ANDROID_HOME=$HOME/android-sdk
export PATH=$ANDROID_HOME/cmdline-tools/latest/bin:$PATH
export PATH=$ANDROID_HOME/platform-tools:$PATH

Rechargez-les :

source ~/.zshrc  # ou ~/.bashrc selon votre shell

Étape 3 : Installer les composants SDK

ExecuTorch nécessite des versions spécifiques du NDK.

# 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éfinir la variable NDK :

export ANDROID_NDK=$ANDROID_HOME/ndk/25.0.8775105

Étape 4 : Récupérer le code

Nous utilisons le executorch-examples dépôt, qui contient la démo Llama mise à jour.

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 rencontrés auparavant et cela pourrait vous être utile :

Corriger « SDK Location not found » :

Créez un local.properties fichier pour indiquer explicitement à Gradle où se trouve le SDK :

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(). Appliquez ce correctif avec cette commande :

sed -i 's/e.getDetailedError()/e.getMessage()/g' llm/android/LlamaDemo/app/src/main/java/com/example/executorchllamademo/MainActivity.java

Étape 6 : Construire l'APK

Cette étape compile l'application et les bibliothèques natives.

1. Accédez au projet Android :

   cd llm/android/LlamaDemo

2. Construire avec Gradle (définir explicitement JAVA_HOME à 17 pour éviter les erreurs de toolchain) :

   Remarque : La première exécution prendra quelques minutes.

   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 (filiaire/sans fil)

Si vous avez adb accès à votre téléphone :

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 l'app-debug.apk à un endroit où vous pouvez la télécharger sur le téléphone

2. Téléchargez-la sur votre téléphone

3. Appuyez pour installer (Activez « Installer 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é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. Ouvrir l'application LlamaDemo : Lancez l'application sur votre téléphone.

3. Sélectionner le modèle

4. Appuyez sur 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 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 ? Les .pte fichiers valides doivent être exportés spécifiquement pour ExecuTorch (généralement backend XNNPACK pour le CPU).

Transférer le modèle vers votre téléphone

Actuellement, executorchllama l'application que nous avons construite ne supporte le chargement du modèle que depuis un répertoire spécifique sur Android qui n'est malheureusement pas accessible via les gestionnaires de fichiers habituels. 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é

adb devices 

1. Si vous vous êtes connecté via le débogage sans fil, vous verrez quelque chose comme ceci :

   

   Ou si vous vous êtes connecté via un câble :

   

   Si vous n'avez pas donné les permissions à l'ordinateur pour accéder à votre téléphone :

   

1. Alors vous devez vérifier votre téléphone pour un dialogue contextuel qui ressemble à (que vous voudrez peut-être autoriser)

Une fois fait, il est temps de créer le dossier où nous devons placer les .pte et tokenizer.json fichiers.

Créez le répertoire indiqué sur le chemin du téléphone.

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éé.

adb shell ls -l /data/local/tmp/llama
total 0

Poussez le contenu vers le répertoire indiqué. Cela peut prendre de quelques minutes à plus selon votre ordinateur, la connexion et le téléphone. Veuillez être patient.

adb push <path_to_tokenizer.json on your computer> /data/local/tmp/llama
adb push <path_to_model.pte on your computer> /data/local/tmp/llama

1. Ouvrez l' executorchllamademo application que vous avez installée à l'étape 5, puis appuyez sur l'icône 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 sélectionnez un modèle. Si vous voyez une boîte blanche vide sans nom de fichier, votre push ADB du modèle a probablement échoué - refaites cette étape. Notez aussi qu'il peut afficher initialement « 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.

1. 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.

1. Il se peut que vous deviez sélectionner le type de modèle en fonction du modèle que vous téléversez. Qwen3 est sélectionné ici.

1. Une fois que vous avez sélectionné les deux fichiers, cliquez sur le bouton « Load Model ».

1. Cela vous ramènera à l'écran d'origine avec la fenêtre de chat, et il se peut qu'il affiche « model loading ». Cela peut prendre quelques secondes pour terminer le chargement selon la RAM et la vitesse de stockage de votre téléphone.

1. Une fois qu'il indique « successfully loaded model », vous pouvez commencer à discuter avec le modèle. Et voilà, vous avez maintenant un LLM fonctionnant nativement sur votre téléphone Android !

📱ExecuTorch alimente des milliards

ExecuTorch alimente des expériences ML sur appareil pour des milliards de personnes 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 l'identification linguistique et la traduction respectueuses de la vie privée 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.

Support d'autres modèles

• Tous les modèles denses Qwen 3 (Qwen3-0.6B, Qwen3-4B, Qwen3-32B etc)

• Tous les modèles Gemma 3 (Gemma3-270M, Gemma3-4B, Gemma3-27B etc)

• Tous les modèles Llama 3 (Llama 3.1 8B, Llama 3.3 70B Instruct etc)

• Qwen 2.5, Phi 4 Mini et bien d'autres !

Vous pouvez personnaliser le notebook Colab gratuit pour Qwen3-0.6B afin de permettre le déploiement sur téléphone pour n'importe lequel des modèles ci-dessus !

Notebook principal de déploiement sur téléphone pour Qwen3 0.6B

Google Colabcolab.research.google.com

Fonctionne avec Gemma 3

Google Colabcolab.research.google.com

Fonctionne avec Llama 3

Google Colabcolab.research.google.com

Allez sur notre Notebooks Unsloth page pour tous les autres notebooks !

🌵 Déploiement vers Cactus pour téléphones

Cactus est un moteur d'inférence open-source pour appareils mobiles, Macs et puces ARM comme le Raspberry Pi.

• En INT8, Cactus exécute Qwen3-0.6B et LFM2-1.2B à 60-70 toks/sec sur iPhone 17 Pro, 13-18 toks/sec sur un Pixel 6a économique.

• Accords INT8 spécifiques à la tâche de Gemma3-270m atteignent 150 toks/sec sur iPhone 17 Pro et 23 toks/sec sur Raspberry Pi.

Démarrage rapide

1. Entraîner (Google Colab / GPU)

Utilisez le notebook fourni ou votre propre script d'entraînement Unsloth :

from unsloth import FastLanguageModel

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/gemma-3-4b-it",
    max_seq_length=2048,
    load_in_4bit=True,
)

model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj"],
    lora_alpha=16,
    lora_dropout=0,
    use_gradient_checkpointing="unsloth",
)

# ... entraîner avec SFTTrainer ...

# Enregistrer l'adaptateur
model.save_pretrained("my-lora-adapter")
tokenizer.save_pretrained("my-lora-adapter")

# Pousser sur le Hub (optionnel)
model.push_to_hub("username/my-lora-adapter")

2. Configurer Cactus

git clone https://github.com/cactus-compute/cactus && cd cactus && source ./setup

3. Convertir pour Cactus

# Depuis un adaptateur local : Utilisez le modèle de base correct !
cactus convert Qwen/Qwen3-0.6B ./my-qwen3-0.6b --lora ./my-lora-adapter 

# Depuis HuggingFace Hub : Utilisez le modèle de base correct !
cactus convert Qwen/Qwen3-0.6B ./my-qwen3-0.6b  --lora username/my-lora-adapter 

4. Exécuter

Testez votre modèle sur Mac :

cactus run ./my-qwen3-0.6b

5. Utiliser dans une app iOS/macOS

Construire la bibliothèque native :

cactus build --apple

Build terminé !
Temps total : 58 secondes
Bibliothèques statiques :
  Appareil : /Users/henry/Desktop/cactus/apple/libcactus-device.a
  Simulateur : /Users/henry/Desktop/cactus/apple/libcactus-simulator.a
XCFrameworks :
  iOS : /Users/henry/Desktop/cactus/apple/cactus-ios.xcframework
  macOS : /Users/henry/Desktop/cactus/apple/cactus-macos.xcframework
Build Apple terminé !
(venv) henry@Henrys-MacBook-Air cactus % 

Lien cactus-ios.xcframework à votre projet Xcode, puis :

import Foundation

// Charger le modèle depuis le bundle de l'application
let modelPath = Bundle.main.path(forResource: "my-model", ofType: nil)!
let model = cactus_init(modelPath, 2048, nil)

// Exécuter la complétion
let messages = "[{\"role\":\"user\",\"content\":\"Hello!\"}]"
var response = [CChar](repeating: 0, count: 4096)
cactus_complete(model, messages, &response, response.count, nil, nil, nil, nil)
print(String(cString: response))

// Nettoyage
cactus_destroy(model)

Vous pouvez maintenant créer des applications iOS en utilisant le code suivant, mais pour voir les performances sur n'importe quel appareil pendant les tests, exécutez les tests cactus en branchant un iPhone à votre Mac puis en exécutant :

cactus test --<model-path-or-name> --ios 

Les applications de démonstration Cactus s'étendront éventuellement pour utiliser vos ajustements personnalisés. De plus, cactus run permettra de brancher un téléphone, de sorte que la session interactive utilise les puces du téléphone ; de cette façon, vous pouvez tester avant de déployer complètement vos applications.

6. Utilisation dans une application Android

Construire la bibliothèque native :

cactus build --android

Build terminé !
Emplacement de la bibliothèque partagée : /Users/henry/Desktop/cactus/android/libcactus.so
Emplacement de la bibliothèque statique : /Users/henry/Desktop/cactus/android/libcactus.a
Compilation Android terminée !
(venv) henry@Henrys-MacBook-Air cactus % 

Copier libcactus.so en app/src/main/jniLibs/arm64-v8a/, puis :

class CactusWrapper {
    init { System.loadLibrary("cactus") }

    external fun init(modelPath: String, contextSize: Long, corpusDir: String?): Long
    external fun complete(model: Long, messagesJson: String, bufferSize: Int): String
    external fun destroy(model: Long)
}

// Utilisation
val cactus = CactusWrapper()
val model = cactus.init("/data/local/tmp/my-model", 2048, null)
val response = cactus.complete(model, """[{"role":"user","content":"Hello!"}]""", 4096)
cactus.destroy(model)

Vous pouvez maintenant créer des applications Android en utilisant le code suivant, mais pour voir les performances sur n'importe quel appareil pendant les tests, exécutez les tests cactus en branchant un téléphone Android à votre Mac puis en exécutant :

cactus test --<model-path-or-name> --android 

Les applications de démonstration Cactus s'étendront éventuellement pour utiliser vos ajustements personnalisés. De plus, cactus run permettra de brancher un téléphone, de sorte que la session interactive utilise les puces du téléphone ; de cette façon, vous pouvez tester avant de déployer complètement vos applications.

Ressources

• Modèles de base pris en charge : Qwen3, Gemma3, LFM2, SmolLM2

• Référence API complète : Moteur Cactus

• En savoir plus et signaler des bugs : Cactus