• 边缘部署轻量化人脸检测模型

    Ultra-Light-Fast-Generic-Face-Detector-1MB-master

    模型是针对边缘计算设备设计的轻量人脸检测模型。

    • 在模型大小上，默认FP32精度下（.pth）文件大小为 1.04~1.1MB，推理框架int8量化后大小为 300KB 左右。
    • 在模型计算量上，320x240的输入分辨率下 90~109 MFlops左右。
    • 模型有两个版本，version-slim(主干精简速度略快)，version-RFB(加入了修改后的RFB模块，精度更高)。
    • 提供320x240、640x480不同输入分辨率下使用widerface训练的预训练模型，更好的工作于不同的应用场景。

    2数据处理

    2.1 输入尺寸的选择

    由于涉及实际部署时的推理速度，因此模型输入尺寸的选择也是一个很重要的话题。

    在作者的原github中，也提到了一点，如果在实际部署的场景中大多数情况为中近距离、人脸大同时人脸的数量也比较少的时候，则可以采用

    320×240

    的输入尺寸；

    如果在实际部署的场景中大多数情况为中远距离、人脸小同时人脸的数量也比较多的时候，则可以采用

    640×480

    或者

    480×360

    的输入尺寸；

    这里由于使用的是EAIDK310进行部署测试，边缘性能不是很好，因此选择原作者推荐的最小尺寸

    320×240

    进行训练和部署测试。 注意：过小的输入分辨率虽然会明显加快推理速度，但是会大幅降低小人脸的召回率。

    2.2 数据筛选

    由于widerface官网数据集中有比较多的低于10像素的人脸照片，因此在这里选择剔除这些像素长宽低于10个pixel的照片；

    3SSD网络结构

    SSD是一个端到端的模型，所有的检测过程和识别过程都是在同一个网络中进行的；同时SSD借鉴了Faster R-CNN的Anchor机制的想法，这样就像相当于在基于回归的的检测过程中结合了区域的思想，可以使得检测效果较定制化边界框的YOLO v1有比较好的提升。

    SSD较传统的检测方法使用顶层特征图的方法选择了使用多尺度特征图，因为在比较浅的特征图中可以对于小目标有比较好的表达，随着特征图的深入，网络对于比较大特征也有了比较好表达能力，故SSD选择使用多尺度特征图可以很好的兼顾大目标和小目标。

    SSD模型结构如下：

    这里关于SSD不进行更多的阐述，想了解的小伙伴自行搜索查看

    整个项目模型搭建如下：

    1. # 网络的主题结构为SSD模型
    2. class SSD(nn.Module):
    3.     def __init__(self, num_classes: int, base_net: nn.ModuleList, source_layer_indexes: List[int],
    4.                  extras: nn.ModuleList, classification_headers: nn.ModuleList,
    5.                  regression_headers: nn.ModuleList, is_test=False, config=None, device=None):
    6.         """Compose a SSD model using the given components.
    7.         """
    8.         super(SSD, self).__init__()
    9.  
    10.         self.num_classes = num_classes
    11.         self.base_net = base_net
    12.         self.source_layer_indexes = source_layer_indexes
    13.         self.extras = extras
    14.         self.classification_headers = classification_headers
    15.         self.regression_headers = regression_headers
    16.         self.is_test = is_test
    17.         self.config = config
    18.  
    19.         # register layers in source_layer_indexes by adding them to a module list
    20.         self.source_layer_add_ons = nn.ModuleList([t[1] for t in source_layer_indexes
    21.                                                    if isinstance(t, tuple) and not isinstance(t, GraphPath)])
    22.         if device:
    23.             self.device = device
    24.         else:
    25.             self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    26.         if is_test:
    27.             self.config = config
    28.             self.priors = config.priors.to(self.device)
    29.  
    30.     def forward(self, x: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
    31.         confidences = []
    32.         locations = []
    33.         start_layer_index = 0
    34.         header_index = 0
    35.         end_layer_index = 0
    36.         for end_layer_index in self.source_layer_indexes:
    37.             if isinstance(end_layer_index, GraphPath):
    38.                 path = end_layer_index
    39.                 end_layer_index = end_layer_index.s0
    40.                 added_layer = None
    41.             elif isinstance(end_layer_index, tuple):
    42.                 added_layer = end_layer_index[1]
    43.                 end_layer_index = end_layer_index[0]
    44.                 path = None
    45.             else:
    46.                 added_layer = None
    47.                 path = None
    48.             for layer in self.base_net[start_layer_index: end_layer_index]:
    49.                 x = layer(x)
    50.             if added_layer:
    51.                 y = added_layer(x)
    52.             else:
    53.                 y = x
    54.             if path:
    55.                 sub = getattr(self.base_net[end_layer_index], path.name)
    56.                 for layer in sub[:path.s1]:
    57.                     x = layer(x)
    58.                 y = x
    59.                 for layer in sub[path.s1:]:
    60.                     x = layer(x)
    61.                 end_layer_index += 1
    62.             start_layer_index = end_layer_index
    63.             confidence, location = self.compute_header(header_index, y)
    64.             header_index += 1
    65.             confidences.append(confidence)
    66.             locations.append(location)
    67.  
    68.         for layer in self.base_net[end_layer_index:]:
    69.             x = layer(x)
    70.  
    71.         for layer in self.extras:
    72.             x = layer(x)
    73.             confidence, location = self.compute_header(header_index, x)
    74.             header_index += 1
    75.             confidences.append(confidence)
    76.             locations.append(location)
    77.  
    78.         confidences = torch.cat(confidences, 1)
    79.         locations = torch.cat(locations, 1)
    80.  
    81.         if self.is_test:
    82.             confidences = F.softmax(confidences, dim=2)
    83.             boxes = box_utils.convert_locations_to_boxes(
    84.                 locations, self.priors, self.config.center_variance, self.config.size_variance
    85.             )
    86.             boxes = box_utils.center_form_to_corner_form(boxes)
    87.             return confidences, boxes
    88.         else:
    89.             return confidences, locations
    90.  
    91.     def compute_header(self, i, x):
    92.         confidence = self.classification_headers[i](x)
    93.         confidence = confidence.permute(0, 2, 3, 1).contiguous()
    94.         confidence = confidence.view(confidence.size(0), -1, self.num_classes)
    95.  
    96.         location = self.regression_headers[i](x)
    97.         location = location.permute(0, 2, 3, 1).contiguous()
    98.         location = location.view(location.size(0), -1, 4)
    99.  
    100.         return confidence, location
    101.  
    102.     def init_from_base_net(self, model):
    103.         self.base_net.load_state_dict(torch.load(model, map_location=lambda storage, loc: storage), strict=True)
    104.         self.source_layer_add_ons.apply(_xavier_init_)
    105.         self.extras.apply(_xavier_init_)
    106.         self.classification_headers.apply(_xavier_init_)
    107.         self.regression_headers.apply(_xavier_init_)
    108.  
    109.     def init_from_pretrained_ssd(self, model):
    110.         state_dict = torch.load(model, map_location=lambda storage, loc: storage)
    111.         state_dict = {k: v for k, v in state_dict.items() if not (k.startswith("classification_headers") or k.startswith("regression_headers"))}
    112.         model_dict = self.state_dict()
    113.         model_dict.update(state_dict)
    114.         self.load_state_dict(model_dict)
    115.         self.classification_headers.apply(_xavier_init_)
    116.         self.regression_headers.apply(_xavier_init_)
    117.  
    118.     def init(self):
    119.         self.base_net.apply(_xavier_init_)
    120.         self.source_layer_add_ons.apply(_xavier_init_)
    121.         self.extras.apply(_xavier_init_)
    122.         self.classification_headers.apply(_xavier_init_)
    123.         self.regression_headers.apply(_xavier_init_)
    124.  
    125.     def load(self, model):
    126.         self.load_state_dict(torch.load(model, map_location=lambda storage, loc: storage))
    127.  
    128.     def save(self, model_path):
    129.         torch.save(self.state_dict(), model_path)

    损失函数

    损失函数作者选择使用的依旧是SSD的Smooth L1 Loss以及Cross Entropy Loss，其中Smooth L1 Loss用于边界框的回归，而Cross Entropy Loss则用于分类。

    具体pytorch实现如下：

    1. class MultiboxLoss(nn.Module):
    2.     def __init__(self, priors, neg_pos_ratio,
    3.                  center_variance, size_variance, device):
    4.         """Implement SSD Multibox Loss.
    6.         Basically, Multibox loss combines classification loss
    7.          and Smooth L1 regression loss.
    8.         """
    9.         super(MultiboxLoss, self).__init__()
    10.         self.neg_pos_ratio = neg_pos_ratio
    11.         self.center_variance = center_variance
    12.         self.size_variance = size_variance
    13.         self.priors = priors
    14.         self.priors.to(device)
    15.  
    16.     def forward(self, confidence, predicted_locations, labels, gt_locations):
    17.         """Compute classification loss and smooth l1 loss.
    19.         Args:
    20.             confidence (batch_size, num_priors, num_classes): class predictions.
    21.             locations (batch_size, num_priors, 4): predicted locations.
    22.             labels (batch_size, num_priors): real labels of all the priors.
    23.             boxes (batch_size, num_priors, 4): real boxes corresponding all the priors.
    24.         """
    25.         num_classes = confidence.size(2)
    26.         with torch.no_grad():
    27.             # derived from cross_entropy=sum(log(p))
    28.             loss = -F.log_softmax(confidence, dim=2)[:, :, 0]
    29.             mask = box_utils.hard_negative_mining(loss, labels, self.neg_pos_ratio)
    30.  
    31.         confidence = confidence[mask, :]
    32.         # 分类损失函数
    33.         classification_loss = F.cross_entropy(confidence.reshape(-1, num_classes), labels[mask], reduction='sum')
    34.         pos_mask = labels > 0
    35.         predicted_locations = predicted_locations[pos_mask, :].reshape(-1, 4)
    36.         gt_locations = gt_locations[pos_mask, :].reshape(-1, 4)
    37.         # 边界框回归损失函数
    38.         smooth_l1_loss = F.smooth_l1_loss(predicted_locations, gt_locations, reduction='sum')  # smooth_l1_loss
    39.         # smooth_l1_loss = F.mse_loss(predicted_locations, gt_locations, reduction='sum')  #l2 loss
    40.         num_pos = gt_locations.size(0)
    41.         return smooth_l1_loss / num_pos, classification_loss / num_pos

    结果预测

    输入为：

    输出为：

    输入为

    输出为

    模型转换
    由于部署使用的是Tengine边缘推理框架，由于pytorch输出的模型无法直接转换到tmfile模型下，因此还是选择使用onnx中间件的形式进行过度，具体实现代码如下：

    1. model_path = "models/pretrained/version-RFB-320.pth"
    2. net = create_Mb_Tiny_RFB_fd(len(class_names), is_test=True)
    3. net.load(model_path)
    4. net.eval()
    5. net.to("cuda")
    6.  
    7. model_name = model_path.split("/")[-1].split(".")[0]
    8. model_path = f"models/onnx/{model_name}.onnx"
    9.  
    10. dummy_input = torch.randn(1, 3, 240, 320).to("cuda")
    11. # dummy_input = torch.randn(1, 3, 480, 640).to("cuda") #if input size is 640*480
    12. torch.onnx.export(net, dummy_input, model_path, verbose=False, input_names=['input'], output_names=['scores', 'boxes'])

    得到onnx模型后便可以进行Tengine模型的转换和部署。

    参考

    https://github.com/Linzaer/Ultra-Light-Fast-Generic-Face-Detector-1MB

    关于cv2.rectangle()函数

    cv2.rectangle(img, pt1, pt2, color, thickness, lineType, shift )

    参数表示依次为： （图片，长方形框左上角坐标, 长方形框右下角坐标， 字体颜色，字体粗细）

    在图片img上画长方形，坐标原点是图片左上角，向右为x轴正方向，向下为y轴正方向。左上角（x，y），右下角（x，y） ，颜色(B,G,R), 线的粗细如：
    cv2.rectangle(frame, (int(bbox[0]), int(bbox[1])), (int(bbox[2]), int(bbox[3])), color, 2)

    关于裁剪下发给对比侧

    #裁剪
    x, y, w, h = (int(box[0]), int(box[1]))[0], (int(box[0]), int(box[1]))[1], (int(box[2]), int(box[3]))[0] - \
    (int(box[0]), int(box[1]))[0], \
    (int(box[2]), int(box[3]))[1] - \
    (int(box[0]), int(box[1]))[1]
    cropped_image = image[y:y + h, x:x + w]
    # 显示裁剪后的图片
    cv2.imshow('Cropped image', cropped_image)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

    # 如果需要保存裁剪后的图片

    cv2.imwrite('cropped_image.jpg', cropped_image)

  • 相关阅读:
    Java面向对象进阶1——static修饰符
    Elasticsearch8.13.4版本的Docker启动关闭HTTPS
    leetcode1302. 层数最深叶子节点的和
    杂想之一个C++内存泄露案例
    【科普向】5G核心网架构和关键技术
    Leetcode刷题Day5休息 & Day6----------哈希表
    搭建私有组件库
    医院陪诊系统：改善患者体验的技术创新
    JAVA后端开发面试基础知识（二）——JAVA
    Java设计模式-创建者模式-工厂模式
  • 原文地址：https://blog.csdn.net/baidu_37366055/article/details/138211546