Glauben Sie keinen Gerüchten und verbreiten Sie keine Gerüchte, prüfen Sie persönlich, ob die Argumentation von ModelBox wirklich "Hochleistung" ist

Zusammenfassung: „High-Performance Reasoning" ist eines der Hauptmerkmale der Promotion von ModelBox. Wenn ich Gerüchten nicht glauben möchte, habe ich mich entschieden, die native API zu verwenden, um denselben Fall mit ModelBox zu vergleichen, um zu sehen, ob ModelBoxs Argumentation wirklich „high" ist -Leistung".

Dieser Artikel wurde von der Huawei Cloud Community „ Ist ModelBox Reasoning Really Efficient? “, Autor: Wu Xiaoyu.

„Hochleistungs-Argumentation" ist eines der Hauptmerkmale der Promotion von ModelBox. Ich glaube nicht an Gerüchte. Ich habe mich entschieden, denselben Fall mit ModelBox über die native API zu vergleichen, um zu sehen, ob die Argumentation von ModelBox wirklich „Hochleistung" ist.

Wir verwenden onnxruntime bzw. ModelBox Windows SDK, um einen End-to-End-Leistungsvergleich desselben Modells mit derselben Argumentationslogik durchzuführen.Um zu verhindern, dass die Bildrate des Testvideos zu einem Leistungsengpass wird, haben wir ein 120-fps-Video als Test vorbereitet Eingang.

Wenn Sie mit der Verwendung des Windows ModelBox SDK nicht vertraut sind, können Sie in unserem ModelBox End-Cloud Collaborative AI Development Kit (Windows) Getting Started Guide nachschlagen . Die für den Fall erforderlichen Ressourcen (Code, Modell, Testdaten usw.) können aus dem obs-Bucket heruntergeladen werden .

Fallschilderung

Um die Argumentationsleistung verschiedener Frameworks vollständig zu testen, habe ich mich für einen etwas umständlichen zweistufigen Fall zur Erkennung menschlicher Schlüsselpunkte durch eine einzelne Person entschieden. Der konkrete Ablauf des Falls sieht wie folgt aus:

Unter ihnen wird das Open-Source-YOLOV7-Tiny-Vortrainingsmodell für die Erkennung von Humanoiden verwendet, und das Open -Source-PP-TinyPose-Vortrainingsmodell wird für die Erkennung von Schlüsselpunkten verwendet früheste ID für Schlüsselpunkterkennung.

onnxruntime-Inferenz

Der native API-Inferenzcode befindet sich im Verzeichnis onnxruntime_infer des Ressourcenpakets. Die spezifische Codeorganisation ist wie folgt:

onnxruntime_infer
    ├─onnxruntime_infer.py  # 推理入口脚本
    ├─utils.py              # 人形检测后处理
    ├─sort.py               # 跟踪
    ├─hrnet_post.py         # 关键点检测后处理
    └─smooth.py             # 关键点时序滤波

Darunter sind die verwendete Modelldatei und das verwendete Testvideo im Eintragsskript onnxruntime_infer.py angegeben:

cam = cv2.VideoCapture("../data/dance_120fps.mp4")
size = (int(cam.get(cv2.CAP_PROP_FRAME_WIDTH)), int(cam.get(cv2.CAP_PROP_FRAME_HEIGHT)))
fourcc = cv2.VideoWriter_fourcc(*"mp4v")
out_fps = cam.get(cv2.CAP_PROP_FPS)
res_cam = cv2.VideoWriter("../hilens_data_dir/rt_result.mp4", fourcc, out_fps, size)
det_sess = rt.InferenceSession("../model/det_human/yolov7-tiny.onnx", providers=["DmlExecutionProvider"]) 
pose_sess = rt.InferenceSession("../model/det_pose/pose.onnx", providers=["CPUExecutionProvider"])

Das humanoide Erkennungsmodell ist GPU-Inferenz und das Schlüsselpunkt-Erkennungsmodell ist CPU-Inferenz. Dieselbe Hardwarekonfiguration wird beibehalten, wenn ModelBox Windows SDK für Inferenz verwendet wird.

fps wird vom Beginn der Erkennungsvorverarbeitung bis zum Zeichnen von Schlüsselpunkten getestet:

class DetPre:
 def __init__(self, net_h=320, net_w=320):
 self.net_h = net_h
 self.net_w = net_w
 def __call__(self, img_data):
 buffer_meta = {}
 buffer_meta["time"] = time.time()
 resized_image, ratio, (dw, dh) = self.letterbox(img_data)
 ...
total_time += time.time() - buffer_meta.get("time")
idx += 1
res_img, pose_data = draw_pose(im, filter_box, pose_data, total_time / idx)
...

