Exportation MNN et déploiement de modèles YOLO26
MNN#
MNN est un framework léger de deep learning développé par Alibaba, qui prend en charge l’inférence et l’entraînement de modèles de deep learning sur l’appareil. MNN est intégré à plus de 30 applications Alibaba, telles que Taobao, Tmall, Youku, DingTalk et Xianyu, et couvre plus de 70 cas d’usage, dont la diffusion en direct, la capture de courtes vidéos, 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é. MNN fonctionne également sur les appareils embarqués et IoT.
À regarder : Comment exporter Ultralytics YOLO 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âche | YOLOv8 | YOLO11 | YOLO26 |
|---|---|---|---|
| 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 :
# Install the required package for YOLO26 and MNN
pip install ultralytics
pip install MNNUtilisation#
Tous les modèles Ultralytics YOLO26 prennent en charge l’exportation dès leur installation, ce qui te permet de les intégrer au processus de déploiement de ton choix. 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.
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 »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")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#
| Argument | Type | Valeur par défaut | Description |
|---|---|---|---|
format | str | 'mnn' | Format cible du modèle exporté, qui définit sa compatibilité avec différents 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 les images carrées ou un tuple (height, width) pour définir des dimensions spécifiques. |
quantize | int ou str | None | Pré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. |
simplify | bool | True | Simplifie le graphe ONNX intermédiaire avec onnxslim. |
opset | int | None | Indique la version de l'opset ONNX pour le graphe ONNX intermédiaire. Si elle n'est pas définie, utilise l'opset 18 (une version inférieure avec PyTorch < 2.4), sans dépasser la version onnx installée. |
batch | int | 1 | Indique 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. |
dynamic | bool | False | Active les dimensions dynamiques des images d’entrée. Ne peut pas être combiné avec nms=True. |
nms | bool, facultatif | None | Sé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. |
device | str | None | Dé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#
Les exemples suivants exécutent le prétraitement, l’inférence et le post-traitement YOLO26 avec MNN uniquement, en Python et en C++, afin que tu puisses déployer sans PyTorch ni le package Ultralytics.
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.5, 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é#
Ce guide explique comment exporter des modèles Ultralytics YOLO26 vers MNN et exécuter l’inférence avec MNN. Le format MNN convient particulièrement aux applications d’IA en périphérie qui déploient des modèles de vision par ordinateur sur des appareils aux ressources limitées.
FAQ#
Pour exporter ton modèle Ultralytics YOLO26 au format MNN, suis ces étapes :
Exportfrom 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 int8Pour 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
predictde la classe YOLO.Prédictionfrom 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 disqueMNN 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 :
- Compiler pour Android : suis le guide MNN pour Android.
- Compiler pour iOS : suis le guide MNN pour iOS.
- Compiler pour Harmony : suis le guide MNN pour Harmony.
Commentaires2
Pose une question, partage tes résultats ou aide quelqu’un d’autre.
robert-hardman
Hello Error: NameError: name 'mnn_model' is not defined ultralytics==8.3.34
Glenn JocherUltralyticsIt seems like there's a minor typo in your code. Ensure you are using
modelinstead ofmnn_modelwhen 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.