Anwendungen für das reComputer RK3576 Module Dev Kit

Zuletzt aktualisiert:

Anwendungen

Lokale LLMs und VLMs mit dem RK1820 ausführen

Der RK1820 eignet sich nicht nur für Leistungstests von Modellen, sondern auch für die Bereitstellung lokaler LLMs (Large Language Models) und VLMs (Vision-Language Models) auf dem reComputer RK3576 über rkllm3-server. Zudem ermöglicht er die Entwicklung lokaler KI-Anwendungen über eine OpenAI-kompatible API.

Dieses Beispiel zeigt:

  • Aufbau eines lokalen LLM-Chat-Dienstes mit Qwen3.5-0.8B

  • Aufbau eines lokalen Bildverstehungsdienstes mit Qwen2.5-VL-3B_prune

rkllm3-server basiert auf der RKNPU3 und stellt LLM-Inferenz über eine OpenAI-kompatible Chat-API bereit. Er lässt sich in Python-Anwendungen, Web-UIs und andere Agent-Frameworks integrieren.

Voraussetzungen

Bevor Sie dieses Tutorial beginnen, stellen Sie sicher, dass die Installation des RK1820 sowie die Konfiguration der RKNN3 Runtime abgeschlossen sind. Führen Sie zur Überprüfung folgenden Befehl aus:

Plain
rknn-smi info -l

Der RK1820 muss ordnungsgemäß erkannt werden.

Ein lokales LLM ausführen

In diesem Beispiel wird Qwen3.5-0.8B verwendet.

Das Modellverzeichnis enthält:

Plain
Qwen2.5-VL-3B_prune/
├── Qwen2.5-VL-3B_prune.embed.bin
├── Qwen2.5-VL-3B_prune.tokenizer.gguf
├── llm_Qwen2.5-VL-3B_prune.rknn
├── llm_Qwen2.5-VL-3B_prune.weight
├── vision_Qwen2.5-VL-3B_prune.rknn
└── vision_Qwen2.5-VL-3B_prune.weight

Wechseln Sie in das Modellverzeichnis:

Plain
cd ~/Downloads/Qwen3.5-0.8B

Den lokalen LLM-Server starten

Führen Sie aus:

Plain
rkllm3-server \
-m Qwen3.5-0.8B.rknn \
--weight Qwen3.5-0.8B.weight \
--vocab Qwen3.5-0.8B.tokenizer.gguf \
--embed Qwen3.5-0.8B.embed.bin \
--host 0.0.0.0 \
--port 8080 \
-c 1024 \
--n_predict 256 \
--core-mask 0xff \
--repeat-penalty 1.1 \
--presence-penalty 1.0 \
--frequency-penalty 1.0 \
--top-k 1 \
--top-p 0.8 \
--temp 0.8

Der Server unterstützt:

Der offizielle rkllm3-server von Rockchip lädt das lokale LLM aus den Dateien model, weight, vocab und embed. Er ermöglicht zudem die Konfiguration der Kontextlänge, der maximalen Anzahl an Ausgabetokens sowie der NPU-Core-Maske.

Nach erfolgreichem Laden des Modells erscheint eine Ausgabe wie diese:

Plain
rknn3_model_init success!
main: model loaded
server is listening on http://0.0.0.0:8080

Damit ist die lokale LLM-API gestartet.

Mit dem lokalen LLM chatten

Öffnen Sie ein weiteres Terminalfenster.

Installieren Sie das Python OpenAI SDK:

Plain
pip3 install openai

Erstellen Sie ein Testprogramm:

Plain
nano llm_chat.py

Schreiben:

Plain
from openai import OpenAI

client = OpenAI(
    base_url="http://127.0.0.1:8080/v1",
    api_key="sk-no-key-required"
)

response = client.chat.completions.create(
    model="",
    messages=[
        {
            "role": "user",
            "content": "Explain edge AI in three sentences."
        }
    ],
    stream=True,
    extra_body={
        "n_keep": 0,
        "cache_prompt": False,
        "id_slot": 0,
        "n_predict": 256
    }
)

for chunk in response:
    content = chunk.choices[0].delta.content

    if content:
        print(content, end="", flush=True)

print()

Ausführen:

