Applications du kit de développement pour module reComputer RK3576

Dernière mise à jour:

Applications

Exécution locale de LLM et VLM avec le RK1820

Le RK1820 ne sert pas uniquement aux tests de performance des modèles. Il permet également de déployer des LLM (modèles de langage à grande échelle) et des VLM (modèles vision-langage) locaux sur le reComputer RK3576 via rkllm3-server, ainsi que de créer des applications IA locales grâce à son API compatible OpenAI.

Cet exemple présente :

  • La création d'un service de chat LLM local avec Qwen3.5-0.8B

  • La création d'un service local de compréhension d'images avec Qwen2.5-VL-3B_prune

rkllm3-server repose sur la RKNPU3 et assure l'inférence LLM via une API Chat compatible OpenAI. Il peut s'intégrer dans des applications Python, des interfaces web ou d'autres frameworks d'agents IA.

Prérequis

Avant de commencer ce tutoriel, installez le RK1820 et configurez le Runtime RKNN3. Vérifiez ensuite que :

Plain
rknn-smi info -l

Le RK1820 est correctement détecté.

Exécution d'un LLM local

Cet exemple utilise Qwen3.5-0.8B.

Le répertoire du modèle contient :

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

Accédez au répertoire du modèle :

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

Démarrage du serveur LLM local

Exécutez :

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

Le serveur prend en charge :

La version officielle de rkllm3-server par Rockchip charge le LLM local à partir des fichiers model, weight, vocab et embed. Elle permet aussi de configurer la longueur du contexte, le nombre maximal de tokens en sortie et le masque des cœurs NPU.

Une fois le modèle chargé avec succès, un message similaire à celui-ci s'affiche :

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

L'API du LLM local est désormais active.

Interagir avec le LLM local

Ouvrez un autre terminal.

Installez le SDK Python OpenAI :

Plain
pip3 install openai

Créez un programme de test :

Plain
nano llm_chat.py

Écrivez :

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

Exécutez :

Plain
python3 llm_chat.py

Le modèle génère les réponses localement via le RK1820.

L'exemple officiel de Rockchip utilise également client.chat.completions.create() pour accéder au serveur RKLLM3 local et prend en charge des paramètres tels que le streaming, le cache KV et le nombre maximal de tokens de sortie.

Performances de Qwen3.5-0.8B

Mesures effectuées sur le kit de développement reComputer RK3576 avec l'accélérateur IA RK1820 :

Les résultats des tests montrent que Qwen3.5-0.8B peut atteindre environ :

Vitesse de génération : environ 92,89 tokens/s

Il répond aux besoins des applications interactives en temps réel telles que les assistants de chat locaux, la génération de texte et la compréhension d'instructions.

Exécuter un VLM local

En plus des LLM purement textuels, le RK1820 peut également exécuter des VLM (modèles vision-langage).

Cet exemple utilise :

Qwen2.5-VL-3B_prune

Ce modèle peut traiter :

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

Autrement dit, il est possible de mettre en œuvre des applications telles que la description d'images, la compréhension de scènes et le question-réponse visuel.

Préparer Qwen2.5-VL-3B_prune

Le répertoire du modèle contient :

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

L'environnement d'exécution de Qwen2.5-VL comprend des modèles Vision et LLM indépendants.

Démarrer le serveur VLM

Si un serveur LLM est actuellement en cours d'exécution, utilisez d'abord :

Plain
Ctrl+C

pour arrêter le service précédent.

Accédez au répertoire du modèle :

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

Exécutez :

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

Les paramètres clés sont :

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

L'exemple officiel de serveur Qwen2.5-VL pour Rockchip utilise également des modèles LLM et vision séparés, et exécute le modèle vision-langage avec une image d'entrée de 392 脳 392.

Test de compréhension d'image

Cet exemple utilise l'image suivante :

Plain
/home/seeed/Downloads/people.png

Créez :

Plain
nano vlm_test.py

Écrivez :

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

Exécutez :

Plain
python3 vlm_test.py

L'exemple multimodal officiel RKLLM3 convertit également l'image locale en Base64 et la soumet au modèle local via le format image_url compatible OpenAI.

Exemple de sortie VLM

Entrée :

Plain
Describe this image in detail.

Qwen2.5-VL-3B_prune est capable de reconnaître les personnes, les relations spatiales, les environnements urbains, les bâtiments, les arbres et l'éclairage dans les images.

Par exemple :

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

Performances de Qwen2.5-VL-3B_prune

Les résultats de bout en bout du test VLM sont résumés ci-dessous.

TTFT (Time To First Token)

Plain
1.42 s

Il s'agit du temps écoulé entre la soumission de l'image et du prompt jusqu'au début de la génération du premier token par le modèle.

Pour un VLM, ce temps inclut le traitement de l'image, l'encodeur visuel, le préfill multimodal et le délai nécessaire pour démarrer la génération de texte. Il reflète donc plus fidèlement l'expérience réelle d'une application que le test d'un LLM pur seul.

Ce test utilise n_predict=256, ce qui tronque la sortie du modèle après 256 Streaming Chunks. Dans une application réelle, vous pouvez ajuster le nombre maximum de Tokens de sortie en fonction de la Context Length et des besoins spécifiques.

Développer des applications IA locales

Grâce à rkllm3-server, les capacités du modèle sur le RK1820 sont exposées aux applications supérieures via une API HTTP standard.

Vous pouvez ainsi développer :

Plain
Local Chat Assistant

Image Understanding

Visual Question Answering

Document / Image Analysis

Private Edge AI Assistant

L'architecture typique d'une application est la suivante :

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

Ainsi, les applications supérieures peuvent interroger les modèles IA locaux exécutés sur le RK1820 via l'API, sans avoir à manipuler directement le Runtime RKNN3.

Surveiller le RK1820

Lors de l'exécution d'applications LLM ou VLM, vous pouvez utiliser :

Plain
sudo rknn-smi info -w

pour visualiser en temps réel :

Plain
NPU Utilization
Memory Usage
Temperature
Health Status

afin d'observer l'état du RK1820 pendant l'inférence du modèle.

Résumé

Le reComputer RK3576, équipé du RK1820, permet d'exécuter localement des LLM et des VLM. Via rkllm3-server, ces capacités sont exposées sous forme d'API locale aux applications supérieures.

La vérification a été effectuée lors de cette session :

ApplicationModèleRésultat
LLM localQwen3.5-0.8B✅ 92.89 tokens/s
VLM localQwen2.5-VL-3B_prune✅ 1.42 s TTFT