OrangePi Kunpeng Pro 开发板测评 | AI 边缘计算 & 大模型部署

0 前言

此次很幸运能够参与 OrangePi Kunpeng Pro 开发板的测评，感谢 CSDN 给予这次机会。

香橙派联合华为发布了基于昇腾的 OrangePi Kunpeng Pro 开发板，具备 8TOPS 的 AI 算力，能覆盖生态开发板者的主流应用场景，具备完善的配套软硬件。

1 硬件

怀着期待的心情，终于拿到 OrangePi Kunpeng Pro 开发板了。

1.1 外观

OrangePi Kunpeng Pro 开发板包装很严实，开发板装在密封的静电袋中，盒子里面上面和下面都有海绵保护，防止开发板被压坏，厂商确实很用心了。配件里面还配有最高 65W 的 PD type-c 电源，电源支持 5V3A、9V3A、12V3A、15V3A、20V3.25A。

OrangePi Kunpeng Pro 开发板的硬件细节可以从官网的细节图看得很清晰：

OrangePi Kunpeng Pro 开发板正面左边有一个包含两个头的天线，两个头分别是 2.4G 和 2.4/5G。左下角 MIPI 摄像头接口（Camera0）和 MIPI 显示屏接口（Display），旁边两个按钮分别是 PowerOff 电源按钮和 ESET 复位按钮，按钮上面又是一个 MIPI 摄像头接口（Camera1）。

开发板右下角就是 40PIN 的排针（GPIO）。开发板正面的 IO接口都集中在上边，从左到右分别是千兆网口、2个USB3.0接口、type-c3.0 接口、HDMI2.0、3.5mm耳机口音频输出/输入、HDMI2.0、type-c电源接口。

开发板中间是一个巨大的散热器。这个散热器的散热能力很不错，风扇最高 3W 功率。散热风扇为 12V 的，接口为 4pin，0.8mm 间距规格。可以通过 PWM 来控制风扇的转速。

OrangePi Kunpeng Pro 开发板背面看起来很漂亮，板子做工很好。

开发板背面主要是存储接口和两个设置启动方式的拨码开关。

如果使用 TF 卡来启动，需要使用 class10 以上的 TF卡；eMMC 接口可以外接 eMMC 模块；M.2 M-KEY 接口可以安装 2280 规格的 NVMe 协议或者 SATA 协议的 SSD。

两个控制启动方法的拨码开关，可以控制开发板从从TF卡、eMMC和SSD启动。BOOT1和BOOT2两个拨码开关都支持左右两种设置状态，所以总共有4种设置状态，开发板目前只使用了其中的三种。不同的设置状态对应的启动设备如下所示：

1.2 硬件规格

2 上电

2.1 ubuntu 系统烧录与配置

OrangePi Kunpeng Pro 开发板的内存卡里面预装了官方的 openEuler 系统，这个系统之前没有接触过，使用起来不是很方便，因此自己重新安装了官方的 ubuntu-22.04 的操作系统。

2.1.1 系统烧录

• 先准备一张32GB或更大容量的TF卡，，TF卡的传输速度必须为class10级或class10级以上。
  把TF卡插入读卡器，再把读卡器插入windows电脑。

• 从官方ubuntu镜像下载OrangePi Ai Pro 的 ubuntu 镜像压缩包（因为目前官方只提供了 openEuler 的镜像，不过 OrangePi Ai Pro 的 ubuntu 镜像在 OrangePi Kunpeng Pro 上也可以完美使用）

• 下载用于烧录Linux镜像的软件——balenaEtcher，下载地址为：https://www.balena.io/etcher/

• 烧录系统到 TF 卡
  打开后的balenaEtcher界面如下图所示：
  

  使用balenaEtcher烧录 Linux镜像的具体步骤：

  • 选择要烧录的Linux镜像文件的路径。
  • 后选择TF卡的盘符
  • 点击Flash就会开始烧录Linux镜像到TF卡中。

  balenaEtcher 烧录 Linux 镜像的过程显示的界面如下图所示，进度条显示紫色表示正在烧录Linux镜像到TF卡中：
  

  镜像烧录完后，balenaEtcher默认还会对烧录到TF卡中的镜像进行校验，确保烧录过程没有出问题。
  

  我在烧录过程中，最后校验完成后提示校验失败，但是把卡插上开发板，还是能够进入 ubuntu 系统。这里校验失败可能就是前面使用了 OrangePi Ai Pro 的 ubuntu 镜像导致的，但是系统在 OrangePi Kunpeng Pro 上可以完美运行。