Plain
python3 llm_chat.py

Das Modell generiert Antworten lokal über den RK1820.

Das offizielle Rockchip-Beispiel verwendet ebenfalls client.chat.completions.create(), um auf den lokalen RKLLM3-Server zuzugreifen, und unterstützt Parameter wie Streaming, KV-Cache und maximale Ausgabe-Tokens.

Leistung von Qwen3.5-0.8B

Gemessen auf dem reComputer RK3576 Dev Kit mit RK1820 AI-Beschleuniger:

Die Testergebnisse zeigen, dass Qwen3.5-0.8B ungefähr folgende Werte erreicht:

Generierungsgeschwindigkeit: ca. 92,89 Tokens/s

Es erfüllt die Anforderungen von Echtzeit-Anwendungen wie lokalen Chat-Assistenten, Textgenerierung und Befehlsverständnis.

Lokales VLM ausführen

Neben reinen Text-LLMs kann der RK1820 auch VLMs (Vision-Language Models) ausführen.

Dieses Beispiel nutzt:

Qwen2.5-VL-3B_prune

Dieses Modell kann verarbeiten:

Plain
Image + Prompt
      ↓
Vision Encoder
      ↓
Multimodal LLM
      ↓
Text Response

Das bedeutet, dass Anwendungen wie Bildbeschreibung, Szenenverständnis und visuelle Frage-Antwort-Systeme implementiert werden können.

Vorbereitung von Qwen2.5-VL-3B_prune

Das Modellverzeichnis enthält:

Plain
Qwen2.5-VL-3B_prune/
├── Qwen2.5-VL-3B_prune.embed.bin
├── Qwen2.5-VL-3B_prune.tokenizer.gguf
├── llm_Qwen2.5-VL-3B_prune.rknn
├── llm_Qwen2.5-VL-3B_prune.weight
├── vision_Qwen2.5-VL-3B_prune.rknn
└── vision_Qwen2.5-VL-3B_prune.weight

Die Laufzeitumgebung von Qwen2.5-VL umfasst ein eigenständiges Vision Model und LLM Model.

Starten des VLM-Servers

Falls bereits ein LLM-Server läuft, verwenden Sie zunächst:

Plain
Ctrl+C

, um den vorherigen Dienst zu beenden.

Wechseln Sie in das Modellverzeichnis:

Plain
cd ~/Downloads/Qwen2.5-VL-3B_prune

Führen Sie aus:

Plain
rkllm3-server \
-m llm_Qwen2.5-VL-3B_prune.rknn \
--weight llm_Qwen2.5-VL-3B_prune.weight \
--model2 vision_Qwen2.5-VL-3B_prune.rknn \
--weight2 vision_Qwen2.5-VL-3B_prune.weight \
--vocab Qwen2.5-VL-3B_prune.tokenizer.gguf \
--embed Qwen2.5-VL-3B_prune.embed.bin \
--host 0.0.0.0 \
--port 8080 \
-c 768 \
--n_predict 256 \
--core-mask 0xff \
--core-mask2 0xff \
--repeat-penalty 1.1 \
--presence-penalty 1.0 \
--frequency-penalty 1.0 \
--top-k 1 \
--top-p 0.8 \
--temp 0.8 \
--img-start "<|vision_start|>" \
--img-end "<|vision_end|>" \
--img-content "<|image_pad|>" \
--img-width 392 \
--img-height 392

Die wichtigsten Parameter sind:

Plain
-m         → LLM Model
--model2   → Vision Model
--core-mask  → NPU Core used by LLM
--core-mask2 → NPU Core used by Vision

Das offizielle Rockchip Qwen2.5-VL Server-Beispiel nutzt ebenfalls separate LLM- und Vision-Modelle und führt das Vision-Language-Modell mit einer Eingabebildgröße von 392 脳 392 aus.

Test der Bildverständnis-Funktion

Dieses Beispiel verwendet das folgende Bild:

Plain
/home/seeed/Downloads/people.png

Erstellen Sie:

Plain
nano vlm_test.py

Schreiben Sie:

Plain
import base64
from openai import OpenAI

client = OpenAI(
    base_url="http://127.0.0.1:8080/v1",
    api_key="sk-no-key-required"
)

