YOLOv11-分割-全网最新创新点改进系列：融合最新顶会提出的HCANet网络中卷 ...

YOLOv11-分割-全网最新创新点改进系列：融合最新顶会提出的HCANet网络中卷积和注意力融合模块(CAFM-2024年3月15月开源)，有效提升小目标检测性能，大幅度拉升目标检测效果！

全部改进代码均经过实行测试跑通！停止发稿时YOLOv11已改进40+！自己分列组合2-4种后，考虑位置不同后可分列组合上千万种！改进不重样！！专注AI学术，关注B站up主：Ai学术叫叫兽！

购买相关资料后畅享一对一答疑！

YOLOv11-分割-全网最新创新点改进系列：融合最新顶会提出的HCANet网络中卷积和注意力融合模块(CAFM-2024年3月15月开源)，有效提升小目标检测性能，大幅度拉升目标检测效果！

---

HCANet提出原文戳这！
一、摘要

摘要高光谱图像去噪是高光谱数据有效分析息争释的关键。然而，同时建模全局和局部特征很少被探索以加强HSI去噪。在这封信中，我们提出了一个混淆卷积和注意力网络（HCANet），它利用了卷积神经网络（CNN）和变压器的优势。为了加强全局和局部特征的建模，我们设计了一个卷积和注意力融合模块，旨在捕获长程依靠性和邻域光谱相关性。别的，为了改善多标准信息聚合，我们设计了一个多标准前馈网络，通过提取不同标准的特征来提高去噪性能。在主流HSI数据集上的实行效果验证了HCANet的合理性和有效性。该模子能有效去除各种复杂噪声。我们的代码可在https://github.com/summitgao/HCANet上获得。
二、先容

超光谱成像是一种强盛的技能，它可以从物体或场景中获取丰富的光谱信息。与RGB数据相比，高光谱图像（HSI）捕获的光谱信息更精细。因此，HSI已被广泛用于很多现实应用中，例如解混[1]和地物分类[2]。然而，HSI经常受到传感器成像过程中不可制止的混淆噪声的困扰，这是由于曝光时间和反射能量不足造成的。这些噪声大概会低沉图像质量并妨碍后续分析息争释的性能。消除这些噪声可以提高地面貌标检测和分类的准确性。因此，HSI去噪是很多遥感应用中预处理阶段的关键和不可缺少的技能。受HSI的空间和光谱特性的启发，传统的HSI去噪方法利用具有先验的优化方案，例如低秩[3]，全变差[4]，非局部相似性[5]，固然这些方法已经取得了可观的性能，但它们通常取决于手工先验和真实世界噪声模子之间的相似程度。近年来，卷积神经网络（CNN）[7]为HSI去噪提供了新的思绪，表现出显着的性能进步。Maffei等人。[8]提出了一种基于CNN的HSI去噪模子，将噪声程度图作为输入来训练网络。Wang等人。[9]提出了一种基于团结Octave和注意力机制的卷积网络，用于HSI去噪。Pan等人。[10]提出了一种渐进的多标准信息聚合网络，以消除HSI中的噪声。这些基于CNN的方法使用卷积核举行局部特征建模。最近，随着Vision Transformer（ViT）的出现，基于Transformer的方法在各种盘算机视觉任务中取得了重大成功。现有的基于Transformer的图像去噪方法通过学习全局上下文信息取得了很大的成功。然而，如果局部特征被有效地考虑和利用，HSI去噪性能大概会进一步提高。因此，通过联合CNN和Transformers来考虑局部和全局信息以提高去噪性能是很重要的。由于以下两个挑衅，为HSI去噪构建有效的Transformer和CNN混淆模子通常是不平凡的：1）局部和全局特征建模的最佳混淆架构仍然是一个悬而未决的标题。卷积核捕捉局部特征，这意味着失去了长距离的信息交互。卷积和注意力的联合可以提供一个可行的办理方案。2)Transformer中前馈网络的单标准特征聚合受到限定。一些方法使用深度卷积来改善FFN中的局部特征聚合。然而，由于隐藏层中的信道数目较多，单标准令牌聚合很难利用丰富的信道表示。为了办理上述两个挑衅，我们提出了一种用于HSI去噪的混淆卷积和注意力网络（HCANet），它同时利用全局上下文信息和局部特征，如图1所示。详细来说，为了加强全局和局部特征的建模，我们设计了一个卷积和注意力融合模块（CAFM），旨在捕获长程依靠性和邻域光谱相关性。别的，为了提高FFN中的多标准信息聚合，我们设计了一个多标准前馈网络（MSFN），通过提取不同标准的特征来提高去噪性能。在MSFN中使用了三个具有不同步长的并行扩张卷积。通过在两个真实世界的数据集上举行实行，我们验证了我们提出的HCANet是上级优于其他国家的最先进的竞争对手。
这封信的贡献可以总结如下：
1.探索了用于HSI去噪的全局和局部特征建模的有前途但具有挑衅性的标题。据我们所知，这是第一个将团结收割机卷积和注意力机制联合起来用于HSI去噪任务的工作。
2.提出了多标准前馈网络，在不同标准上无缝提取特征，有效克制多标准噪声。
3.在两个基准数据集上举行了大量实行，验证了HCANet的合理性和有效性。
结论

