Schnellstart: LLM-Modelle auf RK3576 ausführen

Punkt	Umgebung dieser Prüfung
PC	Ubuntu 20.04.6 LTS, x86_64, Python 3.11, NVIDIA GTX 1070 8 GB
Board	reComputer RK3576, Debian 12 / Armbian `26.05.0-trunk`
Board-Kernel	`6.1.115-vendor-seeed-rk3576`
RKNPU-Treiber	`v0.9.8`
SDK	RKLLM-Toolkit / Runtime `1.3.0`, Repository-Commit `878f936`
Beispielkonto und -adresse	`BOARD_USER@BOARD_IP`

Im lokalen Terminal des Boards ausführen:

bash

sudo apt update
sudo apt install -y openssh-server git
sudo systemctl enable --now ssh

Auf dem PC ausführen:

bash

sudo apt update
sudo apt install -y git wget openssh-client
ssh BOARD_USER@BOARD_IP

#1. Fehlenden RKNPU-Treiber beheben

Auf dem Board ausführen:

bash

uname -m
uname -r
mountpoint -q /sys/kernel/debug || sudo mount -t debugfs debugfs /sys/kernel/debug
sudo cat /sys/kernel/debug/rknpu/version
sudo cat /sys/kernel/debug/rknpu/load
grep "^CONFIG_ROCKCHIP_RKNPU=" /boot/config-$(uname -r)
sudo dmesg | grep -i rknpu | tail -n 20
for node in /sys/class/drm/renderD*; do
  printf '%s -> ' "$node"
  readlink -f "$node/device/driver"
done

Auszug aus der tatsächlichen Board-Ausgabe:

text

RKNPU driver: v0.9.8
NPU load:  Core0:  0%, Core1:  0%
/sys/class/drm/renderD129 -> /sys/bus/platform/drivers/RKNPU
CONFIG_ROCKCHIP_RKNPU=y

renderD129 ist der Knoten dieses Boards, keine feste Nummer. SDK 1.3.0 benötigt Treiber v0.9.8 oder neuer; CONFIG_ROCKCHIP_RKNPU=y bedeutet, dass er in den Kernel eingebaut ist, sodass sein Fehlen in lsmod normal ist. Wenn die Versionsdatei fehlt, auch dmesg und die Treiberbindung prüfen.

Auf dem hier verwendeten reComputer RK3576 Seeed/Armbian Debian-System zuerst die passenden Kernel- und Device-Tree-Pakete prüfen:

bash

sudo apt update
apt-cache policy linux-image-vendor-seeed-rk3576 linux-dtb-vendor-seeed-rk3576

Nachdem bestätigt wurde, dass die Kandidatenversionen beider Pakete aus der Paketquelle dieses Boards stammen, die passenden Pakete installieren oder erneut installieren, falls der Treiber fehlt oder älter als 0.9.8 ist:

bash

sudo apt install --reinstall linux-image-vendor-seeed-rk3576 linux-dtb-vendor-seeed-rk3576
sudo reboot

#2. RKLLM Runtime und RKLLM-Toolkit installieren und prüfen

Komponente	Installationsort	Aufgabe
RKNPU-Kernel-Treiber	Board-Kernel	Zugriff auf die NPU-Hardware
RKLLM Runtime `librkllmrt.so`	Board aarch64	`.rkllm` laden und C/C++-Inferenz-API bereitstellen
RKLLM-Toolkit `rkllm_toolkit`	Ubuntu-x86_64-PC	`.rkllm` konvertieren, quantisieren und exportieren

#2.1 Auf beiden Geräten dieselbe SDK-Version beziehen

Auf dem PC ausführen:

bash

mkdir -p ~/RKLLM_Project
cd ~/RKLLM_Project
git clone --branch release-v1.3.0 --depth 1 https://github.com/airockchip/rknn-llm.git

Auf dem Board ausführen: Dieses Beispiel lädt nur die zum Bauen und Ausführen nötigen Dateien, um Speicherplatz auf dem Board zu sparen.

bash

mkdir -p ~/RKLLM_Project
cd ~/RKLLM_Project
git clone --filter=blob:none --sparse --depth 1 --branch release-v1.3.0 \
  https://github.com/airockchip/rknn-llm.git
cd rknn-llm
git sparse-checkout set examples/rkllm_api_demo/deploy rkllm-runtime/Linux

#2.2 Runtime auf dem Board prüfen

Auf dem Board ausführen:

bash

cd ~/RKLLM_Project/rknn-llm
file rkllm-runtime/Linux/librkllm_api/aarch64/librkllmrt.so
ldd rkllm-runtime/Linux/librkllm_api/aarch64/librkllmrt.so

