🏆 本文收录于 《YOLOv8实战：从入门到深度优化》，该专栏持续复现网络上各种热门内容(全网YOLO改进最全最新的专栏，质量分97分+，全网顶流)，改进内容支持(分类、检测、分割、追踪、关键点、OBB检测)。且专栏会随订阅人数上升而涨价(毕竟不断更新)，当前性价比极高，有一定的参考&学习价值，部分内容会基于现有的国内外顶尖人工智能AIGC等AI大模型技术总结改进而来，嘎嘎硬核。
  
✨ 特惠福利：目前活动一折秒杀价！一次订阅，永久免费，所有后续更新内容均免费阅读！

全文目录：

⏩ 零、摘要

  大家好！欢迎回到我们的《YOLOv8专栏》！在本节中，我们将深入探索专为遥感图像目标检测设计的强大卷积网络——LSKNet（Large Selective Kernel Network）。遥感图像因其独特的“上帝视角”，常常包含着大量尺度差异巨大、背景复杂的物体，这给传统卷积神经网络带来了巨大挑战。

  LSKNet通过其创新的大核选择机制，动态地调整感受野，极大地提升了模型在复杂场景下的特征提取能力。本文将从遥感检测的痛点出发，详细剖析LSKNet的核心原理、模块结构与实现细节，并手把手带您将LSKNet集成到YOLOv8的骨干网络中，通过详尽的代码实战与解析，让您彻底掌握这一前沿技术。准备好了吗？让我们一起开启这场大核卷积的探索之旅吧！🚀

⏩ 一、温故知新：上期内容回顾

  在上一篇 《YOLOv8【卷积创新篇·第3节】EfficientNet系列主干网络替换实战》 中，我们详细探讨了堪称“效率典范”的EfficientNet家族。我们一起回顾了其核心的 **复合缩放（Compound Scaling）**策略，即如何通过一组固定的缩放因子α, β, γ，同时对网络的深度（depth）、宽度（width）和分辨率（resolution）进行优化，从而在提升性能的同时，精确地控制计算资源。

  我们还深入分析了EfficientNet的基础构建块——MBConv，它巧妙地融合了深度可分离卷积、SE注意力机制以及残差连接，实现了特征提取效率和效果的完美平衡。最后，我们通过实战代码，演示了如何将EfficientNet-B0到B7的不同尺寸模型作为YOLOv8的骨干网络，为同学们在不同硬件资源下选择最优模型提供了清晰的指引。

  EfficientNet的设计哲学，即在“资源约束”下追求“最优性能”，为我们后续的网络设计提供了宝贵的思路。而今天，我们将把目光投向一个更具挑战性的领域——遥感图像检测，看看LSKNet是如何用一种全新的“动态视角”来解决这个难题的。✨

⏩ 二、前言：遥感检测的挑战与大感受野的重要性

  当我们处理常规的自然图像时，目标物体通常占据了画面的大部分区域，尺度也相对适中。然而，当我们切换到遥感视角（如卫星、无人机航拍），图像的特性发生了翻天覆地的变化：

  1. 尺度差异悬殊 (Vast Scale Variation): 同一幅图像中，可能既有占地上万平方米的机场、港口，也有仅占几个像素点的车辆、行人。这种巨大的尺度差异要求网络必须具备极强的多尺度特征捕捉能力。
  2. 方向任意性 (Arbitrary Orientation): 地面上的物体从空中俯瞰，可能呈现任意角度，这要求网络对旋转具有更好的鲁棒性。
  3. 背景复杂且小目标密集 (Complex Background & Dense Small Objects): 城市、山林、农田等背景信息极其复杂，小目标（如车辆、船舶）常常密集地排列在一起，极易被背景淹没或相互混淆。

  传统的CNNs，尤其是那些使用3x3小卷积核堆叠而成的网络（如ResNet），其感受野（Receptive Field）的增长是相对缓慢和线性的。对于需要理解大范围上下文信息才能准确分类的大型目标（例如，识别一个“港口”，需要看到码头、船只、集装箱区等多个组成部分），有限的感受野显然力不从心。

  因此，增大感受野，让网络“看”得更远、更广，成为了提升遥感检测性能的关键。简单粗暴地堆叠更多层或使用更大的固定卷积核（如11x11, 15x15）会带来两个问题：一是计算量和参数量急剧增加；二是对小目标的细节特征捕捉能力会下降。

  有没有一种方法，可以智能地、动态地为图像的不同区域匹配不同大小的感受野呢？🤔 这正是LSKNet（Large Selective Kernel Network）试图解决的核心问题。它引入了一种巧妙的空间核选择机制，让网络能够根据输入特征，自适应地为每个像素位置选择最合适的卷积核尺寸，从而在不显著增加计算成本的前提下，实现巨大且灵活的感受野。

  接下来，就让我们正式揭开LSKNet的神秘面纱！

