No publico
Introducción a NanoDet
URL de nanodet: https://github.com/RangiLyu/nanodet
NanoDet es un modelo de detección de objetivos sin anclaje móvil ultrarrápido y ligero. Este modelo tiene las siguientes ventajas:
- Ultraligero: el tamaño del archivo del modelo es de solo 1,8 m;
- Velocidad súper rápida: 97 fps (10.23ms) en CPU ARM móvil;
- Fácil de entrenar: el costo de la memoria de la GPU es mucho más bajo que en otros modelos. El tamaño de lote en GTX1060 6G puede ejecutarse si el tamaño de lote es 80;
- Fácil de implementar: se proporciona la implementación de C ++ y la demostración de Android basada en el marco de razonamiento ncnn.
Rendimiento del modelo
En la actualidad, el modelo de código abierto NanoDet-m tiene un Flops de solo 0.72B con una resolución de entrada de 320x320 , mientras que yolov4-tiny tiene 6.96B, que es casi diez veces más pequeño . El parámetro del modelo también es de solo 0,95 M, y el archivo de peso es de solo 1,8 MB después del almacenamiento de 16 bits usando ncnn optimizar.
Aunque el modelo es muy ligero, su rendimiento no debe subestimarse. Al comparar con otros modelos, el autor del proyecto eligió usar COCO mAP (0.5: 0.95) como índice de evaluación , teniendo en cuenta la precisión de detección y posicionamiento, probando en imágenes COCO val 5000, y no usó Testing-Time-Augmentation . En esta configuración, la entrada de resolución de 320 puede alcanzar un mAP de 20,6, que es 4 puntos más alto que tiny-yolov3 y solo 1 punto porcentual más bajo que yolov4-tiny. Cuando se mantiene la resolución de entrada consistente con YOLO y ambos usan la entrada 416, NanoDet y yolov4-tiny obtienen la misma puntuación. Los resultados específicos se muestran en la siguiente tabla:
[Error en la transferencia de la imagen del enlace externo. El sitio de origen puede tener un mecanismo anti-hotlinking. Se recomienda guardar la imagen y subirla directamente (img-brtkSc4J-1616501467302) (C: \ Users \ zhong \ AppData \ Roaming \ Typora \ typora-user-images \ image-20210323194120724.png)]
El rendimiento anterior se basa en CPU ARM ncnn y Kirin 980 (4xA76 + 4xA55).
Además, el autor del proyecto implementó ncnn en el teléfono móvil (CPU Kirin 980 basada en ARM, 4 núcleos A76 y 4 núcleos A55) y ejecutó el punto de referencia. El tiempo de cálculo hacia adelante del modelo es de solo 10 milisegundos, mientras que yolov3 y v4 tiny Ambos son del orden de 30 milisegundos. En la aplicación de demostración de la cámara de Android, el NanoDet puede ejecutarse fácilmente a más de 40 FPS, incluido el tiempo para el preprocesamiento de la imagen, el posprocesamiento del cuadro de detección y el dibujo del cuadro de detección.
Comparación de rendimiento entre NanoDet y yolov4-tiny.
Finalmente, el proyecto proporciona una demostración de Android, una demostración de C ++ y una demostración de Python. Los resultados de detección de objetivos de NanoDet en el lado de Android son los siguientes:
Entrene su propio conjunto de datos
He puesto todos los códigos que uso en github, bienvenido a empezar.
https://github.com/zlszhonglongshen/nanodet_cigar
Necesita almacenar su propio conjunto de datos en cigar / train y cigar / val, utilizando el software labelimg, puede obtener fácilmente el archivo de etiqueta en formato voc
Nota: el sufijo del archivo de imagen debe ser coherente; de lo contrario, se informará un error
fire
├── train
│ ├── ann
│ │ ├── 1.xml
│ │ └── 2.xml
│ └── img
│ ├── 1.jpg
│ └── 2.jpg
└── val
├── ann
│ └── 1.xml
└── img
└── 1.jpg
Nanodet admite formatos voc y coco, necesita generar su propio archivo de configuración
save_dir: ./fire
num_classes: 1
class_names: &class_names ['fire']
train:
name: xml_dataset
img_path: ./fire/train/img
ann_path: ./fire/train/ann
input_szie: [320,320]
val:
name: xml_dataset
img_path: ./fire/val/img
ann_path: ./fire/val/ann
input_szie: [320,320]
Los comandos de entrenamiento son los siguientes
/home/zhongls/.conda/envs/pyzhongls/bin/python train.py cigar/nanodet_card.yml
Archivo de resultados
Eventualmente obtendrá model_last.pth en la carpeta
Secuencia de comandos de prueba
import time
import os
import cv2
import torch
from nanodet.util import cfg, load_config, Logger
from nanodet.model.arch import build_model
from nanodet.util import load_model_weight
from nanodet.data.transform import Pipeline
config_path = 'nanodet_card.yml'
model_path = 'model_last.pth'
image_path = '000-0.jpg'
load_config(cfg, config_path)
logger = Logger(-1, use_tensorboard=False)
class Predictor(object):
def __init__(self, cfg, model_path, logger, device='cuda:0'):
self.cfg = cfg
self.device = device
model = build_model(cfg.model)
ckpt = torch.load(model_path, map_location=lambda storage, loc: storage)
load_model_weight(model, ckpt, logger)
self.model = model.to(device).eval()
self.pipeline = Pipeline(cfg.data.val.pipeline, cfg.data.val.keep_ratio)
def inference(self, img):
img_info = {}
height, width = img.shape[:2]
img_info['height'] = height
img_info['width'] = width
meta = dict(img_info=img_info,raw_img=img,img=img)
meta = self.pipeline(meta, self.cfg.data.val.input_size)
meta['img'] = torch.from_numpy(meta['img'].transpose(2, 0, 1)).unsqueeze(0).to(self.device)
with torch.no_grad():
results = self.model.inference(meta)
return meta, results
def visualize(self, dets, meta, class_names, score_thres, wait=0):
time1 = time.time()
self.model.head.show_result(meta['raw_img'], dets, class_names, score_thres=score_thres, show=True)
print('viz time: {:.3f}s'.format(time.time()-time1))
predictor = Predictor(cfg, model_path, logger, device='cpu')
from nanodet.util import overlay_bbox_cv
from IPython.display import display
from PIL import Image
def cv2_imshow(a, convert_bgr_to_rgb=True):
"""A replacement for cv2.imshow() for use in Jupyter notebooks.
Args:
a: np.ndarray. shape (N, M) or (N, M, 1) is an NxM grayscale image. shape
(N, M, 3) is an NxM BGR color image. shape (N, M, 4) is an NxM BGRA color
image.
convert_bgr_to_rgb: switch to convert BGR to RGB channel.
"""
a = a.clip(0, 255).astype('uint8')
# cv2 stores colors as BGR; convert to RGB
if convert_bgr_to_rgb and a.ndim == 3:
if a.shape[2] == 4:
a = cv2.cvtColor(a, cv2.COLOR_BGRA2RGBA)
else:
a = cv2.cvtColor(a, cv2.COLOR_BGR2RGB)
display(Image.fromarray(a))
frame = cv2.imread("000-0.jpg")
meta, res = predictor.inference(frame)
result = overlay_bbox_cv(meta['raw_img'], res, cfg.class_names, score_thresh=0.35)
imshow_scale = 1.0
cv2_imshow(cv2.resize(result, None, fx=imshow_scale, fy=imshow_scale))
[Error en la transferencia de la imagen del enlace externo. El sitio de origen puede tener un mecanismo anti-hotlinking. Se recomienda guardar la imagen y subirla directamente (img-CtrqYIoO-1616501467309) (C: \ Users \ zhong \ AppData \ Roaming \ Typora \ typora-user-images \ image-20210323195132895.png)]
Link de referencia
-
https://blog.csdn.net/zicai_jiayou/article/details/110469717
-
https://www.jiqizhixin.com/articles/2020-11-24-5
-
https://blog.csdn.net/qq_34795071/article/details/110083258
-
https://github.com/RangiLyu/nanodet