Ultralytics YOLO27 :
Get Started

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

MNN#

MNN mobile neural network inference framework

MNN est un framework de deep learning très efficace et léger. Il prend en charge l’inférence et l’entraînement de modèles de deep learning et offre des performances de pointe dans ces deux domaines sur l’appareil. À ce jour, MNN est intégré à plus de 30 applications d’Alibaba Inc., comme Taobao, Tmall, Youku, DingTalk et Xianyu, couvrant plus de 70 cas d’utilisation tels que la diffusion en direct, la capture de vidéos courtes, les recommandations de recherche, la recherche de produits par image, le marketing interactif, la distribution de parts et la gestion des risques de sécurité. MNN est également utilisé sur des appareils embarqués, par exemple dans l’IoT.



À regarder : Comment exporter Ultralytics YOLO26 au format MNN | Accélérer l’inférence sur les appareils mobiles📱

Tâches prises en charge#

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

TâcheYOLOv8YOLO11YOLO26
Détecter✅✅✅
Segmenter✅✅✅
Sémantique❌❌✅
Profondeur❌❌✅
Classifier✅✅✅
Pose✅✅✅
OBB✅✅✅

Exporter vers MNN : convertir ton modèle YOLO26#

Tu peux étendre la compatibilité de tes modèles et la flexibilité de leur 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 paquets 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 dès leur installation, ce qui facilite leur intégration à ton flux de déploiement préféré. Tu peux consulter la liste complète des formats d’exportation pris en charge et des options de configuration pour choisir la configuration la mieux adaptée à 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 une inférence ou valider sa précision.

Export
from ultralytics import YOLO

# Charger un modèle YOLO26
model = YOLO("yolo26n.pt")

# Exporter le modèle au format MNN
model.export(format="mnn")  # crée « yolo26n.mnn »
Prédiction
from ultralytics import YOLO

# Charger le modèle MNN exporté
model = YOLO("yolo26n.mnn")

# Exécuter l’inférence
results = model("https://ultralytics.com/images/bus.jpg")
Valider
from ultralytics import YOLO

# Charger le modèle MNN exporté
model = YOLO("yolo26n.mnn")

# Valider la précision sur le jeu de données COCO8
metrics = model.val(data="coco8.yaml")

Arguments d’exportation#

ArgumentTypeValeur par défautDescription
formatstr'mnn'Format cible du modèle exporté, qui définit 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 définir des dimensions spécifiques.
quantizeint ou strNonePrécision de quantification : 16 (FP16) ou 8 (INT8) réduit la taille des poids exportés ; 32/non défini exporte des poids FP32, que MNNBackend d’Ultralytics exécute toujours avec une précision low, et non FP32. Remplace les indicateurs obsolètes half/int8.
simplifyboolTrueSimplifie le graphe ONNX intermédiaire avec onnxslim.
opsetintNoneSpécifie la version d’opset ONNX du graphe ONNX intermédiaire. Si elle n’est pas définie, la dernière version prise en charge est utilisée.
batchint1Indique la taille de lot pour l’inférence du modèle exporté ou le nombre maximal d’images que le modèle exporté traitera simultanément en mode predict.
dynamicboolFalseActive les dimensions dynamiques des images d’entrée. Ne peut pas être combiné avec nms=True.
nmsbool, facultatifNoneSélectionne la sortie brute (None, par défaut), NMS intégré (True) ou la tête sans NMS (False). Le NMS intégré prend en charge la détection et la pose avec dynamic=False.
devicestrNoneDéfinit l’appareil utilisé pour l’export : GPU (device=0), CPU (device=cpu), MPS pour Apple Silicon (device=mps).

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

Inférence exclusivement avec MNN#

Une fonction qui s’appuie uniquement sur MNN pour l’inférence et le prétraitement de YOLO26 est implémentée. Des versions Python et C++ sont disponibles 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 vers 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()
    # forme de output_var : [84, 8400] ; 84 signifie : [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)
    # obtenir la probabilité maximale et l’index
    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)
    # boîte, score et identifiants du résultat 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)
        # limiter aux dimensions de l’image d’origine pour gérer les cas où un remplissage a été appliqué
        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 en savoir plus sur l’utilisation, consulte la documentation MNN.

FAQ#

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

    Export
    from ultralytics import YOLO

# Charger un modèle YOLO26
model = YOLO("yolo26n.pt")

# Exporter au format MNN
model.export(format="mnn")  # crée « yolo26n.mnn » avec des poids fp32
model.export(format="mnn", quantize=16)  # crée « yolo26n.mnn » avec des poids fp16
model.export(format="mnn", quantize=8)  # crée « yolo26n.mnn » avec des poids int8

    Pour obtenir la liste détaillée des options d’exportation, 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

# Charger le modèle YOLO26 MNN
model = YOLO("yolo26n.mnn")

# Exécuter l’inférence
results = model("https://ultralytics.com/images/bus.jpg")

for result in results:
    result.show()  # afficher à l’écran
    result.save(filename="result.jpg")  # enregistrer sur le disque

  • MNN est polyvalent et prend en charge diverses plateformes :

    • Mobile : Android, iOS, Harmony.
    • Systèmes embarqués et appareils IoT : appareils comme 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 pour Android.
    2. Compiler pour iOS : suis le guide MNN pour iOS.
    3. Compiler pour Harmony : suis le guide MNN pour Harmony.
Contributeurs
GLglenn-jocher14RAraimbekovm3LAlakshanthad3JUjules-ai2AMamanharshx1Y-Y-T-G1ONonuralpszr1LALaughing-q1RIRizwanMunawar1WAwangzhaode1

Commentaires