基于RK3576开发板的RKLLM大模型部署教程

1. RKLLM简介

1.1 RKLLM东西链引见

1.1.1 RKLLM-Toolkit功用引见

RKLLM-Toolkit 是为用户供给正在计较机长进止年夜言语模子的量化、转换的开辟套件。经过该 东西供给的 Python 接心能够便利天完成以下功用：

（1）模子转换：撑持将 Hugging Face 战 GGUF 格局的年夜言语模子（Large Language Model, LLM） 转换为 RKLLM 模子，今朝撑持的模子包罗 LLaMA, Qwen, Qwen2, Phi-2, Phi-3, ChatGLM3, Gemma, Gemma2, InternLM2, MiniCPM 战 MiniCPM3，转换后的 RKLLM 模子可以正在 Rockchip NPU 仄台上减载运用。

（2）量化功用：撑持将浮面模子量化为定面模子，今朝撑持的量化范例包罗 w4a16 、wa4a16分组量化(撑持的分组数为32,64,128)、w8a8、w8a8分组量化(撑持的分组数为128,256,512)。

1.1.2 RKLLM Runtime功用引见

RKLLM Runtime 主 要 背 责 减 载 RKLLM-Toolkit 转换失掉的 RKLLM 模子，并正在RK3576/RK3588 板端经过挪用 NPU 驱动正在 Rockchip NPU 上完成 RKLLM 模子的推理。正在推理 RKLLM 模子时，用户能够自止界说 RKLLM 模子的推理参数设置，界说分歧的文本死成体例， 并经过事后界说的回调函数不时取得模子的推理后果。

1.2 RKLLM开辟流程引见