2.1.2 远程连接

• ssh 登录

Linux 系统默认都开启了ssh远程登录，并且允许root用户登录系统。ssh 登录之前先获取到开发板的 IP 地址，可以通过路由器后台查看，也可以连接显示器之后使用ifconfig命令查看。

然后就可以通过ssh命令远程登录Linux系统。 windows 下可以使用各种终端工具来登录，例如 MobaXterm、XShell。Linux 下直接在终端连接即可：

 ssh HwHiAiUser@192.168.xx.xxx
1

成功登录系统后的显示如下图所示：

• 安装并配置 VNC 服务

  sudo apt update
  sudo apt install tigervnc-standalone-server tigervnc-common # 安装TigerVNC服务器及其依赖项
  sudo systemctl stop ufw  #关闭防火墙
  
  vncserver # 提示输出密码，密码为后续vnc view登录该账户的密码。会自动创建一个vncserver 进程
  
  # 创建启动脚本
  vim ~/.vnc/xstartup
  # 并向其中添加以下内容：
  #!/bin/sh
  unset SESSION_MANAGER
  unset DBUS_SESSION_BUS_ADDRESS
  exec startxfce4
  sudo chmod +x ~/.vnc/xstartup
  
  # 启动
  vncserver :1  -geometry 1920x1080  -depth 24 -localhost no
  
  # 查看是否启动成功
  ps -aux |grep -i vnc
  
  # 设置开机自启vnc
  sudo vim ~/.bash_profile
  # 以下内容写入文件中
  vncserver :1  -geometry 1920x1080  -depth 24 -localhost no
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25

• VNC 远程桌面登录
  这里输入开发板的 IP 和端口号
  

  在提示下输入密码即可进入远程桌面。这里应该是由于前面烧录的是 OrangePi Ai Pro 的 ubuntu 镜像，这里neofetch，命令打印的 Host 是 Orange Pi Ai Pro。
  

2.1.3 网络连接

OrangePi Kunpeng Pro 支持 wifi 和千兆有线网络。开发板上的无线网络天线信号非常好，比我的笔记本的要好用（不过由于我的路由器在夏天“高烧”，为了减轻路由器的压力，后面的测试都是通过网线连接有线网络进行的。小声称赞，千兆网口真好用，后面具体用到了再大声称赞。）。不过需要注意的是，在开发板上电的时候，不要让天线接触开发板，避免因为天线导电导致短路烧毁开发板。

避免因为动态 IP 在远程连接的时候需要查开发板的 IP，可以使用nmcli命令来设置静态IP地址。

如果要设置网口的静态IP地址，需要先将网线插入开发板，如果需要设置WIFI的静态IP地址，需要先连接好WIFI，然后再开始设置静态IP地址。

• 通过nmcli con show命令查看网络设备的名字
  

  • 哦豁灬是所连接的wifi的名称
  • Wired connection 1为以太网接口的名字

• 设置静态 IP 地址

  sudo nmcli con mod "Wired connection 1" \
    ipv4.addresses "192.168.1.110" \
    ipv4.gateway "192.168.1.1" \
    ipv4.dns "8.8.8.8" \
    ipv4.method "manual"
  1
  2
  3
  4
  5

  • “Wired connection 1” 表示设置以太网口的静态 IP地址，如果需要设置 WIFI 的静态 IP 地址，修改为WIFI网络接口对应的名字（通过nmcli con show命令可以获取到）。
  • ipv4.addresses 后面是要设置的静态 IP地址，可以修改为自己想要设置的值。
  • ipv4.gateway 表示网关的地址

• 重启开发板

  sudo reboot
  1

• 查看修改是否成功

  ip addr show eth0
  1

2.1.4 散热风扇设置

由于 OrangePi Kunpeng Pro 在有负载的时候有一定的发热量，散热风扇默认的自动模式比较保守，转速有些低，可以把散热风扇切换为手动模式，并根据负载和发热情况设置合适的风扇调速比，使用npu-smi命令可以查询和控制PWM风扇。

• 使用 npi-smi info 命令可以查看 npu core 的信息，包括温度
  

  可以看出来。待机状态下 AICore 的温度为 49 摄氏度。

