> 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 Wir freuen uns, zu zeigen, wie du LLMs trainieren kannst, und dann **sie lokal bereitstellen** zu **Android-Telefone** und **iPhones**. Wir haben zusammengearbeitet mit [ExecuTorch](https://github.com/pytorch/executorch/) von PyTorch & Meta, um einen optimierten Workflow unter Verwendung von quantisierungsbewusstem Training ([QAT](/docs/de/blog/quantization-aware-training-qat.md)) und sie dann direkt auf Edge-Geräten bereitzustellen. Mit [Unsloth](https://github.com/unslothai/unsloth), TorchAO und ExecuTorch zeigen wir, wie du: * Verwende dieselbe Technologie (ExecuTorch), die Meta einsetzt, um Milliarden auf Instagram, WhatsApp * Qwen3-0.6B lokal bereitstellen auf **Pixel 8** und **iPhone 15 Pro mit \~40 Tokens/s** * Wende QAT über TorchAO an, um 70 % der Genauigkeit wiederherzustellen * Erhalte Datenschutz an erster Stelle, sofortige Antworten und Offline-Funktionen * Nutze unser [kostenloses Colab-Notebook](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_\(0_6B\)-Phone_Deployment.ipynb) um Qwen3 0.6B feinabzustimmen und für die Bereitstellung auf dem Smartphone zu exportieren iOS-TutorialAndroid-Tutorial {% columns %} {% column %} **Qwen3-4B** auf einem iPhone 15 Pro bereitgestellt
{% endcolumn %} {% column %} **Qwen3-0.6B** läuft mit \~40 Tokens/s
{% 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 zu signalisieren, dass wir es auf einem Smartphone bereitstellen wollen. Beachte, dass wir auch `full_finetuning = True` für ein vollständiges Fine-Tuning 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", # Flag für die Bereitstellung auf dem Smartphone ) ``` 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-dynamische Aktivierungsquantisierung 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 konvertiert, sodass das On-Device-Modell kleiner ist und typischerweise **behält die Genauigkeit besser bei als naive PTQ**. Nach dem Fine-Tuning, wie im [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 Schlüssel des State Dict des Gewichtungs-Checkpoints in ein Format, das ExecuTorch erwartet python -m executorch.examples.models.qwen3.convert_weights "phone_model" pytorch_model_converted.bin # Lade die Modellkonfiguration aus dem ExecuTorch-Repo herunter 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 leg 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 Tutorial, um dein Modell auf iOS zum Laufen zu bringen (getestet auf einem iPhone 16 Pro, funktioniert aber auch auf anderen iPhones). Du benötigst ein physisches macOS-basiertes Gerät, das in der Lage sein muss, Xcode 15 auszuführen. ### Einrichtung der macOS-Entwicklungsumgebung **Xcode & 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 Kommandozeilentools 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 Zugriff auf den Simulator herunter {% hint style="warning" %} Wichtig: Der erste Start von Xcode ist entscheidend! Überspringe diese zusätzlichen Komponenteninstallationen nicht! Prüfe [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. Falls nicht, wiederhole Schritt 3. ![](/files/b7ccb945ba53525de25a6a89164ab5dc93253ea7) ### Einrichtung des Apple-Entwicklerkontos **Nur für physische Geräte!** {% hint style="info" %} Überspringe diesen gesamten Abschnitt, wenn du nur den iOS-Simulator verwendest. Ein kostenpflichtiges Entwicklerkonto brauchst du nur für die Bereitstellung auf einem physischen iPhone. {% 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 in Xcode hinzu** 1. Öffne Xcode 2. Navigiere zu Xcode → Einstellungen → Accounts 3. Klicke auf die +-Schaltfläche und wähle Apple ID aus 4. Melde dich mit deiner normalen Apple ID an {% endcolumn %} {% column %}
{% endcolumn %} {% endcolumns %} #### **Melde dich beim Apple Developer Program an** ExecuTorch benötigt 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 Sie `apple/etLLM.xcodeproj` in Xcode 2. Wähle in der oberen Symbolleiste `iPhone 16 Pro` den Simulator als Zielgerät aus 3. Drücke auf Play (▶️), um zu bauen und auszuführen 🎉 Erfolg! Die App sollte jetzt im Simulator starten. Sie funktioniert noch nicht; wir müssen dein Modell hinzufügen. {% endcolumn %} {% column %}
{% endcolumn %} {% endcolumns %} ### Bereitstellung im Simulator **Es wird kein Entwicklerkonto benötigt.** **Bereite deine Modelldateien vor** 1. Stoppe den Simulator in Xcode (drücke den Stopp-Button) 2. Navigiere zu deinem HuggingFace-Hub-Repo (sofern nicht lokal gespeichert) 3. Lade diese beiden Dateien herunter: 1. `qwen3_0.6B_model.pte` (dein exportiertes Modell) 2. tokenizer.json (der Tokenizer) **Erstelle einen geteilten Ordner im Simulator** 1. Klicke im Simulator auf die virtuelle Home-Taste 2. Öffne die Dateien-App → Durchsuchen → Auf meinem iPhone 3. Tippe auf die Ellipsen-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 gefunden hast, 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. Kehre in der etLLM-App im Simulator zurück. Tippe sie an, um sie zu starten.
{% endcolumn %} {% column %} 2\. Lade das Modell und den Tokenizer aus dem Qwen3test-Ordner
{% endcolumn %} {% column %} 3\. Beginne, mit deinem feinabgestimmten 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. Wechsle zum Tab Signing & Capabilities 5. Aktiviere „Automatically manage signing“ 6. Wähle dein Team aus dem Dropdown-Menü {% endcolumn %} {% column %}
{% endcolumn %} {% endcolumns %} {% hint style="warning" %} Ändere den Bundle Identifier in etwas Einzigartiges (z. B. com.yourname.etLLM). Das behebt 99 % der Provisioning-Profile-Fehler {% endhint %} **Füge die erforderliche Fähigkeit hinzu** 1. Bleibe in Signing & Capabilities und klicke auf + Capability 2. Suche nach „Increased Memory Limit“ und füge es hinzu **Build & Run** 1. Wähle in der oberen Symbolleiste dein physisches iPhone im Geräteauswahlmenü aus 2. Drücke auf Play (▶️) oder Cmd + R **Vertraue dem Entwicklerzertifikat** 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 es 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 Dateien 4. etLLM aufklappen 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 feinabgestimmtes Qwen3 läuft jetzt nativ auf deinem iPhone!
{% endcolumn %} {% endcolumns %} ## :android: Android-Bereitstellung Diese Anleitung beschreibt, wie du die ExecuTorch-Llama-Demo-App auf einem Android-Gerät baust und installierst (getestet mit Pixel 8, funktioniert aber auch auf anderen Android-Telefonen) – mit einer Linux-/Mac-Kommandozeilenumgebung. Dieser Ansatz minimiert Abhängigkeiten (kein Android Studio erforderlich) und verlagert den aufwändigen Build-Prozess auf deinen Computer. ### Anforderungen Stelle sicher, dass auf deinem Entwicklungsrechner Folgendes installiert ist: * Java 17 (Java 21 ist oft der Standard, 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 ``` Falls das nicht übereinstimmt, installiere es unter 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, solltest du vielleicht [dieser Anleitung folgen](https://docs.oracle.com/en/java/javase/25/install/overview-jdk-installation.html) oder einfach dein bevorzugtes LLM um eine Führung bitten. ### 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 einzuhalten 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 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" ``` Setze die NDK-Variable: ```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 aber früher begegnet sind und sie dir hilfreich sein könnten: **Beheben: „SDK Location not found“:** Erstelle eine `local.properties` Datei, um Gradle ausdrücklich mitzuteilen, wo sich das SDK befindet: ```bash echo "sdk.dir=$HOME/android-sdk" > llm/android/LlamaDemo/local.properties ``` **Beheben `cannot find symbol` Fehler:** Der aktuelle Code verwendet eine veraltete Methode `getDetailedError()`. Patch es 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 In diesem Schritt werden die App und die nativen Bibliotheken kompiliert. 1. Navigiere zum Android-Projekt: ```bash cd llm/android/LlamaDemo ``` 2. Mit Gradle bauen (explizit setzen `JAVA_HOME` auf 17, um Toolchain-Fehler zu vermeiden): Hinweis: Der erste Durchlauf wird ein paar Minuten dauern. ```bash export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64 ./gradlew :app:assembleDebug ``` 3. Das final erzeugte 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 (per Kabel/Funk) 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 arbeitest oder kein Kabel hast: 1. Lade die app-debug.apk an einen Ort hoch, von dem du sie auf dem Telefon herunterladen kannst 2. Lade sie auf deinem Telefon herunter 3. Zum Installieren tippen (falls du dazu aufgefordert wirst, „Install from unknown sources“ aktivieren). ### 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 Download-Ordner. 6. Wähle deine .pte-Datei aus. 7. Wähle deine Tokenizer-Datei aus. Fertig! Du kannst jetzt direkt auf deinem Gerät mit dem LLM chatten. ### Fehlerbehebung * Build fehlgeschlagen? Prüfe java -version. Es MUSS 17 sein. * Modell lädt nicht? Stelle sicher, dass du sowohl das `.pte` UND das `Tokenizer`. * App stürzt ab? Gültige `.pte` Dateien müssen speziell für ExecuTorch exportiert werden (normalerweise XNNPACK-Backend für CPU). ### Modell auf dein Telefon übertragen Derzeit `executorchllama` die von uns gebaute App unterstützt das Laden des Modells nur aus einem bestimmten Verzeichnis auf Android, das leider nicht über normale Dateimanager zugänglich ist. Aber wir können die Modelldateien mit adb in dieses Verzeichnis speichern. #### Stelle sicher, dass adb ordnungsgemäß läuft und verbunden ist ```shellscript adb devices ``` {% columns %} {% column %} 1. Wenn du über drahtloses Debugging verbunden bist, würdest du etwa Folgendes sehen:
Oder wenn du per Kabel verbunden bist:
Wenn du dem Computer keine Berechtigung für den Zugriff auf dein Telefon gegeben hast:
{% 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 legen müssen. Erstelle das genannte Verzeichnis im 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 ordnungsgemäß erstellt wurde. ```shellscript adb shell ls -l /data/local/tmp/llama insgesamt 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 etwas Geduld. ```shellscript adb push /data/local/tmp/llama adb push /data/local/tmp/llama ```
{% columns %} {% column %} 1. Öffne die `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 die Auswahl zu öffnen und ein Modell auszuwählen.\ Wenn du einen leeren weißen Dialog ohne Dateiname siehst, ist dein ADB-Modell-Upload wahrscheinlich fehlgeschlagen – wiederhole diesen Schritt. Beachte außerdem, dass dort zunächst möglicherweise „kein Modell ausgewählt“ angezeigt wird. 3. Nachdem du ein Modell ausgewählt hast, sollte die App den Modell-Dateinamen anzeigen. {% endcolumn %} {% column %}
{% endcolumn %} {% endcolumns %} {% columns %} {% column %} 5\. Wiederhole das nun 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. Qwen3 ist hier ausgewählt.
{% endcolumn %} {% column %} 7\. Sobald du beide Dateien ausgewählt hast, klicke auf die Schaltfläche „Modell laden“.
{% endcolumn %} {% endcolumns %} {% columns %} {% column %} 8\. Du wirst zum ursprünglichen Bildschirm mit dem Chatfenster zurückgebracht, und möglicherweise wird „Modell wird geladen“ angezeigt. Je nach RAM und Speichergeschwindigkeit deines Telefons kann das Laden 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-Telefon!
{% endcolumn %} {% endcolumns %} ### :mobile\_phone:ExecuTorch treibt Milliarden an 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 verwendet ExecuTorch, um bearbeitbare Sticker aus Fotos zu extrahieren. In verschlüsselten Anwendungen wie Messenger ermöglicht ExecuTorch datenschutzbewusste Sprachidentifizierung und Übersetzung direkt auf dem Gerät. ExecuTorch unterstützt über ein Dutzend Hardware-Backends auf Apple, Qualcomm, ARM und [Metas Quest 3 und Ray-Bans](https://ai.meta.com/blog/executorch-reality-labs-on-device-ai/). ## Unterstützung für weitere Modelle * 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 Telefon für eines der obigen Modelle zu ermöglichen! {% columns %} {% column %} **Qwen3 0.6B Haupt-Notebook für die Bereitstellung auf dem Telefon** {% 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/los-gehts/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 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/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 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.