⏩ 三、LSKNet核心思想深度剖析

  LSKNet的核心思想可以概括为：通过并行处理多个大核深度卷积，并利用一个动态选择机制，将它们的输出进行加权融合，从而为不同的空间位置自地分配最合适的感受野。

3.1 大感受野需求分析：为何遥感检测有独钟”？

  为了更直观地理解，我们来看一个例子。如下图所示，要识别左侧的“机场”，模型不仅要看到“跑道”，还要看到“航站楼”、“停机坪”等关联区域。一个小的感受野可能一次只能看到跑道的一部分，很容易将其误判为“公路”。而一个足够大的感受野则能将整个机场的布局尽收眼底，做出更准确的判断。

Large Receptive Field
Small Receptive Field
3x3 Kernel
51x51 Kernel
全局特征: '跑道+航站楼+停机坪'
Feature Map
识别为: 机场!
局部特征: '一条线'
Feature Map
识别为: 公路?

  对于右侧密集停放的车辆，如果感受野过大，可能会将多辆车及其之间的空地“平滑”掉，导致漏检。此时，一个较小的感受野反而能更好地聚焦于单个车辆的精细特征。

  LSKNet的设计正是为了应对这种“见大也见小”的复杂需求。它不满足于单一的、固定的感受野，而是追求一种“按需分配”的智能化特征提取模式。

3.2 LSK模块结构设计：优雅的动态选择艺术

  LSKNet的核心在于其精心设计的LSK（Large Selective Kernel）模块。一个LSK模块通常嵌入在网络的残差结构中，取代标准的3x3卷积。其整体结构如下图所示：

  从宏观上看，它遵循了经典的“瓶颈”设计（Bottleneck Design）：

  1. 1x1卷积/升维：先用一个1x1卷积对输入特征进行通道扩展或压缩，为后续的大核卷积做准备。
  2. LSK核心单元：这是整个模块的灵魂，负责进行动态的大核卷积操作。
  3. 1x1卷积恢复：将核心单元输出的特征通过另一个1x1卷积恢复到与输入匹配的通道数。
  4. 残差连接：将处理后的特征与原始输入（通过一个快捷连接）相加，保证了梯度的顺畅传播，使得网络可以构建得更深。

  真正的魔法发生在LSK核心单元内部。让我们把它“砸开”看看。

3 空间核选择机制：LSKNet的“最强大脑”

  LSK核心单元内部可以分解为两个主要部分：卷积分支 (Large Kernel Convolution Branch) 和 核选择分支 (Kernel Selection Branch)。

