在 AI 产业化落地中，边缘设备因 “低延迟、高可靠、数据本地化” 的特性，成为智能制造、智能安防等场景的核心载体。昇腾 AI 通过 Ascend 310 系列边缘芯片与轻量化工具链，为边缘端开发提供了高效解决方案。本文将以智能摄像头行人检测为例，从模型压缩、边缘部署到实时推理，用代码案例拆解昇腾边缘 AI 开发的关键步骤，助力开发者快速实现边缘场景落地。

一、边缘端模型准备：轻量化与压缩优化

边缘设备算力、内存资源有限，需先对模型进行轻量化改造与压缩，确保适配边缘硬件。以下以 YOLOv5 行人检测模型为例，完成模型压缩与昇腾格式转换。

1. 模型轻量化：裁剪与量化

使用昇腾提供的ModelCompressionTool工具，对 YOLOv5 模型进行通道裁剪与 INT8 量化，平衡精度与性能：

python

from ascend_compression import ModelCompressionTool

# 初始化模型压缩工具
compressor = ModelCompressionTool(
    model_path="./yolov5s_person.pt",  # 原始YOLOv5模型
    framework="PyTorch",
    compress_strategy="channel_pruning+quantization",  # 通道裁剪+量化
    pruning_ratio=0.3,  # 裁剪30%冗余通道
    quant_calib_dataset="./calib_data"  # 量化校准数据集（100-200张样本）
)

# 执行模型压缩
compressed_model = compressor.compress()

# 评估压缩后模型精度（确保精度损失可控）
ori_mAP = compressor.evaluate_original_model()
comp_mAP = compressor.evaluate_compressed_model()
print(f"原始模型mAP：{ori_mAP:.2f}，压缩后mAP：{comp_mAP:.2f}")

# 保存轻量化模型
compressor.save_compressed_model("./yolov5s_person_compressed.pt")

关键价值：经压缩后，YOLOv5 模型体积可减少 60% 以上，推理速度提升 2-3 倍，同时 mAP 损失控制在 1% 以内，完全满足边缘设备资源需求。

2. 转换为昇腾边缘推理格式（OM 文件）

使用昇腾 ATC 工具，将轻量化模型转换为边缘设备支持的 OM 格式（需匹配 Ascend 310 芯片型号）：

bash

# ATC工具模型转换命令
atc --model=./yolov5s_person_compressed.pt \
    --framework=6 \  # 6表示PyTorch框架
    --output=./yolov5s_person_edge \  # 输出OM模型文件名
    --input_shape="images:1,3,640,640" \  # 模型输入维度（N,C,H,W）
    --soc_version=Ascend310 \  # 目标边缘芯片型号
    --insert_op_conf=./preprocess.cfg  # 插入预处理算子（如归一化）

配置文件preprocess.cfg示例（提前完成图像归一化，减少边缘端计算量）：

json

{
    "preprocess": [
        {
            "type": "normalize",
            "mean": [0.485, 0.456, 0.406],
            "std": [0.229, 0.224, 0.225],
            "channel_swap": "0 1 2"
        }
    ]
}

二、昇腾边缘端环境搭建：极简部署方案

昇腾边缘设备（如昇腾 310 边缘盒子）提供简化的开发环境，通过以下步骤快速初始化：

1. 边缘设备环境验证

登录边缘设备，执行 Python 代码验证昇腾驱动与 CANN 环境：

python

import acl

def check_edge_env():
    # 初始化ACL库
    ret = acl.init()
    if ret != 0:
        print(f"ACL初始化失败，错误码：{ret}")
        return False
    
    # 检查边缘设备信息
    device_count = acl.rt.get_device_count()
    if device_count == 0:
        print("未检测到昇腾边缘设备")
        acl.finalize()
        return False
    
    # 确认边缘芯片型号
    device_id = 0
    chip_info = acl.rt.get_chip_info(device_id)
    print(f"边缘设备芯片型号：{chip_info['chip_name']}")
    print("昇腾边缘环境验证通过")
    
    # 释放资源
    acl.finalize()
    return True