• 查询风扇模式

  sudo npu-smi info -t pwm-mode
  # wm-mode                       : auto，可以看到默认是自动模式
  
  # 有两种模式： manual：手动模式；auto：自动模式
  1
  2
  3
  4

• 查询风扇调速比

  sudo npu-smi info -t pwm-duty-ratio
  # pwm-duty-ratio(%)              : 15，可以看到待机状态自动挡的调速比为 15%
  1
  2

• 设置风扇模式为手动模式并来设置风扇的调速比

  sudo npu-smi set -t pwm-mode -d 0
    # Status                         : OK
    # Message                        : Set pwm manual mode success
  
  # 风扇使能模式。分为手动模式、自动模式。默认为自动模式。
  # 0：手动模式
  # 1：自动模式
  
  
  set -t pwm-duty-ratio -d 30           # 将风扇调速比设置为 30%
    # Status                         : OK
    # Message                        : Set pwm duty ratio 30 success
  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13

2.1.5 AI CPU 和 control CPU 设置

OrangePi Kunpeng Pro 使用的昇腾SOC总共有4个CPU，这4个CPU既可以设置为 control CPU，也可以设置为 AI CPU。默认情况下，controlCPU 和 AICPU 的分配数量为 3:1。使用npu-smi info -t cpu-num-cfg -i 0 -c 0命令可以查看下 controlCPU 和 AI CPU 的分配数量。

因此在默认情况下，在 CPU 跑满的时候，使用htop命令会看到有一个CPU的占用率始终接近0，这是正常的。因为这个CPU默认用于 AI CPU。

可以使用npu-smi info -t usages -i 0 -c 0命令查看 AI CPU 的使用率，

如果不需要使用 AI CPU，使用sudo npu-smi set -t cpu-num-cfg -i 0 -c 0 -v 0:4:0命令将4个CPU都设置为 control CPU。设置完后需要重启系统让配置生效。

2.1.6 设置 swap 内存

手上拿到的 OrangePi Kunpeng Pro 的内存是 8GB 的，考虑到后面可能会跑一些有一定内存需求的项目，可以通过Swap内存来扩展系统能使用的最大内存容量。

• 创建一个swap文件

   sudo fallocate -l 4G /swapfile       # 手上只有 32GB 的内存卡，装完 ubuntu 22.04 之后，只剩 11GB 了，考虑到后面配置环境开需要使用一部分，这里先暂时拓展 4GB 的 swap 内存
  1

• 修改文件权限，确保只有root用户可以读写

  sudo chmod 600 /swapfile
  1

• 把这个文件设置成swap空间

   sudo mkswap /swapfile
  1

• 启用swap

  sudo swapon /swapfile
  
  # 修改/etc/fstab文件，使系统启动时自动加载此交换分区
  sudo vim /etc/fstab
  # 在文件末尾添加如下行：
  /swapfile  swap      swap    defaults   0       0
  1
  2
  3
  4
  5
  6

• 检查swap内存是否已经添加成功

  free -h
  1

  

2.1.7 开发环境配置

• conda & pip 配置

  echo "export PATH=/usr/local/miniconda3:$PATH" >> ~/.bashrc  && source ~/.bashrc # 官方的ubuntu镜像自带 conda，但是不在环境变量中，需要把 conda 加入到环境变量
  
  # 进入 conda bash 环境
  conda activate base
  
  # 安装 pip
  sudo apt-get install python3-pip
  
  # 替换 pip 源
  mkdir ~/.pip
  sudo vim ~/.pip/pip.conf
  # 把文件内容修改为如下内容（清华源）
  [global]
  index-url = https://pypi.tuna.tsinghua.edu.cn/simple/ 
  [install]
  trusted-host = pypi.tuna.tsinghua.edu.cn
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16

• 安装必要的 python 包

pip install torch transformers onnx protobuf onnxruntime cloudpickle decorator psutil scipy synr==0.5.0 tornado absl-py  getopt inspect multiprocessing
1

• C/C++ 环境
  官方的 ubuntu 镜像包含了 gcc/g++/cmake 等必要的工具了

3 性能测试

OrangePi Kunpeng Pro 的这个昇腾310B4处理器以前没有接触过，不知道实际性能怎么样，那就跑个分看看吧。