file sollte AArch64 ELF anzeigen, und ldd darf kein not found melden. Runtime erfordert kein pip install. Beim Build des Beispiels in Abschnitt 4 kopiert CMake das passende librkllmrt.so nach lib/ im Deployment-Verzeichnis; vor dem Start LD_LIBRARY_PATH setzen. Auf diesem Board fand ldd Abhängigkeiten wie libgomp.so.1. Falls Ihre Ausgabe not found enthält, zuerst die fehlenden Bibliotheken auf dem Board installieren.

#2.3 Toolkit auf dem PC installieren

Das folgende Beispiel nutzt Ubuntu x86_64 und Python 3.11 in einer isolierten Conda-Umgebung. Wenn Miniforge bereits installiert ist, bei der Zeile source beginnen.

Auf dem PC ausführen:

bash

cd ~/RKLLM_Project
wget -O Miniforge3-Linux-x86_64.sh \
  https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-Linux-x86_64.sh
bash Miniforge3-Linux-x86_64.sh -b -p "$HOME/miniforge3"
source "$HOME/miniforge3/etc/profile.d/conda.sh"
conda create -n rkllm-1.3.0 python=3.11 -y
conda activate rkllm-1.3.0
python -m pip install --upgrade pip
python -m pip install ./rknn-llm/rkllm-toolkit/packages/rkllm_toolkit-1.3.0-cp311-cp311-linux_x86_64.whl
python -m pip install huggingface_hub
python -m pip check
python -c 'from rkllm.api import RKLLM; print("RKLLM-Toolkit import OK")'
nvidia-smi --query-gpu=name,memory.total --format=csv,noheader
python -c 'import torch; print("CUDA available:", torch.cuda.is_available())'

Im Wheel-Dateinamen steht cp311 für Python 3.11 und linux_x86_64 für die PC-Architektur; dieses Wheel nicht auf dem Board installieren. Dieser Test nutzte ein vorhandenes ~/miniconda3 und ergab No broken requirements found., RKLLM-Toolkit import OK und CUDA available: True. Die obigen Befehle für eine Neuinstallation verwenden Miniforge. Abschnitt 3 erfordert außerdem einen funktionierenden NVIDIA-Treiber auf dem PC.

#3. LLM-Modell auf einem Ubuntu-PC konvertieren

#3.1 Originalmodell herunterladen

Auf dem PC ausführen:

bash

source "$HOME/miniforge3/etc/profile.d/conda.sh"
conda activate rkllm-1.3.0
mkdir -p ~/RKLLM_Project/models
hf download deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B \
  config.json tokenizer.json tokenizer_config.json generation_config.json model.safetensors \
  --local-dir ~/RKLLM_Project/models/DeepSeek-R1-Distill-Qwen-1.5B
ls -lh ~/RKLLM_Project/models/DeepSeek-R1-Distill-Qwen-1.5B/model.safetensors

Hier wird das ursprüngliche Hugging-Face-Modell geladen, das nicht direkt an die Board-Runtime übergeben werden kann. Die Konvertierung nutzt data_quant.json aus dem offiziellen Beispielverzeichnis als Demo-Kalibrierungsdatensatz; für den Produktiveinsatz durch Frage-Antwort-Daten ersetzen, die die Zielanwendung abdecken.

#3.2 RK3576-Modell erzeugen

Auf dem PC ausführen: Dieser Test verwendete eine CUDA-Umgebung mit NVIDIA GTX 1070. Das Konvertierungsskript mit den folgenden Parametern erstellen.

bash

cat > ~/RKLLM_Project/convert_rk3576.py <<'PY'
from pathlib import Path
from rkllm.api import RKLLM

root = Path.home() / 'RKLLM_Project'
model = root / 'models/DeepSeek-R1-Distill-Qwen-1.5B'
dataset = root / 'rknn-llm/examples/rkllm_api_demo/export/data_quant.json'
output = root / 'models/DeepSeek-R1-Distill-Qwen-1.5B_W4A16_rk3576.rkllm'

llm = RKLLM()
ret = llm.load_huggingface(model=str(model), model_lora=None,
                           device='cuda', dtype='float16',
                           custom_config=None, load_weight=True)
if ret != 0:
    raise RuntimeError(f'load_huggingface failed: {ret}')
ret = llm.build(do_quantization=True, optimization_level=1,
                quantized_dtype='W4A16', quantized_algorithm='normal',
                target_platform='RK3576', num_npu_core=2,
                extra_qparams=None, dataset=str(dataset),
                hybrid_rate=0, max_context=4096)
if ret != 0:
    raise RuntimeError(f'build failed: {ret}')
ret = llm.export_rkllm(str(output))
if ret != 0:
    raise RuntimeError(f'export_rkllm failed: {ret}')
