📱Wie man LLMs auf deinem iOS- oder Android-Telefon ausführt und bereitstellt

Tutorial zum Finetunen deines eigenen LLM und zur Bereitstellung auf deinem Android oder iPhone mit ExecuTorch.

Wir freuen uns, zu zeigen, wie Sie LLMs trainieren können und dann sie lokal bereitstellen zu Android-Telefone und iPhones. Wir haben mit ExecuTorch von PyTorch & Meta zusammengearbeitet, um einen optimierten Workflow mit quantisierungsbewusstem Training (QAT) zu erstellen und sie dann direkt auf Edge-Geräte bereitzustellen. Mit Unsloth, TorchAO und ExecuTorch zeigen wir, wie Sie:

• Die gleiche Technologie (ExecuTorch) nutzen, die Meta einsetzt, um Milliarden auf Instagram, WhatsApp zu unterstützen

• Qwen3-0.6B lokal bereitzustellen auf Pixel 8 und iPhone 15 Pro mit ~40 Tokens/s

• QAT via TorchAO anwenden, um 70% der Genauigkeit wiederherzustellen

• Datenschutz zuerst erhalten, sofortige Antworten und Offline-Funktionen

• Verwenden Sie unser kostenloses Colab-Notebook um Qwen3 0.6B feinzujustieren und für die Telefonbereitstellung zu exportieren

iOS-TutorialAndroid-Tutorial

Qwen3-4B auf einem iPhone 15 Pro bereitgestellt

Qwen3-0.6B läuft mit ~40 Tokens/s

🦥 Ihr Modell trainieren

Wir unterstützen Qwen3, Gemma3, Llama3, Qwen2.5, Phi4 und viele andere Modelle für die Telefonbereitstellung! Folgen Sie dem kostenloses Colab-Notebook für die Bereitstellung von Qwen3-0.6B:

Google Colabcolab.research.google.com

Aktualisieren Sie zuerst Unsloth und installieren Sie TorchAO und Executorch.

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

Dann verwenden Sie einfach qat_scheme = "phone-deployment" um zu kennzeichnen, dass wir es auf ein Telefon bereitstellen möchten. Beachten Sie, dass wir auch full_finetuning = True für vollständiges Finetuning setzen!

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", # Flag für Telefonbereitstellung
)

Wir verwenden qat_scheme = "phone-deployment" tatsächlich verwenden wir qat_scheme = "int8-int4" unter der Haube, um Unsloth/TorchAO QAT zu ermöglichen, das simuliert INT8 dynamische Aktivierungsquantisierung mit INT4 Gewichtsquantisierung für Linear-Schichten während des Trainings (über Fake-Quantisierungsoperationen), während die Berechnungen in 16 Bit verbleiben. Nach dem Training wird das Modell in eine echte quantisierte Version konvertiert, sodass das On-Device-Modell kleiner ist und typischerweise die Genauigkeit besser erhält als naive PTQ.

Nach dem Finetuning wie im Colab-Notebookbeschrieben, speichern wir es dann in einer .pte Datei via Executorch:

# Konvertiere die Keys des Gewichts-Checkpoint-State-Dicts in solche, die ExecuTorch erwartet
python -m executorch.examples.models.qwen3.convert_weights "phone_model" pytorch_model_converted.bin
# Modellkonfiguration aus dem ExecuTorch-Repo herunterladen
curl -L -o 0.6B_config.json https://raw.githubusercontent.com/pytorch/executorch/main/examples/models/qwen3/config/0_6b_config.json
# Export nach ExecuTorch pte Datei
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]}'

🏁 Bereitstellung nach dem Training

Und nun mit Ihrer qwen3_0.6B_model.pte Datei, die etwa 472MB groß ist, können wir sie bereitstellen! Wählen Sie Ihr Gerät und legen Sie direkt los:

• Run LLMs on your Phone – Xcode-Route, Simulator oder Gerät