工作流程详解:

  1. 分解 (Decompose): 输入特征图在通道维度上被分解成N个部分，每个部分将送入一个不同的大核卷积分支。

  2. 大核卷积分支 (Large Kernel Convolution Branch):
    ** 这里有N个并行的分支，每个分支使用一个不同尺寸的** 大核深度可分离卷积（Large Kernel Depth-wise Convolution）**。例如，分支1用5x5，分支2用7x7，…，直到一个非常大的尺寸，如论文中提到的51x51。

    • 使用深度可分离卷积是为了在拥有大感受野的同时，极大地减少计算量和参数量。
    • 每个分支输出一个经过特定感受野处理后的特征图 Feat_i。

  3. 特征拼接 (Concatenate): 将所有N个分支输出的特征图 Feat_1, Feat_2, ..., Feat_N 沿着通道维度拼接起来。

  4. 择分支 (Kernel Selection Branch):

    • 这一分支的作用是为拼接后的特征图生成一个“注意力图”，告诉模型在每个空间位置上，应该更关注哪个卷积核带来的信息。
    • 它首先对输入特征进行全局平均池化（GAP），得到一个通道描述符。
    • 然后通过两个全连接层（FC）来学习通道间的非线性关系，这与SE模块非常相似。
    • 最后通过Sigmoid函数生成N个注意力权重图，每个图对应一个大核分支。这些权重图的维度与原始特征图的空间维度相同。

  5. 加权融合 (Weighted Sum):

    • 将拼接后的特征图与生成的注意力权重图进行元素级相乘。
    • 这相当于在每个像素位置，用注意力权重去调制来自不同大核分支的特征。如果某个位置的注意力权重在对应51x51核的通道上值很高，那么该位置的最终输出特征就主要来自于51x51核的贡献。
    • 最后将加权后的特征相加（或通过1x1卷积融合），得到最终的输出特征图。

  通过这个机制，LSKNet就实现了在同一层网络中，不同空间位置拥有不同大小的有效感受野，这对于处理尺度变化剧烈的遥感图像来说，无疑是一大利器！

⏩ 四、LSKNet代码全解析与实现 (PyTorch)

  理论讲了这么多，是时候上代码了！Talk is cheap, show me the code. 😊 下面我们用PyTorch来实现一个完整的LSK模块。

4.1 LSK Block核心模块代码实现
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.modules.utils import _pair