Das Ergebnisvideo rt_result.mp4 wird im Ordner hilens_data_dir gespeichert, überprüfen Sie das Ergebnis:

Es ist ersichtlich, dass die zweistufige Einzelspieler-Schlüsselpunkt-Fähigkeit etwa 36 fps in der onnxruntime-Inferenz erreichen kann.

ModelBox Windows SDK-Inferenz

Der ModelBox-Windows-SDK-Inferenzcode befindet sich im Verzeichnis „single_human_pose“ des Ressourcenpakets.Die spezifische Codeorganisation ist wie folgt:

single_human_pose
    ├─bin
    │  ├─main.bat                   // 启动脚本
    │  └─mock_task.toml             // 本地模拟运行输入输出配置文件
    ├─data
    │  └─dance_120fps.mp4           // 测试视频
    ├─etc
    │  └─flowunit                   // 功能单元目录
    │      ├─det_post               // 检测后处理
    │      ├─det_pre                // 检测预处理
    │      ├─draw_pose              // 关键点绘制
    │      ├─expand_box             // 单人图像切分
    │      ├─object_tracker         // 人形跟踪
    │      └─pose_post              // 姿态后处理
    ├─graph
    │  └─single_human_pose.toml     // 技能流程图
    ├─hilens_data_dir               // 运行结果目录
 │  ├─log
    │  ├─mb_profile                 // 性能统计目录
 │  │   ├─performance_[time].toml
 │  │   └─trace_[time].toml
    │  ├─dance_result.mp4           // 运行结果视频
 │  └─rt_result.mp4
    ├─model                         // 推理功能单元
    │  ├─det_human                  // 人形检测推理
    │  │   ├─det_human.toml         // 推理配置文件
    │  │   └─yolov7-tiny.onnx       // 推理模型
    │  └─det_pose                   // 关键点检测推理
    │      ├─det_pose.toml
    │      └─pose.onnx
    └─build_project.sh

Wir können das Skill-Flussdiagramm graph/single_human_pose.toml anzeigen, um die Skill-Logik zu verstehen:

Die fps werden in der Key Point Drawing Functional Unit berechnet, und die End-to-End-Full-Process-fps werden berechnet:

class draw_poseFlowUnit(modelbox.FlowUnit):
 def open(self, config):
 ...
 self.start_time = time.time()
 self.idx = 0
 ...
 def process(self, data_context):
 ...
 self.idx += 1
 self.draw(out_img, bbox, pose_data, self.idx / (time.time() - self.start_time))
 ...

Eingabe und Ausgabe in bin/mock_task.toml konfigurieren:

# 任务输入,mock模拟目前仅支持一路rtsp或者本地url
# rtsp摄像头，type = "rtsp", url里面写入rtsp地址
# 其它用"url"，比如可以是本地文件地址, 或者httpserver的地址，(摄像头 url = "0")
[input]
type = "url"
url = "../data/dance_120fps.mp4"
# 任务输出,目前仅支持"webhook", 和本地输出"local"(输出到屏幕,url="0", 输出到rtsp，填写rtsp地址)
# (local 还可以输出到本地文件，这个时候注意，文件可以是相对路径，是相对这个mock_task.toml文件本身)
[output]
type = "local"
url = "../hilens_data_dir/dance_result.mp4"

Öffnen Sie das Konfigurationselement Leistungsstatistik im Skill-Flussdiagramm:

[profile]
profile=true
trace=true

Doppelklicken Sie danach auf bin/main.bat oder führen Sie den Skill in bash aus:

./bin/main.bat

Die nach dem Ausführen generierten Video- und Leistungsstatistikdateien befinden sich im Ordner hilens_data_dir:

Es ist ersichtlich, dass die Inferenz mit dem ModelBox SDK 79 fps erreichen kann, was wohlverdient ist. Wir können die Leistungsstatistikdatei im Chrome-Browser chrome://tracing/ laden, um sie anzuzeigen:

Nach der Überprüfung von Objekt zu Objekt wird festgestellt, dass die Funktionseinheit der Erkennungsnachbearbeitung mit einer durchschnittlichen Zeit von 11,69 ms die längste Zeit benötigt, da ModelBox eine statische Graph-Parallel-Inferenz ist, fps von der Funktionseinheit abhängt, die am längsten dauert. theoretische Berechnung fps = 1000 / 11,69 \ ungefähr 85 fps = 1000 / 11,69 ≈ 85, was dem Berechnungsergebnis von Punkten im Programm nahe kommt.

Zusammenfassung: ModelBox ist wirklich schnell, schön!

 

Klicken Sie auf „Folgen“, um zum ersten Mal etwas über die neuen Technologien von HUAWEI CLOUD zu erfahren~

{{o.name}}

{{m.name}}