• Run LLMs on your Phone – Kommandozeilen-Route, kein Studio erforderlich

iOS-Bereitstellung

Tutorial, um Ihr Modell auf iOS zum Laufen zu bringen (getestet auf einem iPhone 16 Pro, funktioniert aber auch auf anderen iPhones). Sie benötigen ein physisches macOS-Gerät, das Xcode 15 ausführen kann.

Einrichtung der macOS-Entwicklungsumgebung

Xcode & Command Line Tools installieren

1. Installieren Sie Xcode aus dem Mac App Store (muss Version 15 oder neuer sein)

2. Öffnen Sie das Terminal und überprüfen Sie Ihre Installation: xcode-select -p

3. Installieren Sie die Command Line Tools und akzeptieren Sie die Lizenz:

   1. xcode-select --install

   2. sudo xcodebuild -license accept

4. Starten Sie Xcode zum ersten Mal und installieren Sie bei Aufforderung alle zusätzlichen Komponenten

5. Wenn Sie aufgefordert werden, Plattformen auszuwählen, wählen Sie iOS 18 und laden Sie es für den Simulatorzugriff herunter

Wichtig: Der erste Xcode-Start ist entscheidend! Überspringen Sie nicht die zusätzlichen Komponenteninstallationen! Prüfen Sie hier und hier für zusätzliche Hilfe.

Überprüfen Sie, ob alles funktioniert: xcode-select -p

Sie sollten einen Pfad sehen. Wenn nicht, wiederholen Sie Schritt 3.

Einrichtung eines Apple-Developer-Kontos

Nur für physische Geräte!

Überspringen Sie diesen Abschnitt vollständig, wenn Sie nur den iOS-Simulator verwenden. Sie benötigen nur für die Bereitstellung auf einem physischen iPhone ein kostenpflichtiges Entwicklerkonto.

Erstellen Sie Ihre Apple ID

Haben Sie noch keine Apple ID? Hier registrieren.

Fügen Sie Ihr Konto zu Xcode hinzu

1. Öffnen Sie Xcode

2. Navigieren Sie zu Xcode → Einstellungen → Accounts

3. Klicken Sie auf die + Schaltfläche und wählen Sie Apple ID

4. Melden Sie sich mit Ihrer regulären Apple ID an

Melden Sie sich beim Apple Developer Program an

ExecuTorch erfordert die Fähigkeit "increased-memory-limit", die ein kostenpflichtiges Entwicklerkonto benötigt:

1. Besuchen Sie developer.apple.com

2. Melden Sie sich mit Ihrer Apple ID an

3. Melden Sie sich beim Apple Developer Program an

Richten Sie die ExecuTorch Demo-App ein

Beziehen Sie den Beispielcode:

# Laden Sie die LLM-Beispiel-App direkt herunter
curl -L https://github.com/meta-pytorch/executorch-examples/archive/main.tar.gz | \
  tar -xz --strip-components=2 executorch-examples-main/llm/apple

In Xcode öffnen

1. Öffnen Sie apple/etLLM.xcodeproj in Xcode

2. Wählen Sie in der oberen Symbolleiste iPhone 16 Pro Simulator als Zielgerät

3. Drücken Sie Play (▶️), um zu bauen und auszuführen

🎉 Erfolg! Die App sollte jetzt im Simulator starten. Sie funktioniert noch nicht, wir müssen Ihr Modell hinzufügen.

Bereitstellen im Simulator

Kein Entwicklerkonto erforderlich.

Bereiten Sie Ihre Modell-Dateien vor

1. Stoppen Sie den Simulator in Xcode (drücken Sie die Stop-Taste)

2. Navigieren Sie zu Ihrem HuggingFace Hub Repo (falls nicht lokal gespeichert)

3. Laden Sie diese zwei Dateien herunter:

   1. qwen3_0.6B_model.pte (Ihr exportiertes Modell)

   2. tokenizer.json (der Tokenizer)