(1）模子转换：

正在那一阶段，用户供给的 Hugging Face 格局的年夜言语模子将会被转换为 RKLLM 格局，以便正在 Rockchip NPU 仄台长进止下效的推理。那一步调包罗：

获得本初模子：1、开源的 Hugging Face 格局的年夜言语模子；2、自止练习失掉的年夜语 行模子，请求模子保管的构造取 Hugging Face 仄台上的模子构造分歧；3、GGUF 模子，今朝 仅撑持 q4_0 战 fp16 范例模子；

模子减载：经过 rkllm.load_huggingface()函数减载 huggingface 格局模子，经过rkllm.load_gguf()函数减载 GGUF 模子；

模子量化设置装备摆设：经过 rkllm.build() 函数构建 RKLLM 模子，正在构建进程中可挑选能否停止模子量化去进步模子摆设正在硬件上的功能，和挑选分歧的劣化品级战量化范例。

模子导出：经过 rkllm.export_rkllm() 函数将 RKLLM 模子导出为一个.rkllm 格局文件， 用于后绝的摆设。

(2）板端摆设运转：

那个阶段涵盖了模子的实践摆设战运转。它凡是包罗以下步调：

模子初初化：减载 RKLLM 模子到 Rockchip NPU 仄台，停止响应的模子参数设置去界说所需的文本死成体例，并提早界说用于承受及时推理后果的回调函数，停止推理前预备。

模子推理：履行推理操纵，将输出数据通报给模子并运转模子推理，用户能够经过事后界说的回调函数不时获得推理后果。

模子开释：正在完成推理流程后，开释模子资本，以便其他义务持续运用 NPU 的计较资本。以上那两个步调组成了完好的 RKLLM 开辟流程，确保年夜言语模子可以胜利转换、调试，并 终究正在 Rockchip NPU 上完成下效摆设。

1.3 材料下载

模子文件、模子转换取摆设代码的百度网盘下载链接(比拟年夜，能够挑选去下载):https://pan.baidu.com/s/13CHxaF-Cyp4tYxXpksD8LA?pwd=1234 （提与码：1234 ）

1.4 开辟情况拆建

1.4.1 RKLLM-Toolkit装置

本节次要阐明若何经过 pip 体例去装置 RKLLM-Toolkit，用户能够参考以下的详细流程阐明完成 RKLLM-Toolkit 东西链的装置。

东西装置包链接: https://pan.百度.com/s/1y5ZN5sl4e3HJI5d9Imt4pg?pwd=1234（提与码: 1234）。

1.4.1.1 装置miniforge3东西

为避免零碎对多个分歧版本的 Python 情况的需供，倡议运用 miniforge3 治理 Python 情况。 反省能否装置 miniforge3 战 conda 版本疑息，若已装置则可省略此大节步调。

下载 miniforge3 装置包：

wget -c https://mirrors.bfsu.edu.cn/github-release/conda-forge/miniforge/LatestRelease/Miniforge3-Linux-x86_64.sh

装置miniforge3:

chmod 777 Miniforge3-Linux-x86_64.sh
bash Miniforge3-Linux-x86_64.sh

1.4.1.2 创立 RKLLM-Toolkit Conda 情况

进进 Conda base 情况:

source ~/miniforge3/bin/activate

创立一个 Python3.8 版本（倡议版本）名为 RKLLM-Toolkit 的 Conda 情况:

conda create -n RKLLM-Toolkit python=3.8

进进 RKLLM-Toolkit Conda 情况:

conda activate RKLLM-Toolkit

1.4.1.3 装置RKLLM-Toolkit

正在 RKLLM-Toolkit Conda 情况下运用 pip 东西间接装置所供给的东西链 whl 包，正在装置进程 中，装置东西会主动下载 RKLLM-Toolkit 东西所需求的相干依靠包。

pip3 install nvidia_cublas_cu12-12.1.3.1-py3-none-manylinux1_x86_64.whl
pip3 install torch-2.1.0-cp38-cp38-manylinux1_x86_64.whl
pip3 install rkllm_toolkit-1.1.4-cp38-cp38-linux_x86_64.whl

若正在装置的进程中，某些文件装置很缓，能够登录python民网独自下载:

https://pypi.org/

履行以下号令出有报错，则装置胜利。

1.5 AI模子转换

本章次要阐明若何完成Hugging Face格局的年夜言语模子（Large Language Model, LLM）

若何转换为RKLLM模子，今朝撑持的模子包罗 LLaMA, Qwen, Qwen2, Phi-2, Phi-3, ChatGLM3, Gemma, InternLM2 战 MiniCPM。

1.5.1 模子下载

本节供给两种年夜模子文件，Hugging face的本初模子战转换完成的NPU模子。

下载链接: https://pan.百度.com/s/14BDYQBOMTTK7jtsSa8evHw?pwd=1234 （提与码: 1234）。

1.5.2 模子转换

下载完成后模子战剧本放到统一个目次:

正在RKLLM-Toolkit情况，履行以下指令停止模子转换:

至此模子转换胜利,死成Qwen.rkllm NPU化的年夜模子文件：

test.py转换剧本以下所示, 用于转换Qwen-1_8B-Chat模子:

from rkllm.api import RKLLM
from datasets import load_dataset
from transformers import AutoTokenizer
from tqdm import tqdm
import torch
from torch import nn
import os
# os.environ['CUDA_VISIBLE_DEVICES']='1'

'''
https://huggingface.co/Qwen/Qwen-1_8B-Chat
从下面网址中下载Qwen模子
'''

modelpath = '/home/developer/RKLLM-Toolkit/Qwen-1_8B-Chat'
# modelpath = "./path/to/Qwen-1.8B-F16.gguf"
llm = RKLLM()

# Load model
# Use 'export CUDA_VISIBLE_DEVICES=2' to specify GPU device
# options ['cpu', 'cuda']
ret = llm.load_huggingface(model=modelpath, model_lora = None, device='cpu')
# ret = llm.load_gguf(model = modelpath)
if ret != 0:
    print('Load model failed!')
    exit(ret)

# Build model
dataset = "./data_quant.json"
# Json file format, please note to add prompt in the input，like this:
# [{"input":"Human: 您好！nAssistant: ", "target": "您好！我是野生智能助脚KK！"},...]

qparams = None
# qparams = 'gdq.qparams' # Use extra_qparams
ret = llm.build(do_quantization=True, optimization_level=1, quantized_dtype='w4a16',
                quantized_algorithm='normal', target_platform='rk3576', num_npu_core=2, extra_qparams=qparams, dataset=None)

if ret != 0:
    print('Build model failed!')
    exit(ret)

# Evaluate Accuracy
def eval_wikitext(llm):
    seqlen = 512
    tokenizer = AutoTokenizer.from_pretrained(
        modelpath, trust_remote_code=True)
    # Dataset download link:
    # https://huggingface.co/datasets/Salesforce/wikitext/tree/main/wikitext-2-raw-v1
    testenc = load_dataset(
        "parquet", data_files='./wikitext/wikitext-2-raw-1/test-00000-of-00001.parquet', split='train')
    testenc = tokenizer("nn".join(
        testenc['text']), return_tensors="pt").input_ids
    nsamples = testenc.numel() // seqlen
    nlls = []
    for i in tqdm(range(nsamples), desc="eval_wikitext: "):
        batch = testenc[:, (i * seqlen): ((i + 1) * seqlen)]
        inputs = {"input_ids": batch}
        lm_logits = llm.get_logits(inputs)
        if lm_logits is None:
            print("get logits failed!")
            return
        shift_logits = lm_logits[:, :-1, :]
        shift_labels = batch[:, 1:].to(lm_logits.device)
        loss_fct = nn.CrossEntropyLoss().to(lm_logits.device)
        loss = loss_fct(
            shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1))
        neg_log_likelihood = loss.float() * seqlen
        nlls.append(neg_log_likelihood)
    ppl = torch.exp(torch.stack(nlls).sum() / (nsamples * seqlen))
    print(f'wikitext-2-raw-1-test ppl: {round(ppl.item(), 2)}')

# eval_wikitext(llm)


# Chat with model
messages = "<|im_start| >system You are a helpful assistant.<|im_end| ><|im_start| >user您好！n<|im_end| ><|im_start| >assistant"
kwargs = {"max_length": 128, "top_k": 1, "top_p": 0.8,
          "temperature": 0.8, "do_sample": True, "repetition_penalty": 1.1}
# print(llm.chat_model(messages, kwargs))


# Export rkllm model
ret = llm.export_rkllm("./Qwen_w4a16.rkllm")
if ret != 0:
    print('Export model failed!')
    exit(ret)

1.6 模子转换API阐明

1.6.1 RKLLM 初初化

正在那一局部，用户需求先初初化 RKLLM 工具，那是全部任务流的第一步。正在示例代码中运用 RKLLM()结构函数去初初化 RKLLM 工具：

rkllm = RKLLM()

1.6.2 模子减载

正在 RKLLM 初初化完成后，用户需求挪用 rkllm.load_huggingface()函数去传进模子的详细途径，RKLLM-Toolkit 便可依据对应途径顺遂减载 Hugging Face 或 GGUF 格局的年夜言语模子，从而顺遂完成后绝的转换、量化操纵，详细的函数界说以下：

表 1 load_huggingface 函数接心阐明

函数名	load_huggingface
描绘	用于减载开源的 Hugging Face 格局的年夜言语模子。
参数	model: LLM 模子的文件途径，用于减载模子停止后绝的转换、量化； model_lora: lora 权重的文件途径，转换时 model 必需指背响应的 base model 途径；
前往值	0 暗示模子减载一般；-1 暗示模子减载掉败；

示例代码以下：

ret = rkllm.load_huggingface(
   model = './huggingface_model_dir', 
   model_lora = './huggingface_lora_model_dir'
   )
if ret != 0:
   print('Load model failed!')

表 2 load_gguf 函数接心阐明

函数名	load_gguf
描绘	用于减载开源的 GGUF 格局的年夜言语模子，所撑持的数值范例为 q4_0 战 fp16 两种，gguf 格局的 lora 模子也能够经过此接心减载转换为 rkllm 模子。
参数	model: GGUF 模子文件途径；
前往值	0 暗示模子减载一般；-1 暗示模子减载掉败；

示例代码以下：

ret = rkllm.load_gguf(model = './model-Q4_0.gguf')
if ret != 0:
   print('Load model failed!')

1.6.3 RKLLM 模子的量化构建

用户正在经过 rkllm.load_huggingface()函数完成本初模子的减载后，下一步便是经过 rkllm.build()函数完成对 RKLLM 模子的构建。构建模子时，用户能够挑选能否停止量化，量化有助于加小模子的巨细战进步正在 Rockchip NPU 上的推感性能。rkllm.build()函数的详细界说以下：

表 3 build 函数接心阐明

函数名	build
描绘	用于构建失掉 RKLLM 模子，并正在转换进程中界说详细的量化操纵。
参数	do_quantization: 该参数控造能否对模子停止量化操纵，倡议设置为 True； optimization_level: 该参数用于设置能否停止量化粗度劣化，可挑选的设置为{0,1}，0 暗示没有做任何劣化，1 暗示停止粗度劣化，粗度劣化能够形成模子推感性能降落； quantized_dtype: 该参数用于设置量化的详细范例，今朝撑持的量化范例包罗“ w4a16 ” , “ w4a16_g32 ” , “ w4a16_g64 ” , “ w4a16_g128 ” , “ w8a8 ” ，“w8a8_g128”,“w8a8_g256”,“w8a8_g512”，“w4a16”暗示对权重停止 4bit 量化而对激活值没有停止量化；“w4a16_g64”暗示对权重停止 4bit 分组量化(groupsize=64)而对激活值没有停止量化；“w8a8”暗示对权重战激活值均停止 8bit 量化；“w8a8_g128”暗示对权重战激活值均停止 8bit 分组量化(group size=128)；今朝rk3576 仄台撑持“w4a16”,“w4a16_g32”,“w4a16_g64”,“w4a16_g128”战“w8a8”五种量化范例，rk3588 撑持“w8a8”,“w8a8_g128”,“w8a8_g256”,“ w8a8_g512 ” 四种量化范例； GGUF 模子的 q4_0 对应的量化范例为“w4a16_g32”；留意group size 应能被线性层的输入维度整除，不然会量化掉败！ quantized_algorithm: 量化粗度劣化算法, 可挑选的设置包罗“normal”或“gdq”，一切量化范例都可挑选 normal，而 gdq 算法只撑持 w4a16 及 w4a16 分组量化，且 gdq 对算力请求下，必需运用 GPU 停止减速运算； num_npu_core: 模子推理需求运用的 npu 中心数，“rk3576”可选项为[1,2]，“rk3588”可选项为[1,2,3]； extra_qparams: 运用 gdq 算法会死成 gdq.qparams 量化权重缓存文件，将此参数设置为 gdq.qparams 途径，能够反复停止模子导出； dataset: 用于量化校订数据散，格局为 json，内容示比方下，input 为成绩，需求减上提醒词，target 为答复，多条数据以{}字典方式保管正在列表中：[{"input":"明天气候怎样样？","target":"明天气候阴。"},....] hybrid_rate: 分组战没有分组夹杂量化比率(∈[0,1))，当量化范例为 w4a16/w8a8 时，会按比率辨别夹杂 w4a16 分组/w8a8 分组范例去提下粗度，当量化范例为 w4a16分组/w8a8 分组范例时，会按比率辨别夹杂 w4a16/w8a8 范例去进步推感性能，当hybrid_rate 值为 0 时，没有停止夹杂量化； target_platform: 模子运转的硬件仄台, 可挑选的设置包罗“rk3576”或“rk3588”；
前往值	0 暗示模子转换、量化一般；-1 暗示模子转换掉败；

示例代码以下：

ret = rkllm.build(
       do_quantization=True,
       optimization_level=1,
       quantized_dtype='w8a8',
       quantized_algorithm="normal",
       num_npu_core=3,
       extra_qparams=None,
       dataset="quant_data.json",
       hybrid_rate=0,
       target_platform='rk3588')
if ret != 0:
   print('Build model failed!')

1.6.4 导出 RKLLM 模子

用户正在经过 rkllm.build()函数构建了 RKLLM 模子后，能够经过 rkllm.export_rkllm()函数将RKNN 模子保管为一个.rkllm 文件，以便后绝模子的摆设。rkllm.export_rkllm()函数的详细参数界说以下：

表 4 export_rkllm 函数接心阐明

函数名	export_rkllm
描绘	用于保管转换、量化后的 RKLLM 模子，用于后绝的推理挪用。
参数	export_path: 导出 RKLLM 模子文件的保管途径，lora 模子会主动保管为带_lora 后缀的 rkllm 模子；
前往值	0 暗示模子胜利导出保管；-1 暗示模子导出掉败；

示例代码以下：

ret = rkllm.export_rkllm(export_path = './model.rkllm'）
if ret != 0:
   print('Export model failed!')

1.6.5 仿实粗度评价

用户正在经过 rkllm.build()函数构建了 RKLLM 模子后，能够经过 rkllm.get_logits()函数正在 PC端停止仿实粗度评价，rkllm.get_logits()函数的详细参数界说以下：

函数名	get_logits
函数名	用于 PC 端仿实粗度评价。
参数	inputs: 仿实输出格局取 huggingface 模子推理一样，示比方下：{“input_ids":"","top_k":1,...}
前往值	前往模子推理出的 logits 值；

运用此函数停止 wikitext 数据散 ppl 测试示例代码以下：

ef eval_wikitext(llm):
  seqlen = 512
  tokenizer = AutoTokenizer.from_pretrained(
     modelpath,
     trust_remote_code=True
     )
  #Dataset download link: 
  #https://huggingface.co/datasets/Salesforce/wikitext/tree/main/wiki
text-2-raw-v1
   testenc = load_dataset("parquet", data_files='./wikitext/wikitext-
2-raw-1/test-00000-of-00001.parquet', split='train')
   testenc = tokenizer(
      "nn".join(testenc['text']), 
      return_tensors="pt").input_ids
 nsamples = testenc.numel() // seqlen
 nlls = []
 for i in tqdm(range(nsamples), desc="eval_wikitext: "):
    batch = testenc[:, (i * seqlen): ((i + 1) * seqlen)]
    inputs = {"input_ids": batch}
    lm_logits = llm.get_logits(inputs)
    if lm_logits is None:
       print("get logits failed!")
       return 
    shift_logits = lm_logits[:, :-1, :]
    shift_labels = batch[:, 1:].to(lm_logits.device)
    loss_fct = nn.CrossEntropyLoss().to(lm_logits.device)
    loss = loss_fct(shift_logits.view(-1, shift_logits.size(-1)), 
shift_labels.view(-1))
    neg_log_likelihood = loss.float() * seqlen
    nlls.append(neg_log_likelihood)
   ppl = torch.exp(torch.stack(nlls).sum() / (nsamples * seqlen))
   print(f'wikitext-2-raw-1-test ppl: {round(ppl.item(), 2)}')

1.6.6 仿实模子推理

用户正在经过 rkllm.build()函数构建了 RKLLM 模子后，能够经过 rkllm.chat_model()函数正在 PC端停止仿实推理，rkllm.chat_model()函数的详细参数界说以下：

函数名	chat_model
描绘	用于 PC 端仿实模子推理。
参数	messages: 文本输出，需求减上响应提醒词 args: 推理设置装备摆设参数，比方 topk 等采样战略参数
前往值	前往模子推理后果；

示例代码以下：

args ={
   "max_length":128,
   "top_k":1,
   "temperature":0.8,
   "do_sample":True,
   "repetition_penalty":1.1
   }
mesg = "Human: 明天气候怎样样？nAssistant:"
print(llm.chat_model(mesg, args))

以上的那些操纵涵盖了 RKLLM-Toolkit 模子转换、量化的全数步调，依据分歧的需乞降使用场景，用户能够挑选分歧的设置装备摆设选项战量化体例停止自界说设置，便利后绝停止摆设。

1.7 AI模子摆设

本章次要阐明RKLLM格局的通义千问NPU年夜模子若何运转正在EASY-EAI-Orin-Nano硬件上。

1.7.1 疾速上脚

1.7.1.1 源码下载和例程编译

本节供给转换胜利的通义千问年夜模子文Qwen_w4a16.rkllm及对应的C/C++顺序摆设代码。

下载链接:https://pan.百度.com/s/19GZ_UjsA-IjA9zf10ZZ93w?pwd=1234（提与码: 1234）。

然后把例程【复造粘揭】到nfs挂载目次中。（没有清晰目次若何构建的，能够参考《进门指北/开辟情况预备/nfs效劳拆建取挂载》）。特殊留意:源码目次战模子最好cp到板子上，如/userdata，不然正在nfs目次履行年夜模子会招致模子初初化过缓。

进进到开辟板对应的例程目次履行编译操纵，详细号令以下所示：

cd /userdata/rkllm-demo
./build.sh

1.7.1.2 例程运转及结果

进进例程的rkllm-demo/rkllm-demo_release目次，履行下圆号令，运转示例顺序：

cd rkllm-demo_release/
ulimit -HSn 102400 
./rkllm-demo Qwen_w4a16.rkllm 256 512

至此能够停止对话测试了，试着输出“若何制造PCB板？”。答复以下所示:

1.7.2 RKLLM算法规程

例程目次为rkllm-demo/src/main.cpp，操纵流程以下。

详细代码以下所示:

#include < string.h >
#include < unistd.h >
#include < string >
#include "rkllm.h"
#include < fstream >
#include < iostream >
#include < csignal >
#include < vector >

#define PROMPT_TEXT_PREFIX "<|im_start| >system You are a helpful assistant. <|im_end| > <|im_start| >user"
#define PROMPT_TEXT_POSTFIX "<|im_end| ><|im_start| >assistant"


using namespace std;
LLMHandle llmHandle = nullptr;

void exit_handler(int signal)
{
    if (llmHandle != nullptr)
    {
        {
            cout < < "程序即将退出" < < endl;
            LLMHandle _tmp = llmHandle;
            llmHandle = nullptr;
            rkllm_destroy(_tmp);
        }
    }
    exit(signal);
}

void callback(RKLLMResult *result, void *userdata, LLMCallState state)
{
    if (state == RKLLM_RUN_FINISH)
    {
        printf("n");
    } else if (state == RKLLM_RUN_ERROR) {
        printf("\run errorn");
    } else if (state == RKLLM_RUN_GET_LAST_HIDDEN_LAYER) {
        /* ================================================================================================================
        若使用GET_LAST_HIDDEN_LAYER功能,callback接口会回传内存指针:last_hidden_layer,token数量:num_tokens与隐藏层大小:embd_size
        通过这三个参数可以取得last_hidden_layer中的数据
        注:需要在当前callback中获取,若未及时获取,下一次callback会将该指针释放
        ===============================================================================================================*/
        if (result- >last_hidden_layer.embd_size != 0 && result->last_hidden_layer.num_tokens != 0) {
            int data_size = result->last_hidden_layer.embd_size * result->last_hidden_layer.num_tokens * sizeof(float);
            printf("ndata_size:%d",data_size);
            std::ofstream outFile("last_hidden_layer.bin", std::ios::binary);
            if (outFile.is_open()) {
                outFile.write(reinterpret_cast< const char* >(result->last_hidden_layer.hidden_states), data_size);
                outFile.close();
                std::cout < < "Data saved to output.bin successfully!" < < std::endl;
            } else {
                std::cerr < < "Failed to open the file for writing!" < < std::endl;
            }
        }
    } else if (state == RKLLM_RUN_NORMAL) {
        printf("%s", result- >text);
    }
}

int main(int argc, char **argv)
{
    if (argc < 4) {
        std::cerr < < "Usage: " < < argv[0] < < " model_path max_new_tokens max_context_lenn";
        return 1;
    }

    signal(SIGINT, exit_handler);
    printf("rkllm init startn");

    //设置参数及初始化
    RKLLMParam param = rkllm_createDefaultParam();
    param.model_path = argv[1];

    //设置采样参数
    param.top_k = 1;
    param.top_p = 0.95;
    param.temperature = 0.8;
    param.repeat_penalty = 1.1;
    param.frequency_penalty = 0.0;
    param.presence_penalty = 0.0;

    param.max_new_tokens = std::atoi(argv[2]);
    param.max_context_len = std::atoi(argv[3]);
    param.skip_special_token = true;
    param.extend_param.base_domain_id = 0;

    int ret = rkllm_init(&llmHandle, ¶m, callback);
    if (ret == 0){
        printf("rkllm init successn");
    } else {
        printf("rkllm init failedn");
        exit_handler(-1);
    }

    vector< string > pre_input;
    pre_input.push_back("把上面的古代文翻译成白话文: 到了东风温暖，阳黑暗媚的时分，湖里宁静，出有风平浪静，天气湖光相连，一片碧绿，宽广无边；沙洲上的鸥鸟，时而翱翔，时而停歇，漂亮的鱼游去游来，岸上取小洲上的花卉，翠绿欲滴。");
    pre_input.push_back("以咏梅为标题，帮我写一尾古诗，请求包括梅花、黑雪等元素。");
    pre_input.push_back("上联: 江边惯看千帆过");
    pre_input.push_back("把那句话翻译成中文: Knowledge can be acquired from many sources. These include books, teachers and practical experience, and each has its own advantages. The knowledge we gain from books and formal education enables us to learn about things that we have no opportunity to experience in daily life. We can also develop our analytical skills and learn how to view and interpret the world around us in different ways. Furthermore, we can learn from the past by reading books. In this way, we won't repeat the mistakes of others and can build on their achievements.");
    pre_input.push_back("把那句话翻译成英文: RK3588是新一代下端处置器，具有下算力、低功耗、超强多媒体、丰厚数据接心等特性");
    cout < < "n**********************可输入以下问题对应序号获取回答/或自定义输入********************n"
         < < endl;
    for (int i = 0; i < (int)pre_input.size(); i++)
    {
        cout < < "[" < < i < < "] " < < pre_input[i] < < endl;
    }
    cout < < "n*************************************************************************n"
         < < endl;

    string text;
    RKLLMInput rkllm_input;

    // 初始化 infer 参数结构体
    RKLLMInferParam rkllm_infer_params;
    memset(&rkllm_infer_params, 0, sizeof(RKLLMInferParam));  // 将所有内容初始化为 0

    // 1. 初始化并设置 LoRA 参数（如果需要使用 LoRA）
    // RKLLMLoraAdapter lora_adapter;
    // memset(&lora_adapter, 0, sizeof(RKLLMLoraAdapter));
    // lora_adapter.lora_adapter_path = "qwen0.5b_fp16_lora.rkllm";
    // lora_adapter.lora_adapter_name = "test";
    // lora_adapter.scale = 1.0;
    // ret = rkllm_load_lora(llmHandle, &lora_adapter);
    // if (ret != 0) {
    //     printf("nload lora failedn");
    // }

    // 加载第二个lora
    // lora_adapter.lora_adapter_path = "Qwen2-0.5B-Instruct-all-rank8-F16-LoRA.gguf";
    // lora_adapter.lora_adapter_name = "knowledge_old";
    // lora_adapter.scale = 1.0;
    // ret = rkllm_load_lora(llmHandle, &lora_adapter);
    // if (ret != 0) {
    //     printf("nload lora failedn");
    // }

    // RKLLMLoraParam lora_params;
    // lora_params.lora_adapter_name = "test";  // 指定用于推理的 lora 名称
    // rkllm_infer_params.lora_params = &lora_params;

    // 2. 初始化并设置 Prompt Cache 参数（如果需要使用 prompt cache）
    // RKLLMPromptCacheParam prompt_cache_params;
    // prompt_cache_params.save_prompt_cache = true;                  // 是否保存 prompt cache
    // prompt_cache_params.prompt_cache_path = "./prompt_cache.bin";  // 若需要保存prompt cache, 指定 cache 文件路径
    // rkllm_infer_params.prompt_cache_params = &prompt_cache_params;
    
    // rkllm_load_prompt_cache(llmHandle, "./prompt_cache.bin"); // 加载缓存的cache

    rkllm_infer_params.mode = RKLLM_INFER_GENERATE;

    while (true)
    {
        std::string input_str;
        printf("n");
        printf("user: ");
        std::getline(std::cin, input_str);
        if (input_str == "exit")
        {
            break;
        }
        for (int i = 0; i < (int)pre_input.size(); i++)
        {
            if (input_str == to_string(i))
            {
                input_str = pre_input[i];
                cout < < input_str < < endl;
            }
        }
        text = PROMPT_TEXT_PREFIX + input_str + PROMPT_TEXT_POSTFIX;
        //text = input_str;
        rkllm_input.input_type = RKLLM_INPUT_PROMPT;
        rkllm_input.prompt_input = (char *)text.c_str();
        printf("robot: ");

        // 若要使用普通推理功能,则配置rkllm_infer_mode为RKLLM_INFER_GENERATE或不配置参数
        rkllm_run(llmHandle, &rkllm_input, &rkllm_infer_params, NULL);
    }
    rkllm_destroy(llmHandle);

    return 0;
}

1.8 模子摆设API阐明

1.8.1 回调函数界说

回调函数是用于接纳模子及时输入的后果。正在初初化 RKLLM 时回调函数会被绑定，正在模子推理进程中不时将后果输入至回调函数中，而且每次回调只前往一个 token。

示例代码以下，该回调函数将输入后果及时天挨印输入到末端中：

void callback(RKLLMResult* result, void* userdata, LLMCallState state)
{
   if(state == LLM_RUN_NORMAL){
      printf("%s", result->text);
      for (int i=0; i< result- >num; i++) {
          printf("token_id: %d logprob: %f", result->tokens[i].id, 
          result->tokens[i].logprob);
      }
   }
   if (state == LLM_RUN_FINISH) {
      printf("finishn");
   } else if (state == LLM_RUN_ERROR){
      printf("run errorn");
   }
}

(1）LLMCallState 是一个形态标记，其详细界说以下：

表 1 LLMCallState 形态标记阐明

列举界说	LLMCallState
描绘	用于暗示以后 RKLLM 的运转形态。
列举值	0, LLM_RUN_NORMAL, 暗示 RKLLM 模子以后正正在推理中； 1, LLM_RUN_FINISH, 暗示 RKLLM 模子已完成以后输出的全数推理； 2, LLM_RUN_WAITING, 暗示以后 RKLLM 解码出的字符没有是完好 UTF8 编码，需等候取下一次解码拼接； 3, LLM_RUN_ERROR, 暗示 RKLLM 模子推理呈现毛病；

用户正在回调函数的设想进程中，能够依据 LLMCallState 的分歧形态设置分歧的后处置行动；
(2）RKLLMResult 是前往值构造体，其详细界说以下：

表 2 RKLLMResult 前往值构造体阐明

构造体界说	RKLLMResult
描绘	用于前往以后推理死成后果。
字段	0, text, 暗示以后推理死成的文本内容； 1, token_id, 暗示以后推理死成的 token id；

1.8.2 参数构造体 RKLLMParam 界说

构造体 RKLLMParam 用于描绘、界说 RKLLM 的具体疑息，详细的界说以下：

表 2 RKLLMParam 构造体参数阐明

构造体界说	RKLLMParam
描绘	用于界说 RKLLM 模子的各项细节参数。
字段	const char* model_path: 模子文件的寄存途径； int32_t max_context_len: 设置推理时的最年夜高低文少度； int32_t max_new_tokens: 用于设置模子推理时死成 token 的数目下限； int32_t top_k: top-k 采样是一种文本死成办法，它仅从模子猜测几率最下的 k个 token 当选择下一个 token。该办法有助于下降死成低几率或有意义 token 的风险。更下的值（如 100）将思索更多的 token 挑选，招致文本愈加多样化；而更低的值（如 10）将散焦于最能够的 token，死成愈加守旧的文本。默许值为40； float top_p: top-p 采样，也被称为中心采样，是另外一种文本死成办法，从乏计几率至多为 p 的一组 token 当选择下一个 token。这类办法经过思索 token 的几率战采样的 token 数目正在多样性战量量之间供给均衡。更下的值（如 0.95）使得死成的文本愈加多样化；而更低的值（如 0.5）将死成愈加守旧的文本。默许值为 0.9； float temperature: 节制死成文本随机性的超参数，它经过调剂模子输入token的几率散布去发扬感化；更下的温度（如 1.5）会使输入愈加随机战发明性，当温度较下时，模子正在挑选下一个 token 时会思索更多能够性较低的选项，从而发生更多样战意念没有到的输入；更低的温度（例 0.5）会使输入愈加集合、守旧，较低的温度意味着模子正在死成文本时更偏向于挑选几率下的 token，从而招致更分歧、更可猜测的输入；温度为 0 的极度状况下，模子老是挑选最有能够的下一个 token，那会招致每次运转时输入完整相反；为了确保随机性战肯定性之间的均衡，使输入既不外于单一战可猜测，也不外于随机战芜杂，默许值为 0.8； float repeat_penalty: 节制死成文本中 token 序列反复的状况，协助避免模子死成反复或单调的文本。更下的值（比方 1.5）将更激烈天赏罚反复，而较低的值（比方 0.9）则更加宽大。默许值为 1.1； float frequency_penalty: 单词/短语反复度赏罚果子，增加整体上运用频次较下的单词/短语的几率，添加运用频次较低的单词/短语的能够性，那能够会使死成的文本愈加多样化，但也能够招致死成的文本易以了解或没有契合预期。设置规模为[-2.0, 2.0]，默许为 0； int32_t mirostat: 正在文本死成进程中自动保持死成文本的量量正在希冀的规模内的算法，它旨正在正在连接性战多样性之间找到均衡，防止果过分反复（无聊圈套）或没有连接（紊乱圈套）招致的低量量输入；与值空间为{0, 1, 2}, 0 暗示没有启动该算法，1 暗示运用 mirostat 算法，2 则暗示运用 mirostat2.0 算法； float mirostat_tau: 选项设置 mirostat 的目的熵，代表死成文本的希冀猜疑度。调剂目的熵能够节制死成文本中连接性取多样性的均衡。较低的值将招致文本愈加集合战连接，而较下的值将招致文本愈加多样化，能够连接性较好。默许值是 5.0； float mirostat_eta: 选项设置 mirostat 的进修率，进修率影响算法对死成文本反应的呼应速率。较低的进修率将招致调剂速率较缓，而较下的进修率将使算法愈加活络。默许值是 0.1； bool skip_special_token: 能否跳过非凡 token 没有输入,比方完毕标记等; bool is_async: 能否运用同步形式; const char* img_start: 选项设置多模态输出图象编码的肇端标记符，正在多模态输出形式下需求设置装备摆设； const char* img_end: 选项设置多模态输出图象编码的末行标记符，正在多模态输出形式下需求设置装备摆设； const char* img_content: 选项设置多模态输出图象编码的内容标记符，正在多模态输出形式下需求设置装备摆设；

正在实践的代码构建中，RKLLMParam 需求挪用 rkllm_createDefaultParam()函数去初初化界说，并依据需供设置响应的模子参数。示例代码以下：

RKLLMParam param = rkllm_createDefaultParam();
param.model_path = "model.rkllm";
param.top_k = 1;
param.max_new_tokens = 256;
param.max_context_len = 512;

1.8.3 输出构造体界说

为顺应分歧的输出数据，界说了 RKLLMInput 输出构造体，今朝可承受文本、图片战文本、Token id 和编码背量四种方式的输出，详细的界说以下：

表 3 RKLLMInput 构造体参数阐明

构造体界说	RKLLMInput
描绘	用于接纳分歧方式的输出数据。
字段	RKLLMInputType input_type: 输出形式； union: 用于存储分歧的输出数据范例，详细包括以下几种方式： - const char* prompt_input: 文本提醒输出，用于通报天然言语文本； - RKLLMEmbedInput embed_input: 嵌进背量输出，暗示已处置的特点背量； - RKLLMTokenInput token_input: Token 输出，用于通报 Token 序列； - RKLLMMultiModelInput multimodal_input: 多模态输出，可通报多模态数据，如图片战文本的结合输出。

表 4 RKLLMInputType 输出范例阐明

列举界说	RKLLMInputType
描绘	用于暗示输出数据范例。
列举值	0, RKLLM_INPUT_PROMPT, 暗示输出数据是杂文本； 1, RKLLM_INPUT_TOKEN, 暗示输出数据是 Token id； 2, RKLLM_INPUT_EMBED, 暗示输出数据是编码背量； 3, RKLLM_INPUT_MULTIMODAL, 暗示输出数据是图片战文本；

当输出数据是杂文本时，运用 input_data 间接输出；当输出数据是 Token id、编码背量和图片 战 文 本 时 ， RKLLMInput 需 要 拆 配 RKLLMTokenInput, RKLLMEmbedInput 以 及RKLLMMultiModelInput 三个输出构造体运用，详细的引见以下：

(1）RKLLMTokenInput 是接纳 Token id 的输出构造体，详细的界说以下：

表 5 RKLLMTokenInput 构造体参数阐明

构造体界说	RKLLMTokenInput
描绘	用于接纳 Token id 数据。
字段	int32_t* input_ids: 输出 token ids 的内存指针； size_t n_tokens: 输出数据的 token 数目；

(2）RKLLMEmbedInput 是接纳编码背量的输出构造体，详细的界说以下：

表 6 RKLLMEmbedInput 构造体参数阐明

构造体界说	RKLLMEmbedInput
描绘	用于接纳 Embedding 数据。
字段	float* embed: 输出 token embedding 的内存指针； size_t n_tokens: 输出数据的 token 数目；

(3）RKLLMMultiModelInput 是接纳图片战文本的输出构造体，详细的界说以下：

表 7 RKLLMMultiModelInput 构造体参数阐明

构造体界说	RKLLMMultiModelInput
描绘	用于接纳图片战文本多模态数据。
字段	char* prompt: 输出文本的内存指针； float* image_embed: 输出图片 embedding 的内存指针； size_t n_image_tokens: 输出图片 embedding 的 token 数目；

杂文本输出示例代码以下：

// 提早界说 prompt 前后的文本预设值
#define PROMPT_TEXT_PREFIX "<|im_start| >system You are a helpful 
assistant. <|im_end| > <|im_start| >user"
#define PROMPT_TEXT_POSTFIX "<|im_end| ><|im_start| >assistant"

// 界说输出的 prompt 并完成前后 prompt 的拼接
string input_str = "把那句话翻译成英文：RK3588 是新一代下端处置器，具有下算力、
低功耗、超强多媒体、丰厚数据接心等特性";
input_str = PROMPT_TEXT_PREFIX + input_str + PROMPT_TEXT_POSTFIX;

RKLLMInput rkllm_input;
rkllm_input.input_data = (char*)input_str.c_str();
rkllm_input.input_type = RKLLM_INPUT_PROMPT;

// 初初化 infer 参数构造体
RKLLMInferParam rkllm_infer_params;
memset(&rkllm_infer_params, 0, sizeof(RKLLMInferParam)); // 将一切内容初
初化为 0
rkllm_infer_params.mode = RKLLM_INFER_GENERATE;

图片战文本多模态输出示例代码以下，留意多模态输出的 prompt 中需求参加占位符用于标示图象编码拔出的地位：

// 提早界说 prompt 前后的文本预设值
#define PROMPT_TEXT_PREFIX "<|im_start| >system You are a helpful 
assistant. <|im_end| > <|im_start| >user"
#define PROMPT_TEXT_POSTFIX "<|im_end| ><|im_start| >assistant"

RKLLMInput rkllm_input;

// 界说输出的 prompt 并完成前后 prompt 的拼接
string input_str = "< image >Please describe the image shortly.";
input_str = PROMPT_TEXT_PREFIX + input_str + PROMPT_TEXT_POSTFIX;
rkllm_input.multimodal_input.prompt = (char*)input_str.c_str();

rkllm_input.multimodal_input.n_image_tokens = 256;
int rkllm_input_len = multimodal_input.n_image_tokens * 3072;
rkllm_input.multimodal_input.image_embed = (float 
*)malloc(rkllm_input_len * sizeof(float));
FILE *file;
file = fopen("models/image_embed.bin", "rb");
fread(rkllm_input.multimodal_input.image_embed, sizeof(float), 
rkllm_input_len, file);
fclose(file);

rkllm_input.input_type = RKLLM_INPUT_MULTIMODAL;

// 初初化 infer 参数构造体
RKLLMInferParam rkllm_infer_params;
memset(&rkllm_infer_params, 0, sizeof(RKLLMInferParam)); // 将一切内容初
初化为 0
rkllm_infer_params.mode = RKLLM_INFER_GENERATE;

RKLLM 撑持分歧的推理形式，界说了 RKLLMInferParam 构造体，今朝可撑持正在推理进程取预减载的 LoRA 模子结合推理，或保管 Prompt Cache 用于后绝推理减速，详细的界说以下：

表 8 RKLLMInferParam 构造体参数阐明

构造体界说	RKLLMInferParam
描绘	用于界说分歧的推理形式。
字段	RKLLMInferMode mode: 推理形式，以后仅撑持 RKLLM_INFER_GENERATE 形式； RKLLMLoraParam* lora_params: 推理时运用的 LoRA 的参数设置装备摆设，用于正在减载多个 LoRA 时挑选需求推理的 LoRA，若无需减载 LoRA 则设为 NULL 便可； RKLLMPromptCacheParam* prompt_cache_params: 推理时运用Prompt Cache的参数设置装备摆设，若无需死成 Prompt Cache 则设为 NULL 便可；

表 9 RKLLMLoraParam 构造体参数阐明

构造体界说	RKLLMLoraParam
描绘	用于界说推理时运用 LoRA 的参数；
字段	const char* lora_adapter_name: 推理时运用的 LoRA 称号

表 10 RKLLMInferParam 构造体参数阐明

构造体界说	RKLLMPromptCacheParam
描绘	用于界说推理时运用 Prompt Cache 的参数；
字段	int save_prompt_cache: 能否正在推理时保管 Prompt Cache, 1 为需求, 0 为没有需求； const char* prompt_cache_path: Prompt Cache 保管途径, 若已设置则默许保管到"./prompt_cache.bin"中;

运用 InferRaram 的示比方下：

// 1. 初初化并设置 LoRA 参数（假如需求运用 LoRA）
RKLLMLoraParam lora_params;
lora_params.lora_adapter_name = "test"; // 指定用于推理的 lora 称号
// 2. 初初化并设置 Prompt Cache 参数（假如需求运用 prompt cache）
RKLLMPromptCacheParam prompt_cache_params;
prompt_cache_params.save_prompt_cache = true; // 能否保管 prompt cache
prompt_cache_params.prompt_cache_path = "./prompt_cache.bin"; // 若需求
保管 prompt cache, 指定 cache 文件途径
rkllm_infer_params.mode = RKLLM_INFER_GENERATE;
rkllm_infer_params.lora_params = &lora_params;
rkllm_infer_params.prompt_cache_params = &prompt_cache_params;

1.8.4 初初化模子

正在停止模子的初初化之前，需求提早界说 LLMHandle 句柄，该句柄用于模子的初初化、推理战资本开释进程。留意，准确的模子推理流程需求一致那 3 个流程中的 LLMHandle 句柄工具。正在模子推理前，用户需求经过 rkllm_init()函数完成模子的初初化，详细函数的界说以下：

表 11 rkllm_init 函数接心阐明

函数名	rkllm_init
描绘	用于初初化 RKLLM 模子的详细参数及相干推理设置。
参数	LLMHandle* handle: 将模子注册到响应句柄中，用于后绝推理、开释挪用； RKLLMParam* param: 模子界说的参数构造体； LLMResultCallback callback: 用于承受处置模子及时输入的回调函数；
前往值	0 暗示初初化流程一般；-1 暗示初初化掉败；

示例代码以下：

LLMHandle llmHandle = nullptr;
rkllm_init(&llmHandle, ¶m, callback);

1.8.5 模子推理

用户正在完成 RKLLM 模子的初初化流程后，便可经过 rkllm_run()函数停止模子推理，并能够经过初初化时事后界说的回调函数对及时推理后果停止处置；rkllm_run()的详细函数界说以下：

表 12 rkllm_run 函数接心阐明

函数名	rkllm_run
描绘	挪用完成初初化的 RKLLM 模子停止后果推理；
参数	LLMHandle handle: 模子初初化注册的目的句柄； RKLLMInput* rkllm_input: 模子推理的输出数据； RKLLMInferParam* rkllm_infer_params: 模子推理进程中的参数通报； void* userdata: 用户自界说的函数指针，默许设置为 NULL 便可；
前往值	0 暗示模子推理一般运转；-1 暗示挪用模子推理掉败；

模子推理的示例代码以下：

#define PROMPT_TEXT_PREFIX "<|im_start| >system You are a helpful 
assistant. <|im_end| > <|im_start| >user"
#define PROMPT_TEXT_POSTFIX "<|im_end| ><|im_start| >assistant"

string input_str = "把那句话翻译成英文：RK3588 是新一代下端处置器，具有下算力、
低功耗、超强多媒体、丰厚数据接心等特性";
input_str = PROMPT_TEXT_PREFIX + input_str + PROMPT_TEXT_POSTFIX;

// 初初化 infer 参数构造体
RKLLMInferParam rkllm_infer_params;
memset(&rkllm_infer_params, 0, sizeof(RKLLMInferParam));
rkllm_infer_params.mode = RKLLM_INFER_GENERATE;
// 1. 初初化并设置 LoRA 参数（假如需求运用 LoRA）
RKLLMLoraParam lora_params;
lora_params.lora_adapter_name = "test"; // 指定用于推理的 lora 称号
// 2. 初初化并设置 Prompt Cache 参数（假如需求运用 prompt cache）
RKLLMPromptCacheParam prompt_cache_params;
prompt_cache_params.save_prompt_cache = true; // 能否保管 prompt cache
prompt_cache_params.prompt_cache_path = "./prompt_cache.bin";

rkllm_infer_params.mode = RKLLM_INFER_GENERATE;
// rkllm_infer_params.lora_params = &lora_params;
// rkllm_infer_params.prompt_cache_params = &prompt_cache_params;
rkllm_infer_params.lora_params = NULL;
rkllm_infer_params.prompt_cache_params = NULL;

RKLLMInput rkllm_input;
rkllm_input.input_type = RKLLM_INPUT_PROMPT;
rkllm_input.prompt_input = (char *)text.c_str();

rkllm_run(llmHandle, &rkllm_input, &rkllm_infer_params, NULL);

1.8.6 模子中缀

正在停止模子推理时，用户能够挪用 rkllm_abort()函数中缀推理历程，详细的函数界说以下：

表 13 rkllm_ abort 函数接心阐明

函数名	rkllm_ abort
描绘	用于中缀 RKLLM 模子推理历程。
参数	LLMHandle handle: 模子初初化注册的目的句柄；
前往值	0 暗示 RKLLM 模子中缀胜利；-1 暗示模子中缀掉败；

示例代码以下：

// 此中 llmHandle 为模子初初化时传进的句柄
rkllm_abort(llmHandle);

1.8.7 开释模子资本

正在完玉成部的模子推理挪用后，用户需求挪用 rkllm_destroy()函数停止 RKLLM 模子的烧毁，并开释所请求的 CPU、NPU 计较资本，以供其他历程、模子的挪用。详细的函数界说以下：

表 14 rkllm_ destroy 函数接心阐明

函数名	rkllm_ destroy
描绘	用于烧毁 RKLLM 模子并开释一切计较资本。
参数	LLMHandle handle: 模子初初化注册的目的句柄；
前往值	0 暗示 RKLLM 模子一般烧毁、开释；-1 暗示模子开释掉败；

示例代码以下：

// 此中 llmHandle 为模子初初化时传进的句柄
rkllm_destroy(llmHandle);

1.8.8 LoRA 模子减载

RKLLM 撑持正在推理根底模子的同时推理 LoRA 模子，能够正在挪用 rkllm_run 接心前经过rkllm_load_lora 接心减载 LoRA 模子。RKLLM 撑持减载多个 LoRA 模子，每挪用一次rkllm_load_lora 可减载一个 LoRA 模子。详细的函数界说以下：

表 15 rkllm_load_lora 函数接心阐明

函数名	rkllm_load_lora
描绘	用于减载 LoRA 模子。
参数	LLMHandle handle: 模子初初化注册的目的句柄； RKLLMLoraAdapter* lora_adapter: 减载 LoRA 模子时的参数设置装备摆设;
前往值	0 暗示 LoRA 模子一般减载；-1 暗示模子减载掉败；

表 16 RKLLMLoraAdapter 构造体参数阐明

构造体界说	RKLLMLoraAdapter
描绘	用于设置装备摆设减载 LoRA 时的参数。
字段	const char* lora_adapter_path: 待减载 LoRA 模子的途径； const char* lora_adapter_name: 待减载 LoRA 模子的称号, 由用户自界说, 用于后绝推理时挑选指定 LoRA; float scale: LoRA 模子正在推理进程中对根底模子参数停止调剂的幅度;

减载 LoRA 的示例代码以下：

RKLLMLoraAdapter lora_adapter;
memset(&lora_adapter, 0, sizeof(RKLLMLoraAdapter));
lora_adapter.lora_adapter_path = "lora.rkllm";
lora_adapter.lora_adapter_name = "lora_name";
lora_adapter.scale = 1.0;
ret = rkllm_load_lora(llmHandle, &lora_adapter);
if (ret != 0) {
   printf("nload lora failedn");
}

1.8.9 Prompt Cache 减载

RKLLM 撑持减载预死成的 Prompt Cache 文件，以此减速模子 Prefill 阶段的推理。详细的函数界说以下：

表 17 rkllm_load_prompt_cache 函数接心阐明

函数名	rkllm_load_prompt_cache
描绘	用于减载 Prompt Cache。
参数	LLMHandle handle: 模子初初化注册的目的句柄，可睹 4. 初初化模子； const char* prompt_cache_path: 待减载 Prompt Cache 文件的途径;
前往值	0 暗示 Prompt Cache 模子一般减载；-1 暗示模子减载掉败；

表 18 rkllm_release_prompt_cache 函数接心阐明

函数名	rkllm_release_prompt_cache
描绘	用于开释 Prompt Cache。
参数	LLMHandle handle: 模子初初化注册的目的句柄，可睹 4. 初初化模子；
前往值	0 暗示 Prompt Cache 模子一般开释；-1 暗示模子开释掉败；

减载 Prompt Cache 的示例代码以下：

rkllm_load_prompt_cache(llmHandle, "./prompt_cache.bin");
if (ret != 0) {
printf("nload Prompt Cache failedn");
}

考核编纂 黄宇