print(output)
PY
python ~/RKLLM_Project/convert_rk3576.py
ls -lh ~/RKLLM_Project/models/DeepSeek-R1-Distill-Qwen-1.5B_W4A16_rk3576.rkllm

RK3576 verwendet W4A16-Quantisierung, den Algorithmus normal und 2 NPU-Kerne; diese Kombination wird von der Plattform unterstützt. max_context=4096 entspricht dem späteren Laufzeitargument. Die PC-Konvertierung war erfolgreich und erzeugte ein W4A16-Modell von etwa 1.4 GB. Die Modelldatei auf das zugehörige RK3576-Board übertragen.

#4. C++-Beispiel auf dem Board bereitstellen und ausführen

#4.1 Offizielles `llm_demo` auf dem Board bauen

Auf dem Board ausführen: Den nativen aarch64-Compiler des Boards nutzen, statt des im offiziellen build-linux.sh fest codierten PC-Cross-Compiler-Pfads.

bash

sudo apt update
sudo apt install -y cmake g++ make
cd ~/RKLLM_Project/rknn-llm
cmake -S examples/rkllm_api_demo/deploy \
  -B examples/rkllm_api_demo/deploy/build/native \
  -DCMAKE_BUILD_TYPE=Release
cmake --build examples/rkllm_api_demo/deploy/build/native -j2
cmake --install examples/rkllm_api_demo/deploy/build/native
ls -lh examples/rkllm_api_demo/deploy/install/demo_Linux_aarch64/llm_demo \
  examples/rkllm_api_demo/deploy/install/demo_Linux_aarch64/lib/librkllmrt.so

#4.2 Modell übertragen und ausführen

Auf dem PC ausführen:

bash

scp ~/RKLLM_Project/models/DeepSeek-R1-Distill-Qwen-1.5B_W4A16_rk3576.rkllm \
  BOARD_USER@BOARD_IP:~/RKLLM_Project/rknn-llm/examples/rkllm_api_demo/deploy/install/demo_Linux_aarch64/
sha256sum ~/RKLLM_Project/models/DeepSeek-R1-Distill-Qwen-1.5B_W4A16_rk3576.rkllm
ssh BOARD_USER@BOARD_IP

Auf dem Board ausführen:

bash

cd ~/RKLLM_Project/rknn-llm/examples/rkllm_api_demo/deploy/install/demo_Linux_aarch64
sha256sum ./DeepSeek-R1-Distill-Qwen-1.5B_W4A16_rk3576.rkllm
export LD_LIBRARY_PATH="$PWD/lib${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
ldd ./llm_demo | grep -E 'librkllmrt|not found'
export RKLLM_LOG_LEVEL=1
./llm_demo ./DeepSeek-R1-Distill-Qwen-1.5B_W4A16_rk3576.rkllm 128 4096

Die SHA-256-Werte auf PC und Board müssen übereinstimmen; hier waren beide ce4412147c33c78eb1364458757fbc607acc0ad3ed1fed5cf6894e91506d2051. An der Eingabeaufforderung user: 1+1等于多少？请只回答数字。 eingeben. Auszug aus der tatsächlichen RK3576-Ausgabe:

text

rkllm init start
I rkllm: rkllm-runtime version: 1.3.0, rknpu driver version: 0.9.8, platform: RK3576
I rkllm: rkllm-toolkit version: 1.3.0, max_context_limit: 4096, npu_core_num: 2, target_platform: RK3576, model_dtype: W4A16
rkllm init success
...
1+1等于\boxed{2}

Die genaue Antwortformulierung kann variieren. 128 ist die maximale Anzahl erzeugter Token für diesen Lauf und 4096 die Kontextgrenze; mit exit beenden.

Falls ldd not found anzeigt, zuerst die fehlende gemeinsame Bibliothek reparieren. Schlägt die Initialisierung fehl, Treiberversion, Modellintegrität, Plattformparameter und Toolkit/Runtime-Versionen prüfen. .rkllm-Dateien für RK3576 und RK3588 sind nicht austauschbar.

Schnellstart: LLM-Modelle auf RK3576 ausführen

#1. Fehlenden RKNPU-Treiber beheben

#2. RKLLM Runtime und RKLLM-Toolkit installieren und prüfen

#2.1 Auf beiden Geräten dieselbe SDK-Version beziehen

#2.2 Runtime auf dem Board prüfen

#2.3 Toolkit auf dem PC installieren

#3. LLM-Modell auf einem Ubuntu-PC konvertieren

#3.1 Originalmodell herunterladen

#3.2 RK3576-Modell erzeugen

#4. C++-Beispiel auf dem Board bereitstellen und ausführen

#4.1 Offizielles llm_demo auf dem Board bauen

#4.2 Modell übertragen und ausführen

#Referenzen

#4.1 Offizielles `llm_demo` auf dem Board bauen