Erstellen Sie einen gemeinsamen Ordner im Simulator

1. Klicken Sie auf die virtuelle Home-Taste im Simulator

2. Öffnen Sie die Dateien-App → Durchsuchen → Auf meinem iPhone

3. Tippen Sie auf die Ellipse (•••)-Schaltfläche und erstellen Sie einen neuen Ordner mit dem Namen Qwen3test

Übertragen Sie Dateien mit dem Terminal

# Finden Sie den versteckten Ordner des Simulators
find ~/Library/Developer/CoreSimulator/Devices/ -type d -iname "*Qwen3test*"

Wenn Sie den Ordner sehen, führen Sie Folgendes aus:

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

Laden & Chatten

1. Kehren Sie zur etLLM-App im Simulator zurück. Tippen Sie, um sie zu starten.

1. Laden Sie das Modell und den Tokenizer aus dem Qwen3test-Ordner

1. Beginnen Sie, mit Ihrem feinabgestimmten Modell zu chatten! 🎉

Bereitstellung auf Ihrem physischen iPhone

Erste Geräteeinrichtung

1. Verbinden Sie Ihr iPhone per USB mit Ihrem Mac

2. Entsperren Sie Ihr iPhone und tippen Sie auf "Diesem Computer vertrauen"

3. Öffnen Sie in Xcode Fenster → Geräte und Simulatoren

4. Warten Sie, bis Ihr Gerät links erscheint (es kann kurz "Vorbereiten" anzeigen)

Xcode-Signing konfigurieren

1. Fügen Sie Ihr Apple-Konto hinzu: Xcode → Einstellungen → Accounts → +

2. Klicken Sie im Projekt-Navigator auf das etLLM-Projekt (blaues Symbol)

3. Wählen Sie etLLM unter TARGETS

4. Gehen Sie zur Registerkarte Signing & Capabilities

5. Aktivieren Sie "Automatically manage signing"

6. Wählen Sie Ihr Team aus dem Dropdown-Menü

Ändern Sie die Bundle-Identifier in etwas Einzigartiges (z. B. com.ihreName.etLLM). Das behebt 99% der Fehler mit Provisioning-Profilen

Fügen Sie die erforderliche Fähigkeit hinzu

1. Klicken Sie weiterhin bei Signing & Capabilities auf + Capability

2. Suchen Sie nach "Increased Memory Limit" und fügen Sie es hinzu

Build & Run

1. Wählen Sie in der oberen Symbolleiste Ihr physisches iPhone im Geräteselector

2. Drücken Sie Play (▶️) oder Cmd + R

Vertrauen Sie dem Entwicklerzertifikat

Ihr erster Build wird fehlschlagen—das ist normal!

1. Gehen Sie auf Ihrem iPhone zu Einstellungen → Datenschutz & Sicherheit → Entwicklermodus

2. Schalten Sie ihn ein

3. Zustimmen und Hinweise akzeptieren

4. Starten Sie das Gerät neu, kehren Sie zu Xcode zurück und drücken Sie erneut Play

Der Entwicklermodus erlaubt Xcode, Apps auf Ihrem iPhone auszuführen und zu installieren

Modelldateien auf Ihr iPhone übertragen

1. Sobald die App läuft, öffnen Sie den Finder auf Ihrem Mac

2. Wählen Sie Ihr iPhone in der Seitenleiste aus

3. Klicken Sie auf die Dateien-Registerkarte

4. Erweitern Sie etLLM

5. Ziehen Sie Ihre .pte- und tokenizer.json-Dateien direkt in diesen Ordner

6. Seien Sie geduldig! Diese Dateien sind groß und können einige Minuten dauern

Laden & Chatten

1. Wechseln Sie auf Ihrem iPhone zurück zur etLLM-App

1. Laden Sie das Modell und den Tokenizer über die App-Oberfläche

