Tabla de contenido
2. Introducción al conjunto de datos sobre el humo de los incendios forestales.
3.1gold-yolo presentado a yolov8
4. Análisis de los resultados de la formación.
1. Introducción a Yolov8
Ultralytics YOLOv8 es la última versión del modelo de segmentación de imágenes y detección de objetivos YOLO desarrollado por Ultralytics. YOLOv8 es un modelo de vanguardia (SOTA) que se basa en el éxito anterior de YOLO e introduce nuevas características y mejoras para mejorar aún más el rendimiento y la flexibilidad. Puede entrenarse en grandes conjuntos de datos y es capaz de ejecutarse en una variedad de plataformas de hardware, desde CPU hasta GPU.
Las mejoras específicas son las siguientes:
-
Backbone : todavía usa la idea de CSP, pero el módulo C3 en YOLOv5 ha sido reemplazado por el módulo C2f, logrando un mayor aligeramiento. Al mismo tiempo, YOLOv8 todavía usa el módulo SPPF usado en YOLOv5 y otras arquitecturas;
-
PAN-FPN : No hay duda de que YOLOv8 todavía usa la idea de PAN, pero al comparar los diagramas de estructura de YOLOv5 y YOLOv8, podemos ver que YOLOv8 elimina la estructura convolucional en la etapa de muestreo superior de PAN-FPN en YOLOv5. , y también elimina C3 El módulo es reemplazado por el módulo C2f;
-
Cabeza Desacoplada : ¿Hueles algo diferente? Sí, YOLOv8 va a Deacoplado-Head;
-
Anchor-Free : YOLOv8 abandonó el Anchor-Base anterior y utilizó la idea de Anchor-Free ;
-
Función de pérdida : YOLOv8 utiliza VFL Loss como pérdida de clasificación y DFL Loss+CIOU Loss como pérdida de clasificación;
-
Coincidencia de muestra : YOLOv8 abandona el método anterior de coincidencia de pagarés o asignación de proporción unilateral y, en su lugar, utiliza el método de coincidencia del asignador alineado con tareas.
El diagrama del marco se proporciona en el enlace: Breve resumen de la estructura del modelo YOLOv8 · Número 189 · ultralytics/ultralytics · GitHub
2. Introducción al conjunto de datos sobre el humo de los incendios forestales.
El tamaño del conjunto de datos es 737 imágenes, train:val:test se asigna aleatoriamente a 7:2:1, categoría: humo
3.Oro-YOLO
Enlace: https://arxiv.org/pdf/2309.11331.pdf
Código: https://github.com/huawei-noah/Efficient-Computing/tree/master/Detection/Gold-YOLO
Unidad: Laboratorio del Arca de Noé de Huawei
Para la parte teórica, consulte: ¡ Más allá de la serie YOLO! Huawei propone Gold-YOLO: un eficiente detector de objetivos en tiempo real - Zhihu
Problemas con el YOLO tradicional
En el modelo de detección, una serie de características en diferentes niveles generalmente se extraen primero a través de la columna vertebral. FPN aprovecha esta característica de la columna vertebral para construir una estructura de fusión correspondiente: las características sin nivel contienen información de posición de objetos de diferentes tamaños. Aunque estas características La información contenida es diferente, pero después de integrarse entre sí, estas funciones pueden compensar la información faltante de cada una, mejorar la riqueza de la información en cada nivel y mejorar el rendimiento de la red.
La estructura FPN original permite que la información de las capas adyacentes se fusione completamente debido a su modo de fusión de información progresiva capa por capa, pero también genera problemas en la fusión de información entre capas: cuando la información entre capas se fusiona interactivamente, debido Debido a la falta de conexión directa, los canales interactivos solo pueden depender de la capa intermedia para actuar como un "intermediario" para la integración, lo que resulta en una cierta pérdida de información. Muchos trabajos anteriores han prestado atención a este problema y la solución suele ser agregar más rutas agregando atajos para mejorar el flujo de información.
Resumen: Los modelos actuales de la serie YOLO generalmente utilizan métodos similares a FPN para la fusión de información, pero esta estructura tiene el problema de la pérdida de información al fusionar información entre capas. En respuesta a este problema, propusimos un nuevo mecanismo GD de mecanismo de recopilación y distribución (mecanismo de recopilación y distribución), que integra y distribuye características en diferentes niveles en una perspectiva global para construir una interacción de información más completa y totalmente eficiente. mecanismo de fusión y construyó Gold-YOLO basado en el mecanismo GD. En el conjunto de datos COCO, nuestro Gold-YOLO supera la serie YOLO existente y logra SOTA en la curva precisión-velocidad.
Se propone un nuevo mecanismo de interacción y fusión de información: Mecanismo de recopilación y distribución de información . Este mecanismo obtiene información global fusionando globalmente características en diferentes niveles e inyecta información global en características en diferentes niveles, logrando una interacción y fusión de información eficiente. El mecanismo GD mejora significativamente la capacidad de fusión de información de la parte del Cuello sin aumentar significativamente el retraso y mejora la capacidad de detección del modelo de objetos de diferentes tamaños.
En Gold-YOLO, en respuesta a la necesidad del modelo de detectar objetos de diferentes tamaños y sopesar la precisión y la velocidad, construimos dos ramas de GD para fusionar información: rama de distribución y agregación de información de bajo nivel (Low-GD) y alto nivel La rama de recopilación y distribución de información (High-GD) extrae y fusiona información de características basada en convolución y transformador, respectivamente.
Resultados experimentales:
Se realizaron los experimentos de ablación correspondientes para investigar el impacto de diferentes ramas y estructuras en Gold-YOLO en la precisión y velocidad del modelo.
3.1gold-yolo presentado a yolov8
3.2 gold-yolo se une a yolov8
Código central:
class Attention(torch.nn.Module):
def __init__(self, dim, key_dim, num_heads, attn_ratio=4):
super().__init__()
self.num_heads = num_heads
self.scale = key_dim ** -0.5
self.key_dim = key_dim
self.nh_kd = nh_kd = key_dim * num_heads # num_head key_dim
self.d = int(attn_ratio * key_dim)
self.dh = int(attn_ratio * key_dim) * num_heads
self.attn_ratio = attn_ratio
self.to_q = Conv(dim, nh_kd, 1, act=False)
self.to_k = Conv(dim, nh_kd, 1, act=False)
self.to_v = Conv(dim, self.dh, 1, act=False)
self.proj = torch.nn.Sequential(nn.ReLU6(), Conv(self.dh, dim, act=False))
def forward(self, x): # x (B,N,C)
B, C, H, W = get_shape(x)
qq = self.to_q(x).reshape(B, self.num_heads, self.key_dim, H * W).permute(0, 1, 3, 2)
kk = self.to_k(x).reshape(B, self.num_heads, self.key_dim, H * W)
vv = self.to_v(x).reshape(B, self.num_heads, self.d, H * W).permute(0, 1, 3, 2)
attn = torch.matmul(qq, kk)
attn = attn.softmax(dim=-1) # dim = k
xx = torch.matmul(attn, vv)
xx = xx.permute(0, 1, 3, 2).reshape(B, self.dh, H, W)
xx = self.proj(xx)
return xx
class top_Block(nn.Module):
def __init__(self, dim, key_dim, num_heads, mlp_ratio=4., attn_ratio=2., drop=0.,
drop_path=0.):
super().__init__()
self.dim = dim
self.num_heads = num_heads
self.mlp_ratio = mlp_ratio
self.attn = Attention(dim, key_dim=key_dim, num_heads=num_heads, attn_ratio=attn_ratio)
# NOTE: drop path for stochastic depth, we shall see if this is better than dropout here
self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
mlp_hidden_dim = int(dim * mlp_ratio)
self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, drop=drop)
def forward(self, x1):
x1 = x1 + self.drop_path(self.attn(x1))
x1 = x1 + self.drop_path(self.mlp(x1))
return x1
class TopBasicLayer(nn.Module):
def __init__(self, embedding_dim, ouc_list, block_num=2, key_dim=8, num_heads=4,
mlp_ratio=4., attn_ratio=2., drop=0., attn_drop=0., drop_path=0.):
super().__init__()
self.block_num = block_num
self.transformer_blocks = nn.ModuleList()
for i in range(self.block_num):
self.transformer_blocks.append(top_Block(
embedding_dim, key_dim=key_dim, num_heads=num_heads,
mlp_ratio=mlp_ratio, attn_ratio=attn_ratio,
drop=drop, drop_path=drop_path[i] if isinstance(drop_path, list) else drop_path))
self.conv = nn.Conv2d(embedding_dim, sum(ouc_list), 1)
def forward(self, x):
# token * N
for i in range(self.block_num):
x = self.transformer_blocks[i](x)
return self.conv(x)
class AdvPoolFusion(nn.Module):
def forward(self, x):
x1, x2 = x
if torch.onnx.is_in_onnx_export():
self.pool = onnx_AdaptiveAvgPool2d
else:
self.pool = nn.functional.adaptive_avg_pool2d
N, C, H, W = x2.shape
output_size = np.array([H, W])
x1 = self.pool(x1, output_size)
return torch.cat([x1, x2], 1)Código central:
4. Análisis de los resultados de la formación.
Los resultados del entrenamiento son los siguientes:
Mapa [email protected] 0.839 mejorado a 0.954
YOLOv8-goldYOLO summary: 359 layers, 6015123 parameters, 0 gradients, 11.9 GFLOPs
Class Images Instances Box(P R mAP50 mAP50-95): 100%|██████████| 25/25 [00:06<00:00, 3.84it/s]
all 199 199 0.88 0.93 0.954 0.555