> 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/de/grundlagen/inference-and-deployment/deploy-llms-phone.md).
# Wie man LLMs auf deinem iOS- oder Android-Telefon ausführt und bereitstellt
Tutorial zum Feinabstimmen deines eigenen LLMs und zur Bereitstellung auf deinem Android- oder iPhone mit ExecuTorch.
Wir freuen uns, zu zeigen, wie du LLMs trainieren kannst und dann **sie lokal bereitstellen kannst** zu **Android-Smartphones** und **iPhones**. Wir haben mit [ExecuTorch](https://github.com/pytorch/executorch/) von PyTorch & Meta zusammengearbeitet, um einen optimierten Workflow mit quantisierungsbewusstem Training ([QAT](/docs/de/blog/quantization-aware-training-qat.md)) zu erstellen und sie dann direkt auf Edge-Geräten bereitzustellen. Mit [Unsloth](https://github.com/unslothai/unsloth), TorchAO und ExecuTorch zeigen wir, wie du Folgendes tun kannst:
* Verwende dieselbe Technologie (ExecuTorch), die Meta für Milliarden auf Instagram und WhatsApp einsetzt
* Deploye Qwen3-0.6B lokal auf **Pixel 8** und **iPhone 15 Pro mit \~40 Tokens/s**
* Wende QAT über TorchAO an, um 70 % der Genauigkeit wiederherzustellen
* Erhalte datenschutzfreundliche, sofortige Antworten und Offline-Funktionen
* Verwenden Sie unseren [kostenloses Colab-Notebook](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_\(0_6B\)-Phone_Deployment.ipynb) um Qwen3 0.6B fein abzustimmen und für die Bereitstellung auf dem Smartphone zu exportieren
iOS-TutorialAndroid-Tutorial
{% columns %}
{% column %}
**Qwen3-4B** auf einem iPhone 15 Pro bereitgestellt
{% endcolumn %}
{% endcolumns %}
### 🦥 Dein Modell trainieren
Wir unterstützen Qwen3, Gemma3, Llama3, Qwen2.5, Phi4 und viele andere Modelle für die Bereitstellung auf dem Smartphone! Folge der [**kostenloses Colab-Notebook**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_\(0_6B\)-Phone_Deployment.ipynb) **für die Bereitstellung von Qwen3-0.6B:**
{% embed url="" %}
Aktualisiere zuerst Unsloth und installiere TorchAO und Executorch.
```bash
pip install --upgrade unsloth unsloth_zoo
pip install torchao==0.14.0 executorch pytorch_tokenizers
```
Dann verwende einfach `qat_scheme = "phone-deployment"` um anzuzeigen, dass wir es auf ein Smartphone bereitstellen möchten. Beachte, dass wir auch `full_finetuning = True` für vollständiges Finetuning setzen!
```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", # Markierung für die Smartphone-Bereitstellung
)
```
Wir verwenden `qat_scheme = "phone-deployment"` wir tatsächlich verwenden `qat_scheme = "int8-int4"` unter der Haube, um Unsloth/TorchAO QAT zu aktivieren, das *simuliert* INT8-Dynamikaktivierungsquantisierung mit INT4-Gewichtsquantisierung für Linear-Schichten während des Trainings (über Fake-Quantisierungsoperationen), während die Berechnungen in 16 Bit bleiben. Nach dem Training wird das Modell in eine echte quantisierte Version umgewandelt, sodass das On-Device-Modell kleiner ist und typischerweise **die Genauigkeit besser beibehält als naives PTQ**.
Nach dem Finetuning wie in der [Colab-Notebook](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_\(0_6B\)-Phone_Deployment.ipynb), speichern wir es dann in einer `.pte` -Datei über Executorch:
{% code expandable="true" %}
```bash
# Konvertiere die State-Dict-Keys des Gewichts-Checkpoints in ein Format, das 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
# In eine ExecuTorch-pte-Datei exportieren
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 %}
### 🏁 Bereitstellung nach dem Training
Und jetzt mit deiner `qwen3_0.6B_model.pte` Datei, die etwa 472 MB groß ist, können wir sie bereitstellen! Wähle dein Gerät und lege direkt los:
* [#ios-deployment](#ios-deployment "mention") – Xcode-Weg, Simulator oder Gerät
* [#android-deployment](#android-deployment "mention") – Kommandozeilen-Weg, kein Unsloth erforderlich
## :apple: iOS-Bereitstellung
Anleitung, um dein Modell auf iOS zum Laufen zu bringen (getestet auf einem iPhone 16 Pro, funktioniert aber auch auf anderen iPhones). Du brauchst ein physisches macOS-basiertes Gerät, das in der Lage ist, XCode 15 auszuführen.
### Einrichtung der macOS-Entwicklungsumgebung
**Xcode und Command Line Tools installieren**
1. Installiere Xcode aus dem Mac App Store (muss Version 15 oder höher sein)
2. Öffne das Terminal und überprüfe deine Installation: `xcode-select -p`
3. Installiere die Command-Line-Tools und akzeptiere die Lizenz:
1. `xcode-select --install`
2. `sudo xcodebuild -license accept`
4. Starte Xcode zum ersten Mal und installiere alle zusätzlichen Komponenten, wenn du dazu aufgefordert wirst
5. Wenn du aufgefordert wirst, Plattformen auszuwählen, wähle iOS 18 und lade es für den Simulator herunter
{% hint style="warning" %}
Wichtig: Der erste Xcode-Start ist entscheidend! Überspringe diese zusätzlichen Komponenteninstallationen nicht! Sieh nach [hier](https://developer.apple.com/documentation/xcode/downloading-and-installing-additional-xcode-components) und [hier](https://developer.apple.com/documentation/safari-developer-tools/adding-additional-simulators) für weitere Hilfe.
{% endhint %}
**Überprüfe, ob alles funktioniert:** `xcode-select -p`
Du solltest einen Pfad ausgegeben sehen. Wenn nicht, wiederhole Schritt 3.
### Einrichtung des Apple-Entwicklerkontos
**Nur für physische Geräte!**
{% hint style="info" %}
Überspringe diesen gesamten Abschnitt, wenn du nur den iOS-Simulator verwendest. Du benötigst nur für die Bereitstellung auf einem physischen iPhone ein kostenpflichtiges Entwicklerkonto.
{% endhint %}
{% columns %}
{% column %}
**Erstelle deine Apple-ID**
Du hast keine Apple-ID?[ Hier registrieren](https://support.apple.com/en-us/108647?device-type=iphone).
#### **Füge dein Konto zu Xcode hinzu**
1. Öffne Xcode
2. Navigiere zu Xcode → Einstellungen → Accounts
3. Klicke auf die + Schaltfläche und wähle Apple ID
4. Melde dich mit deiner regulären Apple-ID an
{% endcolumn %}
{% column %}
{% endcolumn %}
{% endcolumns %}
#### **Melde dich beim Apple Developer Program an**
ExecuTorch erfordert die `Fähigkeit für erhöhtes Speicherlimit`, wofür ein kostenpflichtiges Entwicklerkonto erforderlich ist:
1. Besuche[ developer.apple.com](https://developer.apple.com)
2. Melde dich mit deiner Apple-ID an
3. Melde dich beim Apple Developer Program an
### Richte die ExecuTorch-Demo-App ein
**Hol dir den Beispielcode:**
```bash
# Lade 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
```
{% columns %}
{% column %}
**In Xcode öffnen**
1. Öffnen `apple/etLLM.xcodeproj` in Xcode
2. Wähle in der oberen Symbolleiste `iPhone 16 Pro` Simulator als Zielgerät aus
3. Drücke Play (▶️), um zu bauen und auszuführen
🎉 Erfolg! Die App sollte jetzt im Simulator starten. Sie wird noch nicht funktionieren, wir müssen dein Modell hinzufügen.
{% endcolumn %}
{% column %}
{% endcolumn %}
{% endcolumns %}
### Bereitstellung auf dem Simulator
**Es ist kein Entwicklerkonto erforderlich.**
**Bereite deine Modelldateien vor**
1. Stoppe den Simulator in Xcode (drücke den Stop-Button)
2. Navigiere zu deinem HuggingFace-Hub-Repo (falls nicht lokal gespeichert)
3. Lade diese zwei Dateien herunter:
1. `qwen3_0.6B_model.pte` (dein exportiertes Modell)
2. tokenizer.json (der Tokenizer)
**Erstelle einen gemeinsamen Ordner im Simulator**
1. Klicke im Simulator auf die virtuelle Home-Schaltfläche
2. Öffne die Dateien-App → Durchsuchen → Auf meinem iPhone
3. Tippe auf die Ellipsis-Schaltfläche (•••) und erstelle einen neuen Ordner mit dem Namen `Qwen3test`
**Dateien über das Terminal übertragen**
```bash
# Finde den versteckten Ordner des Simulators
find ~/Library/Developer/CoreSimulator/Devices/ -type d -iname "*Qwen3test*"
```
Wenn du den Ordner siehst, führe Folgendes aus:
```bash
cp tokenizer.json /path/to/Qwen3test/tokenizer.json
cp qwen3_0.6B_model.pte /path/to/Qwen3test/qwen3_model.pte
```
**Laden & Chatten**
{% columns %}
{% column %}
1. Wechsle zurück zur etLLM-App im Simulator. Tippe sie an, um sie zu starten.
{% endcolumn %}
{% column %}
2\. Lade das Modell und den Tokenizer aus dem Ordner Qwen3test
{% endcolumn %}
{% column %}
3\. Beginne mit deinem fein abgestimmten Modell zu chatten! 🎉
{% endcolumn %}
{% endcolumns %}
### Bereitstellung auf deinem physischen iPhone
**Ersteinrichtung des Geräts**
1. Verbinde dein iPhone per USB mit deinem Mac
2. Entsperre dein iPhone und tippe auf „Diesem Gerät vertrauen“
3. Gehe in Xcode zu Fenster → Geräte und Simulatoren
4. Warte, bis dein Gerät links erscheint (es kann eine Weile „Preparing“ anzeigen)
**Xcode-Signing konfigurieren**
{% columns %}
{% column %}
1. Füge dein Apple-Konto hinzu: Xcode → Einstellungen → Accounts → `+`
2. Klicke im Projekt-Navigator auf das etLLM-Projekt (blaues Symbol)
3. Wähle etLLM unter TARGETS aus
4. Gehe zum Tab Signing & Capabilities
5. Aktiviere „Automatically manage signing“
6. Wähle dein Team aus dem Dropdown-Menü aus
{% endcolumn %}
{% column %}
{% endcolumn %}
{% endcolumns %}
{% hint style="warning" %}
Ändere die Bundle Identifier in etwas Eindeutiges (z. B. com.deinname.etLLM). Das behebt 99 % der Probleme mit dem Provisioning-Profil
{% endhint %}
**Die erforderliche Fähigkeit hinzufügen**
1. Bleibe in Signing & Capabilities und klicke auf + Capability
2. Suche nach „Increased Memory Limit“ und füge es hinzu
**Bauen & Ausführen**
1. Wähle in der oberen Symbolleiste dein physisches iPhone im Gerätauswahlmenü aus
2. Drücke Play (▶️) oder Cmd + R
**Dem Entwicklerzertifikat vertrauen**
Dein erster Build wird fehlschlagen – das ist normal!
1. Gehe auf deinem iPhone zu Einstellungen → Datenschutz & Sicherheit → Entwicklermodus
2. Einschalten
3. Zustimmen und Hinweise akzeptieren
4. Gerät neu starten, zu Xcode zurückkehren und erneut auf Play drücken
{% hint style="warning" %}
Der Entwicklermodus erlaubt XCode, Apps auf deinem iPhone auszuführen und zu installieren
{% endhint %}
**Modelldateien auf dein iPhone übertragen**
1. Sobald die App läuft, öffne den Finder auf deinem Mac
2. Wähle dein iPhone in der Seitenleiste aus
3. Klicke auf den Reiter Files
4. Erweitere etLLM
5. Ziehe deine .pte- und tokenizer.json-Dateien direkt in diesen Ordner
6. Hab Geduld! Diese Dateien sind groß und können ein paar Minuten dauern
**Laden & Chatten**
{% columns %}
{% column %}
1. Wechsle auf deinem iPhone zurück zur etLLM-App
2. Lade das Modell und den Tokenizer über die App-Oberfläche
{% endcolumn %}
{% column %}
3\. Dein fein abgestimmtes Qwen3 läuft jetzt nativ auf deinem iPhone!
{% endcolumn %}
{% endcolumns %}
## :android: 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-Smartphones) unter Verwendung einer Linux-/Mac-Kommandozeilenumgebung. Dieser Ansatz minimiert Abhängigkeiten (kein Android Studio erforderlich) und verlagert den aufwendigen Build-Prozess auf deinen Computer.
### Anforderungen
Stelle sicher, dass auf deinem Entwicklungsrechner Folgendes installiert ist:
* Java 17 (Java 21 ist oft die Standardversion, kann aber Build-Probleme verursachen)
* Git
* Wget / Curl
* Android Command Line Tools
* [Anleitung zur Installation](https://www.xda-developers.com/install-adb-windows-macos-linux/) und Einrichtung `adb` auf deinem Android-Gerät und deinem Computer
#### Überprüfung
Prüfe, ob deine Java-Version 17.x entspricht:
```bash
# Die Ausgabe sollte etwa so aussehen: openjdk version "17.0.x"
java -version
```
Wenn das nicht übereinstimmt, installiere es über Ubuntu/Debian:
```bash
sudo apt install openjdk-17-jdk
```
Setze es dann als Standard oder exportiere `JAVA_HOME`:
```bash
export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64
export PATH=$JAVA_HOME/bin:$PATH
```
Wenn du ein anderes Betriebssystem oder eine andere Distribution verwendest, möchtest du vielleicht [diese Anleitung](https://docs.oracle.com/en/java/javase/25/install/overview-jdk-installation.html) befolgen oder einfach dein bevorzugtes LLM bitten, dich durchzuführen.
### Schritt 1: Android SDK & NDK installieren
Richte eine minimale Android-SDK-Umgebung ohne das vollständige Android Studio ein.
1\. Erstelle das SDK-Verzeichnis:
```bash
mkdir -p ~/android-sdk/cmdline-tools
cd ~/android-sdk
```
2. Android Command Line Tools installieren
```bash
wget https://dl.google.com/android/repository/commandlinetools-linux-11076708_latest.zip
unzip commandlinetools-linux-*.zip -d cmdline-tools
# Wichtig: Neu anordnen, um die SDK-Struktur zu erfüllen
mv cmdline-tools/cmdline-tools cmdline-tools/latest
```
### Schritt 2: Umgebungsvariablen konfigurieren
Füge diese zu deiner `~/.bashrc` oder `~/.zshrc`:
```bash
export ANDROID_HOME=$HOME/android-sdk
export PATH=$ANDROID_HOME/cmdline-tools/latest/bin:$PATH
export PATH=$ANDROID_HOME/platform-tools:$PATH
```
Lade sie neu:
```bash
source ~/.zshrc # oder ~/.bashrc, je nach deiner Shell
```
### Schritt 3: SDK-Komponenten installieren
ExecuTorch erfordert bestimmte NDK-Versionen.
```bash
# Lizenzen akzeptieren
yes | sdkmanager --licenses
# API 34 und NDK 25 installieren
sdkmanager "platforms;android-34" "platform-tools" "build-tools;34.0.0" "ndk;25.0.8775105"
```
NDK-Variable setzen:
```bash
export ANDROID_NDK=$ANDROID_HOME/ndk/25.0.8775105
```
### Schritt 4: Den Code holen
Wir verwenden das `executorch-examples` Repository, das die aktualisierte Llama-Demo enthält.
```bash
cd ~
git clone https://github.com/meta-pytorch/executorch-examples.git
cd executorch-examples
```
### Schritt 5: Häufige Kompilierungsprobleme beheben
Beachte, dass der aktuelle Code diese Probleme nicht hat, wir ihnen jedoch zuvor begegnet sind und sie dir helfen könnten:
**Behebung von „SDK Location not found“:**
Erstelle eine `local.properties` -Datei, um Gradle explizit mitzuteilen, wo sich das SDK befindet:
```bash
echo "sdk.dir=$HOME/android-sdk" > llm/android/LlamaDemo/local.properties
```
**Behebung von `cannot find symbol` -Fehler:**
Der aktuelle Code verwendet eine veraltete Methode `getDetailedError()`. Patch ihn mit diesem Befehl:
```bash
sed -i 's/e.getDetailedError()/e.getMessage()/g' llm/android/LlamaDemo/app/src/main/java/com/example/executorchllamademo/MainActivity.java
```
### Schritt 6: Das APK bauen
Dieser Schritt kompiliert die App und die nativen Bibliotheken.
1. Navigiere zum Android-Projekt:
```bash
cd llm/android/LlamaDemo
```
2. Mit Gradle bauen (setze explizit `JAVA_HOME` auf 17, um Toolchain-Fehler zu vermeiden):
Hinweis: Der erste Lauf wird ein paar Minuten dauern.
```bash
export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64
./gradlew :app:assembleDebug
```
3. Das endgültig generierte APK findest du unter:
```
app/build/outputs/apk/debug/app-debug.apk
```
### Schritt 7: Auf deinem Android-Gerät installieren
Du hast zwei Möglichkeiten, die App zu installieren.
#### Option A: Mit ADB (Kabel/Wireless)
Wenn du `adb` Zugriff auf dein Telefon hast:
```bash
adb install -r app/build/outputs/apk/debug/app-debug.apk
```
#### Option B: Direkte Dateiübertragung
Wenn du auf einer entfernten VM bist oder kein Kabel hast:
1. Lade app-debug.apk an einen Ort hoch, von dem du es auf dem Telefon herunterladen kannst
2. Lade es auf deinem Telefon herunter
3. Tippe zum Installieren (aktiviere „Aus unbekannten Quellen installieren“, wenn du dazu aufgefordert wirst).
### Schritt 8: Modelldateien übertragen
Die App benötigt die .pte-Modell- und Tokenizer-Dateien.
1. Dateien übertragen: Verschiebe deine model.pte und tokenizer.bin (oder tokenizer.model) in den Speicher deines Telefons (z. B. den Downloads-Ordner).
2. LlamaDemo-App öffnen: Starte die App auf deinem Telefon.
3. Modell auswählen
4. Tippe auf Einstellungen (Zahnradsymbol) oder den Dateiauswahldialog.
5. Navigiere zu deinem Downloads-Ordner.
6. Wähle deine .pte-Datei aus.
7. Wähle deine Tokenizer-Datei aus.
Fertig! Jetzt kannst du direkt auf deinem Gerät mit dem LLM chatten.
### Fehlerbehebung
* Build schlägt fehl? Prüfe java -version. Es MUSS 17 sein.
* Modell lädt nicht? Stelle sicher, dass du sowohl das `.pte` UND den `Tokenizer`.
* App stürzt ab? Gültige `.pte` Dateien müssen speziell für ExecuTorch exportiert werden (normalerweise XNNPACK-Backend für CPU).
### Das Modell auf dein Telefon übertragen
Derzeit, `executorchllama` die App, die wir gebaut haben, unterstützt das Laden des Modells auf Android nur aus einem bestimmten Verzeichnis, auf das leider über reguläre Dateimanager nicht zugegriffen werden kann. Wir können die Modelldateien jedoch mit adb in dieses Verzeichnis speichern.
#### Stelle sicher, dass adb korrekt läuft und verbunden ist
```shellscript
adb devices
```
{% columns %}
{% column %}
1. Wenn du dich über Wireless Debugging verbunden hast, würdest du so etwas sehen:
Oder wenn du dich per Kabel verbunden hast:
Wenn du dem Computer keine Berechtigung erteilt hast, auf dein Telefon zuzugreifen:
{% endcolumn %}
{% column %}
2\. Dann musst du auf deinem Telefon nach einem Popup-Dialog suchen, der so aussieht (den du möglicherweise zulassen möchtest)
{% endcolumn %}
{% endcolumns %}
Sobald das erledigt ist, ist es Zeit, den Ordner zu erstellen, in den wir die `.pte` und `tokenizer.json` -Dateien ablegen müssen.
Erstelle das genannte Verzeichnis auf dem Pfad des Telefons.
```shellscript
adb shell mkdir -p /data/local/tmp/llama
adb shell chmod 777 /data/local/tmp/llama
```
Überprüfe, ob das Verzeichnis korrekt erstellt wurde.
```shellscript
adb shell ls -l /data/local/tmp/llama
total 0
```
Übertrage den Inhalt in das genannte Verzeichnis. Das kann je nach deinem Computer, der Verbindung und dem Telefon ein paar Minuten oder länger dauern. Bitte hab Geduld.
```shellscript
adb push /data/local/tmp/llama
adb push /data/local/tmp/llama
```
{% columns %}
{% column %}
1. Öffnen Sie den `executorchllamademo` App, die du in Schritt 5 installiert hast, und tippe dann auf das Zahnradsymbol oben rechts, um die Einstellungen zu öffnen.
2. Tippe auf den Pfeil neben „Model“, um den Auswahlbereich zu öffnen und ein Modell auszuwählen.\
Wenn du einen leeren weißen Dialog ohne Dateinamen siehst, ist das Hochladen deines ADB-Modells wahrscheinlich fehlgeschlagen – wiederhole diesen Schritt. Beachte auch, dass dort zunächst möglicherweise „kein Modell ausgewählt“ angezeigt wird.
3. Nachdem du ein Modell ausgewählt hast, sollte die App den Dateinamen des Modells anzeigen.
{% endcolumn %}
{% column %}
{% endcolumn %}
{% endcolumns %}
{% columns %}
{% column %}
5\. Wiederhole das jetzt für den Tokenizer. Klicke auf den Pfeil neben dem Tokenizer-Feld und wähle die entsprechende Datei aus.
{% endcolumn %}
{% column %}
6\. Möglicherweise musst du den Modelltyp auswählen, je nachdem, welches Modell du hochlädst. Hier ist Qwen3 ausgewählt.
{% endcolumn %}
{% column %}
7\. Sobald du beide Dateien ausgewählt hast, klicke auf die Schaltfläche „Modell laden“.
{% endcolumn %}
{% endcolumns %}
{% columns %}
{% column %}
8\. Es bringt dich zurück zum ursprünglichen Bildschirm mit dem Chatfenster, und dort könnte „Modell wird geladen“ angezeigt werden. Das Laden kann je nach RAM und Speichergeschwindigkeit deines Telefons einige Sekunden dauern.
{% endcolumn %}
{% column %}
9\. Sobald dort „Modell erfolgreich geladen“ steht, kannst du mit dem Modell chatten.\
\
Et voilà, jetzt läuft ein LLM nativ auf deinem Android-Smartphone!
{% endcolumn %}
{% endcolumns %}
### :mobile\_phone:ExecuTorch ermöglicht Milliarden von
ExecuTorch [ermöglicht ML-Erlebnisse auf dem Gerät für Milliarden von Menschen](https://engineering.fb.com/2025/07/28/android/executorch-on-device-ml-meta-family-of-apps/) auf Instagram, WhatsApp, Messenger und Facebook. Instagram Cutouts nutzt ExecuTorch, um aus Fotos bearbeitbare Sticker zu extrahieren. In verschlüsselten Anwendungen wie Messenger ermöglicht ExecuTorch datenschutzbewusste Spracherkennung und -übersetzung direkt auf dem Gerät. ExecuTorch unterstützt über ein Dutzend Hardware-Backends für Apple, Qualcomm, ARM und [Metas Quest 3 und Ray-Bans](https://ai.meta.com/blog/executorch-reality-labs-on-device-ai/).
## Weitere Modellunterstützung
* Alle Qwen-3-Dense-Modelle ([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) usw.)
* Alle Gemma-3-Modelle ([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) usw.)
* Alle Llama-3-Modelle ([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) usw.)
* Qwen 2.5, Phi-4-Mini-Modelle und vieles mehr!
Du kannst das [**kostenloses Colab-Notebook**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_\(0_6B\)-Phone_Deployment.ipynb) für Qwen3-0.6B anpassen, um die Bereitstellung auf dem Smartphone für eines der oben genannten Modelle zu ermöglichen!
{% columns %}
{% column %}
**Haupt-Notebook für die Telefonbereitstellung von Qwen3 0.6B**
{% embed url="" %}
{% endcolumn %}
{% column %}
Funktioniert mit Gemma 3
{% embed url="" %}
{% endcolumn %}
{% column %}
Funktioniert mit Llama 3
{% embed url="" %}
{% endcolumn %}
{% endcolumns %}
Gehe zu unserer [Unsloth-Notebooks](/docs/de/loslegen/unsloth-notebooks.md) Seite für alle anderen 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/de/grundlagen/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.