image_path = "/home/seeed/Downloads/people.png"

with open(image_path, "rb") as image_file:
    base64_image = base64.b64encode(
        image_file.read()
    ).decode("utf-8")

response = client.chat.completions.create(
    model="Qwen2.5-VL",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {
                        "url":
                        f"data:image/png;base64,{base64_image}"
                    }
                },
                {
                    "type": "text",
                    "text":
                    "Describe this image in detail."
                }
            ]
        }
    ],
    stream=True,
    extra_body={
        "n_keep": 0,
        "cache_prompt": False,
        "id_slot": 0,
        "n_predict": 256
    }
)

for chunk in response:
    content = chunk.choices[0].delta.content

    if content:
        print(content, end="", flush=True)

print()

Ausführen:

Plain
python3 vlm_test.py

Das offizielle RKLLM3 Multimodal-Beispiel konvertiert das lokale Bild ebenfalls in Base64 und sendet es im OpenAI-kompatiblen image_url-Format an das lokale Modell.

Beispiel für VLM-Ausgabe

Eingabe:

Plain
Describe this image in detail.

Qwen2.5-VL-3B_prune kann Personen, räumliche Beziehungen, Straßenumgebungen, Gebäude, Bäume und Lichtverhältnisse in Bildern erkennen.

Zum Beispiel:

Plain
The image depicts a group of people walking down
an urban street on what appears to be a sunny day...

Leistung von Qwen2.5-VL-3B_prune

Die End-to-End-VLM-Ergebnisse dieses Tests sind nachfolgend zusammengefasst.

TTFT (Time To First Token)

Plain
1.42 s

Dies ist die Zeit vom Senden des Bildes und Prompts bis zur Generierung des ersten Tokens durch das Modell.

Bei einem VLM umfasst diese Zeit die Bildverarbeitung, den Vision Encoder, das multimodale Prefill sowie die Startzeit für die Textgenerierung. Sie spiegelt daher die reale Anwendungserfahrung besser wider als ein Test mit einem reinen LLM.

Dieser Test verwendet n_predict=256, sodass die Modellausgabe nach 256 Streaming Chunks abgebrochen wird. In echten Anwendungen kann die maximale Anzahl der Output-Tokens je nach Kontextlänge und Anwendungsanforderungen angepasst werden.

Lokale KI-Anwendungen erstellen

Über rkllm3-server können die Modellfähigkeiten des RK1820 über eine standardisierte HTTP API für Anwendungen auf einer höheren Ebene bereitgestellt werden.

Daraus lassen sich folgende Szenarien ableiten:

Plain
Local Chat Assistant

Image Understanding

Visual Question Answering

Document / Image Analysis

Private Edge AI Assistant

Eine typische Anwendungsarchitektur sieht wie folgt aus:

Plain
Web UI / Python / Application
              │
              │ OpenAI-compatible API
              ▼
        rkllm3-server
              │
              ▼
          RKNN3 Runtime
              │
         PCIe Gen2 x1
              │
              ▼
            RK1820
        ┌─────┴─────┐
        │           │
       LLM         VLM

Auf diese Weise können Anwendungen auf höherer Ebene die lokalen KI-Modelle auf dem RK1820 über die API aufrufen, ohne direkt mit der RKNN3 Runtime interagieren zu müssen.

Überwachung des RK1820

Beim Betrieb von LLM- oder VLM-Anwendungen kann folgender Befehl verwendet werden:

Plain
sudo rknn-smi info -w

um in Echtzeit Folgendes anzuzeigen:

Plain
NPU Utilization
Memory Usage
Temperature
Health Status

Damit lässt sich der Status des RK1820 während des Modellbetriebs überwachen.

Zusammenfassung

Mit dem RK1820 kann der reComputer RK3576 lokale LLMs und VLMs ausführen. Über rkllm3-server werden die Modellfähigkeiten als lokale API für Anwendungen auf höherer Ebene bereitgestellt.

Die folgenden Tests wurden erfolgreich verifiziert:

AnwendungModellErgebnis
Lokales LLMQwen3.5-0.8B✅ 92,89 Tokens/s
Lokales VLMQwen2.5-VL-3B_prune✅ 1,42 s TTFT