3.1 室温下CPU温度

在室温 22 摄氏度的条件下，待机状态下，使用npu-smi info命令查看CPU温度：43摄氏度

3.2 lscpu命令

可以看到，OrangePi Kunpeng Pro 的 BogoMIPS 是 96，MIPS 是 millions of instructions per second(百万条指令每秒)的缩写，其代表CPU的运算速度，是cpu性能的重要指标。但只能用来粗略计算处理器的性能，并不十分精确。

3.3 软件 CPU 跑分

这里使用 Sysbench 这个软件来测试CPU的性能。

Sysbench是一个开源的、模块化的、跨平台的多线程性能测试工具，可以用来进行CPU、内存、磁盘I/O、线程、数据库的性能测试。

安装使用命令 sudo apt-get install sysbench
测试CPU命令 sysbench cpu run

其中CPU speed: events per second是衡量CPU速度的指标。

在单线程下，OrangePi Kunpeng Pro 的是：2060.64

4 AI 应用样例体验

在官方的 ubuntu 镜像中预装了 JupyterLab 软件。Jupyter Lab 软件是一个基于web的交互式开发环境，集成了代码编辑器、终端、文件管理器等功能。

4.1 登录 juypterlab

# 切换到保存AI应用样例的目录下
cd samples/notebooks/

# 安装 jupyter
sudo apt-get install jupyter

# 执行start_notebook.sh脚本启动 Jupyter Lab
./start_notebook.sh

# 根据终端中打印出来的登录Jupyter Lab的网址链接在浏览器中登录JupyterLab软件
1
2
3
4
5
6
7
8
9
10

也可以利用官方的 sample 样例，自己写推理脚本来执行不同的 AI 应用。后面将自己编写推理脚本来执行AI 样例应用。

准备好训练好的 onnx 模型，可以直接使用 onnxruntime 来执行推理任务。为了进一步优化模型推理性能，更好的发挥 OrangePi Kunpeng Pro 硬件的 AI 性能，可以借助官方提供的工具将 onnx 模型转换为 om 模型进行使用，转换指令：

atc --model=yolov5s.onnx --framework=5 --output=yolo --input_format=NCHW --input_shape="input_image:1,3,640,640" --log=error --soc_version=Ascend310B1
1

其中转换参数的含义：

• –model，输入 onnx 模型的路径
• –framework，原始网络模型框架类型，5 表示 onnx
• –output，输出模型路径
• –input_format，输入 tensor 的内存配列方式
• –input_shape，指定模型输入数据的类型
• –log，日志级别
• –soc_version，昇腾 AI 处理器型号
• –input_fp16_nodes，指定输入数据类型为 fp16 的输入节点的名称
• –output_type，指定网络输出数据类型或者指定某个输出节点的输出类型

后面执行 AI 程序也都会把 onnx 转换成 om 模型来跑。

4.2 文字识别

OCR一般指 SceneText Recognition（场景文字识别），主要面向自然场景。

进入 ocr 样例目录：cd ~/samples/notebooks/02-ocr，可以看到目录下有两个模型，ctpn.om 是基于 faster rcnn 模型修改而来，作为检测模型负责找出图像或视频中的文字位置；svtr.om 是基于近几年十分流行的 vision transformer 模型，作为识别模型负责将图像信息转换为文本信息。

