Aplicaciones del Kit de Desarrollo para Módulo reComputer RK3576

Última actualización: 2026-10-18

Aplicaciones

Ejecutar LLM y VLM locales con RK1820

El RK1820 no solo sirve para pruebas de rendimiento de modelos, sino que también permite desplegar LLMs (modelos de lenguaje grandes) y VLMs (modelos de visión-lenguaje) locales en el reComputer RK3576 mediante rkllm3-server, así como crear aplicaciones de IA locales a través de su API compatible con OpenAI.

En este ejemplo se mostrará cómo:

Usar Qwen3.5-0.8B para construir un servicio local de chat con LLM
Usar Qwen2.5-VL-3B_prune para construir un servicio local de comprensión de imágenes

rkllm3-server se basa en RKNPU3 y ofrece inferencia de LLM a través de una API Chat compatible con OpenAI. Puede integrarse en aplicaciones Python, interfaces web y otros frameworks de agentes de IA.

Requisitos previos

Antes de comenzar con este tutorial, asegúrese de haber instalado el RK1820 y configurado el Runtime de RKNN3, y confirme lo siguiente:
Plain
rknn-smi info -l
El RK1820 debe ser reconocido correctamente.

Ejecutar un LLM local

Este ejemplo utiliza Qwen3.5-0.8B.

El directorio del modelo contiene:

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

Acceda al directorio del modelo:

Plain

cd ~/Downloads/Qwen3.5-0.8B

Iniciar el servidor LLM local

Ejecute:

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

El servidor admite:

La versión oficial de rkllm3-server de Rockchip carga el LLM local desde los archivos model, weight, vocab y embed. También permite configurar la longitud del contexto, el número máximo de tokens de salida y la máscara de núcleos de la NPU.

Una vez cargado el modelo correctamente, verá algo similar a:

Plain

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

En este punto, la API del LLM local ya está activa.

Chatear con el LLM local

Abra otra terminal.

Instale el SDK de OpenAI para Python:

Plain

pip3 install openai

Cree un programa de prueba:

Plain

nano llm_chat.py

Escribe:

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

Ejecuta:

Plain

python3 llm_chat.py

El modelo generará respuestas localmente a través del RK1820.

El ejemplo oficial de Rockchip también utiliza client.chat.completions.create() para acceder al servidor RKLLM3 local y admite parámetros como streaming, caché KV y tokens de salida máximos.

Rendimiento de Qwen3.5-0.8B

Medido en el Dev Kit reComputer RK3576 con el acelerador de IA RK1820:

Los resultados de las pruebas muestran que Qwen3.5-0.8B puede alcanzar aproximadamente:

Velocidad de generación: ~92.89 tokens/s

Puede satisfacer las necesidades de aplicaciones interactivas en tiempo real, como asistentes de chat locales, generación de texto y comprensión de instrucciones.

Ejecutar un VLM local

Además de los LLM solo de texto, el RK1820 también puede ejecutar VLM (Modelos de Visión-Lenguaje).

Este ejemplo utiliza:

Qwen2.5-VL-3B_prune

Este modelo puede procesar:

Plain

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

Es decir, se pueden implementar aplicaciones como descripción de imágenes, comprensión de escenas y respuesta a preguntas visuales.

Preparar Qwen2.5-VL-3B_prune

El directorio del modelo contiene:

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

El entorno de ejecución de Qwen2.5-VL incluye modelos Vision Model y LLM Model independientes.

Iniciar el servidor VLM

Si hay un LLM Server en ejecución actualmente, usa primero:

Plain

Ctrl+C

para detener el servicio anterior.

Accede al directorio del modelo:

Plain

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

Ejecuta:

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

Los parámetros clave son:

Plain

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

El ejemplo oficial del servidor Qwen2.5-VL de Rockchip también utiliza modelos LLM y de visión separados, y ejecuta el modelo de lenguaje visual con una imagen de entrada de 392 脳 392.

Prueba de comprensión de imágenes

Este ejemplo usa la siguiente imagen:

Plain

/home/seeed/Downloads/people.png

Crea:

Plain

nano vlm_test.py

Escribe:

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

Ejecuta:

Plain

python3 vlm_test.py

El ejemplo multimodal oficial de RKLLM3 también convierte la imagen local a Base64 y la envía al modelo local en formato image_url compatible con OpenAI.

Ejemplo de salida del VLM

Entrada:

Plain

Describe this image in detail.

Qwen2.5-VL-3B_prune puede reconocer personas, relaciones espaciales, entornos urbanos, edificios, árboles e iluminación en las imágenes.

Por ejemplo:

Plain

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

Rendimiento de Qwen2.5-VL-3B_prune

A continuación se resumen los resultados de extremo a extremo del VLM obtenidos en esta prueba.

TTFT (Time To First Token)

Plain

1.42 s

Es el tiempo transcurrido desde que se envían la imagen y el prompt hasta que el modelo comienza a generar el primer token.

En un VLM, este tiempo incluye el procesamiento de imágenes, el codificador de visión (Vision Encoder), el prefill multimodal y el tiempo necesario para iniciar la generación de texto, por lo que refleja mejor la experiencia real de aplicación que las pruebas realizadas únicamente con un LLM puro.

Esta prueba establece n_predict=256, por lo que la salida del modelo se trunca al alcanzar 256 Streaming Chunks. En aplicaciones reales, puede ajustar el número máximo de tokens de salida según la longitud del contexto (Context Length) y los requisitos de la aplicación.

Crear aplicaciones de IA locales

Mediante rkllm3-server, la capacidad del modelo del RK1820 se expone a las aplicaciones de nivel superior a través de una API HTTP estándar.

Por lo tanto, puede desarrollar:

Plain

Local Chat Assistant

Image Understanding

Visual Question Answering

Document / Image Analysis

Private Edge AI Assistant

La arquitectura típica de una aplicación es la siguiente:

Plain

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

De esta manera, las aplicaciones de nivel superior pueden llamar a los modelos de IA locales que se ejecutan en el RK1820 a través de la API, sin necesidad de interactuar directamente con el Runtime de RKNN3.

Monitorizar el RK1820

Al ejecutar aplicaciones LLM o VLM, puede usar:

Plain

sudo rknn-smi info -w

para ver en tiempo real:

Plain

NPU Utilization
Memory Usage
Temperature
Health Status

y observar el estado del RK1820 durante la operación del modelo.

Resumen

Gracias al RK1820, el reComputer RK3576 puede ejecutar LLM y VLM locales, y mediante rkllm3-server ofrece la capacidad del modelo como una API local para las aplicaciones de nivel superior.

Se ha completado la verificación práctica en esta ejecución:

Aplicación	Modelo	Resultado
LLM local	Qwen3.5-0.8B	✅ 92.89 tokens/s
VLM local	Qwen2.5-VL-3B_prune	✅ 1.42 s TTFT

AnteriorDirectrices de Uso de Interfaces del Kit de Desarrollo para Módulo reComputer RK3576

SiguienteConfigurar