Ultralytics YOLO27 :

Exportation MNN des modèles YOLO26 et déploiement#

MNN#

MNN mobile neural network inference framework

MNN est un framework de deep learning léger et très efficace. Il prend en charge l’inférence et l’entraînement de modèles de deep learning, et offre des performances de pointe pour l’inférence et l’entraînement sur appareil. Actuellement, MNN est intégré à plus de 30 applications d’Alibaba Inc., telles que Taobao, Tmall, Youku, DingTalk, Xianyu, etc., couvrant plus de 70 scénarios d’utilisation comme la diffusion en direct, la capture de vidéos courtes, les recommandations de recherche, la recherche de produits par image, le marketing interactif, la répartition des capitaux propres et la gestion des risques de sécurité. En outre, MNN est également utilisé sur des appareils embarqués, notamment pour l’IoT.



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

Tâches prises en charge#

L’exportation MNN prend en charge les sept tâches Ultralytics. La segmentation sémantique et l’estimation de profondeur sont disponibles uniquement avec YOLO26, la seule famille à proposer ces têtes.

TâcheYOLOv8YOLO11YOLO26
Détection✅✅✅
Segmentation✅✅✅
Sémantique❌❌✅
Profondeur❌❌✅
Classification✅✅✅
Pose✅✅✅
OBB✅✅✅

Exporter vers MNN : convertir ton modèle YOLO26#

Tu peux étendre la compatibilité des modèles et la flexibilité du déploiement en convertissant les modèles Ultralytics YOLO au format MNN. Cette conversion optimise tes modèles pour les environnements mobiles et embarqués, afin de garantir des performances efficaces sur les appareils aux ressources limitées.

Installation#

Pour installer les packages requis, exécute :

Installation
# Install the required package for YOLO26 and MNN
pip install ultralytics
pip install MNN

Utilisation#

Tous les modèles Ultralytics YOLO26 sont conçus pour prendre en charge l’exportation directement, ce qui facilite leur intégration à ton workflow de déploiement préféré. Tu peux consulter la liste complète des formats d’exportation et des options de configuration pris en charge pour choisir la meilleure configuration pour ton application.

Le format MNN prend en charge les modes Export, Predict et Validate. Exporte ton modèle, puis charge le modèle exporté pour effectuer l’inférence ou valider sa précision.

Exportation
from ultralytics import YOLO

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

# Export the model to MNN format
model.export(format="mnn")  # creates 'yolo26n.mnn'
Prédiction
from ultralytics import YOLO

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

# Run inference
results = model("https://ultralytics.com/images/bus.jpg")
Valider
from ultralytics import YOLO

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

# Validate accuracy on the COCO8 dataset
metrics = model.val(data="coco8.yaml")

Arguments d'exportation#

ArgumentTypeValeur par défautDescription
formatstr'mnn'Format cible du modèle exporté, définissant sa compatibilité avec différents environnements de déploiement.
imgszint ou tuple640Taille d’image souhaitée pour l’entrée du modèle. Peut être un entier pour les images carrées ou un tuple (height, width) pour des dimensions spécifiques.
quantizeint ou strNonePrécision de quantification : 16 (FP16) ou 8 (INT8) réduisent la taille des poids exportés ; 32/non défini exporte des poids FP32, que le runtime CPU de MNN calcule toujours avec sa précision par défaut low plutôt qu’en FP32. Remplace les indicateurs obsolètes half/int8.
simplifyboolTrueSimplifie le graphe ONNX intermédiaire avec onnxslim.
opsetintNoneSpécifie la version de l’opset ONNX pour le graphe ONNX intermédiaire. Si elle n’est pas définie, la dernière version prise en charge est utilisée.
batchint1Indique la taille du lot d'inférence du modèle exporté ou le nombre maximal d'images que le modèle exporté traitera simultanément en mode predict.
dynamicboolFalseActive des dimensions dynamiques pour les images d’entrée. Ne peut pas être combiné avec nms=True.
nmsbool, optionnelNoneSélectionne la sortie brute (None, par défaut), le NMS intégré (True) ou la tête sans NMS (False). Le NMS intégré prend en charge la détection et l'estimation de pose avec dynamic=False.
devicestrNoneIndique l’appareil utilisé pour l’exportation : GPU (device=0), CPU (device=cpu), MPS pour Apple Silicon (device=mps).

Pour plus de détails sur le processus d’exportation, consulte la page de la documentation Ultralytics consacrée à l’exportation.

Inférence exclusivement avec MNN#

Une fonction qui s’appuie uniquement sur MNN pour l’inférence et le prétraitement de YOLO26 est disponible. Elle propose des versions Python et C++ pour faciliter le déploiement dans tous les scénarios.

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)

Résumé#

Dans ce guide, nous expliquons comment exporter le modèle Ultralytics YOLO26 vers MNN et utiliser MNN pour l’inférence. Le format MNN offre d’excellentes performances pour les applications d’IA en périphérie, ce qui le rend idéal pour déployer des modèles de vision par ordinateur sur des appareils aux ressources limitées.

Pour plus d’informations sur l’utilisation, consulte la documentation MNN.

FAQ#

  • Pour exporter ton modèle Ultralytics YOLO26 au format MNN, suis ces étapes :

    Exportation
    from ultralytics import YOLO

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

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

    Pour connaître les options d’exportation détaillées, consulte la page Export de la documentation.

  • Pour effectuer des prédictions avec un modèle YOLO26 MNN exporté, utilise la fonction predict de la classe YOLO.

    Prédiction
    from ultralytics import YOLO

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

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

for result in results:
    result.show()  # display to screen
    result.save(filename="result.jpg")  # save to disk

  • MNN est polyvalent et prend en charge différentes plateformes :

    • Mobile : Android, iOS, Harmony.
    • Systèmes embarqués et appareils IoT : appareils tels que Raspberry Pi et NVIDIA Jetson.
    • Ordinateurs de bureau et serveurs : Linux, Windows et macOS.

  • Pour déployer tes modèles YOLO26 sur des appareils mobiles :

    1. Compiler pour Android : suis le guide MNN Android.
    2. Compiler pour iOS : suis le guide MNN iOS.
    3. Compiler pour Harmony : suis le guide MNN Harmony.
Contributeurs
GLglenn-jocher14LAlakshanthad3JUjules-ai2RAraimbekovm1AMamanharshx1Y-Y-T-G1ONonuralpszr1LALaughing-q1RIRizwanMunawar1WAwangzhaode1

Commentaires