Bắt đầu

Xuất MNN cho model YOLO26 và triển khai

MNN#

MNN mobile neural network inference framework

MNN là framework deep learning nhẹ của Alibaba, hỗ trợ suy luận và huấn luyện model deep learning trên thiết bị. MNN được tích hợp vào hơn 30 ứng dụng của Alibaba, chẳng hạn như Taobao, Tmall, Youku, DingTalk và Xianyu, phục vụ hơn 70 trường hợp sử dụng, bao gồm phát 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 và kiểm soát rủi ro bảo mật. MNN cũng chạy trên các thiết bị nhúng và IoT.



Xem: Cách xuất Ultralytics YOLO sang định dạng MNN | Tăng tốc suy luận trên thiết bị di động📱

Các tác vụ được hỗ trợ#

MNN hỗ trợ xuất cho cả bảy tác vụ của Ultralytics. Phân đoạn ngữ nghĩa và ước tính độ sâu chỉ khả dụng với YOLO26, dòng model duy nhất có các head này.

Tác vụYOLOv8YOLO11YOLO26
Phát hiện✅✅✅
Phân đoạn✅✅✅
Ngữ nghĩa❌❌✅
Độ sâu❌❌✅
Phân loại✅✅✅
Tư thế✅✅✅
OBB✅✅✅

Xuất sang MNN: Chuyển đổi model YOLO26#

Bạn có thể mở rộng khả năng tương thích model và tính linh hoạt khi triển khai bằng cách chuyển đổi model Ultralytics YOLO sang định dạng MNN. Việc chuyển đổi này tối ưu hóa model cho môi trường di động và nhúng, đảm bảo hiệu năng hiệu quả trên các thiết bị có tài nguyên hạn chế.

Cài đặt#

Để cài đặt các package cần thiết, hãy chạy:

Cài đặt
# Install the required package for YOLO26 and MNN
pip install ultralytics
pip install MNN

Cách sử dụng#

Tất cả model Ultralytics YOLO26 đều hỗ trợ xuất ngay, vì vậy bạn có thể tích hợp chúng vào quy trình triển khai mong muốn. Bạn có thể xem danh sách đầy đủ các định dạng xuất và tùy chọn cấu hình được hỗ trợ để chọn thiết lập phù hợp nhất cho ứng dụng.

Định dạng MNN hỗ trợ các chế độ Export, Predict và Validate. Hãy xuất model, sau đó tải model đã xuất để chạy suy luận hoặc xác thực độ chính xác.

Export
from ultralytics import YOLO

# Nạp model YOLO26
model = YOLO("yolo26n.pt")

# Xuất model sang định dạng MNN
model.export(format="mnn")  # tạo 'yolo26n.mnn'
Dự đoán
from ultralytics import YOLO

# Tải model MNN đã xuất
model = YOLO("yolo26n.mnn")

# Chạy suy luận
results = model("https://ultralytics.com/images/bus.jpg")
Xác thực
from ultralytics import YOLO

# Tải model MNN đã xuất
model = YOLO("yolo26n.mnn")

# # Đánh giá độ chính xác trên bộ dữ liệu COCO8
metrics = model.val(data="coco8.yaml")

Các tham số xuất model#

Đối sốKiểuMặc địnhMô tả
formatstr'mnn'Định dạng đích của model đã xuất, xác định khả năng tương thích với nhiều môi trường triển khai.
imgszint hoặc tuple640Kích thước ảnh mong muốn cho đầu vào model. Có thể là số nguyên cho ảnh vuông hoặc tuple (height, width) để chỉ định kích thước cụ thể.
quantizeint hoặc strNoneĐộ chính xác lượng tử hóa: 16 (FP16) hoặc 8 (INT8) giúp giảm dung lượng trọng số đã xuất; 32/để trống sẽ xuất trọng số FP32, nhưng MNNBackend của Ultralytics vẫn chạy ở độ chính xác low thay vì FP32. Thay thế các cờ half/int8 đã lỗi thời.
simplifyboolTrueĐơn giản hóa đồ thị ONNX trung gian bằng onnxslim.
opsetintNoneChỉ định phiên bản ONNX opset cho đồ thị ONNX trung gian. Nếu không được thiết lập, phiên bản opset 18 sẽ được sử dụng (thấp hơn trên PyTorch < 2.4), tối đa bằng phiên bản onnx đã cài đặt.
batchint1Chỉ định kích thước batch suy luận của model khi xuất hoặc số lượng ảnh tối đa mà model đã xuất xử lý đồng thời ở chế độ predict.
dynamicboolFalseBật kích thước ảnh đầu vào động. Không thể kết hợp với nms=True.
nmsbool, không bắt buộcNoneChọn đầu ra thô (None, mặc định), NMS tích hợp (True) hoặc head không dùng NMS (False). NMS tích hợp hỗ trợ detect và pose với dynamic=False.
devicestrNoneChỉ định thiết bị dùng để xuất: GPU (device=0), CPU (device=cpu), MPS cho Apple silicon (device=mps).