if __name__ == "__main__":
    check_edge_env()

2. 依赖库安装

在边缘设备上安装推理所需依赖（如 OpenCV 用于图像处理）：

bash

# 安装边缘设备依赖
pip3 install opencv-python numpy
# 确认昇腾Python库是否正常
python3 -c "import acl; print('ACL库导入成功')"

三、边缘端实时推理：智能摄像头行人检测

基于昇腾边缘设备与转换后的 OM 模型，实现摄像头实时行人检测，完整代码如下：

python

import acl
import cv2
import numpy as np
import time

# 全局配置（适配边缘设备）
MODEL_PATH = "./yolov5s_person_edge.om"  # 边缘推理模型
DEVICE_ID = 0
INPUT_SHAPE = (1, 3, 640, 640)  # 模型输入维度
CONF_THRESH = 0.5  # 检测置信度阈值
IOU_THRESH = 0.45  # IOU阈值（用于NMS）

# 初始化昇腾边缘推理引擎
def init_edge_engine():
    # 初始化ACL与设备
    acl.init()
    acl.rt.set_device(DEVICE_ID)
    context, _ = acl.rt.create_context(DEVICE_ID)
    
    # 创建异步流（提升边缘推理效率）
    stream, _ = acl.rt.create_stream()
    
    # 加载OM模型
    model_id, _ = acl.mdl.load_from_file(MODEL_PATH)
    
    # 获取模型输入/输出内存大小
    input_size = acl.mdl.get_input_size(model_id, 0)
    output_size = acl.mdl.get_output_size(model_id, 0)
    
    return context, stream, model_id, input_size, output_size

# 图像预处理（适配模型输入）
def preprocess_frame(frame):
    # 调整图像尺寸（保持比例，填充黑边）
    h, w = frame.shape[:2]
    scale = min(640/w, 640/h)
    new_w, new_h = int(w*scale), int(h*scale)
    resized = cv2.resize(frame, (new_w, new_h))
    
    # 创建640x640输入图像
    input_img = np.zeros((640, 640, 3), dtype=np.uint8)
    input_img[:new_h, :new_w, :] = resized
    
    # 转换格式：HWC→CHW，uint8→float32
    input_img = input_img.transpose((2, 0, 1)).astype(np.float32)
    input_img = np.expand_dims(input_img, axis=0)
    
    return input_img, scale, (new_w, new_h)

# YOLOv5推理结果后处理（边缘端轻量化实现）
def postprocess_output(output_data, scale, img_size):
    output_data = output_data.reshape(1, -1, 85)  # YOLOv5输出格式：(1, 25200, 85)
    boxes, confs, classes = [], [], []
    
    for data in output_data[0]:
        x1, y1, x2, y2, conf, cls = data[:6]
        if conf < CONF_THRESH:
            continue
        
        # 坐标映射回原始图像
        x1 = (x1 - (640 - img_size[0])/2) / scale
        y1 = (y1 - (640 - img_size[1])/2) / scale
        x2 = (x2 - (640 - img_size[0])/2) / scale
        y2 = (y2 - (640 - img_size[1])/2) / scale
        
        boxes.append([x1, y1, x2, y2])
        confs.append(conf)
        classes.append(cls)
    
    # 非极大值抑制（NMS）去除重叠框
    indices = cv2.dnn.NMSBoxes(boxes, confs, CONF_THRESH, IOU_THRESH)
    return [boxes[i] for i in indices], [confs[i] for i in indices]