1. Ihr feinabgestimmtes Qwen3 läuft jetzt nativ auf Ihrem iPhone!

Android-Bereitstellung

Diese Anleitung beschreibt, wie man die ExecuTorch Llama-Demo-App auf einem Android-Gerät baut und installiert (getestet mit Pixel 8, funktioniert aber auch auf anderen Android-Telefonen) unter Verwendung einer Linux-/Mac-Kommandozeilenumgebung. Dieser Ansatz minimiert Abhängigkeiten (kein Android Studio erforderlich) und verlagert den aufwändigen Build-Prozess auf Ihren Computer.

Anforderungen

Stellen Sie sicher, dass Ihr Entwicklungsrechner Folgendes installiert hat:

• Java 17 (Java 21 ist oft Standard, kann aber Build-Probleme verursachen)

• Git

• Wget / Curl

• Android Command Line Tools

• Anleitung zur Installation und Einrichtung von adb auf Ihrem Android und Ihrem Computer

Verifikation

Überprüfen Sie, ob Ihre Java-Version 17.x entspricht:

# Die Ausgabe sollte in etwa so aussehen: openjdk version "17.0.x"
java -version

Wenn dies nicht der Fall ist, installieren Sie es unter Ubuntu/Debian:

sudo apt install openjdk-17-jdk

Setzen Sie es dann als Standard oder exportieren Sie JAVA_HOME:

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

Wenn Sie ein anderes OS oder eine andere Distribution verwenden, sollten Sie möglicherweise diese Anleitung oder einfach Ihr Lieblings-LLM bitten, Sie durchzuführen.

Schritt 1: Android SDK & NDK installieren

Richten Sie eine minimale Android-SDK-Umgebung ohne das komplette Android Studio ein.

1. Erstellen Sie das SDK-Verzeichnis:

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

1. Android Command Line Tools installieren

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

# Wichtig: Umstrukturieren, um die SDK-Struktur zu erfüllen
mv cmdline-tools/cmdline-tools cmdline-tools/latest

Schritt 2: Umgebungsvariablen konfigurieren

Fügen Sie diese zu Ihrer ~/.bashrc oder ~/.zshrc:

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

Laden Sie sie neu:

source ~/.zshrc  # oder ~/.bashrc je nach Ihrer Shell

Schritt 3: SDK-Komponenten installieren

ExecuTorch benötigt bestimmte NDK-Versionen.

# Lizenzen akzeptieren
yes | sdkmanager --licenses

# Installieren Sie API 34 und NDK 25
sdkmanager "platforms;android-34" "platform-tools" "build-tools;34.0.0" "ndk;25.0.8775105"

Setzen Sie die NDK-Variable:

export ANDROID_NDK=$ANDROID_HOME/ndk/25.0.8775105

Schritt 4: Code holen

Wir verwenden das executorch-examples Repository, das die aktualisierte Llama-Demo enthält.

cd ~
git clone https://github.com/meta-pytorch/executorch-examples.git
cd executorch-examples

Schritt 5: Häufige Kompilationsprobleme beheben

Beachten Sie, dass der aktuelle Code diese Probleme nicht hat, wir hatten sie jedoch zuvor und sie könnten für Sie hilfreich sein:

Behebe "SDK Location not found":

Erstellen Sie eine local.properties Datei, um Gradle explizit zu sagen, wo sich das SDK befindet:

echo "sdk.dir=$HOME/android-sdk" > llm/android/LlamaDemo/local.properties

Behebe cannot find symbol Fehler:

Der aktuelle Code verwendet eine veraltete Methode getDetailedError(). Patchen Sie es mit diesem Befehl:

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

Schritt 6: APK bauen

Dieser Schritt kompiliert die App und die nativen Bibliotheken.

1. Wechseln Sie zum Android-Projekt:

   cd llm/android/LlamaDemo

