跳到主要内容

使用OpenVINO进行高效目标检测:从模型加载到结果可视化的完整教程

鱼雪

在计算机视觉领域,目标检测是深度学习中的核心任务之一,广泛应用于安防监控、工业检测、自动驾驶和智能零售等多个场景。 随着模型的不断进化与优化,如何在实际部署中充分利用硬件和软件资源,加速推理性能成为关键需求。 OpenVINO作为英特尔推出的高性能推理工具,能有效加速深度学习模型的推理过程。本文将详细介绍如何使用OpenVINO Runtime对目标检测模型进行推理, 并通过实例代码向您展示从数据预处理、模型加载、推理到后处理和结果可视化的完整流程。

为什么选择OpenVINO?

OpenVINO(Open Visual Inference & Neural Network Optimization)是英特尔提供的深度学习推理和优化工具套件。与传统的推理框架相比,OpenVINO具有以下优势:

  1. 跨平台与多硬件支持:支持在CPU、GPU、VPU以及FPGA等多种硬件设备上进行推理,加速多元化的应用场景。
  2. 高性能推理:通过模型优化和低精度推理(如FP16、INT8量化),OpenVINO可大幅降低推理延迟,提高吞吐量。
  3. 丰富的API和工具:为开发者提供了易于使用的Python API和C++接口,方便快速集成和部署。
  4. 广泛的模型支持:兼容ONNX、TensorFlow、PyTorch等主流框架导出的模型,降低迁移成本。

环境准备

开始之前,请确保您已安装以下依赖:

  • Python 3.7+
  • OpenVINO Runtime(可参考官方文档
  • OpenCV
  • NumPy

使用pip安装必要的依赖:

pip install openvino opencv-python numpy
备注

如果要转换ONNX模型为OpenVINO,则需要安装openvino-dev包。

pip install openvino-dev

代码详解

下面的示例代码展示了如何使用OpenVINO进行目标检测推理。请根据实际需求自行修改路径和参数。

导入必要的库

import cv2
import numpy as np
import hashlib
from openvino.runtime import Core
  • cv2:用于图像预处理和可视化。
  • numpy:用于数据处理和数值计算。
  • hashlib:用于生成类别对应的颜色哈希值。
  • openvino.runtime.Core:用于加载和编译OpenVINO模型,执行推理任务。

定义类别和颜色映射

# 定义12个类别
CLASSES = [
'book', 'bottle', 'cellphone', 'drink', 'eat', 'face',
'food', 'head', 'keyboard', 'mask', 'person', 'talk'
]

def name_to_color(name):
# 使用哈希为每个类别生成唯一颜色
hash_str = hashlib.md5(name.encode('utf-8')).hexdigest()
r = int(hash_str[0:2], 16)
g = int(hash_str[2:4], 16)
b = int(hash_str[4:6], 16)
return (r, g, b)

通过哈希生成稳定的颜色映射,确保多次运行中同一类别颜色一致。

辅助函数

包括Sigmoid激活函数、坐标转换和IoU计算等常用操作。

def sigmoid(x):
return 1 / (1 + np.exp(-x))

def xywh2xyxy(x):
y = np.copy(x)
y[..., 0] = x[..., 0] - x[..., 2]/2
y[..., 1] = x[..., 1] - x[..., 3]/2
y[..., 2] = x[..., 0] + x[..., 2]/2
y[..., 3] = x[..., 1] + x[..., 3]/2
return y

def compute_iou(box, boxes):
xmin = np.maximum(box[0], boxes[:, 0])
ymin = np.maximum(box[1], boxes[:, 1])
xmax = np.minimum(box[2], boxes[:, 2])
ymax = np.minimum(box[3], boxes[:, 3])

inter_w = np.maximum(0, xmax - xmin)
inter_h = np.maximum(0, ymax - ymin)
intersection = inter_w * inter_h

box_area = (box[2]-box[0])*(box[3]-box[1])
boxes_area = (boxes[:,2]-boxes[:,0])*(boxes[:,3]-boxes[:,1])

union = box_area + boxes_area - intersection
iou = intersection / union
return iou

模型加载

使用OpenVINO Runtime加载并编译模型。

def load_model(model_path, device='CPU'):
ie = Core()
model = ie.read_model(model_path)
compiled_model = ie.compile_model(model=model, device_name=device)
input_layer = compiled_model.inputs[0]
output_layer = compiled_model.outputs[0]
input_shape = input_layer.shape
return compiled_model, input_layer, output_layer, input_shape
  • load_model:读取并编译模型,可选择设备(如CPU、GPU)。
  • input_layeroutput_layer:获取模型输入输出层信息,用于推理时的数据输入输出操作。

图像预处理

将输入图像转换为模型所需的格式。

def preprocess_image(image_path, input_width, input_height):
image = cv2.imread(image_path)
if image is None:
raise FileNotFoundError(f"图像未找到: {image_path}")
original_height, original_width = image.shape[:2]
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
resized = cv2.resize(image_rgb, (input_width, input_height))
input_image = resized.astype(np.float32)/255.0
input_image = input_image.transpose(2,0,1)
input_tensor = np.expand_dims(input_image, 0)
return image, input_tensor, original_width, original_height

后处理与NMS

对模型输出结果进行解析、阈值筛选和NMS去重。

def postprocess(outputs, original_width, original_height, input_width, input_height, conf_threshold=0.7, iou_threshold=0.5):
predictions = np.squeeze(outputs, axis=0).T

print(f"总预测数量: {predictions.shape[0]}")

boxes = predictions[:, :4]
class_scores = sigmoid(predictions[:, 4:])
class_ids = np.argmax(class_scores, axis=1)
confidences = np.max(class_scores, axis=1)

mask = confidences > conf_threshold
boxes = boxes[mask]
confidences = confidences[mask]
class_ids = class_ids[mask]

print(f"应用置信度阈值后: {boxes.shape[0]} 个框")
if len(confidences) > 0:
print(f"置信度分布: 最小={confidences.min():.4f}, 最大={confidences.max():.4f}, 平均={confidences.mean():.4f}")

if len(boxes) == 0:
return [], [], []

boxes_xyxy = xywh2xyxy(boxes)
scale_w = original_width/input_width
scale_h = original_height/input_height
boxes_xyxy[:, [0,2]] *= scale_w
boxes_xyxy[:, [1,3]] *= scale_h
boxes_xyxy = boxes_xyxy.astype(np.int32)

boxes_list = boxes_xyxy.tolist()
scores_list = confidences.tolist()

final_boxes = []
final_confidences = []
final_class_ids = []

unique_classes = np.unique(class_ids)
for cls in unique_classes:
cls_mask = (class_ids==cls)
cls_boxes = [boxes_list[i] for i in range(len(class_ids)) if cls_mask[i]]
cls_scores = [scores_list[i] for i in range(len(class_ids)) if cls_mask[i]]

if len(cls_boxes)==0:
continue

cls_boxes_xywh = []
for box in cls_boxes:
x1,y1,x2,y2 = box
cls_boxes_xywh.append([x1,y1,x2-x1,y2-y1])

indices = cv2.dnn.NMSBoxes(cls_boxes_xywh, cls_scores, conf_threshold, iou_threshold)

if len(indices)>0:
for i in indices.flatten():
final_boxes.append(cls_boxes[i])
final_confidences.append(cls_scores[i])
final_class_ids.append(cls)

print(f"应用NMS后: {len(final_boxes)} 个框")

return final_boxes, final_confidences, final_class_ids

可视化结果

在原图上绘制检测结果。

def visualize(image, boxes, confidences, class_ids, output_path='result.jpg'):
image_draw = image.copy()
for (bbox, score, cls_id) in zip(boxes, confidences, class_ids):
x1,y1,x2,y2 = bbox
cls_name = CLASSES[cls_id]
label = f"{cls_name}:{score:.2f}"
color = name_to_color(cls_name)
cv2.rectangle(image_draw, (x1,y1), (x2,y2), color, 2)
(lw, lh), _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX,0.5,1)
cv2.rectangle(image_draw, (x1, y1 - lh -10), (x1+lw,y1), color, -1)
cv2.putText(image_draw, label, (x1,y1-5), cv2.FONT_HERSHEY_SIMPLEX,0.5,(0,0,0),1)
cv2.imwrite(output_path, image_draw)
print(f"推理完成,结果已保存为 {output_path}")