• 文字识别（OCR）的模型推理主要有以下几个步骤：

  • 前处理
    前处理的主要目的是将输入处理成模型需要的输入格式，最常见的比如NLP任务中使用的 tokenlizer，CV 任务中使用的标准化/色域转换/缩放等操作

  • CTPN
    CTPN 模型的前处理由简单的 resize 和 Normalization 组成，代码如下所示

    def preprocess(self, img):
        # resize image and convert dtype to fp32
        dst_img = cv2.resize(img, (int(self.model_width), int(self.model_height))).astype(np.float32)
    
        # normalization
        dst_img -= self.mean
        dst_img /= self.std
    
        # hwc to chw
        dst_img = dst_img.transpose((2, 0, 1))
    
        # chw to nchw
        dst_img = np.expand_dims(dst_img, axis=0)
        dst_img = np.ascontiguousarray(dst_img).astype(np.float32)
        return dst_img
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15

  • SVTR
    SVTR 模型的前处理和 CTPN 稍有不一样，除了 resize 和 Normalization 之外，为了保证图片缩放后的宽高比以及符合模型输入的 shape，我们还需要对其做 Padding 操作，代码如下所示

    def preprocess(self, img):
        h, w, _ = img.shape
        ratio = w / h
        if math.ceil(ratio * self.model_height) > self.model_width:
            resize_w = self.model_width
        else:
            resize_w = math.ceil(ratio * self.model_height)
    
        img = cv2.resize(img, (resize_w, self.model_height))
    
        _, w, _ = img.shape
        padding_w = self.model_width - w
        img = cv2.copyMakeBorder(img, 0, 0, 0, padding_w, cv2.BORDER_CONSTANT, value=0.).astype(np.float32)
        img *= self.scale
        img -= self.mean
        img /= self.std
    
        # hwc to chw
        dst_img = img.transpose((2, 0, 1))
    
        # chw to nchw
        dst_img = np.expand_dims(dst_img, axis=0)
        dst_img = np.ascontiguousarray(dst_img).astype(np.float32)
    
        return dst_img
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25

  • 推理接口
    两个模型的推理接口部分是相似的，在复制输入数据至模型输入的地址之后我们调用 execute api 就可以推理了

    def infer(self, tensor):
        np_ptr = acl.util.bytes_to_ptr(tensor.tobytes())
        # copy input data from host to device
        ret = acl.rt.memcpy(self.input_data[0]["buffer"], self.input_data[0]["size"], np_ptr,
                            self.input_data[0]["size"], ACL_MEMCPY_HOST_TO_DEVICE)
    
        # infer exec
        ret = acl.mdl.execute(self.model_id, self.load_input_dataset, self.load_output_dataset)
    
        inference_result = []
    
        for i, item in enumerate(self.output_data):
            buffer_host, ret = acl.rt.malloc_host(self.output_data[i]["size"])
            # copy output data from device to host
            ret = acl.rt.memcpy(buffer_host, self.output_data[i]["size"], self.output_data[i]["buffer"],
                                self.output_data[i]["size"], ACL_MEMCPY_DEVICE_TO_HOST)
    
            data = acl.util.ptr_to_bytes(buffer_host, self.output_data[i]['size'])
            data = np.frombuffer(data, dtype=self.output_dtypes[i]).reshape(self.output_shapes[i])
            inference_result.append(data)
    
        return inference_result
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22

  • 后处理
    CTPN 与传统的检测模型的后处理相似，CTPN 的后处理也有着 NMS 等操作。与之不同的是 CTPN 使用了文本线构造方法使多个 bbox 组成了一个文本框:

    def postprocess(self, output):
        proposal = output[0]
        proposal_mask = output[1]
        all_box_tmp = proposal
        all_mask_tmp = np.expand_dims(proposal_mask, axis=1)
        using_boxes_mask = all_box_tmp * all_mask_tmp
        textsegs = using_boxes_mask[:, 0:4].astype(np.float32)
        scores = using_boxes_mask[:, 4].astype(np.float32)
        bboxes = detect(textsegs, scores[:, np.newaxis], (self.model_height, self.model_width))
        return bboxes
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10

    svrt 与大部分文本识别模型相似，SVTR 的后处理就是一个简单的 Argmax 操作之后查表的过程:

    def postprocess(self, output):
        output = np.argmax(output[0], axis=2).reshape(-1)
        ans = []
        last_char = ''
        for i, char in enumerate(output):
            if char and self.labels[char] != last_char:
                ans.append(self.labels[char])
            last_char = self.labels[char]
        return ''.join(ans)
    1
    2
    3
    4
    5
    6
    7
    8
    9

• 编写推理脚本infer.py：

import cv2
import numpy as np
import ipywidgets as widgets
from IPython.display import display
import torch
from skvideo.io import vreader, FFmpegWriter
import IPython.display
# from ais_bench.infer.interface import InferSession
import onnxruntime

from det_utils import letterbox, scale_coords, nms

def preprocess_image(image, cfg, bgr2rgb=True):
    """图片预处理"""
    img, scale_ratio, pad_size = letterbox(image, new_shape=cfg['input_shape'])
    if bgr2rgb:
        img = img[:, :, ::-1]
    img = img.transpose(2, 0, 1)  # HWC2CHW
    img = np.ascontiguousarray(img, dtype=np.float32)
    return img, scale_ratio, pad_size