2. Bauen mit Gradle (setzen Sie explizit JAVA_HOME auf 17, um Toolchain-Fehler zu vermeiden):

   Hinweis: Der erste Lauf dauert ein paar Minuten.

   export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64
   ./gradlew :app:assembleDebug

3. Die schließlich erzeugte apk finden Sie unter:

   app/build/outputs/apk/debug/app-debug.apk

Schritt 7: Auf Ihrem Android-Gerät installieren

Sie haben zwei Optionen, um die App zu installieren.

Option A: Mit ADB (kabelgebunden/wireless)

Wenn Sie adb Zugriff auf Ihr Telefon haben:

adb install -r app/build/outputs/apk/debug/app-debug.apk

Option B: Direkte Dateitransfer

Wenn Sie auf einer entfernten VM sind oder kein Kabel haben:

1. Laden Sie die app-debug.apk an einen Ort hoch, von dem Sie sie auf dem Telefon herunterladen können

2. Laden Sie sie auf Ihrem Telefon herunter

3. Tippen Sie zum Installieren (aktivieren Sie "Installation aus unbekannten Quellen zulassen", falls aufgefordert).

Schritt 8: Modelldateien übertragen

Die App benötigt die .pte Modell- und Tokenizer-Dateien.

1. Dateien übertragen: Verschieben Sie Ihre model.pte und tokenizer.bin (oder tokenizer.model) in den Speicher Ihres Telefons (z. B. Downloads-Ordner).

2. LlamaDemo App öffnen: Starten Sie die App auf Ihrem Telefon.

3. Modell auswählen

4. Tippen Sie auf Einstellungen (Zahnrad-Symbol) oder den Dateiauswähler.

5. Navigieren Sie zu Ihrem Download-Ordner.

6. Wählen Sie Ihre .pte-Datei aus.

7. Wählen Sie Ihre Tokenizer-Datei aus.

Fertig! Sie können nun direkt auf Ihrem Gerät mit dem LLM chatten.

Fehlerbehebung

• Build schlägt fehl? Prüfen Sie java -version. Es MUSS 17 sein.

• Modell lädt nicht? Stellen Sie sicher, dass Sie sowohl das .pte ALS AUCH das tokenizer.

• App stürzt ab? Gültige .pte Dateien müssen speziell für ExecuTorch exportiert werden (normalerweise XNNPACK-Backend für die CPU).

Modell auf Ihr Telefon übertragen

Derzeit executorchllama App, die wir gebaut haben, unterstützt das Laden des Modells nur aus einem bestimmten Verzeichnis auf Android, das leider nicht über normale Dateimanager erreichbar ist. Aber wir können die Modellausgaben mit adb in dieses Verzeichnis speichern.

Stellen Sie sicher, dass adb richtig läuft und verbunden ist

adb devices 

1. Wenn Sie über Wireless-Debugging verbunden sind, sehen Sie so etwas:

   

   Oder wenn Sie über ein Kabel verbunden sind:

   

   Wenn Sie dem Computer keine Berechtigungen zum Zugriff auf Ihr Telefon gegeben haben:

   

1. Müssen Sie auf Ihrem Telefon einen Popup-Dialog prüfen, der so aussieht (den Sie zulassen möchten)

Sobald dies erledigt ist, ist es Zeit, den Ordner zu erstellen, in den wir die .pte und tokenizer.json Dateien legen müssen.

Erstellen Sie das genannte Verzeichnis auf dem Telefonpfad.

adb shell mkdir -p /data/local/tmp/llama
adb shell chmod 777 /data/local/tmp/llama

Überprüfen Sie, dass das Verzeichnis korrekt erstellt wurde.

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

Schieben Sie den Inhalt in das genannte Verzeichnis. Dies kann je nach Computer, Verbindung und Telefon ein paar Minuten oder länger dauern. Bitte seien Sie geduldig.

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. Öffnen Sie die executorchllamademo App, die Sie in Schritt 5 installiert haben, und tippen Sie dann auf das Zahnrad oben rechts, um die Einstellungen zu öffnen.