完整预测流程

将上述步骤整合到predict函数中。

def predict(model_path, image_path, output_image_file, conf_threshold=0.6, iou_threshold=0.5):

# 加载模型
compiled_model, input_layer, output_layer, input_shape = load_model(model_path, device='CPU')
_, _, input_height, input_width = input_shape

# 预处理图像
image, input_tensor, original_width, original_height = preprocess_image(image_path, input_width, input_height)

# 推理
results = compiled_model([input_tensor])
outputs = results[output_layer]

# 后处理
boxes, confidences, class_ids = postprocess(
outputs,
original_width=original_width,
original_height=original_height,
input_width=input_width,
input_height=input_height,
conf_threshold=conf_threshold,
iou_threshold=iou_threshold
)

if len(boxes)==0:
print("未检测到任何目标。")
return

# 可视化结果
visualize(image, boxes, confidences, class_ids, output_path=output_image_file)

if __name__ == "__main__":
model_path = 'classroom_obd.onnx' # 请替换为您的ONNX模型路径(OpenVINO IR模型请先转换)
image_path = '002899.jpg'
output_image_file = "result.jpg"
predict(model_path, image_path, output_image_file)

YOLO OpenVINO的检测结果

性能优化建议

  1. 使用FP16或INT8精度:通过模型量化降低模型精度,如FP16或INT8,可提升推理速度。
  2. 指定设备:尝试将device设为GPU或其他加速设备,获得更高性能。
  3. 批量推理:对多张图像同时推理,提高吞吐量。

结论

本文介绍了如何使用OpenVINO Runtime对目标检测模型进行高效推理。 从模型加载、数据预处理,到推理后的非极大值抑制和结果可视化,您已了解完整的实现步骤。 OpenVINO在CPU、GPU等多种硬件设备上的高效支持,能够有效提升推理性能,为实际应用中部署深度学习目标检测模型提供了可靠的解决方案。

通过上述代码示例和优化建议,您可以轻松地将自己的目标检测模型集成到OpenVINO中,并根据实际需求进行性能调优和优化,加速您的计算机视觉应用落地。