最近发现hailo有一个parse的选项可以先探索模型，得到har文件，再利用har文件就可以转换自定义的模型，这里先用yolov5s作为例子。

parse yolov5s 模型（原始库，ultralytics库测试后仍会报错）

原始库地址 ： https://github.com/ultralytics/yolov5 

pytorch版本 ：torch==1.11.0+cu113
                        torchaudio==0.11.0+cu113
                        torchvision==0.12.0+cu113

转换为onnx时： onnx=1.14.0

                           opset=11

查看帮助信息，发现 hailomz parse 可以给出输入输出节点和yaml文件：

因此只需要得到输入输出节点对应输入即可，对于添加了模块的模型，指定模型结构yaml文件应该也能实现转换（暂未实验，有待补充）

此外注意到能用的模型不包括yolov5n，只有分割版本的yolov5n-seg，因此用yolov5s作为例子。

这里给出yolov5s的一版模型，已经到处为onnx格式，利用netron查看输入输出节点。

netron下载地址为：Release 8.4.4 · lutzroeder/netron

利用netron看到输入输出节点名称分别为image和output0

输入parse命令

hailomz parse yolov5s --ckpt=best.onnx --hw-arch hailo8l --start-node-names images --end-node-names output0

用pycharm或vscode打开har文件，跳过乱码部分

根据output_layers_order的模块名称按顺序修改后处理输出头名称

path/to/site-packages/hailo_model_zoo/cfg/postprocess_config/yolov5s_nms_config.json

根据har文件进行compile

hailomz compile yolov5s --ckpt=best.onnx --hw-arch hailo8l --classes 80 --har yolov5s.har --performance

————————————————以下是之前写的精细修改——————————————

这段时间和小伙伴们交流hailo的转换模型，有小伙伴提到好像只能转官方模型，不利于改模型堆工作量。为此我研究了一下转模型的方法，捣鼓了很久还真让我搞通了yolov8加注意力机制模型的转hef格式。我这里仅以CBAM注意力模块做介绍，其他的注意力模块操作也类似。但如果加的是其他类型的模块还请自行捣鼓，或者私信我也可以。

一、前期工作

训练部分加注意力机制不做展开，参考:

最新！YOLOv8添加注意力机制——轻松上手_哔哩哔哩_bilibili

我这里选用yolov8n+CBAM模块进行演示，其代码如下：

class ChannelAttention(nn.Module):
    """Channel-attention module https://github.com/open-mmlab/mmdetection/tree/v3.0.0rc1/configs/rtmdet."""

    def __init__(self, channels: int) -> None:
        """Initializes the class and sets the basic configurations and instance variables required."""
        super().__init__()
        self.pool = nn.AdaptiveAvgPool2d(1)
        self.cv2 = nn.Conv2d(channels, channels, 1, 1, 0, bias=True)
        self.act = nn.Sigmoid()

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        """Applies forward pass using activation on convolutions of the input, optionally using batch normalization."""
        return x * self.act(self.fc(self.pool(x)))


class SpatialAttention(nn.Module):
    """Spatial-attention module."""

    def __init__(self, kernel_size=7):
        """Initialize Spatial-attention module with kernel size argument."""
        super().__init__()
        assert kernel_size in (3, 7), "kernel size must be 3 or 7"
        padding = 3 if kernel_size == 7 else 1
        self.cv1 = nn.Conv2d(2, 1, kernel_size, padding=padding, bias=False)
        self.act = nn.Sigmoid()

    def forward(self, x):
        """Apply channel and spatial attention on input for feature recalibration."""
        return x * self.act(self.cv1(torch.cat([torch.mean(x, 1, keepdim=True), torch.max(x, 1, keepdim=True)[0]], 1)))

class CBAM(nn.Module):
    """Convolutional Block Attention Module."""

    def __init__(self, c1, kernel_size=7):
        """Initialize CBAM with given input channel (c1) and kernel size."""
        super().__init__()
        self.channel_attention = ChannelAttention(c1)
        self.spatial_attention = SpatialAttention(kernel_size)

    def forward(self, x):
        """Applies the forward pass through C1 module."""
        return self.spatial_attention(self.channel_attention(x))

其模型结构的yaml文件如下：

# Ultralytics YOLO 🚀, GPL-3.0 license
# YOLOv8 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect

# Parameters
nc: 11  # number of classes
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
  # [depth, width, max_channels]
  n: [0.33, 0.25, 1024]  # YOLOv8n summary: 225 layers,  3157200 parameters,  3157184 gradients,   8.9 GFLOPs
  s: [0.33, 0.50, 1024]  # YOLOv8s summary: 225 layers, 11166560 parameters, 11166544 gradients,  28.8 GFLOPs
  m: [0.67, 0.75, 768]   # YOLOv8m summary: 295 layers, 25902640 parameters, 25902624 gradients,  79.3 GFLOPs
  l: [1.00, 1.00, 512]   # YOLOv8l summary: 365 layers, 43691520 parameters, 43691504 gradients, 165.7 GFLOPs
  x: [1.00, 1.25, 512]   # YOLOv8x summary: 365 layers, 68229648 parameters, 68229632 gradients, 258.5 GFLOPs