2. Tippen Sie auf den Pfeil neben Model, um den Auswähler zu öffnen und ein Modell auszuwählen. Wenn Sie ein leeres weißes Dialogfeld ohne Dateinamen sehen, ist Ihr ADB-Model-Push wahrscheinlich fehlgeschlagen - wiederholen Sie diesen Schritt. Beachten Sie auch, dass anfänglich "kein Modell ausgewählt" angezeigt werden kann.

3. Nachdem Sie ein Modell ausgewählt haben, sollte die App den Modell-Dateinamen anzeigen.

1. Wiederholen Sie nun das Gleiche für den Tokenizer. Klicken Sie auf den Pfeil neben dem Tokenizer-Feld und wählen Sie die entsprechende Datei aus.

1. Möglicherweise müssen Sie den Modelltyp auswählen, abhängig davon, welches Modell Sie hochladen. Qwen3 ist hier ausgewählt.

1. Sobald Sie beide Dateien ausgewählt haben, klicken Sie auf die Schaltfläche "Load Model".

1. Sie kehren zum ursprünglichen Bildschirm mit dem Chat-Fenster zurück, und es kann "model loading" anzeigen. Je nach RAM und Speichergeschwindigkeit Ihres Telefons kann das Laden ein paar Sekunden dauern.

1. Sobald "successfully loaded model" angezeigt wird, können Sie beginnen, mit dem Modell zu chatten. Et Voila, Sie haben jetzt ein LLM, das nativ auf Ihrem Android-Telefon läuft!

📱ExecuTorch treibt Milliarden an

ExecuTorch ermöglicht On-Device-ML-Erfahrungen für Milliarden von Menschen auf Instagram, WhatsApp, Messenger und Facebook. Instagram Cutouts verwendet ExecuTorch, um editierbare Sticker aus Fotos zu extrahieren. In verschlüsselten Anwendungen wie Messenger ermöglicht ExecuTorch geräteinterne, datenschutzbewusste Spracherkennung und Übersetzung. ExecuTorch unterstützt mehr als ein Dutzend Hardware-Backends über Apple, Qualcomm, ARM und Metas Quest 3 und Ray Bans.

Weitere Modellunterstützung

• Alle Qwen 3 Dense-Modelle (Qwen3-0.6B, Qwen3-4B, Qwen3-32B usw.)

• Alle Gemma 3 Modelle (Gemma3-270M, Gemma3-4B, Gemma3-27B usw.)

• Alle Llama 3 Modelle (Llama 3.1 8B, Llama 3.3 70B Instruct usw.)

• Qwen 2.5, Phi 4 Mini-Modelle und vieles mehr!

Sie können die kostenloses Colab-Notebook für Qwen3-0.6B anpassen, um die Telefonbereitstellung für eines der oben genannten Modelle zu ermöglichen!

Qwen3 0.6B Haupt-Notebook für Telefonbereitstellung

Google Colabcolab.research.google.com

Funktioniert mit Gemma 3

Google Colabcolab.research.google.com

Funktioniert mit Llama 3

Google Colabcolab.research.google.com

Gehen Sie zu unserer Unsloth-Notebooks Seite für alle anderen Notebooks!

🌵 Bereitstellung auf Cactus für Telefone

Cactus ist eine Open-Source-Inferenz-Engine für mobile Geräte, Macs und ARM-Chips wie Raspberry Pi.

• Bei INT8 läuft Cactus Qwen3-0.6B und LFM2-1.2B mit 60-70 toks/sec auf dem iPhone 17 Pro, 13-18 toks/sec auf dem günstigen Pixel 6a.

• Aufgaben-spezifische INT8-Tunes von Gemma3-270m erreichen 150 toks/sec auf dem iPhone 17 Pro und 23 toks/sec auf dem Raspberry Pi.

