Xuất khẩu MNN cho YOLO11 Mô hình và triển khai
MNN
MNN là một khuôn khổ học sâu hiệu quả cao và nhẹ. Nó hỗ trợ suy luận và đào tạo các mô hình học sâu và có hiệu suất hàng đầu trong ngành về suy luận và đào tạo trên thiết bị. Hiện tại, MNN đã được tích hợp vào hơn 30 ứng dụng của Alibaba Inc, chẳng hạn như Taobao, Tmall, Youku, DingTalk, Xianyu, v.v., bao gồm hơn 70 tình huống sử dụng như phát sóng trực tiếp, quay video ngắn, đề xuất tìm kiếm, tìm kiếm sản phẩm bằng hình ảnh, tiếp thị tương tác, phân phối vốn chủ sở hữu, kiểm soát rủi ro bảo mật. Ngoài ra, MNN cũng được sử dụng trên các thiết bị nhúng, chẳng hạn như IoT.
Xuất sang MNN: Chuyển đổi YOLO11 Người mẫu
Bạn có thể mở rộng khả năng tương thích của mô hình và tính linh hoạt triển khai bằng cách chuyển đổi YOLO11 mô hình theo định dạng MNN.
Cài đặt
Để cài đặt các gói cần thiết, hãy chạy:
Cách sử dụng
Trước khi tìm hiểu hướng dẫn sử dụng, điều quan trọng cần lưu ý là mặc dù tất cả các mẫu Ultralytics YOLO11 đều có thể xuất, nhưng bạn có thể đảm bảo rằng mẫu bạn chọn có hỗ trợ chức năng xuất tại đây .
Cách sử dụng
from ultralytics import YOLO
# Load the YOLO11 model
model = YOLO("yolo11n.pt")
# Export the model to MNN format
model.export(format="mnn") # creates 'yolo11n.mnn'
# Load the exported MNN model
mnn_model = YOLO("yolo11n.mnn")
# Run inference
results = mnn_model("https://ultralytics.com/images/bus.jpg")
Để biết thêm chi tiết về các tùy chọn xuất được hỗ trợ, hãy truy cập trang tài liệu Ultralytics về các tùy chọn triển khai .
Suy luận chỉ MNN
Một chức năng chỉ dựa vào MNN cho YOLO11 suy luận và xử lý trước được thực hiện, cung cấp cả Python và phiên bản C++ để triển khai dễ dàng trong mọi tình huống.
MNN
import argparse
import MNN
import MNN.cv as cv2
import MNN.numpy as np
def inference(model, img, precision, backend, thread):
config = {}
config["precision"] = precision
config["backend"] = backend
config["numThread"] = thread
rt = MNN.nn.create_runtime_manager((config,))
# net = MNN.nn.load_module_from_file(model, ['images'], ['output0'], runtime_manager=rt)
net = MNN.nn.load_module_from_file(model, [], [], runtime_manager=rt)
original_image = cv2.imread(img)
ih, iw, _ = original_image.shape
length = max((ih, iw))
scale = length / 640
image = np.pad(original_image, [[0, length - ih], [0, length - iw], [0, 0]], "constant")
image = cv2.resize(
image, (640, 640), 0.0, 0.0, cv2.INTER_LINEAR, -1, [0.0, 0.0, 0.0], [1.0 / 255.0, 1.0 / 255.0, 1.0 / 255.0]
)
input_var = np.expand_dims(image, 0)
input_var = MNN.expr.convert(input_var, MNN.expr.NC4HW4)
output_var = net.forward(input_var)
output_var = MNN.expr.convert(output_var, MNN.expr.NCHW)
output_var = output_var.squeeze()
# output_var shape: [84, 8400]; 84 means: [cx, cy, w, h, prob * 80]
cx = output_var[0]
cy = output_var[1]
w = output_var[2]
h = output_var[3]
probs = output_var[4:]
# [cx, cy, w, h] -> [y0, x0, y1, x1]
x0 = cx - w * 0.5
y0 = cy - h * 0.5
x1 = cx + w * 0.5
y1 = cy + h * 0.5
boxes = np.stack([x0, y0, x1, y1], axis=1)
# get max prob and idx
scores = np.max(probs, 0)
class_ids = np.argmax(probs, 0)
result_ids = MNN.expr.nms(boxes, scores, 100, 0.45, 0.25)
print(result_ids.shape)
# nms result box, score, ids
result_boxes = boxes[result_ids]
result_scores = scores[result_ids]
result_class_ids = class_ids[result_ids]
for i in range(len(result_boxes)):
x0, y0, x1, y1 = result_boxes[i].read_as_tuple()
y0 = int(y0 * scale)
y1 = int(y1 * scale)
x0 = int(x0 * scale)
x1 = int(x1 * scale)
print(result_class_ids[i])
cv2.rectangle(original_image, (x0, y0), (x1, y1), (0, 0, 255), 2)
cv2.imwrite("res.jpg", original_image)
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("--model", type=str, required=True, help="the yolo11 model path")
parser.add_argument("--img", type=str, required=True, help="the input image path")
parser.add_argument("--precision", type=str, default="normal", help="inference precision: normal, low, high, lowBF")
parser.add_argument(
"--backend",
type=str,
default="CPU",
help="inference backend: CPU, OPENCL, OPENGL, NN, VULKAN, METAL, TRT, CUDA, HIAI",
)
parser.add_argument("--thread", type=int, default=4, help="inference using thread: int")
args = parser.parse_args()
inference(args.model, args.img, args.precision, args.backend, args.thread)
#include <stdio.h>
#include <MNN/ImageProcess.hpp>
#include <MNN/expr/Module.hpp>
#include <MNN/expr/Executor.hpp>
#include <MNN/expr/ExprCreator.hpp>
#include <MNN/expr/Executor.hpp>
#include <cv/cv.hpp>
using namespace MNN;
using namespace MNN::Express;
using namespace MNN::CV;
int main(int argc, const char* argv[]) {
if (argc < 3) {
MNN_PRINT("Usage: ./yolo11_demo.out model.mnn input.jpg [forwardType] [precision] [thread]\n");
return 0;
}
int thread = 4;
int precision = 0;
int forwardType = MNN_FORWARD_CPU;
if (argc >= 4) {
forwardType = atoi(argv[3]);
}
if (argc >= 5) {
precision = atoi(argv[4]);
}
if (argc >= 6) {
thread = atoi(argv[5]);
}
MNN::ScheduleConfig sConfig;
sConfig.type = static_cast<MNNForwardType>(forwardType);
sConfig.numThread = thread;
BackendConfig bConfig;
bConfig.precision = static_cast<BackendConfig::PrecisionMode>(precision);
sConfig.backendConfig = &bConfig;
std::shared_ptr<Executor::RuntimeManager> rtmgr = std::shared_ptr<Executor::RuntimeManager>(Executor::RuntimeManager::createRuntimeManager(sConfig));
if(rtmgr == nullptr) {
MNN_ERROR("Empty RuntimeManger\n");
return 0;
}
rtmgr->setCache(".cachefile");
std::shared_ptr<Module> net(Module::load(std::vector<std::string>{}, std::vector<std::string>{}, argv[1], rtmgr));
auto original_image = imread(argv[2]);
auto dims = original_image->getInfo()->dim;
int ih = dims[0];
int iw = dims[1];
int len = ih > iw ? ih : iw;
float scale = len / 640.0;
std::vector<int> padvals { 0, len - ih, 0, len - iw, 0, 0 };
auto pads = _Const(static_cast<void*>(padvals.data()), {3, 2}, NCHW, halide_type_of<int>());
auto image = _Pad(original_image, pads, CONSTANT);
image = resize(image, Size(640, 640), 0, 0, INTER_LINEAR, -1, {0., 0., 0.}, {1./255., 1./255., 1./255.});
auto input = _Unsqueeze(image, {0});
input = _Convert(input, NC4HW4);
auto outputs = net->onForward({input});
auto output = _Convert(outputs[0], NCHW);
output = _Squeeze(output);
// output shape: [84, 8400]; 84 means: [cx, cy, w, h, prob * 80]
auto cx = _Gather(output, _Scalar<int>(0));
auto cy = _Gather(output, _Scalar<int>(1));
auto w = _Gather(output, _Scalar<int>(2));
auto h = _Gather(output, _Scalar<int>(3));
std::vector<int> startvals { 4, 0 };
auto start = _Const(static_cast<void*>(startvals.data()), {2}, NCHW, halide_type_of<int>());
std::vector<int> sizevals { -1, -1 };
auto size = _Const(static_cast<void*>(sizevals.data()), {2}, NCHW, halide_type_of<int>());
auto probs = _Slice(output, start, size);
// [cx, cy, w, h] -> [y0, x0, y1, x1]
auto x0 = cx - w * _Const(0.5);
auto y0 = cy - h * _Const(0.5);
auto x1 = cx + w * _Const(0.5);
auto y1 = cy + h * _Const(0.5);
auto boxes = _Stack({x0, y0, x1, y1}, 1);
auto scores = _ReduceMax(probs, {0});
auto ids = _ArgMax(probs, 0);
auto result_ids = _Nms(boxes, scores, 100, 0.45, 0.25);
auto result_ptr = result_ids->readMap<int>();
auto box_ptr = boxes->readMap<float>();
auto ids_ptr = ids->readMap<int>();
auto score_ptr = scores->readMap<float>();
for (int i = 0; i < 100; i++) {
auto idx = result_ptr[i];
if (idx < 0) break;
auto x0 = box_ptr[idx * 4 + 0] * scale;
auto y0 = box_ptr[idx * 4 + 1] * scale;
auto x1 = box_ptr[idx * 4 + 2] * scale;
auto y1 = box_ptr[idx * 4 + 3] * scale;
auto class_idx = ids_ptr[idx];
auto score = score_ptr[idx];
rectangle(original_image, {x0, y0}, {x1, y1}, {0, 0, 255}, 2);
}
if (imwrite("res.jpg", original_image)) {
MNN_PRINT("result image write to `res.jpg`.\n");
}
rtmgr->updateCache();
return 0;
}
Bản tóm tắt
Trong hướng dẫn này, chúng tôi giới thiệu cách xuất Ultralytics YOLO11 mô hình hóa MNN và sử dụng MNN để suy luận.
Để biết thêm cách sử dụng, vui lòng tham khảo tài liệu MNN .
CÂU HỎI THƯỜNG GẶP
Làm thế nào để tôi xuất khẩu Ultralytics YOLO11 mô hình theo định dạng MNN?
Để xuất khẩu của bạn Ultralytics YOLO11 mô hình sang định dạng MNN, hãy làm theo các bước sau:
Xuất khẩu
from ultralytics import YOLO
# Load the YOLO11 model
model = YOLO("yolo11n.pt")
# Export to MNN format
model.export(format="mnn") # creates 'yolo11n.mnn' with fp32 weight
model.export(format="mnn", half=True) # creates 'yolo11n.mnn' with fp16 weight
model.export(format="mnn", int8=True) # creates 'yolo11n.mnn' with int8 weight
Để biết các tùy chọn xuất chi tiết, hãy kiểm tra trang Xuất trong tài liệu.
Làm thế nào để tôi dự đoán với một xuất khẩu YOLO11 Mô hình MNN?
Để dự đoán với một xuất khẩu YOLO11 Mô hình MNN, sử dụng predict chức năng từ YOLO lớp học.
Dự đoán
from ultralytics import YOLO
# Load the YOLO11 MNN model
model = YOLO("yolo11n.mnn")
# Export to MNN format
results = mnn_model("https://ultralytics.com/images/bus.jpg") # predict with `fp32`
results = mnn_model("https://ultralytics.com/images/bus.jpg", half=True) # predict with `fp16` if device support
for result in results:
result.show() # display to screen
result.save(filename="result.jpg") # save to disk
MNN hỗ trợ những nền tảng nào?
MNN rất linh hoạt và hỗ trợ nhiều nền tảng khác nhau:
- Di động : Android , iOS , Hòa hợp.
- Hệ thống nhúng và thiết bị IoT : Các thiết bị như Raspberry Pi và NVIDIA Jetson.
- Máy tính để bàn và máy chủ : Linux, Windows và macOS.
Tôi có thể triển khai như thế nào Ultralytics YOLO11 Mô hình MNN trên thiết bị di động?
Để triển khai của bạn YOLO11 các mẫu trên thiết bị di động:
- Xây dựng cho Android : Thực hiện theo MNN Android .
- Xây dựng cho iOS : Thực hiện theo MNN iOS .
- Xây dựng sự hài hòa : Thực hiện theo MNN Harmony .
📅 Được tạo cách đây 1 tháng ✏️ Đã cập nhật cách đây 1 tháng