def draw_bbox(bbox, img0, color, wt, names):
    """在图片上画预测框"""
    det_result_str = ''
    for idx, class_id in enumerate(bbox[:, 5]):
        if float(bbox[idx][4] < float(0.05)):
            continue
        img0 = cv2.rectangle(img0, (int(bbox[idx][0]), int(bbox[idx][1])), (int(bbox[idx][2]), int(bbox[idx][3])),
                             color, wt)
        img0 = cv2.putText(img0, str(idx) + ' ' + names[int(class_id)], (int(bbox[idx][0]), int(bbox[idx][1] + 16)),
                           cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 1)
        img0 = cv2.putText(img0, '{:.4f}'.format(bbox[idx][4]), (int(bbox[idx][0]), int(bbox[idx][1] + 32)),
                           cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 1)
        det_result_str += '{} {} {} {} {} {}\n'.format(
            names[bbox[idx][5]], str(bbox[idx][4]), bbox[idx][0], bbox[idx][1], bbox[idx][2], bbox[idx][3])
    return img0


def get_labels_from_txt(path):
    """从txt文件获取图片标签"""
    labels_dict = dict()
    with open(path) as f:
        for cat_id, label in enumerate(f.readlines()):
            labels_dict[cat_id] = label.strip()
    return labels_dict


def draw_prediction(pred, image, labels):
    """在图片上画出预测框并进行可视化展示"""
    imgbox = widgets.Image(format='jpg', height=720, width=1280)
    img_dw = draw_bbox(pred, image, (0, 255, 0), 2, labels)
    imgbox.value = cv2.imencode('.jpg', img_dw)[1].tobytes()
    display(imgbox)


def infer_image(img_path, model, class_names, cfg):
    """图片推理"""
    image = cv2.imread(img_path)
    img, scale_ratio, pad_size = preprocess_image(image, cfg)
    output = model.infer([img])[0]

    output = torch.tensor(output)
    boxout = nms(output, conf_thres=cfg["conf_thres"], iou_thres=cfg["iou_thres"])
    pred_all = boxout[0].numpy()
    scale_coords(cfg['input_shape'], pred_all[:, :4], image.shape, ratio_pad=(scale_ratio, pad_size))
    draw_prediction(pred_all, image, class_names)


def infer_frame_with_vis(image, model, labels_dict, cfg, bgr2rgb=True):
    # 数据预处理
    img, scale_ratio, pad_size = preprocess_image(image, cfg, bgr2rgb)
    # output = model.infer([img])[0]
    output = model.run([img])[0]

    output = torch.tensor(output)
    boxout = nms(output, conf_thres=cfg["conf_thres"], iou_thres=cfg["iou_thres"])
    pred_all = boxout[0].numpy()
    scale_coords(cfg['input_shape'], pred_all[:, :4], image.shape, ratio_pad=(scale_ratio, pad_size))
    img_vis = draw_bbox(pred_all, image, (0, 255, 0), 2, labels_dict)
    return img_vis


def img2bytes(image):
    """将图片转为字节码"""
    return bytes(cv2.imencode('.jpg', image)[1])


def infer_video(video_path, model, labels_dict, cfg):
    """视频推理"""
    image_widget = widgets.Image(format='jpeg', width=800, height=600)
    display(image_widget)

    cap = cv2.VideoCapture(video_path)
    while True:
        ret, img_frame = cap.read()
        if not ret:
            break
        image_pred = infer_frame_with_vis(img_frame, model, labels_dict, cfg, bgr2rgb=True)
        image_widget.value = img2bytes(image_pred)


def infer_camera(model, labels_dict, cfg):
    """外设摄像头实时推理"""
    def find_camera_index():
        max_index_to_check = 10  # Maximum index to check for camera

        for index in range(max_index_to_check):
            cap = cv2.VideoCapture(index)
            if cap.read()[0]:
                cap.release()
                return index

        # If no camera is found
        raise ValueError("No camera found.")

    camera_index = find_camera_index()
    cap = cv2.VideoCapture(camera_index)
    image_widget = widgets.Image(format='jpeg', width=1280, height=720)
    display(image_widget)
    while True:
        _, img_frame = cap.read()
        image_pred = infer_frame_with_vis(img_frame, model, labels_dict, cfg)
        image_widget.value = img2bytes(image_pred)


