学习资源站

YOLOv11改进-主干_Backbone篇-目标检测网络EfficientNetV1均衡缩放网络改进特征提取层（适配yolov11全系列N,S,M,L,X）

一、本文介绍

这次给大家带来的改进机制是 EfficientNetV1主干 ，用其替换我们YOLOv11的 特征提取网络 ，其主要思想是通过均衡地缩放网络的深度、宽度和分辨率，以提高卷积 神经网络 的性能。这种方法采用了一个简单但有效的复合系数，统一调整所有维度。经过我的实验该主干网络确实能够涨点在大中小三种物体检测上， 同时该主干网络提供多种版本 ，大家可以在 源代码 中进行修改版本的使用。 本文通过介绍其主要框架原理，然后教大家如何添加该网络结构到网络模型中。

（本文内容可根据yolov11的N、S、M、L、X进行二次缩放，轻量化更上一层）。

二、EfficientNetV1的框架原理

​

官方论文地址： 官方论文地址点击即可跳转

官方代码地址： 官方代码地址点击即可跳转

​

EfficientNetV1的主要思想是通过均衡地缩放网络的深度、宽度和 分辨率 ，以提高卷积神经网络的性能。这种方法采用了一个简单但有效的复合系数，统一调整所有维度。EfficientNet在多个方面优于现有的ConvNets，特别是在ImageNet数据集上，EfficientNet-B7模型在保持较小的大小和更快的推理速度的同时，达到了84.3%的顶级准确率。此外，EfficientNet还在CIFAR-100和Flowers等其他数据集上展示了出色的 迁移学习 性能，参数数量大大减少。

总结： EfficientNetV1的主要创新为 提出了一种新的模型缩放方法，该方法使用一个复合系数来统一地缩放网络的深度、宽度和分辨率，实现更均衡的网络扩展

​这张图展示了EfficientNet提出的模型缩放方法。图中(a)表示基线网络，而图(b)-(d)表示传统的缩放方法，只增加网络的一个维度：宽度、深度或分辨率。图(e)展示了EfficientNet的创新之处，即复合缩放方法，它使用固定比例同时均匀地缩放网络的所有三个维度。

