Редактировать страницу на GitHub (EN)

Экспорт в MNN для моделей YOLO26 и развертывание

MNN

MNN mobile neural network inference framework

MNN — это высокоэффективный и легковесный фреймворк глубокого обучения. Он поддерживает инференс и обучение моделей глубокого обучения и обладает лучшей в отрасли производительностью для выполнения этих задач на устройствах. На данный момент MNN интегрирован в более чем 30 приложений Alibaba Inc., таких как Taobao, Tmall, Youku, DingTalk, Xianyu и др., и охватывает более 70 сценариев использования, включая прямые трансляции, захват коротких видео, рекомендательные системы поиска, поиск товаров по изображению, интерактивный маркетинг, распределение активов и контроль рисков безопасности. Кроме того, MNN также используется на встраиваемых устройствах, например в IoT.



Watch: How to Export Ultralytics YOLO26 to MNN Format | Speed up Inference on Mobile Devices📱

Экспорт в MNN: конвертация твоей модели YOLO26

Ты можешь расширить совместимость моделей и гибкость развертывания, конвертируя модели Ultralytics YOLO в формат MNN. Эта конвертация оптимизирует твои модели для мобильных и встраиваемых сред, обеспечивая эффективную работу на устройствах с ограниченными ресурсами.

Установка

Чтобы установить необходимые пакеты, выполни:

Установка
# Install the required package for YOLO26 and MNN
pip install ultralytics
pip install MNN

Использование

Все модели Ultralytics YOLO26 разработаны с поддержкой экспорта «из коробки», что упрощает их интеграцию в предпочитаемый тобой рабочий процесс развертывания. Ты можешь ознакомиться с полным списком поддерживаемых форматов экспорта и параметров конфигурации, чтобы выбрать оптимальные настройки для своего приложения.

Использование
  from ultralytics import YOLO

  # Load the YOLO26 model
  model = YOLO("yolo26n.pt")

  # Export the model to MNN format
  model.export(format="mnn")  # creates 'yolo26n.mnn'

  # Load the exported MNN model
  mnn_model = YOLO("yolo26n.mnn")

  # Run inference
  results = mnn_model("https://ultralytics.com/images/bus.jpg")

Аргументы экспорта

АргументТипПо умолчаниюОписание
formatstr'mnn'Целевой формат для экспортируемой модели, определяющий совместимость с различными средами развертывания.
imgszint или tuple640Желаемый размер изображения для входных данных модели. Может быть целым числом для квадратных изображений или кортежем (height, width) для указания конкретных размеров.
halfboolFalseВключает квантование FP16 (половинной точности), уменьшая размер модели и потенциально ускоряя логический вывод на поддерживаемом оборудовании.
int8boolFalseАктивирует квантование INT8, дополнительно сжимая модель и ускоряя логический вывод с минимальной потерей точности, в основном для периферийных устройств.
batchint1Указывает размер пакетного инференса для экспортированной модели или максимальное количество изображений, которые модель будет обрабатывать одновременно в режиме predict.
devicestrNoneУказывает устройство для экспорта: GPU (device=0), CPU (device=cpu), MPS для процессоров Apple (device=mps).

Для получения более подробной информации о процессе экспорта посети страницу документации Ultralytics по экспорту.

Инференс только с MNN

Реализована функция, которая опирается исключительно на MNN для инференса и предобработки YOLO26, предоставляя версии как для Python, так и для C++ для удобного развертывания в любом сценарии.

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]  # BGR to 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 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)
    # ensure ratio is within the valid range [0.0, 1.0]
    boxes = np.clip(boxes, 0, 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)
        # clamp to the original image size to handle cases where padding was applied
        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)

Резюме

В этом руководстве мы рассказываем, как экспортировать модель Ultralytics YOLO26 в MNN и использовать MNN для инференса. Формат MNN обеспечивает превосходную производительность для приложений edge AI, что делает его идеальным для развертывания моделей компьютерного зрения на устройствах с ограниченными ресурсами.

Для получения дополнительной информации обратись к документации MNN.

Часто задаваемые вопросы (FAQ)

Как экспортировать модели Ultralytics YOLO26 в формат MNN?

Чтобы экспортировать свою модель Ultralytics YOLO26 в формат MNN, выполни следующие действия:

Экспорт (Export)
from ultralytics import YOLO

# Load the YOLO26 model
model = YOLO("yolo26n.pt")

# Export to MNN format
model.export(format="mnn")  # creates 'yolo26n.mnn' with fp32 weight
model.export(format="mnn", half=True)  # creates 'yolo26n.mnn' with fp16 weight
model.export(format="mnn", int8=True)  # creates 'yolo26n.mnn' with int8 weight

Подробные параметры экспорта можно найти на странице Экспорт в документации.

Как выполнять предсказания с экспортированной моделью YOLO26 MNN?

Для выполнения предсказаний с экспортированной моделью YOLO26 MNN используй функцию predict из класса YOLO.

Прогнозирование
from ultralytics import YOLO

# Load the YOLO26 MNN model
model = YOLO("yolo26n.mnn")

# Export to MNN format
results = model("https://ultralytics.com/images/bus.jpg")  # predict with `fp32`
results = 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?

MNN универсален и поддерживает различные платформы:

  • Мобильные: Android, iOS, Harmony.
  • Встраиваемые системы и IoT-устройства: такие как Raspberry Pi и NVIDIA Jetson.
  • Десктоп и серверы: Linux, Windows и macOS.

Как развернуть модели Ultralytics YOLO26 MNN на мобильных устройствах?

Чтобы развернуть свои модели YOLO26 на мобильных устройствах:

  1. Сборка для Android: следуй руководству MNN Android.
  2. Сборка для iOS: следуй руководству MNN iOS.
  3. Сборка для Harmony: следуй руководству MNN Harmony.
Contributors
Редактировать страницу на GitHub (EN)
GLglenn-jocher7LAlakshanthad3JUjules-ai2LALaughing-q1RIRizwanMunawar1WAwangzhaode1

Комментарии