# YOLOv8.0n backbone
backbone:
  # [from, repeats, module, args]
  - [-1, 1, Conv, [64, 3, 2]]  # 0-P1/2
  - [-1, 1, Conv, [128, 3, 2]]  # 1-P2/4
  - [-1, 3, C2f, [128, True]]
  - [-1, 1, Conv, [256, 3, 2]]  # 3-P3/8
  - [-1, 6, C2f, [256, True]]
  - [-1, 1, Conv, [512, 3, 2]]  # 5-P4/16
  - [-1, 6, C2f, [512, True]]
  - [-1, 1, Conv, [1024, 3, 2]]  # 7-P5/32
  - [-1, 3, C2f, [1024, True]]
  - [-1, 1, SPPF, [1024, 5]]  # 9

# YOLOv8.0n head
head:
  - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
  - [[-1, 6], 1, Concat, [1]]  # cat backbone P4
  - [-1, 3, C2f, [512]]  # 12

  - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
  - [[-1, 4], 1, Concat, [1]]  # cat backbone P3
  - [-1, 3, C2f, [256]]  # 15 (P3/8-small)
  - [-1, 1, CBAM, [256]]  # 16 (P5/32-large)

  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 12], 1, Concat, [1]]  # cat head P4
  - [-1, 3, C2f, [512]]  # 19 (P4/16-medium)
  - [-1, 1, CBAM, [512]]  # 20 (P5/32-large)

  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 9], 1, Concat, [1]]  # cat head P5
  - [-1, 3, C2f, [1024]]  # 23 (P5/32-large)
  - [-1, 1, CBAM, [1024]]  # 24 (P5/32-large)

  - [[16, 20, 24], 1, Detect, [nc]]  # Detect(P3, P4, P5)

hailo模型转换用的ubuntu系统和相关环境配置参考我的另一篇博客：

树莓派5B+AI_KIT基于hailo模块转换重新训练的YOLO模型_hailo8 yolo-CSDN博客

接下来正式介绍需要修改的部分

二、复制需要的模型文件

对于yolov8修改而来的模型，我们导航到hailo运行环境下的site-packages文件夹下的hailo_model_zoo文件夹，找到以下三个文件：

path/to/site-packages/hailo_model_zoo/cfg/alls/generic/yolov8n.alls

path/to/site-packages/hailo_model_zoo/cfg/networks/yolov8n.yaml

path/to/site-packages/hailo_model_zoo/cfg/postprocess_config/yolov8n_nms_config.json

将他们复制并重命名到各自所在文件夹：

path/to/site-packages/hailo_model_zoo/cfg/alls/generic/CBAM_yolov8n.alls

path/to/site-packages/hailo_model_zoo/cfg/networks/CBAM_yolov8n.yaml

path/to/site-packages/hailo_model_zoo/cfg/postprocess_config/CBAM_yolov8n_nms_config.json

以文本格式打开CBAM_yolov8n.alls，做以下修改：

保存文件

找回我们训练yolo模型时打印出来的模型结构：

最后一层为25，然后我们以文本形式打开CBAM_yolov8n.yaml,修改network_name和nodes下的模块名称(修改后的模块名称需要记录)：

保存yaml文件

三、结构文件修改

我们需要得知hailo转换过程中对我们新增的结构是如何重构的，导航到hailo运行环境下的site-packages文件夹下的

path/to/site-packages/hailo_sdk_common/hailo_nn/hailo_nn.py

修改程序中的大概857行左右的位置，将函数add_scope_name_to_component修改如下：

def add_scope_name_to_component(self, component, scope_name):
        names_mapping = {}
        from pathlib import Path
        _USER_DATA_DIR = Path.home() / ".hailomz"
        save_layer_dict = component.layers_by_index
        save_layer_dict = {int(key): str(save_layer_dict[key]) for key in save_layer_dict.keys()}
        import json
        with open(_USER_DATA_DIR / 'layer_dict.json', 'w') as f:
            json.dump(save_layer_dict, f)
        for layer in component.stable_toposort(key="name"):
            old_name = layer.name
            self._set_layer_scope_name(layer, scope_name)
            names_mapping[old_name] = layer.name
    return names_mapping

随后我们先尝试运行转换命令， 获取转换结构：

hailomz compile CBAM_yolov8n --ckpt=best.onnx --hw-arch hailo8l --classes 30 --performance

先忽略报错信息，在主目录下.hailomz文件夹下找到layer_dict.json文件。如果文件不存在，则可能是由于添加的模块无法被hailo正确的识别出类型，此时再查看报错信息予以确认。

将layer_dict.json文件打开，将步骤一中记录的输出模块名称在json文件中进行搜索，记录其对应的layer名称：

搜索到的layer名称依次为conv42、conv43、conv54、conv55、conv65、conv66，打开path/to/site-packages/hailo_model_zoo/cfg/postprocess_config/yolov8n_nms_config.json

依次做出修改：

保存文件后再次打开CBAM_yolov8n.alls，做以下修改：

保存文件

上述修改主要让增加模块后的模型能对应上三个输出头的模块名称，这个名称是hailo根据对每一层网络进行解读、归类、排序后得到的。

每个输出头有两个相邻的conv模块，它的具体名称取决于我们添加的模块里面是否有会被hailo识别出conv模块的部分及其位置和数量，本文我们用查询的方法加以确认。

alls文件中三个conv块应该是三个输出头中序号靠后的conv块，因此依次为conv43、conv55、conv66。

最后我们重新运行转换程序即可

hailomz compile CBAM_yolov8n --ckpt=best.onnx --hw-arch hailo8l --classes 30 --performance

值得注意的是，一些操作和方法可能无法被hailo正确识别，例如nn.Softmax和比较复杂的reshape操作等，具体的还需要进一步探究。本文初步的介绍了一下思路，但其中可能出现问题的地方比较多，有疑问的小伙伴可以在评论区评论或者与我私信交流。