三、EfficientNetV1的核心代码 

  1. import re
  2. import math
  3. import collections
  4. from functools import partial
  5. import torch
  6. from torch import nn
  7. from torch.nn import functional as F
  8. from torch.utils import model_zoo
  11. # Parameters for the entire model (stem, all blocks, and head)
  12. GlobalParams = collections.namedtuple('GlobalParams', [
  13.     'width_coefficient', 'depth_coefficient', 'image_size', 'dropout_rate',
  14.     'num_classes', 'batch_norm_momentum', 'batch_norm_epsilon',
  15.     'drop_connect_rate', 'depth_divisor', 'min_depth', 'include_top'])
  17. # Parameters for an individual model block
  18. BlockArgs = collections.namedtuple('BlockArgs', [
  19.     'num_repeat', 'kernel_size', 'stride', 'expand_ratio',
  20.     'input_filters', 'output_filters', 'se_ratio', 'id_skip'])
  22. # Set GlobalParams and BlockArgs's defaults
  23. GlobalParams.__new__.__defaults__ = (None,) * len(GlobalParams._fields)
  24. BlockArgs.__new__.__defaults__ = (None,) * len(BlockArgs._fields)
  26. # Swish activation function
  27. if hasattr(nn, 'SiLU'):
  28.     Swish = nn.SiLU
  29. else:
  30.     # For compatibility with old PyTorch versions
  31.     class Swish(nn.Module):
  32.         def forward(self, x):
  33.             return x * torch.sigmoid(x)
  36. # A memory-efficient implementation of Swish function
  37. class SwishImplementation(torch.autograd.Function):
  38.     @staticmethod
  39.     def forward(ctx, i):
  40.         result = i * torch.sigmoid(i)
  41.         ctx.save_for_backward(i)
  42.         return result
  44.     @staticmethod
  45.     def backward(ctx, grad_output):
  46.         i = ctx.saved_tensors[0]
  47.         sigmoid_i = torch.sigmoid(i)
  48.         return grad_output * (sigmoid_i * (1 + i * (1 - sigmoid_i)))
  51. class MemoryEfficientSwish(nn.Module):
  52.     def forward(self, x):
  53.         return SwishImplementation.apply(x)
  56. def round_filters(filters, global_params):
  57.     """Calculate and round number of filters based on width multiplier.
  58.        Use width_coefficient, depth_divisor and min_depth of global_params.
  60.     Args:
  61.         filters (int): Filters number to be calculated.
  62.         global_params (namedtuple): Global params of the model.
  64.     Returns:
  65.         new_filters: New filters number after calculating.
  66.     """
  67.     multiplier = global_params.width_coefficient
  68.     if not multiplier:
  69.         return filters
  70.     # TODO: modify the params names.
  71.     #       maybe the names (width_divisor,min_width)
  72.     #       are more suitable than (depth_divisor,min_depth).
  73.     divisor = global_params.depth_divisor
  74.     min_depth = global_params.min_depth
  75.     filters *= multiplier
  76.     min_depth = min_depth or divisor  # pay attention to this line when using min_depth
  77.     # follow the formula transferred from official TensorFlow implementation
  78.     new_filters = max(min_depth, int(filters + divisor / 2) // divisor * divisor)
  79.     if new_filters < 0.9 * filters:  # prevent rounding by more than 10%
  80.         new_filters += divisor
  81.     return int(new_filters)
  84. def round_repeats(repeats, global_params):
  85.     """Calculate module's repeat number of a block based on depth multiplier.
  86.        Use depth_coefficient of global_params.
  88.     Args:
  89.         repeats (int): num_repeat to be calculated.
  90.         global_params (namedtuple): Global params of the model.
  92.     Returns:
  93.         new repeat: New repeat number after calculating.
  94.     """
  95.     multiplier = global_params.depth_coefficient
  96.     if not multiplier:
  97.         return repeats
  98.     # follow the formula transferred from official TensorFlow implementation
  99.     return int(math.ceil(multiplier * repeats))
  102. def drop_connect(inputs, p, training):
  103.     """Drop connect.
  105.     Args:
  106.         input (tensor: BCWH): Input of this structure.
  107.         p (float: 0.0~1.0): Probability of drop connection.
  108.         training (bool): The running mode.
  110.     Returns:
  111.         output: Output after drop connection.
  112.     """
  113.     assert 0 <= p <= 1, 'p must be in range of [0,1]'
  115.     if not training:
  116.         return inputs
  118.     batch_size = inputs.shape[0]
  119.     keep_prob = 1 - p
  121.     # generate binary_tensor mask according to probability (p for 0, 1-p for 1)
  122.     random_tensor = keep_prob
  123.     random_tensor += torch.rand([batch_size, 1, 1, 1], dtype=inputs.dtype, device=inputs.device)
  124.     binary_tensor = torch.floor(random_tensor)
  126.     output = inputs / keep_prob * binary_tensor
  127.     return output
  130. def get_width_and_height_from_size(x):
  131.     """Obtain height and width from x.
  133.     Args:
  134.         x (int, tuple or list): Data size.
  136.     Returns:
  137.         size: A tuple or list (H,W).
  138.     """
  139.     if isinstance(x, int):
  140.         return x, x
  141.     if isinstance(x, list) or isinstance(x, tuple):
  142.         return x
  143.     else:
  144.         raise TypeError()
  147. def calculate_output_image_size(input_image_size, stride):
  148.     """Calculates the output image size when using Conv2dSamePadding with a stride.
  149.        Necessary for static padding. Thanks to mannatsingh for pointing this out.
  151.     Args:
  152.         input_image_size (int, tuple or list): Size of input image.
  153.         stride (int, tuple or list): Conv2d operation's stride.
  155.     Returns:
  156.         output_image_size: A list [H,W].
  157.     """
  158.     if input_image_size is None:
  159.         return None
  160.     image_height, image_width = get_width_and_height_from_size(input_image_size)
  161.     stride = stride if isinstance(stride, int) else stride[0]
  162.     image_height = int(math.ceil(image_height / stride))
  163.     image_width = int(math.ceil(image_width / stride))
  164.     return [image_height, image_width]
  167. # Note:
  168. # The following 'SamePadding' functions make output size equal ceil(input size/stride).
  169. # Only when stride equals 1, can the output size be the same as input size.
  170. # Don't be confused by their function names ! ! !
  172. def get_same_padding_conv2d(image_size=None):
  173.     """Chooses static padding if you have specified an image size, and dynamic padding otherwise.
  174.        Static padding is necessary for ONNX exporting of models.
  176.     Args:
  177.         image_size (int or tuple): Size of the image.
  179.     Returns:
  180.         Conv2dDynamicSamePadding or Conv2dStaticSamePadding.
  181.     """
  182.     if image_size is None:
  183.         return Conv2dDynamicSamePadding
  184.     else:
  185.         return partial(Conv2dStaticSamePadding, image_size=image_size)
  188. class Conv2dDynamicSamePadding(nn.Conv2d):
  189.     """2D Convolutions like TensorFlow, for a dynamic image size.
  190.        The padding is operated in forward function by calculating dynamically.
  191.     """
  193.     # Tips for 'SAME' mode padding.
  194.     #     Given the following:
  195.     #         i: width or height
  196.     #         s: stride
  197.     #         k: kernel size
  198.     #         d: dilation
  199.     #         p: padding
  200.     #     Output after Conv2d:
  201.     #         o = floor((i+p-((k-1)*d+1))/s+1)
  202.     # If o equals i, i = floor((i+p-((k-1)*d+1))/s+1),
  203.     # => p = (i-1)*s+((k-1)*d+1)-i
  205.     def __init__(self, in_channels, out_channels, kernel_size, stride=1, dilation=1, groups=1, bias=True):
  206.         super().__init__(in_channels, out_channels, kernel_size, stride, 0, dilation, groups, bias)
  207.         self.stride = self.stride if len(self.stride) == 2 else [self.stride[0]] * 2
  209.     def forward(self, x):
  210.         ih, iw = x.size()[-2:]
  211.         kh, kw = self.weight.size()[-2:]
  212.         sh, sw = self.stride
  213.         oh, ow = math.ceil(ih / sh), math.ceil(iw / sw)  # change the output size according to stride ! ! !
  214.         pad_h = max((oh - 1) * self.stride[0] + (kh - 1) * self.dilation[0] + 1 - ih, 0)
  215.         pad_w = max((ow - 1) * self.stride[1] + (kw - 1) * self.dilation[1] + 1 - iw, 0)
  216.         if pad_h > 0 or pad_w > 0:
  217.             x = F.pad(x, [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2])
  218.         return F.conv2d(x, self.weight, self.bias, self.stride, self.padding, self.dilation, self.groups)
  221. class Conv2dStaticSamePadding(nn.Conv2d):
  222.     """2D Convolutions like TensorFlow's 'SAME' mode, with the given input image size.
  223.        The padding mudule is calculated in construction function, then used in forward.
  224.     """
  226.     # With the same calculation as Conv2dDynamicSamePadding
  228.     def __init__(self, in_channels, out_channels, kernel_size, stride=1, image_size=None, **kwargs):
  229.         super().__init__(in_channels, out_channels, kernel_size, stride, **kwargs)
  230.         self.stride = self.stride if len(self.stride) == 2 else [self.stride[0]] * 2
  232.         # Calculate padding based on image size and save it
  233.         assert image_size is not None
  234.         ih, iw = (image_size, image_size) if isinstance(image_size, int) else image_size
  235.         kh, kw = self.weight.size()[-2:]
  236.         sh, sw = self.stride
  237.         oh, ow = math.ceil(ih / sh), math.ceil(iw / sw)
  238.         pad_h = max((oh - 1) * self.stride[0] + (kh - 1) * self.dilation[0] + 1 - ih, 0)
  239.         pad_w = max((ow - 1) * self.stride[1] + (kw - 1) * self.dilation[1] + 1 - iw, 0)
  240.         if pad_h > 0 or pad_w > 0:
  241.             self.static_padding = nn.ZeroPad2d((pad_w // 2, pad_w - pad_w // 2,
  242.                                                 pad_h // 2, pad_h - pad_h // 2))
  243.         else:
  244.             self.static_padding = nn.Identity()
  246.     def forward(self, x):
  247.         x = self.static_padding(x)
  248.         x = F.conv2d(x, self.weight, self.bias, self.stride, self.padding, self.dilation, self.groups)
  249.         return x
  252. def get_same_padding_maxPool2d(image_size=None):
  253.     """Chooses static padding if you have specified an image size, and dynamic padding otherwise.
  254.        Static padding is necessary for ONNX exporting of models.
  256.     Args:
  257.         image_size (int or tuple): Size of the image.
  259.     Returns:
  260.         MaxPool2dDynamicSamePadding or MaxPool2dStaticSamePadding.
  261.     """
  262.     if image_size is None:
  263.         return MaxPool2dDynamicSamePadding
  264.     else:
  265.         return partial(MaxPool2dStaticSamePadding, image_size=image_size)
  268. class MaxPool2dDynamicSamePadding(nn.MaxPool2d):
  269.     """2D MaxPooling like TensorFlow's 'SAME' mode, with a dynamic image size.
  270.        The padding is operated in forward function by calculating dynamically.
  271.     """
  273.     def __init__(self, kernel_size, stride, padding=0, dilation=1, return_indices=False, ceil_mode=False):
  274.         super().__init__(kernel_size, stride, padding, dilation, return_indices, ceil_mode)
  275.         self.stride = [self.stride] * 2 if isinstance(self.stride, int) else self.stride
  276.         self.kernel_size = [self.kernel_size] * 2 if isinstance(self.kernel_size, int) else self.kernel_size
  277.         self.dilation = [self.dilation] * 2 if isinstance(self.dilation, int) else self.dilation
  279.     def forward(self, x):
  280.         ih, iw = x.size()[-2:]
  281.         kh, kw = self.kernel_size
  282.         sh, sw = self.stride
  283.         oh, ow = math.ceil(ih / sh), math.ceil(iw / sw)
  284.         pad_h = max((oh - 1) * self.stride[0] + (kh - 1) * self.dilation[0] + 1 - ih, 0)
  285.         pad_w = max((ow - 1) * self.stride[1] + (kw - 1) * self.dilation[1] + 1 - iw, 0)
  286.         if pad_h > 0 or pad_w > 0:
  287.             x = F.pad(x, [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2])
  288.         return F.max_pool2d(x, self.kernel_size, self.stride, self.padding,
  289.                             self.dilation, self.ceil_mode, self.return_indices)
  292. class MaxPool2dStaticSamePadding(nn.MaxPool2d):
  293.     """2D MaxPooling like TensorFlow's 'SAME' mode, with the given input image size.
  294.        The padding mudule is calculated in construction function, then used in forward.
  295.     """
  297.     def __init__(self, kernel_size, stride, image_size=None, **kwargs):
  298.         super().__init__(kernel_size, stride, **kwargs)
  299.         self.stride = [self.stride] * 2 if isinstance(self.stride, int) else self.stride
  300.         self.kernel_size = [self.kernel_size] * 2 if isinstance(self.kernel_size, int) else self.kernel_size
  301.         self.dilation = [self.dilation] * 2 if isinstance(self.dilation, int) else self.dilation
  303.         # Calculate padding based on image size and save it
  304.         assert image_size is not None
  305.         ih, iw = (image_size, image_size) if isinstance(image_size, int) else image_size
  306.         kh, kw = self.kernel_size
  307.         sh, sw = self.stride
  308.         oh, ow = math.ceil(ih / sh), math.ceil(iw / sw)
  309.         pad_h = max((oh - 1) * self.stride[0] + (kh - 1) * self.dilation[0] + 1 - ih, 0)
  310.         pad_w = max((ow - 1) * self.stride[1] + (kw - 1) * self.dilation[1] + 1 - iw, 0)
  311.         if pad_h > 0 or pad_w > 0:
  312.             self.static_padding = nn.ZeroPad2d((pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2))
  313.         else:
  314.             self.static_padding = nn.Identity()
  316.     def forward(self, x):
  317.         x = self.static_padding(x)
  318.         x = F.max_pool2d(x, self.kernel_size, self.stride, self.padding,
  319.                          self.dilation, self.ceil_mode, self.return_indices)
  320.         return x
  323. ################################################################################
  324. # Helper functions for loading model params
  325. ################################################################################
  327. # BlockDecoder: A Class for encoding and decoding BlockArgs
  328. # efficientnet_params: A function to query compound coefficient
  329. # get_model_params and efficientnet:
  330. #     Functions to get BlockArgs and GlobalParams for efficientnet
  331. # url_map and url_map_advprop: Dicts of url_map for pretrained weights
  332. # load_pretrained_weights: A function to load pretrained weights
  334. class BlockDecoder(object):
  335.     """Block Decoder for readability,
  336.        straight from the official TensorFlow repository.
  337.     """
  339.     @staticmethod
  340.     def _decode_block_string(block_string):
  341.         """Get a block through a string notation of arguments.
  343.         Args:
  344.             block_string (str): A string notation of arguments.
  345.                                 Examples: 'r1_k3_s11_e1_i32_o16_se0.25_noskip'.
  347.         Returns:
  348.             BlockArgs: The namedtuple defined at the top of this file.
  349.         """
  350.         assert isinstance(block_string, str)
  352.         ops = block_string.split('_')
  353.         options = {}
  354.         for op in ops:
  355.             splits = re.split(r'(\d.*)', op)
  356.             if len(splits) >= 2:
  357.                 key, value = splits[:2]
  358.                 options[key] = value
  360.         # Check stride
  361.         assert (('s' in options and len(options['s']) == 1) or
  362.                 (len(options['s']) == 2 and options['s'][0] == options['s'][1]))
  364.         return BlockArgs(
  365.             num_repeat=int(options['r']),
  366.             kernel_size=int(options['k']),
  367.             stride=[int(options['s'][0])],
  368.             expand_ratio=int(options['e']),
  369.             input_filters=int(options['i']),
  370.             output_filters=int(options['o']),
  371.             se_ratio=float(options['se']) if 'se' in options else None,
  372.             id_skip=('noskip' not in block_string))
  374.     @staticmethod
  375.     def _encode_block_string(block):
  376.         """Encode a block to a string.
  378.         Args:
  379.             block (namedtuple): A BlockArgs type argument.
  381.         Returns:
  382.             block_string: A String form of BlockArgs.
  383.         """
  384.         args = [
  385.             'r%d' % block.num_repeat,
  386.             'k%d' % block.kernel_size,
  387.             's%d%d' % (block.strides[0], block.strides[1]),
  388.             'e%s' % block.expand_ratio,
  389.             'i%d' % block.input_filters,
  390.             'o%d' % block.output_filters
  391.         ]
  392.         if 0 < block.se_ratio <= 1:
  393.             args.append('se%s' % block.se_ratio)
  394.         if block.id_skip is False:
  395.             args.append('noskip')
  396.         return '_'.join(args)
  398.     @staticmethod
  399.     def decode(string_list):
  400.         """Decode a list of string notations to specify blocks inside the network.
  402.         Args:
  403.             string_list (list[str]): A list of strings, each string is a notation of block.
  405.         Returns:
  406.             blocks_args: A list of BlockArgs namedtuples of block args.
  407.         """
  408.         assert isinstance(string_list, list)
  409.         blocks_args = []
  410.         for block_string in string_list:
  411.             blocks_args.append(BlockDecoder._decode_block_string(block_string))
  412.         return blocks_args
  414.     @staticmethod
  415.     def encode(blocks_args):
  416.         """Encode a list of BlockArgs to a list of strings.
  418.         Args:
  419.             blocks_args (list[namedtuples]): A list of BlockArgs namedtuples of block args.
  421.         Returns:
  422.             block_strings: A list of strings, each string is a notation of block.
  423.         """
  424.         block_strings = []
  425.         for block in blocks_args:
  426.             block_strings.append(BlockDecoder._encode_block_string(block))
  427.         return block_strings
  430. def efficientnet_params(model_name):
  431.     """Map EfficientNet model name to parameter coefficients.
  433.     Args:
  434.         model_name (str): Model name to be queried.
  436.     Returns:
  437.         params_dict[model_name]: A (width,depth,res,dropout) tuple.
  438.     """
  439.     params_dict = {
  440.         # Coefficients:   width,depth,res,dropout
  441.         'efficientnet-b0': (1.0, 1.0, 224, 0.2),
  442.         'efficientnet-b1': (1.0, 1.1, 240, 0.2),
  443.         'efficientnet-b2': (1.1, 1.2, 260, 0.3),
  444.         'efficientnet-b3': (1.2, 1.4, 300, 0.3),
  445.         'efficientnet-b4': (1.4, 1.8, 380, 0.4),
  446.         'efficientnet-b5': (1.6, 2.2, 456, 0.4),
  447.         'efficientnet-b6': (1.8, 2.6, 528, 0.5),
  448.         'efficientnet-b7': (2.0, 3.1, 600, 0.5),
  449.         'efficientnet-b8': (2.2, 3.6, 672, 0.5),
  450.         'efficientnet-l2': (4.3, 5.3, 800, 0.5),
  451.     }
  452.     return params_dict[model_name]
  455. def efficientnet(width_coefficient=None, depth_coefficient=None, image_size=None,
  456.                  dropout_rate=0.2, drop_connect_rate=0.2, num_classes=1000, include_top=True):
  457.     """Create BlockArgs and GlobalParams for efficientnet model.
  459.     Args:
  460.         width_coefficient (float)
  461.         depth_coefficient (float)
  462.         image_size (int)
  463.         dropout_rate (float)
  464.         drop_connect_rate (float)
  465.         num_classes (int)
  467.         Meaning as the name suggests.
  469.     Returns:
  470.         blocks_args, global_params.
  471.     """
  473.     # Blocks args for the whole model(efficientnet-b0 by default)
  474.     # It will be modified in the construction of EfficientNet Class according to model
  475.     blocks_args = [
  476.         'r1_k3_s11_e1_i32_o16_se0.25',
  477.         'r2_k3_s22_e6_i16_o24_se0.25',
  478.         'r2_k5_s22_e6_i24_o40_se0.25',
  479.         'r3_k3_s22_e6_i40_o80_se0.25',
  480.         'r3_k5_s11_e6_i80_o112_se0.25',
  481.         'r4_k5_s22_e6_i112_o192_se0.25',
  482.         'r1_k3_s11_e6_i192_o320_se0.25',
  483.     ]
  484.     blocks_args = BlockDecoder.decode(blocks_args)
  486.     global_params = GlobalParams(
  487.         width_coefficient=width_coefficient,
  488.         depth_coefficient=depth_coefficient,
  489.         image_size=image_size,
  490.         dropout_rate=dropout_rate,
  492.         num_classes=num_classes,
  493.         batch_norm_momentum=0.99,
  494.         batch_norm_epsilon=1e-3,
  495.         drop_connect_rate=drop_connect_rate,
  496.         depth_divisor=8,
  497.         min_depth=None,
  498.         include_top=include_top,
  499.     )
  501.     return blocks_args, global_params
  504. def get_model_params(model_name, override_params):
  505.     """Get the block args and global params for a given model name.
  507.     Args:
  508.         model_name (str): Model's name.
  509.         override_params (dict): A dict to modify global_params.
  511.     Returns:
  512.         blocks_args, global_params
  513.     """
  514.     if model_name.startswith('efficientnet'):
  515.         w, d, s, p = efficientnet_params(model_name)
  516.         # note: all models have drop connect rate = 0.2
  517.         blocks_args, global_params = efficientnet(
  518.             width_coefficient=w, depth_coefficient=d, dropout_rate=p, image_size=s)
  519.     else:
  520.         raise NotImplementedError('model name is not pre-defined: {}'.format(model_name))
  521.     if override_params:
  522.         # ValueError will be raised here if override_params has fields not included in global_params.
  523.         global_params = global_params._replace(**override_params)
  524.     return blocks_args, global_params
  527. # train with Standard methods
  528. # check more details in paper(EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks)
  529. url_map = {
  530.     'efficientnet-b0': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/efficientnet-b0-355c32eb.pth',
  531.     'efficientnet-b1': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/efficientnet-b1-f1951068.pth',
  532.     'efficientnet-b2': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/efficientnet-b2-8bb594d6.pth',
  533.     'efficientnet-b3': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/efficientnet-b3-5fb5a3c3.pth',
  534.     'efficientnet-b4': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/efficientnet-b4-6ed6700e.pth',
  535.     'efficientnet-b5': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/efficientnet-b5-b6417697.pth',
  536.     'efficientnet-b6': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/efficientnet-b6-c76e70fd.pth',
  537.     'efficientnet-b7': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/efficientnet-b7-dcc49843.pth',
  538. }
  540. # train with Adversarial Examples(AdvProp)
  541. # check more details in paper(Adversarial Examples Improve Image Recognition)
  542. url_map_advprop = {
  543.     'efficientnet-b0': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/adv-efficientnet-b0-b64d5a18.pth',
  544.     'efficientnet-b1': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/adv-efficientnet-b1-0f3ce85a.pth',
  545.     'efficientnet-b2': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/adv-efficientnet-b2-6e9d97e5.pth',
  546.     'efficientnet-b3': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/adv-efficientnet-b3-cdd7c0f4.pth',
  547.     'efficientnet-b4': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/adv-efficientnet-b4-44fb3a87.pth',
  548.     'efficientnet-b5': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/adv-efficientnet-b5-86493f6b.pth',
  549.     'efficientnet-b6': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/adv-efficientnet-b6-ac80338e.pth',
  550.     'efficientnet-b7': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/adv-efficientnet-b7-4652b6dd.pth',
  551.     'efficientnet-b8': 'https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/adv-efficientnet-b8-22a8fe65.pth',
  552. }
  554. # TODO: add the petrained weights url map of 'efficientnet-l2'
  557. def load_pretrained_weights(model, model_name, weights_path=None, load_fc=True, advprop=False, verbose=True):
  558.     """Loads pretrained weights from weights path or download using url.
  560.     Args:
  561.         model (Module): The whole model of efficientnet.
  562.         model_name (str): Model name of efficientnet.
  563.         weights_path (None or str):
  564.             str: path to pretrained weights file on the local disk.
  565.             None: use pretrained weights downloaded from the Internet.
  566.         load_fc (bool): Whether to load pretrained weights for fc layer at the end of the model.
  567.         advprop (bool): Whether to load pretrained weights
  568.                         trained with advprop (valid when weights_path is None).
  569.     """
  570.     if isinstance(weights_path, str):
  571.         state_dict = torch.load(weights_path)
  572.     else:
  573.         # AutoAugment or Advprop (different preprocessing)
  574.         url_map_ = url_map_advprop if advprop else url_map
  575.         state_dict = model_zoo.load_url(url_map_[model_name])
  577.     if load_fc:
  578.         ret = model.load_state_dict(state_dict, strict=False)
  579.         assert not ret.missing_keys, 'Missing keys when loading pretrained weights: {}'.format(ret.missing_keys)
  580.     else:
  581.         state_dict.pop('_fc.weight')
  582.         state_dict.pop('_fc.bias')
  583.         ret = model.load_state_dict(state_dict, strict=False)
  584.         assert set(ret.missing_keys) == set(
  585.             ['_fc.weight', '_fc.bias']), 'Missing keys when loading pretrained weights: {}'.format(ret.missing_keys)
  586.     assert not ret.unexpected_keys, 'Missing keys when loading pretrained weights: {}'.format(ret.unexpected_keys)
  588.     if verbose:
  589.         print('Loaded pretrained weights for {}'.format(model_name))
  592. VALID_MODELS = (
  593.     'efficientnet-b0', 'efficientnet-b1', 'efficientnet-b2', 'efficientnet-b3',
  594.     'efficientnet-b4', 'efficientnet-b5', 'efficientnet-b6', 'efficientnet-b7',
  595.     'efficientnet-b8',
  597.     # Support the construction of 'efficientnet-l2' without pretrained weights
  598.     'efficientnet-l2'
  599. )
  602. class MBConvBlock(nn.Module):
  603.     """Mobile Inverted Residual Bottleneck Block.
  605.     Args:
  606.         block_args (namedtuple): BlockArgs, defined in utils.py.
  607.         global_params (namedtuple): GlobalParam, defined in utils.py.
  608.         image_size (tuple or list): [image_height, image_width].
  610.     References:
  611.         [1] https://arxiv.org/abs/1704.04861 (MobileNet v1)
  612.         [2] https://arxiv.org/abs/1801.04381 (MobileNet v2)
  613.         [3] https://arxiv.org/abs/1905.02244 (MobileNet v3)
  614.     """
  616.     def __init__(self, block_args, global_params, image_size=None):
  617.         super().__init__()
  618.         self._block_args = block_args
  619.         self._bn_mom = 1 - global_params.batch_norm_momentum  # pytorch's difference from tensorflow
  620.         self._bn_eps = global_params.batch_norm_epsilon
  621.         self.has_se = (self._block_args.se_ratio is not None) and (0 < self._block_args.se_ratio <= 1)
  622.         self.id_skip = block_args.id_skip  # whether to use skip connection and drop connect
  624.         # Expansion phase (Inverted Bottleneck)
  625.         inp = self._block_args.input_filters  # number of input channels
  626.         oup = self._block_args.input_filters * self._block_args.expand_ratio  # number of output channels
  627.         if self._block_args.expand_ratio != 1:
  628.             Conv2d = get_same_padding_conv2d(image_size=image_size)
  629.             self._expand_conv = Conv2d(in_channels=inp, out_channels=oup, kernel_size=1, bias=False)
  630.             self._bn0 = nn.BatchNorm2d(num_features=oup, momentum=self._bn_mom, eps=self._bn_eps)
  631.             # image_size = calculate_output_image_size(image_size, 1) <-- this wouldn't modify image_size
  633.         # Depthwise convolution phase
  634.         k = self._block_args.kernel_size
  635.         s = self._block_args.stride
  636.         Conv2d = get_same_padding_conv2d(image_size=image_size)
  637.         self._depthwise_conv = Conv2d(
  638.             in_channels=oup, out_channels=oup, groups=oup,  # groups makes it depthwise
  639.             kernel_size=k, stride=s, bias=False)
  640.         self._bn1 = nn.BatchNorm2d(num_features=oup, momentum=self._bn_mom, eps=self._bn_eps)
  641.         image_size = calculate_output_image_size(image_size, s)
  643.         # Squeeze and Excitation layer, if desired
  644.         if self.has_se:
  645.             Conv2d = get_same_padding_conv2d(image_size=(1, 1))
  646.             num_squeezed_channels = max(1, int(self._block_args.input_filters * self._block_args.se_ratio))
  647.             self._se_reduce = Conv2d(in_channels=oup, out_channels=num_squeezed_channels, kernel_size=1)
  648.             self._se_expand = Conv2d(in_channels=num_squeezed_channels, out_channels=oup, kernel_size=1)
  650.         # Pointwise convolution phase
  651.         final_oup = self._block_args.output_filters
  652.         Conv2d = get_same_padding_conv2d(image_size=image_size)
  653.         self._project_conv = Conv2d(in_channels=oup, out_channels=final_oup, kernel_size=1, bias=False)
  654.         self._bn2 = nn.BatchNorm2d(num_features=final_oup, momentum=self._bn_mom, eps=self._bn_eps)
  655.         self._swish = MemoryEfficientSwish()
  657.     def forward(self, inputs, drop_connect_rate=None):
  658.         """MBConvBlock's forward function.
  660.         Args:
  661.             inputs (tensor): Input tensor.
  662.             drop_connect_rate (bool): Drop connect rate (float, between 0 and 1).
  664.         Returns:
  665.             Output of this block after processing.
  666.         """
  668.         # Expansion and Depthwise Convolution
  669.         x = inputs
  670.         if self._block_args.expand_ratio != 1:
  671.             x = self._expand_conv(inputs)
  672.             x = self._bn0(x)
  673.             x = self._swish(x)
  675.         x = self._depthwise_conv(x)
  676.         x = self._bn1(x)
  677.         x = self._swish(x)
  679.         # Squeeze and Excitation
  680.         if self.has_se:
  681.             x_squeezed = F.adaptive_avg_pool2d(x, 1)
  682.             x_squeezed = self._se_reduce(x_squeezed)
  683.             x_squeezed = self._swish(x_squeezed)
  684.             x_squeezed = self._se_expand(x_squeezed)
  685.             x = torch.sigmoid(x_squeezed) * x
  687.         # Pointwise Convolution
  688.         x = self._project_conv(x)
  689.         x = self._bn2(x)
  691.         # Skip connection and drop connect
  692.         input_filters, output_filters = self._block_args.input_filters, self._block_args.output_filters
  693.         if self.id_skip and self._block_args.stride == 1 and input_filters == output_filters:
  694.             # The combination of skip connection and drop connect brings about stochastic depth.
  695.             if drop_connect_rate:
  696.                 x = drop_connect(x, p=drop_connect_rate, training=self.training)
  697.             x = x + inputs  # skip connection
  698.         return x
  700.     def set_swish(self, memory_efficient=True):
  701.         """Sets swish function as memory efficient (for training) or standard (for export).
  703.         Args:
  704.             memory_efficient (bool): Whether to use memory-efficient version of swish.
  705.         """
  706.         self._swish = MemoryEfficientSwish() if memory_efficient else Swish()
  709. class EfficientNet(nn.Module):
  712.     def __init__(self,blocks_args=None, global_params=None, factor=0.5, depth_factor=0.5):
  713.         super().__init__()
  714.         assert isinstance(blocks_args, list), 'blocks_args should be a list'
  715.         assert len(blocks_args) > 0, 'block args must be greater than 0'
  716.         new_blocks_args = []
  717.         for block in blocks_args:
  718.             new_block = BlockArgs(
  719.                 num_repeat=max(1, int(block.num_repeat * depth_factor)),
  720.                 kernel_size=block.kernel_size,
  721.                 stride=block.stride,
  722.                 expand_ratio=block.expand_ratio,
  723.                 input_filters=int(block.input_filters * factor),
  724.                 output_filters=int(block.output_filters * factor),
  725.                 se_ratio=block.se_ratio,
  726.                 id_skip=block.id_skip
  727.             )
  728.             new_blocks_args.append(new_block)
  729.         channel = int(32 * factor)
  730.         # 将新的列表替换掉原来的 blocks_args
  731.         blocks_args = new_blocks_args
  732.         self._global_params = global_params
  733.         self._blocks_args = blocks_args
  735.         # Batch norm parameters
  736.         bn_mom = 1 - self._global_params.batch_norm_momentum
  737.         bn_eps = self._global_params.batch_norm_epsilon
  739.         # Get stem static or dynamic convolution depending on image size
  740.         image_size = global_params.image_size
  741.         Conv2d = get_same_padding_conv2d(image_size=image_size)
  743.         # Stem
  744.         in_channels = 3  # rgb
  745.         out_channels = round_filters(channel, self._global_params)  # number of output channels
  746.         self._conv_stem = Conv2d(in_channels, out_channels, kernel_size=3, stride=2, bias=False)
  747.         self._bn0 = nn.BatchNorm2d(num_features=out_channels, momentum=bn_mom, eps=bn_eps)
  748.         image_size = calculate_output_image_size(image_size, 2)
  750.         # Build blocks
  751.         self._blocks = nn.ModuleList([])
  752.         for block_args in self._blocks_args:
  754.             # Update block input and output filters based on depth multiplier.
  755.             block_args = block_args._replace(
  756.                 input_filters=round_filters(block_args.input_filters, self._global_params),
  757.                 output_filters=round_filters(block_args.output_filters, self._global_params),
  758.                 num_repeat=round_repeats(block_args.num_repeat, self._global_params)
  759.             )
  761.             # The first block needs to take care of stride and filter size increase.
  762.             self._blocks.append(MBConvBlock(block_args, self._global_params, image_size=image_size))
  763.             image_size = calculate_output_image_size(image_size, block_args.stride)
  764.             if block_args.num_repeat > 1:  # modify block_args to keep same output size
  765.                 block_args = block_args._replace(input_filters=block_args.output_filters, stride=1)
  766.             for _ in range(block_args.num_repeat - 1):
  767.                 self._blocks.append(MBConvBlock(block_args, self._global_params, image_size=image_size))
  768.                 # image_size = calculate_output_image_size(image_size, block_args.stride)  # stride = 1
  770.         # Head
  771.         in_channels = block_args.output_filters  # output of final block
  772.         out_channels = round_filters(1280, self._global_params)
  773.         Conv2d = get_same_padding_conv2d(image_size=image_size)
  774.         self._conv_head = Conv2d(in_channels, out_channels, kernel_size=1, bias=False)
  775.         self._bn1 = nn.BatchNorm2d(num_features=out_channels, momentum=bn_mom, eps=bn_eps)
  777.         # Final linear layer
  778.         self._avg_pooling = nn.AdaptiveAvgPool2d(1)
  779.         if self._global_params.include_top:
  780.             self._dropout = nn.Dropout(self._global_params.dropout_rate)
  781.             self._fc = nn.Linear(out_channels, self._global_params.num_classes)
  783.         # set activation to memory efficient swish by default
  784.         self._swish = MemoryEfficientSwish()
  785.         self.width_list = [i.size(1) for i in self.forward(torch.randn(1, 3, 640, 640))]
  786.     def set_swish(self, memory_efficient=True):
  787.         """Sets swish function as memory efficient (for training) or standard (for export).
  788.         Args:
  789.             memory_efficient (bool): Whether to use memory-efficient version of swish.
  790.         """
  791.         self._swish = MemoryEfficientSwish() if memory_efficient else Swish()
  792.         for block in self._blocks:
  793.             block.set_swish(memory_efficient)
  795.     def extract_endpoints(self, inputs):
  796.         # """Use convolution layer to extract features
  797.         # from reduction levels i in [1, 2, 3, 4, 5].
  798.         #
  799.         # Args:
  800.         #     inputs (tensor): Input tensor.
  801.         #
  802.         # Returns:
  803.         #     Dictionary of last intermediate features
  804.         #     with reduction levels i in [1, 2, 3, 4, 5].
  805.         #     Example:
  806.         #         >>> import torch
  807.         #         >>> from efficientnet.model import EfficientNet
  808.         #         >>> inputs = torch.rand(1, 3, 224, 224)
  809.         #         >>> model = EfficientNet.from_pretrained('efficientnet-b0')
  810.         #         >>> endpoints = model.extract_endpoints(inputs)
  811.         #         >>> print(endpoints['reduction_1'].shape)  # torch.Size([1, 16, 112, 112])
  812.         #         >>> print(endpoints['reduction_2'].shape)  # torch.Size([1, 24, 56, 56])
  813.         #         >>> print(endpoints['reduction_3'].shape)  # torch.Size([1, 40, 28, 28])
  814.         #         >>> print(endpoints['reduction_4'].shape)  # torch.Size([1, 112, 14, 14])
  815.         #         >>> print(endpoints['reduction_5'].shape)  # torch.Size([1, 320, 7, 7])
  816.         #         >>> print(endpoints['reduction_6'].shape)  # torch.Size([1, 1280, 7, 7])
  817.         # """
  818.         endpoints = dict()
  820.         # Stem
  821.         x = self._swish(self._bn0(self._conv_stem(inputs)))
  822.         prev_x = x
  824.         # Blocks
  825.         for idx, block in enumerate(self._blocks):
  826.             drop_connect_rate = self._global_params.drop_connect_rate
  827.             if drop_connect_rate:
  828.                 drop_connect_rate *= float(idx) / len(self._blocks)  # scale drop connect_rate
  829.             x = block(x, drop_connect_rate=drop_connect_rate)
  830.             if prev_x.size(2) > x.size(2):
  831.                 endpoints['reduction_{}'.format(len(endpoints) + 1)] = prev_x
  832.             elif idx == len(self._blocks) - 1:
  833.                 endpoints['reduction_{}'.format(len(endpoints) + 1)] = x
  834.             prev_x = x
  836.         # Head
  837.         x = self._swish(self._bn1(self._conv_head(x)))
  838.         endpoints['reduction_{}'.format(len(endpoints) + 1)] = x
  840.         return endpoints
  842.     def forward(self, inputs):
  843.         """use convolution layer to extract feature .
  845.         Args:
  846.             inputs (tensor): Input tensor.
  848.         Returns:
  849.             Output of the final convolution
  850.             layer in the efficientnet model.
  851.         """
  852.         # Stem
  853.         x = self._swish(self._bn0(self._conv_stem(inputs)))
  854.         unique_tensors = {}
  855.         # Blocks
  856.         for idx, block in enumerate(self._blocks):
  857.             drop_connect_rate = self._global_params.drop_connect_rate
  858.             if drop_connect_rate:
  859.                 drop_connect_rate *= float(idx) / len(self._blocks)  # scale drop connect_rate
  860.             x = block(x, drop_connect_rate=drop_connect_rate)
  861.             width, height = x.shape[2], x.shape[3]
  862.             unique_tensors[(width, height)] = x
  863.         result_list = list(unique_tensors.values())[-4:]
  864.         # Head
  865.         return result_list
  867.     @classmethod
  868.     def from_name(cls, model_name, in_channels=3, **override_params):
  869.         """Create an efficientnet model according to name.
  871.         Args:
  872.             model_name (str): Name for efficientnet.
  873.             in_channels (int): Input data's channel number.
  874.             override_params (other key word params):
  875.                 Params to override model's global_params.
  876.                 Optional key:
  877.                     'width_coefficient', 'depth_coefficient',
  878.                     'image_size', 'dropout_rate',
  879.                     'num_classes', 'batch_norm_momentum',
  880.                     'batch_norm_epsilon', 'drop_connect_rate',
  881.                     'depth_divisor', 'min_depth'
  883.         Returns:
  884.             An efficientnet model.
  885.         """
  886.         cls._check_model_name_is_valid(model_name)
  887.         blocks_args, global_params = get_model_params(model_name, override_params)
  888.         model = cls(blocks_args, global_params)
  889.         model._change_in_channels(in_channels)
  890.         return model
  892.     @classmethod
  893.     def from_pretrained(cls, model_name, weights_path=None, advprop=False,
  894.                         in_channels=3, num_classes=1000, **override_params):
  895.         """Create an efficientnet model according to name.
  897.         Args:
  898.             model_name (str): Name for efficientnet.
  899.             weights_path (None or str):
  900.                 str: path to pretrained weights file on the local disk.
  901.                 None: use pretrained weights downloaded from the Internet.
  902.             advprop (bool):
  903.                 Whether to load pretrained weights
  904.                 trained with advprop (valid when weights_path is None).
  905.             in_channels (int): Input data's channel number.
  906.             num_classes (int):
  907.                 Number of categories for classification.
  908.                 It controls the output size for final linear layer.
  909.             override_params (other key word params):
  910.                 Params to override model's global_params.
  911.                 Optional key:
  912.                     'width_coefficient', 'depth_coefficient',
  913.                     'image_size', 'dropout_rate',
  914.                     'batch_norm_momentum',
  915.                     'batch_norm_epsilon', 'drop_connect_rate',
  916.                     'depth_divisor', 'min_depth'
  918.         Returns:
  919.             A pretrained efficientnet model.
  920.         """
  921.         model = cls.from_name(model_name, num_classes=num_classes, **override_params)
  922.         load_pretrained_weights(model, model_name, weights_path=weights_path,
  923.                                 load_fc=(num_classes == 1000), advprop=advprop)
  924.         model._change_in_channels(in_channels)
  925.         return model
  927.     @classmethod
  928.     def get_image_size(cls, model_name):
  929.         """Get the input image size for a given efficientnet model.
  931.         Args:
  932.             model_name (str): Name for efficientnet.
  934.         Returns:
  935.             Input image size (resolution).
  936.         """
  937.         cls._check_model_name_is_valid(model_name)
  938.         _, _, res, _ = efficientnet_params(model_name)
  939.         return res
  941.     @classmethod
  942.     def _check_model_name_is_valid(cls, model_name):
  943.         """Validates model name.
  945.         Args:
  946.             model_name (str): Name for efficientnet.
  948.         Returns:
  949.             bool: Is a valid name or not.
  950.         """
  951.         if model_name not in VALID_MODELS:
  952.             raise ValueError('model_name should be one of: ' + ', '.join(VALID_MODELS))
  954.     def _change_in_channels(self, in_channels):
  955.         """Adjust model's first convolution layer to in_channels, if in_channels not equals 3.
  957.         Args:
  958.             in_channels (int): Input data's channel number.
  959.         """
  960.         if in_channels != 3:
  961.             Conv2d = get_same_padding_conv2d(image_size=self._global_params.image_size)
  962.             out_channels = round_filters(32, self._global_params)
  963.             self._conv_stem = Conv2d(in_channels, out_channels, kernel_size=3, stride=2, bias=False)
  966. def efficient(model_name='efficientnet-b0', factor=0.25, depth_factor=0.5, pretrained=False):
  967.     if pretrained:
  968.         model = EfficientNet.from_pretrained('{}'.format(model_name, factor=factor, depth_factor=depth_factor))
  969.     else:
  970.         model = EfficientNet.from_name('{}'.format(model_name, factor=factor, depth_factor=depth_factor))
  971.     return model
  973. if __name__ == "__main__":
  976.     # VALID_MODELS = (
  977.     #     'efficientnet-b0', 'efficientnet-b1', 'efficientnet-b2', 'efficientnet-b3',
  978.     #     'efficientnet-b4', 'efficientnet-b5', 'efficientnet-b6', 'efficientnet-b7',
  979.     #     'efficientnet-b8',
  980.     #     # Support the construction of 'efficientnet-l2' without pretrained weights
  981.     #     'efficientnet-l2'
  982.     # )
  984.     # Generating Sample image
  985.     image_size = (1, 3, 640, 640)
  986.     image = torch.rand(*image_size)
  988.     # Model
  989.     model = efficient('efficientnet-b0', factor=0.25, depth_factor=0.5)
  991.     out = model(image)
  992.     print(len(out))

四、手把手教你添加EfficientNetV1机制

4.1 修改一

第一步还是建立文件，我们找到如下ultralytics/nn文件夹下建立一个目录名字呢就是'Addmodules'文件夹( 用群内的文件的话已经有了无需新建) ！然后在其内部建立一个新的py文件将核心代码复制粘贴进去即可

4.2 修改二

第二步我们在该目录下创建一个新的py文件名字为'__init__.py'( 用群内的文件的话已经有了无需新建) ，然后在其内部导入我们的检测头如下图所示。

4.3 修改三

第三步我门中到如下文件'ultralytics/nn/tasks.py'进行导入和注册我们的模块( 用群内的文件的话已经有了无需重新导入直接开始第四步即可) ！

从今天开始以后的教程就都统一成这个样子了，因为我默认大家用了我群内的文件来进行修改！！

4.4 修改四

添加如下两行代码！！！

​

4.5 修改五

找到七百多行大概把具体看图片，按照图片来修改就行，添加红框内的部分，注意没有()只是 函数 名。 

  1.         elif m in {自行添加对应的模型即可，下面都是一样的}:
  2.             m = m(*args)
  3.             c2 = m.width_list  # 返回通道列表
  4.             backbone = True

4.6 修改六

下面的两个红框内都是需要改动的。

​ 

  1.         if isinstance(c2, list):
  2.             m_ = m
  3.             m_.backbone = True
  4.         else:
  5.             m_ = nn.Sequential(*(m(*args) for _ in range(n))) if n > 1 else m(*args)  # module
  6.             t = str(m)[8:-2].replace('__main__.', '')  # module type
  9.         m.np = sum(x.numel() for x in m_.parameters())  # number params
  10.         m_.i, m_.f, m_.type = i + 4 if backbone else i, f, t  # attach index, 'from' index, type

4.7 修改七

如下的也需要修改，全部按照我的来。

​

代码如下把原先的代码替换了即可。 

  1.         if verbose:
  2.             LOGGER.info(f'{i:>3}{str(f):>20}{n_:>3}{m.np:10.0f}  {t:<45}{str(args):<30}')  # print
  4.         save.extend(x % (i + 4 if backbone else i) for x in ([f] if isinstance(f, int) else f) if x != -1)  # append to savelist
  5.         layers.append(m_)
  6.         if i == 0:
  7.             ch = []
  8.         if isinstance(c2, list):
  9.             ch.extend(c2)
  10.             if len(c2) != 5:
  11.                 ch.insert(0, 0)
  12.         else:
  13.             ch.append(c2)

4.8 修改八

修改八和前面的都不太一样，需要修改前向传播中的一个部分， 已经离开了parse_model方法了。

可以在图片中开代码行数，没有离开task.py文件都是同一个文件。 同时这个部分有好几个前向传播都很相似，大家不要看错了， 是70多行左右的！！！，同时我后面提供了代码，大家直接复制粘贴即可，有时间我针对这里会出一个视频。

​​

代码如下-> 

  1.     def _predict_once(self, x, profile=False, visualize=False, embed=None):
  2.         """
  3.         Perform a forward pass through the network.
  5.         Args:
  6.             x (torch.Tensor): The input tensor to the model.
  7.             profile (bool):  Print the computation time of each layer if True, defaults to False.
  8.             visualize (bool): Save the feature maps of the model if True, defaults to False.
  9.             embed (list, optional): A list of feature vectors/embeddings to return.
  11.         Returns:
  12.             (torch.Tensor): The last output of the model.
  13.         """
  14.         y, dt, embeddings = [], [], []  # outputs
  15.         for m in self.model:
  16.             if m.f != -1:  # if not from previous layer
  17.                 x = y[m.f] if isinstance(m.f, int) else [x if j == -1 else y[j] for j in m.f]  # from earlier layers
  18.             if profile:
  19.                 self._profile_one_layer(m, x, dt)
  20.             if hasattr(m, 'backbone'):
  21.                 x = m(x)
  22.                 if len(x) != 5:  # 0 - 5
  23.                     x.insert(0, None)
  24.                 for index, i in enumerate(x):
  25.                     if index in self.save:
  26.                         y.append(i)
  27.                     else:
  28.                         y.append(None)
  29.                 x = x[-1]  # 最后一个输出传给下一层
  30.             else:
  31.                 x = m(x)  # run
  32.                 y.append(x if m.i in self.save else None)  # save output
  33.             if visualize:
  34.                 feature_visualization(x, m.type, m.i, save_dir=visualize)
  35.             if embed and m.i in embed:
  36.                 embeddings.append(nn.functional.adaptive_avg_pool2d(x, (1, 1)).squeeze(-1).squeeze(-1))  # flatten
  37.                 if m.i == max(embed):
  38.                     return torch.unbind(torch.cat(embeddings, 1), dim=0)
  39.         return x

到这里就完成了修改部分，但是这里面细节很多，大家千万要注意不要替换多余的代码，导致报错，也不要拉下任何一部，都会导致运行失败，而且报错很难排查！！！很难排查！！！

注意！！！ 额外的修改！

关注我的其实都知道，我大部分的修改都是一样的，这个网络需要额外的修改一步，就是s一个参数，将下面的s改为640！！！即可完美运行！！

打印计算量问题解决方案

我们找到如下文件'ultralytics/utils/torch_utils.py'按照如下的图片进行修改，否则容易打印不出来计算量。

​

注意事项！！！

如果大家在验证的时候报错形状不匹配的错误可以固定验证集的图片尺寸，方法如下 ->

找到下面这个文件ultralytics/ models /yolo/detect/train.py然后其中有一个类是DetectionTrainer class中的build_dataset函数中的一个参数rect=mode == 'val'改为rect=False

五、EfficientNetV1的yaml文件

复制如下yaml文件进行运行！！！

5.1 EfficientNetV1 的yaml文件版本

此版本训练信息：YOLO11-EfficientNetV1 summary: 337 layers, 3,515,595 parameters, 3,515,579 gradients, 3.7 GFLOPs

使用说明：# 下面 [-1, 1, efficientnet-b0}, [efficientnet-b0, 0.25，0.5]] 参数位置的0.25是通道放缩的系数, YOLOv11N是0.25 YOLOv11S是0.5 YOLOv11M是1. YOLOv11l是1 YOLOv11是1.5大家根据自己训练的YOLO版本设定即可.
#  0.5对应的是模型的深度系数
#  efficientnet-b0为模型的版本

# 本文支持版本有 

#     'efficientnet-b0', 'efficientnet-b1', 'efficientnet-b2', 'efficientnet-b3',
#     'efficientnet-b4', 'efficientnet-b5', 'efficientnet-b6', 'efficientnet-b7',
#     'efficientnet-b8', 'efficientnet-l2'
  1. # Ultralytics YOLO 🚀, AGPL-3.0 license
  2. # YOLO11 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
  4. # Parameters
  5. nc: 80 # number of classes
  6. scales: # model compound scaling constants, i.e. 'model=yolo11n.yaml' will call yolo11.yaml with scale 'n'
  7.   # [depth, width, max_channels]
  8.   n: [0.50, 0.25, 1024] # summary: 319 layers, 2624080 parameters, 2624064 gradients, 6.6 GFLOPs
  9.   s: [0.50, 0.50, 1024] # summary: 319 layers, 9458752 parameters, 9458736 gradients, 21.7 GFLOPs
  10.   m: [0.50, 1.00, 512] # summary: 409 layers, 20114688 parameters, 20114672 gradients, 68.5 GFLOPs
  11.   l: [1.00, 1.00, 512] # summary: 631 layers, 25372160 parameters, 25372144 gradients, 87.6 GFLOPs
  12.   x: [1.00, 1.50, 512] # summary: 631 layers, 56966176 parameters, 56966160 gradients, 196.0 GFLOPs
  14. # 下面 [-1, 1, efficientnet-b0}, [efficientnet-b0, 0.25，0.5]] 参数位置的0.25是通道放缩的系数, YOLOv11N是0.25 YOLOv11S是0.5 YOLOv11M是1. YOLOv11l是1 YOLOv11是1.5大家根据自己训练的YOLO版本设定即可.
  15.                                 #  0.5对应的是模型的深度系数
  16.                                 #  efficientnet-b0为模型的版本
  17. # 支持的版本:
  18. #     'efficientnet-b0', 'efficientnet-b1', 'efficientnet-b2', 'efficientnet-b3',
  19. #     'efficientnet-b4', 'efficientnet-b5', 'efficientnet-b6', 'efficientnet-b7',
  20. #     'efficientnet-b8', 'efficientnet-l2'
  21. # YOLO11n backbone
  22. backbone:
  23.   # [from, repeats, module, args]
  24.   - [-1, 1, efficient, [efficientnet-b0, 0.25,0.5]] # 0-4 P1/2
  25.   - [-1, 1, SPPF, [1024, 5]] # 5
  26.   - [-1, 2, C2PSA, [1024]] # 6
  28. # YOLO11n head
  29. head:
  30.   - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  31.   - [[-1, 3], 1, Concat, [1]] # cat backbone P4
  32.   - [-1, 2, C3k2, [512, False]] # 9
  34.   - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  35.   - [[-1, 2], 1, Concat, [1]] # cat backbone P3
  36.   - [-1, 2, C3k2, [256, False]] # 12 (P3/8-small)
  38.   - [-1, 1, Conv, [256, 3, 2]]
  39.   - [[-1, 9], 1, Concat, [1]] # cat head P4
  40.   - [-1, 2, C3k2, [512, False]] # 15 (P4/16-medium)
  42.   - [-1, 1, Conv, [512, 3, 2]]
  43.   - [[-1, 6], 1, Concat, [1]] # cat head P5
  44.   - [-1, 2, C3k2, [1024, True]] # 18 (P5/32-large)
  46.   - [[12, 15, 18], 1, Detect, [nc]] # Detect(P3, P4, P5)

5.2 训练文件 

  1. import warnings
  2. warnings.filterwarnings('ignore')
  3. from ultralytics import YOLO
  5. if __name__ == '__main__':
  6.     model = YOLO('ultralytics/cfg/models/v8/yolov8-C2f-FasterBlock.yaml')
  7.     # model.load('yolov8n.pt') # loading pretrain weights
  8.     model.train(data=r'替换数据集yaml文件地址',
  9.                 # 如果大家任务是其它的'ultralytics/cfg/default.yaml'找到这里修改task可以改成detect, segment, classify, pose
  10.                 cache=False,
  11.                 imgsz=640,
  12.                 epochs=150,
  13.                 single_cls=False,  # 是否是单类别检测
  14.                 batch=4,
  15.                 close_mosaic=10,
  16.                 workers=0,
  17.                 device='0',
  18.                 optimizer='SGD', # using SGD
  19.                 # resume='', # 如过想续训就设置last.pt的地址
  20.                 amp=False,  # 如果出现训练损失为Nan可以关闭amp
  21.                 project='runs/train',
  22.                 name='exp',
  23.                 )

六、成功运行记录

下面是成功运行的截图，已经完成了有1个epochs的训练，图片太大截不全第2个epochs，这里改完之后打印出了点问题，但是不影响任何功能，后期我找时间修复一下这个问题。

​​

七、本文总M结

到此本文的正式分享内容就结束了，在这里给大家推荐我的YOLOv11改进有效涨点专栏，本专栏目前为新开的平均质量分98分，后期我会根据各种最新的前沿顶会进行论文复现，也会对一些老的改进机制进行补充， 目前本专栏免费阅读(暂时，大家尽早关注不迷路~) ，如果大家觉得本文帮助到你了，订阅本专栏，关注后续更多的更新~

​​

​