Link to this sectionExportation MNN pour les modèles YOLO26 et déploiement#

Link to this sectionMNN#

MNN mobile neural network inference framework

MNN est un framework d'apprentissage profond très efficace et léger. Il prend en charge l'inférence et l'entraînement de modèles d'apprentissage profond et possède des performances de pointe dans l'industrie pour l'inférence et l'entraînement sur appareil. Actuellement, MNN a été 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 tels que la diffusion en direct, la capture de courtes vidéos, la recommandation de recherche, la recherche de produits par image, le marketing interactif, la distribution d'actions, le contrôle des risques de sécurité. De plus, MNN est également utilisé sur des appareils embarqués, tels que l'IoT.

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

Link to this sectionExporter vers MNN : Conversion de ton modèle YOLO26#

Tu peux étendre la compatibilité des modèles et la flexibilité de 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, garantissant des performances efficaces sur les appareils aux ressources limitées.

Link to this sectionInstallation#

Pour installer les paquets requis, exécute :

Installation

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

Link to this sectionUtilisation#

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 dans ton workflow 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 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 exécuter l'inférence ou valider sa précision.

Export

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'

Predict

from ultralytics import YOLO

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

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

Validate

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")

Link to this sectionArguments d'exportation#

Argument	Type	Par défaut	Description
`format`	`str`	`'mnn'`	Format cible pour le modèle exporté, définissant la compatibilité avec divers environnements de déploiement.
`imgsz`	`int` ou `tuple`	`640`	Taille d'image souhaitée pour l'entrée du modèle. Peut être un entier pour des images carrées ou un tuple `(height, width)` pour des dimensions spécifiques.
`half`	`bool`	`False`	Active la quantification FP16 (demi-précision), réduisant la taille du modèle et accélérant potentiellement l'inférence sur le matériel pris en charge.
`int8`	`bool`	`False`	Active la quantification INT8, compressant davantage le modèle et accélérant l'inférence avec une perte minimale de précision, principalement pour les appareils edge.
`batch`	`int`	`1`	Spécifie la taille d'inférence du lot du modèle exporté ou le nombre maximal d'images que le modèle exporté traitera simultanément en mode `predict`.
`device`	`str`	`None`	Spécifie l'appareil 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, visite la page de documentation Ultralytics sur l'exportation.

Link to this sectionInférence MNN uniquement#

Une fonction qui repose uniquement sur MNN pour l'inférence et le prétraitement YOLO26 est implémentée, fournissant à la fois des versions Python et C++ pour un déploiement facile dans n'importe quel scénario.

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)

Link to this sectionRésumé#

Dans ce guide, nous présentons 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'edge AI, 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'utilisation, veuillez te référer à la documentation MNN.

Link to this sectionFAQ#

Link to this sectionComment exporter des modèles Ultralytics YOLO26 au format MNN ?#

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

Export

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", half=True)  # creates 'yolo26n.mnn' with fp16 weight
model.export(format="mnn", int8=True)  # creates 'yolo26n.mnn' with int8 weight

Pour des options d'exportation détaillées, consulte la page Export dans la documentation.

Link to this sectionComment effectuer une prédiction avec un modèle MNN YOLO26 exporté ?#

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

Predict

from ultralytics import YOLO

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

# Run inference
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

Link to this sectionQuelles plateformes sont prises en charge pour MNN ?#

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.
Bureau et serveurs : Linux, Windows et macOS.

Link to this sectionComment puis-je déployer des modèles MNN Ultralytics YOLO26 sur des appareils mobiles ?#

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

Construire pour Android : Suis le guide MNN Android.
Construire pour iOS : Suis le guide MNN iOS.
Construire pour Harmony : Suis le guide MNN Harmony.

Contributeurs

GLglenn-jocher⁹ LAlakshanthad³ JUjules-ai² LALaughing-q¹ RIRizwanMunawar¹ WAwangzhaode¹

Créé 30 oct. 2024Mis à jour la semaine dernière