# 边缘端实时检测主逻辑
def edge_realtime_detection(camera_idx=0):
    # 初始化推理引擎
    context, stream, model_id, input_size, output_size = init_edge_engine()
    
    # 打开摄像头（边缘设备外接USB摄像头）
    cap = cv2.VideoCapture(camera_idx)
    if not cap.isOpened():
        print("无法打开摄像头")
        return
    
    print("边缘端行人检测开始（按'q'退出）")
    while True:
        ret, frame = cap.read()
        if not ret:
            break
        
        # 1. 图像预处理
        input_data, scale, img_size = preprocess_frame(frame)
        
        # 2. 申请边缘设备内存并拷贝数据
        input_ptr = acl.create_buffer(input_data.nbytes)
        acl.rt.memcpy(input_ptr, input_data.ctypes.data, input_data.nbytes,
                      acl.rt.MEMCPY_HOST_TO_DEVICE, stream)
        acl.rt.synchronize_stream(stream)
        
        # 3. 执行边缘推理
        output_data = np.zeros((output_size//4,), dtype=np.float32)  # float32占4字节
        output_ptr = acl.create_buffer(output_size)
        acl.mdl.execute_async(model_id, [input_ptr], [output_ptr], stream)
        acl.rt.synchronize_stream(stream)
        
        # 4. 拷贝推理结果到主机
        acl.rt.memcpy(output_data.ctypes.data, output_ptr, output_size,
                      acl.rt.MEMCPY_DEVICE_TO_HOST, stream)
        acl.rt.synchronize_stream(stream)
        
        # 5. 结果后处理与可视化
        boxes, confs = postprocess_output(output_data, scale, img_size)
        for box, conf in zip(boxes, confs):
            x1, y1, x2, y2 = map(int, box)
            cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
            cv2.putText(frame, f"Person: {conf:.2f}", (x1, y1-10),
                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1)
        
        # 显示检测结果（边缘设备外接屏幕或远程查看）
        cv2.imshow("Edge Person Detection", frame)
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
        
        # 释放内存
        acl.destroy_buffer(input_ptr)
        acl.destroy_buffer(output_ptr)
    
    # 资源清理
    cap.release()
    cv2.destroyAllWindows()
    acl.mdl.unload(model_id)
    acl.rt.destroy_stream(stream)
    acl.rt.destroy_context(context)
    acl.rt.reset_device(DEVICE_ID)
    acl.finalize()

if __name__ == "__main__":
    edge_realtime_detection()

四、边缘端性能优化：低延迟与高可靠

在边缘场景中，“低延迟” 与 “高可靠” 是核心需求，可通过以下方式优化：

1. 推理速度优化

• 异步推理：通过Stream实现数据拷贝与推理并行，减少等待时间；
• 算子融合：在模型转换时通过--fusion_switch_file配置算子融合，减少计算步骤；
• 批量推理：若摄像头帧率稳定，可积累 2-4 帧进行批量推理，提升单位时间处理效率。

2. 可靠性保障

• 异常处理：在代码中增加设备断连、内存申请失败等异常捕获逻辑；
• 模型备份：在边缘设备中存储多个版本的 OM 模型，避免单一模型故障导致服务中断；
• 日志记录：通过acl.rt.get_stream_status()等接口记录推理状态，便于问题排查。

五、边缘端场景拓展：从检测到联动

基于本文的行人检测方案，可快速拓展至更多边缘场景：

• 智能安防：检测到异常行人后，联动边缘设备的声光报警模块；
• 智能制造：将摄像头替换为工业相机，实现生产线上的人员闯入检测；
• 智慧零售：统计门店入口的行人数量，为客流分析提供数据支撑。

昇腾 AI 边缘端开发的核心是 “资源适配与场景贴合”—— 通过模型轻量化降低资源消耗，通过异步推理与硬件优化提升实时性，最终实现 AI 技术在边缘场景的高效落地。无论是开发者还是企业，掌握这套边缘开发流程，都能在 “云边协同” 的 AI 产业化浪潮中抢占先机。

2025年昇腾CANN训练营第二季，基于CANN开源开放全场景，推出0基础入门系列、码力全开特辑、开发者案例等专题课程，助力不同阶段开发者快速提升算子开发技能。获得Ascend C算子中级认证，即可领取精美证书，完成社区任务更有机会赢取华为手机，平板、开发板等大奖。

报名链接:https://www.hiascend.com/developer/activities/cann20252
————————————————
版权声明：本文为CSDN博主「寒季666」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/2501_94333695/article/details/155004921