Schnellstart

1. Trainieren (Google Colab / GPU)

Verwenden Sie das bereitgestellte Notebook oder Ihr eigenes Unsloth-Trainingsskript:

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",
)

# ... train with SFTTrainer ...

# Adapter speichern
model.save_pretrained("my-lora-adapter")
tokenizer.save_pretrained("my-lora-adapter")

# Zum Hub pushen (optional)
model.push_to_hub("username/my-lora-adapter")

2. Cactus einrichten

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

3. Für Cactus konvertieren

# Vom lokalen Adapter: Verwenden Sie das korrekte Basismodell!
cactus convert Qwen/Qwen3-0.6B ./my-qwen3-0.6b --lora ./my-lora-adapter 

# Vom HuggingFace Hub: Verwenden Sie das korrekte Basismodell!
cactus convert Qwen/Qwen3-0.6B ./my-qwen3-0.6b  --lora username/my-lora-adapter 

4. Ausführen

Testen Sie Ihr Modell auf dem Mac:

cactus run ./my-qwen3-0.6b

5. In iOS/macOS App verwenden

Bauen Sie die native Bibliothek:

cactus build --apple

Build abgeschlossen!
Gesamtzeit: 58 Sekunden
Statische Bibliotheken:
  Gerät: /Users/henry/Desktop/cactus/apple/libcactus-device.a
  Simulator: /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
Apple-Build abgeschlossen!
(venv) henry@Henrys-MacBook-Air cactus % 

Link cactus-ios.xcframework zu Ihrem Xcode-Projekt, dann:

import Foundation

// Modell aus dem App-Bundle laden
let modelPath = Bundle.main.path(forResource: "my-model", ofType: nil)!
let model = cactus_init(modelPath, 2048, nil)

// Ausführung der Komplettierung
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))

// Aufräumen
cactus_destroy(model)

Sie können jetzt iOS-Apps mit dem folgenden Code erstellen, aber um die Leistung auf einem Gerät während des Testens zu sehen, führen Sie cactus tests aus, indem Sie ein beliebiges iPhone an Ihren Mac anschließen und dann ausführen:

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

Cactus-Demo-Apps werden schließlich erweitert, um Ihre benutzerdefinierten Feineinstellungen zu verwenden. Außerdem cactus run ermöglicht das Anschließen eines Telefons, sodass die interaktive Sitzung die Chips des Telefons verwendet; auf diese Weise können Sie testen, bevor Sie Ihre Apps vollständig erstellen.

6. Verwendung in einer Android-App

Bauen Sie die native Bibliothek:

cactus build --android

Build abgeschlossen!
Ort der Shared Library: /Users/henry/Desktop/cactus/android/libcactus.so
Ort der statischen Bibliothek: /Users/henry/Desktop/cactus/android/libcactus.a
Android-Build abgeschlossen!
(venv) henry@Henrys-MacBook-Air cactus % 

Kopieren libcactus.so zu app/src/main/jniLibs/arm64-v8a/, dann:

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

// Verwendung
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)

Sie können jetzt Android-Apps mit dem folgenden Code erstellen, aber um die Leistung auf einem Gerät während des Testens zu sehen, führen Sie cactus tests aus, indem Sie ein beliebiges Android-Telefon an Ihren Mac anschließen und dann ausführen:

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

Cactus-Demo-Apps werden schließlich erweitert, um Ihre benutzerdefinierten Feineinstellungen zu verwenden. Außerdem cactus run ermöglicht das Anschließen eines Telefons, sodass die interaktive Sitzung die Chips des Telefons verwendet; auf diese Weise können Sie testen, bevor Sie Ihre Apps vollständig erstellen.

Ressourcen

• Unterstützte Basismodelle: Qwen3, Gemma3, LFM2, SmolLM2

• Vollständige API-Referenz: Cactus Engine

• Erfahren Sie mehr und melden Sie Fehler: Cactus