Để biết thêm chi tiết về quy trình xuất, hãy truy cập trang tài liệu Ultralytics về xuất model.

Chỉ suy luận bằng MNN#

Các ví dụ sau chạy tiền xử lý, suy luận và hậu xử lý YOLO26 chỉ bằng MNN, trong cả Python và C++, nhờ đó bạn có thể triển khai mà không cần PyTorch hoặc gói Ultralytics.

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]
    )
    image = image[..., ::-1]  # Chuyển BGR sang RGB
    input_var = image[None]
    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 có nghĩa là: [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] -> [x0, y0, x1, y1]
    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)
    # lấy prob và idx lớn nhất
    scores = np.max(probs, 0)
    class_ids = np.argmax(probs, 0)
    result_ids = MNN.expr.nms(boxes, scores, 100, 0.5, 0.25)
    print(result_ids.shape)
    # box, score, ids của kết quả nms
    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)
        # giới hạn trong kích thước ảnh gốc để xử lý các trường hợp đã áp dụng padding
        x1 = min(iw, x1)
        y1 = min(ih, y1)
        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 yolo26 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)

Tóm tắt#

Hướng dẫn này trình bày cách xuất model Ultralytics YOLO26 sang MNN và chạy suy luận bằng MNN. Định dạng MNN phù hợp với các ứng dụng AI edge triển khai model thị giác máy tính trên các thiết bị có tài nguyên hạn chế.

Câu hỏi thường gặp#

  • Để xuất model Ultralytics YOLO26 sang định dạng MNN, hãy làm theo các bước sau:

    Export
    from ultralytics import YOLO
    
    # Nạp model YOLO26
    model = YOLO("yolo26n.pt")
    
    # Xuất sang định dạng MNN
    model.export(format="mnn")  # tạo 'yolo26n.mnn' với trọng số fp32
    model.export(format="mnn", quantize=16)  # tạo 'yolo26n.mnn' với trọng số fp16
    model.export(format="mnn", quantize=8)  # tạo 'yolo26n.mnn' với trọng số int8

    Để biết chi tiết các tùy chọn xuất, hãy xem trang Export trong tài liệu.

  • Để dự đoán bằng model YOLO26 MNN đã xuất, hãy sử dụng hàm predict từ lớp YOLO.

    Dự đoán
    from ultralytics import YOLO
    
    # Tải model YOLO26 MNN
    model = YOLO("yolo26n.mnn")
    
    # Chạy suy luận
    results = model("https://ultralytics.com/images/bus.jpg")
    
    for result in results:
        result.show()  # hiển thị trên màn hình
        result.save(filename="result.jpg")  # lưu vào ổ đĩa
  • MNN hỗ trợ nhiều nền tảng:

    • Di động: Android, iOS, Harmony.
    • 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.
  • Để triển khai model YOLO26 trên thiết bị di động:

    1. Build cho Android: Làm theo hướng dẫn MNN Android.
    2. Build cho iOS: Làm theo hướng dẫn MNN iOS.
    3. Build cho Harmony: Làm theo hướng dẫn MNN Harmony.

Bình luận2

Đặt câu hỏi, chia sẻ kết quả hoặc giúp đỡ người khác.

    1. Glenn JocherUltralytics

      It seems like there's a minor typo in your code. Ensure you are using model instead of mnn_model when calling the inference function. Here's a quick fix:

      from ultralytics import YOLO
      
      # Load the YOLO11 MNN model
      model = YOLO("yolo11n.mnn")
      
      # Run inference
      results = model("https://ultralytics.com/images/bus.jpg")

      This should resolve the NameError. If you need more help, please check the MNN documentation.