cfg = {
    'conf_thres': 0.4,  
    'iou_thres': 0.5,  
    'input_shape': [640, 640], 
}

model_path = 'yolo.om'
label_path = './coco_names.txt'
onnx_model_path = './yolov5s.onnx'
# model = InferSession(0, model_path)
model = onnxruntime.InferenceSession(onnx_model_path)
labels_dict = get_labels_from_txt(label_path)


infer_mode = 'video'

if infer_mode == 'image':
    img_path = 'world_cup.jpg'
    infer_image(img_path, model, labels_dict, cfg)
elif infer_mode == 'camera':
    infer_camera(model, labels_dict, cfg)
elif infer_mode == 'video':
    video_path = 'racing.mp4'
    infer_video(video_path, model, labels_dict, cfg)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

• 开始推理

  python3 infer.py
  1

推理脚本执行过程中会在 terminal 中输出识别到的文字信息：

待识别的图片是当前路径下的 sample.png:

除此之外，还会在当前目录下存储推理的结果到 infer_result 文件夹中：

打开 infer_result/sample_res.png，可以看到在到识别图片中使用红色的框框出了图片中的文字：

框选出的内容与 terminal 中输出的文字结果一致。

这里只跑了图片的 OCR，上面的推理代码也支持视频和摄像头的视频源的实时识别。

OrangePi Kunpeng Pro 具有强大的 AI 算力，执行 CV 模型毫无压力，出结果速度也非常快。前面 ocr 模型也使用到了 vision transformer 模型，那么，基于 transformer 的大语言模型是否也可以部署并轻松跑起来呢？

5 推理大模型

OrangePi Kunpeng Pro 在前面的 CV 模型的表现非常出色，那么对于当下火热的大语言模型，开发板表现如何呢？考虑到开发板的内存大小这里使用 Google 开源的 gemma-2b-it 模型进行实验。后面对模型进行量化的时候，再使用规模更大的 Meta 最新开源的 llama3-8b。

在这里，由于大语言模型的权重比较大，我使用的 tf 卡所剩空间不多，因此就把大模型的权重存放在另外一台机器上，这台机器和 OrangePi Kunpeng Pro 都通过网线连接到同一台千兆交换机上，再把这台机器的硬盘挂载到 OrangePi Kunpeng Pro 上。得益于 OrangePi Kunpeng Pro 的千兆网口，这里在跑大模型的时候，OrangePi Kunpeng Pro 从另一台机器上搬运模型权重的时候，网络带宽基本没有形成瓶颈。

5.1 pytorch 推理

这里为了方便写推理脚本，在 OrangePi Kunpeng Pro 的 workspace 下把挂载在 OrangePi Kunpeng Pro 上的硬盘内的 gemma-2b-it 软链接了过来。

Hugging Face 的 Transformers 已经支持了 Gemma 模型，使用 pytroch 直接推理 gemma-2b-it 很简单，推理脚本只需要几行就够了：

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed
set_seed(1234)  # For reproducibility
prompt = "The best recipe for pasta is"
checkpoint = "./gemma-2b-it"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
model = AutoModelForCausalLM.from_pretrained(checkpoint, torch_dtype=torch.float16, device_map="cpu")
inputs = tokenizer(prompt, return_tensors="pt").to('cpu')
outputs = model.generate(**inputs, do_sample=True, max_new_tokens=150)
result = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(result)
1
2
3
4
5
6
7
8
9
10
11

直接执行脚本开始推理python3 run_gemma-2b-it.py。

在推理过程中，load 模型耗时比较久，这个过程需要把模型的权重从硬盘搬到内存中。对于 gemma-2b-it，load 模型花费了 224 秒：

由于这里使用 pytorch 进行推理，只能使用 CPU 来计算，因此也只能使用 float32 数据类型。在推理过程中，四个 control core 都满载了，内存占用为 5.85GB。

模型权重 load 进来之后，就是真正的推理过程了。推理过程耗时 282 秒：

由于是没有量化的模型，使用 pytorch 推理，基本没有精度损失，因此虽然 gemma-2b-it 的模型规模不大，但是模型的输出效果还是比较好的。