我们提出了HCANet，一种新的网络HSI去噪。特殊是，我们提出了卷积和注意力融合模块，CAFM，融合全局和局部特征。别的，我们提出了多标准前馈网络，MSFN从多个标准提取特征，提高去噪性能。在具有挑衅性的HSI数据集上的实行效果表明，与现有的HSI去噪方法相比，我们提出的模子是有效的。我们的模子实现了显着的去噪性能的定量指标和重建图像的视觉质量。
二、HCANet全文代码

1. import sys
2. import torch
3. import torch.nn as nn
4. import torch.nn.functional as F
5. from pdb import set_trace as stx
6. import numbers
8. from einops import rearrange
9. import os
10. sys.path.append(os.getcwd())
12. # m_seed = 1
13. # # 设置seed
14. # torch.manual_seed(m_seed)
15. # torch.cuda.manual_seed_all(m_seed)
18. def to_3d(x):
19.     return rearrange(x, 'b c h w -> b (h w) c')
21. def to_4d(x,h,w):
22.     return rearrange(x, 'b (h w) c -> b c h w',h=h,w=w)
24. class BiasFree_LayerNorm(nn.Module):
25.     def __init__(self, normalized_shape):
26.         super(BiasFree_LayerNorm, self).__init__()
27.         if isinstance(normalized_shape, numbers.Integral):
28.             normalized_shape = (normalized_shape,)
29.         normalized_shape = torch.Size(normalized_shape)
31.         assert len(normalized_shape) == 1
33.         self.weight = nn.Parameter(torch.ones(normalized_shape))
34.         self.normalized_shape = normalized_shape
36.     def forward(self, x):
37.         sigma = x.var(-1, keepdim=True, unbiased=False)
38.         return x / torch.sqrt(sigma+1e-5) * self.weight
40. class WithBias_LayerNorm(nn.Module):
41.     def __init__(self, normalized_shape):
42.         super(WithBias_LayerNorm, self).__init__()
43.         if isinstance(normalized_shape, numbers.Integral):
44.             normalized_shape = (normalized_shape,)
45.         normalized_shape = torch.Size(normalized_shape)
47.         assert len(normalized_shape) == 1
49.         self.weight = nn.Parameter(torch.ones(normalized_shape))
50.         self.bias = nn.Parameter(torch.zeros(normalized_shape))
51.         self.normalized_shape = normalized_shape
53.     def forward(self, x):
54.         mu = x.mean(-1, keepdim=True)
55.         sigma = x.var(-1, keepdim=True, unbiased=False)
56.         return (x - mu) / torch.sqrt(sigma+1e-5) * self.weight + self.bias
59. class LayerNorm(nn.Module):
60.     def __init__(self, dim, LayerNorm_type):
61.         super(LayerNorm, self).__init__()
62.         if LayerNorm_type =='BiasFree':
63.             self.body = BiasFree_LayerNorm(dim)
64.         else:
65.             self.body = WithBias_LayerNorm(dim)
67.     def forward(self, x):
68.         h, w = x.shape[-2:]
69.         return to_4d(self.body(to_3d(x)), h, w)
73. ##########################################################################
74. ## Multi-Scale Feed-Forward Network (MSFN)
75. class FeedForward(nn.Module):
76.     def __init__(self, dim, ffn_expansion_factor, bias):
77.         super(FeedForward, self).__init__()
79.         hidden_features = int(dim*ffn_expansion_factor)
81.         self.project_in = nn.Conv3d(dim, hidden_features*3, kernel_size=(1,1,1), bias=bias)
83.         self.dwconv1 = nn.Conv3d(hidden_features, hidden_features, kernel_size=(3,3,3), stride=1, dilation=1, padding=1, groups=hidden_features, bias=bias)
84.         # self.dwconv2 = nn.Conv3d(hidden_features, hidden_features, kernel_size=(3,3,3), stride=1, dilation=2, padding=2, groups=hidden_features, bias=bias)
85.         # self.dwconv3 = nn.Conv3d(hidden_features, hidden_features, kernel_size=(3,3,3), stride=1, dilation=3, padding=3, groups=hidden_features, bias=bias)
86.         self.dwconv2 = nn.Conv2d(hidden_features, hidden_features, kernel_size=(3,3), stride=1, dilation=2, padding=2, groups=hidden_features, bias=bias)
87.         self.dwconv3 = nn.Conv2d(hidden_features, hidden_features, kernel_size=(3,3), stride=1, dilation=3, padding=3, groups=hidden_features, bias=bias)
90.         self.project_out = nn.Conv3d(hidden_features, dim, kernel_size=(1,1,1), bias=bias)
92.     def forward(self, x):
93.         x = x.unsqueeze(2)
94.         x = self.project_in(x)
95.         x1,x2,x3 = x.chunk(3, dim=1)
96.         x1 = self.dwconv1(x1).squeeze(2)
97.         x2 = self.dwconv2(x2.squeeze(2))
98.         x3 = self.dwconv3(x3.squeeze(2))
99.         # x1 = self.dwconv1(x1)
100.         # x2 = self.dwconv2(x2)
101.         # x3 = self.dwconv3(x3)
102.         x = F.gelu(x1)*x2*x3
103.         x = x.unsqueeze(2)
104.         x = x.squeeze(2)      
105.         return x
109. ##########################################################################
110. ## Convolution and Attention Fusion Module  (CAFM)
111. class Attention(nn.Module):
112.     def __init__(self, dim, num_heads, bias):
113.         super(Attention, self).__init__()
114.         self.num_heads = num_heads
115.         self.temperature = nn.Parameter(torch.ones(num_heads, 1, 1))
117.         self.qkv = nn.Conv3d(dim, dim*3, kernel_size=(1,1,1), bias=bias)
118.         self.qkv_dwconv = nn.Conv3d(dim*3, dim*3, kernel_size=(3,3,3), stride=1, padding=1, groups=dim*3, bias=bias)
119.         self.project_out = nn.Conv3d(dim, dim, kernel_size=(1,1,1), bias=bias)
120.         self.fc = nn.Conv3d(3*self.num_heads, 9, kernel_size=(1,1,1), bias=True)
122.         self.dep_conv = nn.Conv3d(9*dim//self.num_heads, dim, kernel_size=(3,3,3), bias=True, groups=dim//self.num_heads, padding=1)
125.     def forward(self, x):
126.         b,c,h,w = x.shape
127.         x = x.unsqueeze(2)
128.         qkv = self.qkv_dwconv(self.qkv(x))
129.         qkv = qkv.squeeze(2)
130.         f_conv = qkv.permute(0,2,3,1)
131.         f_all = qkv.reshape(f_conv.shape[0], h*w, 3*self.num_heads, -1).permute(0, 2, 1, 3)
132.         f_all = self.fc(f_all.unsqueeze(2))
133.         f_all = f_all.squeeze(2)
135.         #local conv
136.         f_conv = f_all.permute(0, 3, 1, 2).reshape(x.shape[0], 9*x.shape[1]//self.num_heads, h, w)
137.         f_conv = f_conv.unsqueeze(2)
138.         out_conv = self.dep_conv(f_conv) # B, C, H, W
139.         out_conv = out_conv.squeeze(2)
142.         # global SA
143.         q,k,v = qkv.chunk(3, dim=1)   
144.         
145.         q = rearrange(q, 'b (head c) h w -> b head c (h w)', head=self.num_heads)
146.         k = rearrange(k, 'b (head c) h w -> b head c (h w)', head=self.num_heads)
147.         v = rearrange(v, 'b (head c) h w -> b head c (h w)', head=self.num_heads)
149.         q = torch.nn.functional.normalize(q, dim=-1)
150.         k = torch.nn.functional.normalize(k, dim=-1)
152.         attn = (q @ k.transpose(-2, -1)) * self.temperature
153.         attn = attn.softmax(dim=-1)
155.         out = (attn @ v)
156.         
157.         out = rearrange(out, 'b head c (h w) -> b (head c) h w', head=self.num_heads, h=h, w=w)
158.         out = out.unsqueeze(2)
159.         out = self.project_out(out)
160.         out = out.squeeze(2)
161.         output =  out + out_conv
163.         return output
167. ##########################################################################
168. ## CAMixing Block
169. class TransformerBlock(nn.Module):
170.     def __init__(self, dim, num_heads, ffn_expansion_factor, bias, LayerNorm_type):
171.         super(TransformerBlock, self).__init__()
173.         self.norm1 = LayerNorm(dim, LayerNorm_type)
174.         self.attn = Attention(dim, num_heads, bias)
175.         self.norm2 = LayerNorm(dim, LayerNorm_type)
176.         self.ffn = FeedForward(dim, ffn_expansion_factor, bias)
178.     def forward(self, x):
179.         x = x + self.attn(self.norm1(x))
180.         x = x + self.ffn(self.norm2(x))
182.         return x
186. class OverlapPatchEmbed(nn.Module):
187.     def __init__(self, in_c=31, embed_dim=48, bias=False):
188.         super(OverlapPatchEmbed, self).__init__()
189.         
191.         self.proj = nn.Conv3d(in_c, embed_dim, kernel_size=(3,3,3), stride=1, padding=1, bias=bias)
193.     def forward(self, x):
194.         x = x.unsqueeze(2)
195.         x = self.proj(x)
196.         x = x.squeeze(2)
197.         return x
201. class Downsample(nn.Module):
202.     def __init__(self, n_feat):
203.         super(Downsample, self).__init__()
205.         self.body = nn.Sequential(nn.Conv2d(n_feat, n_feat//2, kernel_size=3, stride=1, padding=1, bias=False),
206.                                   nn.PixelUnshuffle(2))
208.     def forward(self, x):
209.         # x = x.unsqueeze(2)
210.         x = self.body(x)
211.         # x = x.squeeze(2)
212.         return x
214. class Upsample(nn.Module):
215.     def __init__(self, n_feat):
216.         super(Upsample, self).__init__()
218.         self.body = nn.Sequential(nn.Conv2d(n_feat, n_feat*2, kernel_size=3, stride=1, padding=1, bias=False),
219.                                   nn.PixelShuffle(2))
221.     def forward(self, x):
222.         # x = x.unsqueeze(2)
223.         x = self.body(x)
224.         # x = x.squeeze(2)
225.         return x
227. ##########################################################################
228. ##---------- HCANet -----------------------
229. class HCANet(nn.Module):
230.     def __init__(self,
231.         inp_channels=31,
232.         out_channels=31,
233.         dim = 48,
234.         num_blocks = [2,3,3,4],
235.         num_refinement_blocks = 1,
236.         heads = [1,2,4,8],
237.         ffn_expansion_factor = 2.66,
238.         bias = False,
239.         LayerNorm_type = 'WithBias',
240.     ):
242.         super(HCANet, self).__init__()
244.         self.patch_embed = OverlapPatchEmbed(inp_channels, dim)
246.         self.encoder_level1 = nn.Sequential(*[TransformerBlock(dim=dim, num_heads=heads[0], ffn_expansion_factor=ffn_expansion_factor, bias=bias, LayerNorm_type=LayerNorm_type) for i in range(num_blocks[0])])
247.         
248.         self.down1_2 = Downsample(dim)
249.         self.encoder_level2 = nn.Sequential(*[TransformerBlock(dim=int(dim*2**1), num_heads=heads[1], ffn_expansion_factor=ffn_expansion_factor, bias=bias, LayerNorm_type=LayerNorm_type) for i in range(num_blocks[1])])
250.         
251.         self.down2_3 = Downsample(int(dim*2**1))
252.         self.encoder_level3 = nn.Sequential(*[TransformerBlock(dim=int(dim*2**2), num_heads=heads[2], ffn_expansion_factor=ffn_expansion_factor, bias=bias, LayerNorm_type=LayerNorm_type) for i in range(num_blocks[2])])
255.         self.up3_2 = Upsample(int(dim*2**2))
256.         self.reduce_chan_level2 = nn.Conv3d(int(dim*2**2), int(dim*2**1), kernel_size=(1,1,1), bias=bias)
257.         self.decoder_level2 = nn.Sequential(*[TransformerBlock(dim=int(dim*2**1), num_heads=heads[1], ffn_expansion_factor=ffn_expansion_factor, bias=bias, LayerNorm_type=LayerNorm_type) for i in range(num_blocks[1])])
258.         
259.         self.up2_1 = Upsample(int(dim*2**1))  
260.         self.decoder_level1 = nn.Sequential(*[TransformerBlock(dim=int(dim*2**1), num_heads=heads[0], ffn_expansion_factor=ffn_expansion_factor, bias=bias, LayerNorm_type=LayerNorm_type) for i in range(num_blocks[0])])
261.         
262.         self.refinement = nn.Sequential(*[TransformerBlock(dim=int(dim*2**1), num_heads=heads[0], ffn_expansion_factor=ffn_expansion_factor, bias=bias, LayerNorm_type=LayerNorm_type) for i in range(num_refinement_blocks)])
263.         
264.             
265.         self.output = nn.Conv3d(int(dim*2**1), out_channels, kernel_size=(3,3,3), stride=1, padding=1, bias=bias)
267.     def forward(self, inp_img):
268.         
270.         inp_enc_level1 = self.patch_embed(inp_img)
272.         out_enc_level1 = self.encoder_level1(inp_enc_level1)
275.         
276.         inp_enc_level2 = self.down1_2(out_enc_level1)
278.         out_enc_level2 = self.encoder_level2(inp_enc_level2)
280.         inp_enc_level3 = self.down2_3(out_enc_level2)
281.         out_enc_level3 = self.encoder_level3(inp_enc_level3)
283.         out_dec_level3 = out_enc_level3
284.         inp_dec_level2 = self.up3_2(out_dec_level3)
286.         inp_dec_level2 = torch.cat([inp_dec_level2, out_enc_level2], 1)
288.         inp_dec_level2 = self.reduce_chan_level2(inp_dec_level2.unsqueeze(2))
289.         inp_dec_level2 = inp_dec_level2.squeeze(2)
291.         out_dec_level2 = self.decoder_level2(inp_dec_level2)
294.         inp_dec_level1 = self.up2_1(out_dec_level2)
296.         inp_dec_level1 = torch.cat([inp_dec_level1, out_enc_level1], 1)
298.         out_dec_level1 = self.decoder_level1(inp_dec_level1)
300.         
301.         out_dec_level1 = self.refinement(out_dec_level1)
304.         out_dec_level1 = self.output(out_dec_level1.unsqueeze(2)).squeeze(2) + inp_img
308.         return out_dec_level1
310. if __name__ == "__main__":
311.     model = HCANet()
312.     # print(model)
313.     # summary(model, (1,31,128,128))
314.     inputs = torch.ones([2,31,128,128]) #[b,c,h,w]
315.     outputs = model(inputs)
316.     print(outputs.size())

复制代码

三、 改进教程

2.1 修改YAML文件

详细的改进教程以及源码，戳这！戳这！！戳这！！！B站：AI学术叫叫兽 源码在相簿的链接中，动态中也有链接，感谢支持！祝科研遥遥领先！
2.2 新建HCANet.py

详细的改进教程以及源码，戳这！戳这！！戳这！！！B站：AI学术叫叫兽er 源码在相簿的链接中，动态中也有链接，感谢支持！祝科研遥遥领先！
2.3 修改tasks.py

详细的改进教程以及源码，戳这！戳这！！戳这！！！B站：AI学术叫叫兽er 源码在相簿的链接中，动态中也有链接，感谢支持！祝科研遥遥领先！
四、验证是否成功即可

执行命令

1. python train.py

复制代码

改完收工！
关注B站：AI学术叫叫兽
从此走上科研快速路
遥遥领先同行！！！！
详细的改进教程以及源码，戳这！戳这！！戳这！！！B站：AI学术叫叫兽er 源码在相簿的链接中，动态中也有链接，感谢支持！祝科研遥遥领先！
五、写在最后

学术因方向、个人实行和写作本领以及详细创新内容的不同而无法做到一通百通，以是本文作者即B站Up主：Ai学术叫叫兽
在全部B站资料中留下接洽方式以便在科研之余为家人们答疑解惑，本up主获得过国奖，发表多篇SCI，善于目标检测领域，拥有多项比赛履历，拥有软件著作权，焦点期刊等履历。由于履历过以是更懂小白的痛苦！由于履历过以是更具有指向性的引导！
祝全部科研工作者都能够在自己的领域上更上一层楼！！！
详细的改进教程以及源码，戳这！戳这！！戳这！！！B站：AI学术叫叫兽 源码在动态中有链接，感谢支持！祝科研遥遥领先！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。