YOLO11 Modelleri için MNN Dışa Aktarımı ve Dağıtımı
MNN
MNN, son derece verimli ve hafif bir derin öğrenme çerçevesidir. Derin öğrenme modellerinin çıkarımını ve eğitimini destekler ve cihaz üzerinde çıkarım ve eğitim için sektör lideri performansa sahiptir. Şu anda MNN, canlı yayın, kısa video çekimi, arama önerisi, resimle ürün arama, etkileşimli pazarlama, öz sermaye dağıtımı, güvenlik risk kontrolü gibi 70'den fazla kullanım senaryosunu kapsayan Taobao, Tmall, Youku, DingTalk, Xianyu vb. gibi Alibaba Inc'in 30'dan fazla uygulamasına entegre edilmiştir. Ek olarak, MNN ayrıca IoT gibi gömülü cihazlarda da kullanılmaktadır.
MNN'ye Aktarma: YOLO11 Modelinizi Dönüştürme
Ultralytics YOLO modellerini MNN formatına dönüştürerek model uyumluluğunu ve dağıtım esnekliğini genişletebilirsiniz. Bu dönüştürme, modellerinizi mobil ve gömülü ortamlar için optimize ederek kaynak kısıtlı cihazlarda verimli performans sağlar.
Kurulum
Gerekli paketleri kurmak için şunu çalıştırın:
Kurulum
# Install the required package for YOLO11 and MNN
pip install ultralytics
pip install MNN
Kullanım
Tüm Ultralytics YOLO11 modelleri, kutudan çıkar çıkmaz dışa aktarmayı destekleyecek şekilde tasarlanmıştır ve bu da onları tercih ettiğiniz dağıtım iş akışına entegre etmeyi kolaylaştırır. Uygulamanız için en iyi kurulumu seçmek üzere desteklenen dışa aktarma biçimlerinin ve yapılandırma seçeneklerinin tam listesini görüntüleyebilirsiniz.
Kullanım
from ultralytics import YOLO
# Load the YOLO11 model
model = YOLO("yolo11n.pt")
# Export the model to MNN format
model.export(format="mnn") # creates 'yolo11n.mnn'
# Load the exported MNN model
mnn_model = YOLO("yolo11n.mnn")
# Run inference
results = mnn_model("https://ultralytics.com/images/bus.jpg")
# Export a YOLO11n PyTorch model to MNN format
yolo export model=yolo11n.pt format=mnn # creates 'yolo11n.mnn'
# Run inference with the exported model
yolo predict model='yolo11n.mnn' source='https://ultralytics.com/images/bus.jpg'
Dışa Aktarma Argümanları
Argüman | Tür | Varsayılan | Açıklama |
---|---|---|---|
format |
str |
'mnn' |
Çeşitli dağıtım ortamlarıyla uyumluluğu tanımlayan, dışa aktarılan modelin hedef formatı. |
imgsz |
int veya tuple |
640 |
Model girişi için istenen görüntü boyutu. Kare görüntüler için bir tamsayı veya bir demet olabilir (height, width) belirli boyutlar için. |
half |
bool |
False |
FP16 (yarı duyarlıklı) nicelemeyi etkinleştirir, model boyutunu küçültür ve desteklenen donanımda çıkarımı potansiyel olarak hızlandırır. |
int8 |
bool |
False |
INT8 nicelemesini etkinleştirir, modeli daha da sıkıştırır ve öncelikle uç cihazlar için minimum doğruluk kaybıyla çıkarımı hızlandırır. |
batch |
int |
1 |
Dışa aktarma modeli toplu çıkarım boyutunu veya dışa aktarılan modelin aynı anda işleyeceği maksimum görüntü sayısını belirtir. predict modu. |
device |
str |
None |
Dışa aktarma için cihazı belirtir: GPU (device=0 ), CPU (device=cpu ), Apple silikon için MPS (device=mps ). |
Dışa aktarma süreci hakkında daha fazla bilgi için Ultralytics'in dışa aktarma hakkındaki dokümantasyon sayfasını ziyaret edin.
Yalnızca MNN Çıkarımı
YOLO11 çıkarımı ve ön işleme için yalnızca MNN'ye dayanan bir fonksiyon uygulanır ve herhangi bir senaryoda kolay dağıtım için hem python hem de C++ sürümleri sağlanır.
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 = np.expand_dims(image, 0)
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 yolo11 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)
#include <stdio.h>
#include <MNN/ImageProcess.hpp>
#include <MNN/expr/Module.hpp>
#include <MNN/expr/Executor.hpp>
#include <MNN/expr/ExprCreator.hpp>
#include <MNN/expr/Executor.hpp>
#include <cv/cv.hpp>
using namespace MNN;
using namespace MNN::Express;
using namespace MNN::CV;
int main(int argc, const char* argv[]) {
if (argc < 3) {
MNN_PRINT("Usage: ./yolo11_demo.out model.mnn input.jpg [forwardType] [precision] [thread]\n");
return 0;
}
int thread = 4;
int precision = 0;
int forwardType = MNN_FORWARD_CPU;
if (argc >= 4) {
forwardType = atoi(argv[3]);
}
if (argc >= 5) {
precision = atoi(argv[4]);
}
if (argc >= 6) {
thread = atoi(argv[5]);
}
MNN::ScheduleConfig sConfig;
sConfig.type = static_cast<MNNForwardType>(forwardType);
sConfig.numThread = thread;
BackendConfig bConfig;
bConfig.precision = static_cast<BackendConfig::PrecisionMode>(precision);
sConfig.backendConfig = &bConfig;
std::shared_ptr<Executor::RuntimeManager> rtmgr = std::shared_ptr<Executor::RuntimeManager>(Executor::RuntimeManager::createRuntimeManager(sConfig));
if(rtmgr == nullptr) {
MNN_ERROR("Empty RuntimeManger\n");
return 0;
}
rtmgr->setCache(".cachefile");
std::shared_ptr<Module> net(Module::load(std::vector<std::string>{}, std::vector<std::string>{}, argv[1], rtmgr));
auto original_image = imread(argv[2]);
auto dims = original_image->getInfo()->dim;
int ih = dims[0];
int iw = dims[1];
int len = ih > iw ? ih : iw;
float scale = len / 640.0;
std::vector<int> padvals { 0, len - ih, 0, len - iw, 0, 0 };
auto pads = _Const(static_cast<void*>(padvals.data()), {3, 2}, NCHW, halide_type_of<int>());
auto image = _Pad(original_image, pads, CONSTANT);
image = resize(image, Size(640, 640), 0, 0, INTER_LINEAR, -1, {0., 0., 0.}, {1./255., 1./255., 1./255.});
image = cvtColor(image, COLOR_BGR2RGB);
auto input = _Unsqueeze(image, {0});
input = _Convert(input, NC4HW4);
auto outputs = net->onForward({input});
auto output = _Convert(outputs[0], NCHW);
output = _Squeeze(output);
// output shape: [84, 8400]; 84 means: [cx, cy, w, h, prob * 80]
auto cx = _Gather(output, _Scalar<int>(0));
auto cy = _Gather(output, _Scalar<int>(1));
auto w = _Gather(output, _Scalar<int>(2));
auto h = _Gather(output, _Scalar<int>(3));
std::vector<int> startvals { 4, 0 };
auto start = _Const(static_cast<void*>(startvals.data()), {2}, NCHW, halide_type_of<int>());
std::vector<int> sizevals { -1, -1 };
auto size = _Const(static_cast<void*>(sizevals.data()), {2}, NCHW, halide_type_of<int>());
auto probs = _Slice(output, start, size);
// [cx, cy, w, h] -> [y0, x0, y1, x1]
auto x0 = cx - w * _Const(0.5);
auto y0 = cy - h * _Const(0.5);
auto x1 = cx + w * _Const(0.5);
auto y1 = cy + h * _Const(0.5);
auto boxes = _Stack({x0, y0, x1, y1}, 1);
// ensure ratio is within the valid range [0.0, 1.0]
boxes = _Maximum(boxes, _Scalar<float>(0.0f));
boxes = _Minimum(boxes, _Scalar<float>(1.0f));
auto scores = _ReduceMax(probs, {0});
auto ids = _ArgMax(probs, 0);
auto result_ids = _Nms(boxes, scores, 100, 0.45, 0.25);
auto result_ptr = result_ids->readMap<int>();
auto box_ptr = boxes->readMap<float>();
auto ids_ptr = ids->readMap<int>();
auto score_ptr = scores->readMap<float>();
for (int i = 0; i < 100; i++) {
auto idx = result_ptr[i];
if (idx < 0) break;
auto x0 = box_ptr[idx * 4 + 0] * scale;
auto y0 = box_ptr[idx * 4 + 1] * scale;
auto x1 = box_ptr[idx * 4 + 2] * scale;
auto y1 = box_ptr[idx * 4 + 3] * scale;
// clamp to the original image size to handle cases where padding was applied
x1 = std::min(static_cast<float>(iw), x1);
y1 = std::min(static_cast<float>(ih), y1);
auto class_idx = ids_ptr[idx];
auto score = score_ptr[idx];
rectangle(original_image, {x0, y0}, {x1, y1}, {0, 0, 255}, 2);
}
if (imwrite("res.jpg", original_image)) {
MNN_PRINT("result image write to `res.jpg`.\n");
}
rtmgr->updateCache();
return 0;
}
Özet
Bu kılavuzda, Ultralytics YOLO11 modelini MNN'ye nasıl aktaracağımızı ve çıkarım için MNN'yi nasıl kullanacağımızı tanıtıyoruz. MNN biçimi, edge AI uygulamaları için mükemmel performans sağlar ve bu da onu kaynak kısıtlı cihazlarda bilgisayar görüşü modellerini dağıtmak için ideal hale getirir.
Daha fazla kullanım için lütfen MNN belgelerine bakın.
SSS
Ultralytics YOLO11 modellerini MNN formatına nasıl aktarırım?
Ultralytics YOLO11 modelinizi MNN formatına aktarmak için şu adımları izleyin:
Dışa aktar
from ultralytics import YOLO
# Load the YOLO11 model
model = YOLO("yolo11n.pt")
# Export to MNN format
model.export(format="mnn") # creates 'yolo11n.mnn' with fp32 weight
model.export(format="mnn", half=True) # creates 'yolo11n.mnn' with fp16 weight
model.export(format="mnn", int8=True) # creates 'yolo11n.mnn' with int8 weight
yolo export model=yolo11n.pt format=mnn # creates 'yolo11n.mnn' with fp32 weight
yolo export model=yolo11n.pt format=mnn half=True # creates 'yolo11n.mnn' with fp16 weight
yolo export model=yolo11n.pt format=mnn int8=True # creates 'yolo11n.mnn' with int8 weight
Ayrıntılı dışa aktarma seçenekleri için, belgelerdeki Dışa Aktarma sayfasına bakın.
Dışa aktarılmış bir YOLO11 MNN modeli ile nasıl tahmin yaparım?
Dışa aktarılmış bir YOLO11 MNN modeliyle tahmin yapmak için şunu kullanın: predict
YOLO sınıfından fonksiyon.
Tahmin et
from ultralytics import YOLO
# Load the YOLO11 MNN model
model = YOLO("yolo11n.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
yolo predict model='yolo11n.mnn' source='https://ultralytics.com/images/bus.jpg' # predict with `fp32`
yolo predict model='yolo11n.mnn' source='https://ultralytics.com/images/bus.jpg' --half=True # predict with `fp16` if device support
MNN için hangi platformlar desteklenmektedir?
MNN çok yönlüdür ve çeşitli platformları destekler:
- Mobil: Android, iOS, Harmony.
- Gömülü Sistemler ve IoT Cihazları: Raspberry Pi ve NVIDIA Jetson gibi cihazlar.
- Masaüstü ve Sunucular: Linux, Windows ve macOS.
Ultralytics YOLO11 MNN modellerini Mobil Cihazlarda nasıl dağıtabilirim?
YOLO11 modellerinizi Mobil cihazlara dağıtmak için:
- Android için Derleme: MNN Android kılavuzunu izleyin.
- iOS için Derleme: MNN iOS kılavuzunu izleyin.
- Harmony için Derleme: MNN Harmony kılavuzunu izleyin.