由于推理脚本中设置了max_new_tokens=150，可以看到最后模型的输出被截断了，因此这里一共输出了 150 个 tokens，那么很容易得到，使用 OrangePi Kunpeng Pro 纯 CPU 推理的情况下，gemma-2b-it 能达到 0.53 tokens/s。这个结果还是挺超出预期的，毕竟是使用 CPU 推理，并且跑的是 float32的，能跑出来已经很惊喜了。

5.2 使用 llama.cpp 量化部署

让 OrangePi Kunpeng Pro 的 CPU 使用 float32 进行大模型推理确实是有些难为它了。对于大模型推理这种对数据精度要求不高，并且还是在这种边缘计算定位的设备上，还是先将模型量化到低精度再跑更合适一些。考虑到 OrangePi Kunpeng Pro 的 npu 的特殊性，这里还是选择使用 CPU 来跑推理，因此使用 llama.cpp 来对模型进行量化和部署。

• 克隆和编译llama.cpp，拉取 llama.cpp 仓库最新代码

  git clone https://github.com/ggerganov/llama.cpp.git
  1

• 对llama.cpp项目进行编译，生成./main（用于推理）和./quantize（用于量化）二进制文件

  make -j4
  1

开发板的CPU算力和内存有限，可以在PC上使用 llama.cpp 对大模型进行量化编译处理，详细操作可以参考 使用llama.cpp量化部署LLM。

使用在PC上量化编译好的 .gguf 格式的模型，在开发板上运行大语言模型。

推理量化至 2bit 的 gemma-2b-it 模型

在 llama.cpp 根目录下，执行命令 ./main -m /rpi_hdd2/gemma-2b-it/ggml-model-q2_k.gguf --color -f prompts/alpaca.txt -ins -c 2048 --temp 0.2 -n 256 --repeat_penalty 1.3 来推理量化至 2bit 的 gemma-2b-it 模型：

使用和 pytorch 推理的时候相同的提示词，这次的推理速度快了很多，最后的结果统计里可以看到，真正的推理阶段的速度有 4.36 tokens/s。但是由于 gemma-2b-it 模型本身模型规模很小，并且被量化到了 2bit，精度损失非常大，因此回答的结果不尽人意，甚至都乱码了。

推理量化至 2bit 的 llama3-8b 模型

那么使用更大规模的模型呢？我们紧接着跑量化至 2bit 的 llama3-8b 模型，命令./main -m /rpi_hdd2/llama_cpp_model/ggml-model-q2_k.gguf --color -f prompts/alpaca.txt -ins -c 2048 --temp 0.2 -n 256 --repeat_penalty 1.3:

使用更大规模的模型，量化至 2bit 的 llama3-8b 模型的输出就好很多了，同时推理速度也下降到了 1.56 tokens/s，但是模型的回答效果好了很多:

推理量化至 4bit 的 llama3-8b 模型

我们把 llama3-8b 量化到 4bit，继续使用 CPU 推理./main -m /rpi_hdd2/llama_cpp_model/ggml-model-q4_0.gguf --color -f prompts/alpaca.txt -ins -c 2048 --temp 0.2 -n 256 --repeat_penalty 1.3:

随着量化精度的提高，模型的回答效果肉眼可见的变好了，并且还能够保持 1.47 tokens/s的推理速度，与 2bit 的模型推理速度差距很小。

5.3 优化方向

前面的方式都是使用 CPU 来跑的大模型退，没有真正发挥出 OrangePi Kunpeng Pro 的AI性能，本次测评时间有限，后面还会尝试将大语言模型转换成 OrangePi Kunpeng Pro 支持的 om 模型，更多地调用 OrangePi Kunpeng Pro 的 AI core，进一步发掘开发板的 AI 性能，相信 OrangePi Kunpeng Pro 在大语言模型上会有更加亮眼的表现。

6 总结

开发板的整体体验远超出预期，作为低功耗 AI 边缘计算开发板，支持Ubuntu、openEuler操作系统，能够满足大多数AI算法原型验证、推理应用开发的需求，结合昇腾 AI 生态支持，在 CV 网络上的表现令人满意。更让人意外的是，甚至对于大语言模型也有一战之力。

开发板是一块很值得尝试的开发板，IO 接口丰富，拓展性强，可玩性很高，可广泛适用于AI边缘计算、深度视觉学习及视频流AI分析、视频图像分析、自然语言处理、智能小车、机械臂、人工智能、无人机、云计算、AR/VR、智能安防、智能家居等领域。