class LSKBlock(nn.Module):
    """
    LSK Block: Large Selective Kernel Block
    专门为遥感等需要大感受野的场景设计
    """
    def __init__(self, dim, kernel_sizes=[5, 7, 9, 11], LSK_group=4, split_ratio=0.25):
        """
        初始化LSK模块
        :param dim: 输入和输出的维度 (channels)
        :param kernel_sizes: 一系列大卷积核的尺寸列表
        :param LSK_group: LSK核心操作中的分组数
        :param split_ratio: 维度划分比例，用于注意力机制
        """
        super().__init__()
        self.dim = dim
        self.kernel_sizes = kernel_sizes
        self.num_kernels = len(kernel_sizes)
        self.LSK_group = LSK_group
        
        # 1. 瓶颈结构中的第一个1x1卷积，用于升维
        self.conv1 = nn.Conv2d(dim, dim, kernel_size=1)
        self.bn1 = nn.BatchNorm2d(dim)
        
        # 2. LSK核心单元
        # 使用分组卷积实现并行的深度可分离卷积
        # 每个组对应一个不同尺寸的卷积核
        self.conv_dw = nn.ModuleList()
        for i, ks in enumerate(kernel_sizes):
            # 为每个卷积核创建一个深度可分离卷积层
            # groups=dim // self.num_kernels 保证了每个组独立进行深度卷积
            self.conv_dw.append(
                nn.Conv2d(
                    dim // self.num_kernels, 
                    dim // self.num_kernels, 
                    kernel_size=ks, 
                    padding=ks // 2, 
                    groups=dim // self.num_kernels
                )
            )

        # 3. 空间核选择机制 (注意力分支)
        self.split_channels = int(dim * split_ratio)
        self.conv_split = nn.Conv2d(dim, self.split_channels * self.num_kernels, 
                                    kernel_size=1, groups=self.LSK_group)
        self.bn_split = nn.BatchNorm2d(self.split_channels * self.num_kernels)
        
        # 全局平均池化
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        
        # 两个全连接层
        self.fc1 = nn.Conv2d(dim, self.dim, kernel_size=1)
        self.fc2 = nn.Conv2d(dim, self.dim * self.num_kernels, kernel_size=1)
        
        # Softmax用于归一化注意力权重
        self.softmax = nn.Softmax(dim=1)

        # 4. 瓶颈结构中的第二个1x1卷积，用于降维/恢复
        self.conv3 = nn.Conv2d(dim, dim, kernel_size=1)
        self.bn3 = nn.BatchNorm2d(dim)

        # 激活函数
        self.act = nn.GELU()

    def forward(self, x):
        """
        前向传播函数
        """
        # 保存输入，用于残差连接
        identity = x
        
        # -------- 进入瓶颈结构 ---------
        # 1. 第一个1x1卷积和BN
        x = self.bn1(self.conv1(x))
        
        # -------- LSK核心单元 ---------
        # 2. 将特征图在通道维度上分割成 N 份
        # N = self.num_kernels
        x_split = torch.split(x, self.dim // self.num_kernels, dim=1)
        
        # 3. 并行执行不同尺寸的大核深度卷积
        x_conv = []
        for i in range(self.num_kernels):
            x_conv.append(self.conv_dw[i](x_split[i]))
        
        # 4. 将卷积后的结果拼接起来
        x_merged = torch.cat(x_conv, dim=1)
        
        # -------- 空间核选择机制 ---------
        # 5. 计算注意力权重
        # 全局池化 + 全连接层
        s = self.avg_pool(x_merged)
        s = self.fc2(self.act(self.fc1(s)))
        
        # (B, N*C, 1, 1) -> (B, N, C, 1, 1)
        # N是卷积核数量, C是每个分支的通道数
        s = s.view(s.size(0), self.num_kernels, self.dim // self.num_kernels, 1, 1)
        
        # 使用softmax在 'N' 这个维度上进行归一化，得到权重
        attn_weights = self.softmax(s)
        
        # 6. 加权融合
        # (B, C_total, H, W) -> (B, N, C_branch, H, W)
        x_merged_view = x_merged.view(x_merged.size(0), self.num_kernels, self.dim // self.num_kernels, 
                                      x_merged.size(2), x_merged.size(3))
        
        # 注意力权重与特征图相乘
        # attn_weights: (B, N, C, 1, 1)
        # x_merged_view: (B, N, C, H, W)
        # 广播机制会自动处理
        fused_feat = attn_weights * x_merged_view
        
        # (B, N, C, H, W) -> (B, N*C, H, W)
        fused_feat = fused_feat.view(fused_feat.size(0), -1, fused_feat.size(3), fused_feat.size(4))
        
        # -------- 瓶颈结构收尾 ---------
        # 7. 第三个1x1卷积
        x_out = self.bn3(self.conv3(fused_feat))
        
        # 8. 残差连接
        output = identity + x_out
        
        return output

# 测试代码
if __name__ == '__main__':
    # 创建一个 LSKBlock 实例
    # 输入维度为64, 使用 5x5, 7x7, 9x9, 11x11 四种卷积核
    lsk_block = LSKBlock(dim=64, kernel_sizes=[5, 7, 9, 11])
    
    # 创建一个随机的输入张量
    # B, C, H, W = (4, 64, 56, 56)
    input_tensor = torch.randn(4, 64, 56, 56)
    
    # 将模型和数据移动到GPU (如果可用)
    if torch.cuda.is_available():
        lsk_block = lsk_block.cuda()
        input_tensor = input_tensor.cuda()
        
    print("输入张量尺寸:", input_tensor.shape)
    
    # 执行前向传播
    output_tensor = lsk_block(input_tensor)
    
    print("输出张量尺寸:", output_tensor.shape)
    
    # 检查参数量
    num_params = sum(p.numel() for p in lsk_block.parameters() if p.requires_grad)
    print(f"LSKBlock 参数量: {num_params / 1e6:.2f} M")
4.2 代码逐行解析

  • __init__(self, ...):

    • dim: 定义了模块处理的特征通道数，输入和输出通道数相同，符合残差块的设计。
    • kernel_zes: 一个列表，定义了所有并行大核卷积的尺寸。代码的灵活性体现在这里，你可以轻松地尝试不同的组合，比如 [7, 11, 13]。
    • self.conv1, self.bn1: 瓶颈结构的入口，一个1x1卷积，用于特征变换，后面跟着一个BN层。
    • self.conv_dw: 这是一个nn.oduleList，是实现并行处理的关键。我们循环kernel_sizes列表，为每个尺寸都创建一个深度可分离卷积层（groupsdim // self.num_kernels是实现深度卷积的核心）。注意padding = ks // 2是为了保持卷积后特征图的尺寸不变。
    • self.avg_pool, self.fc1, self.fc2: 这三部分构成了注意力权重的生成网络。AdaptiveAvgPool2d(1)将每个通道的空间信息压缩成一个值，fc1和fc2（用1x1卷积实现，效率更高）则学习通道间的复杂关系，并最终输出足够多的通道数，以便为每个大核分支的每个通道都生成一个权重。
    • self.softmax: 在dim=1（即我们自己view出来的num_kernels维度）上进行Softmax，确保对于每个像素的每个通道组，所有大核的权重之和为1。
    • self.conv3, self.bn3: 瓶颈结构的出口，用于融合特征并恢复最终的通道数。

  • forward(self, x):

    • identity = x: 保存原始输入，用于最后的残差连接，这是所有现代网络设计的基石。
    • torch.split(, ...): 这是一个非常高效的操作，它将输入张量x沿着通道维度（dim=1）切分成self.num\_kernels\个小块，每个小块送入对应的大核卷积。
    • x_conv.append(...)->torch.cat(…)`: 分别计算每个分支的卷积，然后将结果重新拼接起来。
    • s = self.avg_pool(merged)…attn_weights = self.softmax(s): 完整地执行了注意力权重的计算过程。注意view操作的使用，它在不改变数据存储的情况下，重塑了张量的形状，以便进行后续的softmax和加权操作。
    • attn_weights * x_merged_view: 这是最核心的加权操作。PyTorch的广播机制（Broadcasting）在这里发挥了巨大作用。attn_weights的形状是(B, N, C, 1, 1)，x_merged_view的形状是(B N, C, H, W)。相乘时，attn_weights会自动扩展（广播）到(B, N, C, H,W)，从而实现元素级的加权。
    • output = identity + x_out: 最后的残差相加，完成一次LSK Block的计算。

这段代码不仅实现了LSKNet的核心功能，而且具有很好的可读性和扩展性，您可以基于它进行各种实验和改进。👍

⏩ 五、实战演练：将LSKNet集成为YOLOv干网络

现在，激动人心的时刻到了！我们要将上面实现的LSKBlock集成到YOLOv8的骨干网络中，替换掉原有的C2f模块，打造一个拥有超大动态感受野的全新YOLOv8！

集成过程主要分为三步：

  1. 创建LSK模块文件: 将我们的LSKBlock代码保存成一个独立的Python文件。
  2. 修改YOLOv8模型定义: 在YOLOv8的代码库中，引入LSKBlock并用它构建新的主干。
  3. 编写新的YAML配置文件: 定义新模型的网络结构。
5.1建LSKNet基础模块 (ultralytics/nn/modules/lsk_block.py)

首先，在你的YOLOv8项目文件夹中，找到ultralytics/nn/modules/目录，在里面创建一个新的文件，命名为lsk_block.py，然后将我们上面写的LSKBlock类的全部代码粘贴进去。

为了能和YOLOv8的C2f模块无缝替换，我们最好再封装一层，让它的输入输出参数和C2f保持一致。我们创建一个LSKCSP`模块。

# 在 lsk_block.py 文件中，除了 LSKBlock，再增加以下内容

import torch
import torch.nn as nn

# ... (LSKBlock 的代码放在这里) ...

class LSKCSP(nn.Module):
    """
    LSK Block with Cross Stage Partial connection.
    参照 C2f 模块的结构，将核心卷积替换为 LSKBlock
    """
    def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):
        """
        初始化LSKCSP模块
        :param c1: 输入通道数
        :param c2: 输出通道数
        :param n: LSKBlock 的重复次数
        :param shortcut: 是否使用残差连接
        :param g: 分组数 (未使用，保持接口一致)
        :param e: 通道扩展因子
        """
        super().__init__()
        # 计算隐藏层通道数
        self.c = int(c2 * e)
        # 两个1x1卷积，用于分割和融合特征
        self.cv1 = nn.Conv2d(c1, 2 * self.c, 1, 1, bias=False)
        self.cv2 = nn.Conv2d((2 + n) * self.c, c2, 1, bias=False)
        self.bn = nn.BatchNorm2d(2 * self.c)
        self.act = nn.SiLU()
        
        # 核心的 LSKBlock 堆叠
        # 注意：这里我们简化了kernel_sizes的配置，实际可以做的更灵活
        self.m = nn.Sequential(*(LSKBlock(self.c, kernel_sizes=[5, 7, 9]) for _ in range(n)))

    def forward(self, x):
        # 将输入x通过cv1后，在通道维度上分割成两部分
        y = list(self.cv1(x).split((self.c, self.c), 1))
        # 其中一部分经过n个LSKBlock的处理，并将每次的输出都拼接起来
        y.extend(m(y[-1]) for m in self.m)
        # 最后通过cv2进行特征融合
        return self.cv2(torch.cat(y, 1))

说明:

  • LSKCSP的结构模仿了C2f，它首先将输入特征分成两半，一半直接保留，另一半送入由n个LSKBlock组成的序列中进行深度处理。
  • y.xtend(...) 这种结构保留了每一层LSKBlock的输出，实现了跨阶段的特征融合，这有助于梯度的传播和特征的复用。
  • 这样封装后，LSKCSP就可以像C2f一样，在YAML文件中被直接调用了。
5.2 改造YOLOv8主干，融入LSKNet

现在我们需要让YOLOv8认识我们新的LSKCSP模块。

  1. 在 ultralytics/nn/tasks.py 中导入块:
    打开 tasks.py 文件，在最顶部的导入区域，加入我们的LSKCSP。

    # ultralytics/nn/tasks.py

# ... other imports
from .modules import (C1, C2, C3, C2f, ...)
from .modules.lsk_block import LSKCSP # <--- 添加这一行

  2. 在 __init__ 函数中注册新模块:
    在同一个文件的parse_model函数附近（通常在DetectionModel类或其基类BaseModel的__init__中），找到一个类似字典或if-elif链的模块注册表，将LSCSP加进去。

    # 在 DetectionModel 类的 __init__ 方法或 parse_model 函数中
# 找到模块映射的地方

# 例如，在 ultralytics/nn/tasks.py 的 parse_model 函数内部
# ...
# for i, (f, n, m, args) in enumerate(d['backbone'] + d['head']):
#     m = eval(m) if isinstance(m, str) else m  # eval strings
#     if m in (Classify, C1, C2, C3, C2f, ..., LSKCSP): # <--- 在这里加上 LSKCSP
#         c1, c2 = ch[f], args[0]
# ...

# 不同的YOLOv8版本可能位置不同，关键是找到这个模块解析的地方
# 在较新版本中，可能是在 ultralytics/nn/tasks.py 的 DetectionModel 类里
# self.model, self.save = parse_model(deepcopy(self.yaml), ch=[ch])  # model, savelist
# ...
# 需要确保在调用 `eval(m)` 时，LSKCSP 已经被导入并可见。

    小提示: 最简单的方式是直接在tasks.py的MODULES字典（如果存在）或全局作用域内，让LSKCSP这个名字可被eval函数找到。上面的导入语句通常就能实现这一点。

5.3 配置模型YAML文件，训练

最后一步，也是最灵活的一步，就是编写一个新的.yaml文件来定义我们基于LSKNet的YOLOv8模型结构。

  1. 创建 yolov8-lsk.yaml:
    在ultralytics/models/v8/目录下，复制一份yolov8.yaml并重命名为yolov8-lsk.yaml。

  2. 修改 backe 部分:
    打开yolov8-lsk.yaml，找到backbone的定义，将原来的C2f模块替换为我们自定义的LSKCSP模块。你可以选择性地替换，比如只替换后面几层感受野需求更大的C2f`。

    # Ultralytics YOLO 🚀, AGPL-3.0 license
# YOLOv8-LSKNet model configuration file

# Parameters
nc: 80  # number of classes
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.50  # layer channel multiple

# Anchors
anchors: null

# Backbone
backbone:
  # [from, number, 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, LSKCSP, [512, True]] # <--- 在这里替换！使用 LSKCSP
  - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
  - [-1, 3, LSKCSP, [1024, True]] # <--- 在这里替换！使用 LSKCSP
  - [-1, 1, SPPF, [1024, 5]]

# Head
head:
  # ... (head部分保持不变)

    在这个例子中，我们替换了主干网络后面两个阶段的C2f模块。因为网络的深层部分负责提取更高级的语义信息，对感受野的要求更大，所以在这里使用LSKCSP能最大化其优势。

  3. 开始训练！
    现在，你可以像训练标准YOLOv8模型一样，使用这个新的配置文件了：

   yolo detect train data=your_dataset.yaml model=yolov8-lsk.yaml epochs=100 imgsz=640

恭喜你！你已经成功地将一个先进的大核选择网络集成到了YOLOv8中。通过这个过程，你不仅学会了LSKNet的原理，更掌握了如何对YOLOv8进行深度定制和魔改的核心技能！这绝对是值得庆祝的巨大进步！🎉

⏩ 六、SKNet性能优势与思考

6.1 遥感图像特征提取的优势

相比于传统的CNN，LSKNet在遥感图像上展现出明显的优势：

  • 上下文感知能力强: 巨大的感受野使得模型能够理解目标与其周围环境的关系，有效区分相似物体（如区分河流中的“桥”和岸边的“堤坝”）。
  • 抑制噪声: 通过动态选择，模型可以为简单的背景区域分配一个平滑的大核，有效抑制纹理噪声，同时为包含小目标的复杂区域分配更精细的小核。
  • 参数效率高: 借助深度可分离卷积，LSKNet在获得巨大感受野的同时，并没有引入过多的参数和计算量，保持了模型的轻量化。
6.2 多目标的完美适配

LSKNet最核心的亮点在于其对多尺度目标的自适应能力。传统的图像金字塔（Image Pyramid）或特征金字塔网络（FPN）是在不同层级上解决多尺度问题，而LSKNet是在同一层内，通过空间维度的动态选择来解决多尺度问题。这两种方法是互补的，当LSKNet作为主干网络，再配合YOLOv8的FPN结构（如PANet），就形成了一个从“层内”到“层间”的全方位多尺度解决方案，理论上能极大地提升对各种尺寸目标的检测精度。

⏩ 七、总结与展望

在本篇超长篇幅的教程中，我们进行了一次从理论到实践的深度探索：

  1. 我们分析了遥感检测的痛点，明确了大感受的重要性。
  2. 深入剖析了LSKNet的核心，理解了其并行大核分支与空间核机制的精妙设计。
  3. 我们从零开始，用PyTorch手写了LSKBlock，并对其代码进行了逐行解析。
  4. 最终，我们通过三步走的实战演练，成功地将LSKNet集成为YOLOv8的自定义主干，并给出了训练方法。

LSKNet为我们打开了一扇新的大门，它告诉我们卷积核不一定是固定不变的，而是可以根据内容动态变化的。这种“选择性”和“适应性”的思想，是近年来计算机视觉领域发展的一个重要趋势。

希望通过本文的学习，你不仅掌握了LSKNet这一个具体的模型，更能举一反三，将这种动态设计的思想应用到你未来的研究和项目中去。不断探索，不断创新，这正是我们学习的乐趣所在！你做得非常棒，坚持学到这里，已经超越了很多人！给你点赞！👍

⏩ 八、敬请期待：内容预告

在探索了专为遥感设计的“重量级”选手LSKNet之后，下一节，我们将把目光转向另一个极端——极致的轻量化！

在 《YOLOv8【卷积创新篇·第35节】MobileNetV3轻主干深度优化》 中，我们将一起探究大名鼎鼎的MobileNet家族的第三代力作。

  • 它是如何利用**神经架构搜索（NAS）**技术，自动设计出最优的网络结构？
  • 全新的h-swish激活函数相比ReLU和swish有何优势？
  • 它又是如何巧妙地结合SE注意力机制，在极低的计算量下实现高精度的？

如果你对移动端部署、模型压缩和加速充满兴趣，那么下一节绝对不容错过！让我们一起揭开MobileNetV3高效背后的秘密！我们下期再见！👋 Bye~

  希望本文所提供的YOLOv8内容能够帮助到你，特别是在模型精度提升和推理速度优化方面。

  PS：如果你在按照本文提供的方法进行YOLOv8优化后，依然遇到问题，请不要急躁或抱怨！YOLOv8作为一个高度复杂的目标检测框架，其优化过程涉及硬件、数据集、训练参数等多方面因素。如果你在应用过程中遇到新的Bug或未解决的问题，欢迎将其粘贴到评论区，我们可以一起分析、探讨解决方案。如果你有新的优化思路，也欢迎分享给大家，互相学习，共同进步！

🧧🧧 文末福利，等你来拿！🧧🧧

  文中讨论的技术问题大部分来源于我在YOLOv8项目开发中的亲身经历，也有部分来自网络及读者提供的案例。如果文中内容涉及版权问题，请及时告知，我会立即修改或删除。同时，部分解答思路和步骤来自全网社区及人工智能问答平台，若未能帮助到你，还请谅解！YOLOv8模型的优化过程复杂多变，遇到不同的环境、数据集或任务时，解决方案也各不相同。如果你有更优的解决方案，欢迎在评论区分享，撰写教程与方案，帮助更多开发者提升YOLOv8应用的精度与效率！

  OK，以上就是我这期关于YOLOv8优化的解决方案，如果你还想深入了解更多YOLOv8相关的优化策略与技巧，欢迎查看我专门收集YOLOv8及其他目标检测技术的专栏《YOLOv8实战：从入门到深度优化》。希望我的分享能帮你解决在YOLOv8应用中的难题，提升你的技术水平。下期再见！

  码字不易，如果这篇文章对你有所帮助，帮忙给我来个一键三连（关注、点赞、收藏），你的支持是我持续创作的最大动力。

  同时也推荐大家关注我的公众号：「猿圈奇妙屋」，第一时间获取更多YOLOv8优化内容及技术资源，包括目标检测相关的最新优化方案、BAT大厂面试题、技术书籍、工具等，期待与你一起学习，共同进步！

🫵 Who am I?

我是数学建模与数据科学领域的讲师 & 技术博客作者，笔名bug菌，CSDN | 掘金 | InfoQ | 51CTO | 华为云 | 阿里云 | 腾讯云 等社区博客专家，C站博客之星Top30，华为云多年度十佳博主，掘金多年度人气作者Top40，掘金等各大社区平台签约作者，51CTO年度博主Top12，掘金/InfoQ/51CTO等社区优质创作者；全网粉丝合计 30w+；更多精彩福利点击这里；硬核微信公众号「猿圈奇妙屋」，欢迎你的加入！免费白嫖最新BAT互联网公司面试真题、4000G PDF电子书籍、简历模板等海量资料，你想要的我都有，关键是你不来拿。

-End-

# 深度学习
Logo
北京朝阳AI社区

更多推荐

cover

具身智能：从 LLMs 到世界模型（下）

avatar 北京朝阳AI社区
cover

具身智能：从 LLMs 到世界模型（上）

avatar 北京朝阳AI社区

人工智能重塑未来机遇、挑战与伦理边界探索

在当代科技发展的浪潮中，一项具有颠覆性的技术正以前所未有的速度重塑人类社会的基本结构。然而，伴随这些机遇而来的是对就业市场、经济结构和社会秩序的深刻冲击，传统职业面临被自动化替代的风险，技能需求格局发生剧变，数字鸿沟问题也日益凸显。未来需要建立跨国界、跨学科的对话机制，促进技术创新与伦理规范的协同发展，形成既能鼓励创新又能防范风险的良好生态。算法决策过程中的偏见问题日益引发关注，训练数据中隐含的社

avatar 北京朝阳AI社区