程序员经验分享-hwhale

yolov5加入CBAM,SE,CA,ECA注意力机制，纯代码（22.3.1还更新）

2023-11-11

 本文所涉及到的yolov5网络为5.0版本，后续有需求会更新6.0版本。

CBAM注意力

# class ChannelAttention(nn.Module):
#     def __init__(self, in_planes, ratio=16):
#         super(ChannelAttention, self).__init__()
#         self.avg_pool = nn.AdaptiveAvgPool2d(1)
#         self.max_pool = nn.AdaptiveMaxPool2d(1)
#
#         self.f1 = nn.Conv2d(in_planes, in_planes // ratio, 1, bias=False)
#         self.relu = nn.ReLU()
#         self.f2 = nn.Conv2d(in_planes // ratio, in_planes, 1, bias=False)
#         # 写法二,亦可使用顺序容器
#         # self.sharedMLP = nn.Sequential(
#         # nn.Conv2d(in_planes, in_planes // ratio, 1, bias=False), nn.ReLU(),
#         # nn.Conv2d(in_planes // rotio, in_planes, 1, bias=False))
#
#         self.sigmoid = nn.Sigmoid()
#
#     def forward(self, x):
#         avg_out = self.f2(self.relu(self.f1(self.avg_pool(x))))
#         max_out = self.f2(self.relu(self.f1(self.max_pool(x))))
#         out = self.sigmoid(avg_out + max_out)
#         return out
#
#
# class SpatialAttention(nn.Module):
#     def __init__(self, kernel_size=7):
#         super(SpatialAttention, self).__init__()
#
#         assert kernel_size in (3, 7), 'kernel size must be 3 or 7'
#         padding = 3 if kernel_size == 7 else 1
#
#         self.conv = nn.Conv2d(2, 1, kernel_size, padding=padding, bias=False)
#         self.sigmoid = nn.Sigmoid()
#
#     def forward(self, x):
#         avg_out = torch.mean(x, dim=1, keepdim=True)
#         max_out, _ = torch.max(x, dim=1, keepdim=True)
#         x = torch.cat([avg_out, max_out], dim=1)
#         x = self.conv(x)
#         return self.sigmoid(x)
#
#
# class CBAMC3(nn.Module):
#     # CSP Bottleneck with 3 convolutions
#     def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):  # ch_in, ch_out, number, shortcut, groups, expansion
#         super(CBAMC3, self).__init__()
#         c_ = int(c2 * e)  # hidden channels
#         self.cv1 = Conv(c1, c_, 1, 1)
#         self.cv2 = Conv(c1, c_, 1, 1)
#         self.cv3 = Conv(2 * c_, c2, 1)
#         self.m = nn.Sequential(*[Bottleneck(c_, c_, shortcut, g, e=1.0) for _ in range(n)])
#         self.channel_attention = ChannelAttention(c2, 16)
#         self.spatial_attention = SpatialAttention(7)
#
#         # self.m = nn.Sequential(*[CrossConv(c_, c_, 3, 1, g, 1.0, shortcut) for _ in range(n)])
#
#     def forward(self, x):
#         out = self.channel_attention(x) * x
#         print('outchannels:{}'.format(out.shape))
#         out = self.spatial_attention(out) * out
#         return out

CBAM代码 2022.1.26更新

受大佬指点，指出上述cbam模块不匹配yolov5工程代码，yolov5加入cbam注意力的代码以下述代码为准：（如果用这段代码，yolo.py和yaml文件中相应的CBAMC3也要换成CBAM，下面的SE同理）

class ChannelAttention(nn.Module):
    def __init__(self, in_planes, ratio=16):
        super(ChannelAttention, self).__init__()
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.max_pool = nn.AdaptiveMaxPool2d(1)

        self.f1 = nn.Conv2d(in_planes, in_planes // ratio, 1, bias=False)
        self.relu = nn.ReLU()
        self.f2 = nn.Conv2d(in_planes // ratio, in_planes, 1, bias=False)
        # 写法二,亦可使用顺序容器
        # self.sharedMLP = nn.Sequential(
        # nn.Conv2d(in_planes, in_planes // ratio, 1, bias=False), nn.ReLU(),
        # nn.Conv2d(in_planes // rotio, in_planes, 1, bias=False))

        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        avg_out = self.f2(self.relu(self.f1(self.avg_pool(x))))
        max_out = self.f2(self.relu(self.f1(self.max_pool(x))))
        out = self.sigmoid(avg_out + max_out)
        return out


class SpatialAttention(nn.Module):
    def __init__(self, kernel_size=7):
        super(SpatialAttention, self).__init__()

        assert kernel_size in (3, 7), 'kernel size must be 3 or 7'
        padding = 3 if kernel_size == 7 else 1

        self.conv = nn.Conv2d(2, 1, kernel_size, padding=padding, bias=False)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        avg_out = torch.mean(x, dim=1, keepdim=True)
        max_out, _ = torch.max(x, dim=1, keepdim=True)
        x = torch.cat([avg_out, max_out], dim=1)
        x = self.conv(x)
        return self.sigmoid(x)


class CBAM(nn.Module):
    # CSP Bottleneck with 3 convolutions
    def __init__(self, c1, c2, ratio=16, kernel_size=7):  # ch_in, ch_out, number, shortcut, groups, expansion
        super(CBAM, self).__init__()
        # c_ = int(c2 * e)  # hidden channels
        # self.cv1 = Conv(c1, c_, 1, 1)
        # self.cv2 = Conv(c1, c_, 1, 1)
        # self.cv3 = Conv(2 * c_, c2, 1)
        # self.m = nn.Sequential(*[Bottleneck(c_, c_, shortcut, g, e=1.0) for _ in range(n)])
        self.channel_attention = ChannelAttention(c1, ratio)
        self.spatial_attention = SpatialAttention(kernel_size)

        # self.m = nn.Sequential(*[CrossConv(c_, c_, 3, 1, g, 1.0, shortcut) for _ in range(n)])

    def forward(self, x):
        out = self.channel_attention(x) * x
        # print('outchannels:{}'.format(out.shape))
        out = self.spatial_attention(out) * out
        return out

 1.这里是卷积注意力的代码，我一般喜欢加在common.py的C3模块后面，不需要做改动，傻瓜ctrl+c+v就可以了。

2.在yolo.py里做改动。在parse_model函数里将对应代码用以下代码替换，还是傻瓜ctrl+c+v。

 if m in [Conv, GhostConv, Bottleneck, GhostBottleneck, SPP, DWConv, MixConv2d, Focus, CrossConv, BottleneckCSP,
                 C3, C3TR,CBAMC3]:
            c1, c2 = ch[f], args[0]
            if c2 != no:  # if not output
                c2 = make_divisible(c2 * gw, 8)

            args = [c1, c2, *args[1:]]
            if m in [BottleneckCSP, C3,CBAMC3]:
                args.insert(2, n)  # number of repeats
                n = 1

3.在yaml文件里改动。比如你要用s网络，我是这样改的：将骨干网络中的C3模块全部替换为CBAMC3模块（这里需要注意的是，这样改动只能加载少部分预训练权重）。如果不想改动这么大，那么接着往下看。

pytorch中加入注意力机制（CBAM），以yolov5为例_YY_172的博客-CSDN博客_yolov5加注意力

这是首发将CBAM注意力添加到yolov5网络中的博主，我也是看了他的方法，侵删。

backbone:
  # [from, number, module, args]
  [[-1, 1, Focus, [64, 3]],  # 0-P1/2
   [-1, 1, Conv, [128, 3, 2]],  # 1-P2/4
   [-1, 3,CBAMC3, [128]],
   [-1, 1, Conv, [256, 3, 2]],  # 3-P3/8
   [-1, 9, CBAMC3, [256]],
   [-1, 1, Conv, [512, 3, 2]],  # 5-P4/16
   [-1, 9, CBAMC3, [512]],
   [-1, 1, Conv, [1024, 3, 2]],  # 7-P5/32
   [-1, 1, SPP, [1024, [5, 9, 13]]],
   [-1, 3, CBAMC3, [1024, False]],  # 9
  ]

 SE注意力

class SELayer(nn.Module):
    def __init__(self, c1, r=16):
        super(SELayer, self).__init__()
        self.avgpool = nn.AdaptiveAvgPool2d(1)
        self.l1 = nn.Linear(c1, c1 // r, bias=False)
        self.relu = nn.ReLU(inplace=True)
        self.l2 = nn.Linear(c1 // r, c1, bias=False)
        self.sig = nn.Sigmoid()

    def forward(self, x):
        b, c, _, _ = x.size()
        y = self.avgpool(x).view(b, c)
        y = self.l1(y)
        y = self.relu(y)
        y = self.l2(y)
        y = self.sig(y)
        y = y.view(b, c, 1, 1)
        return x * y.expand_as(x)

2022.1.26SE代码更新 

受同一位大佬指正，上述部分的se代码同样没有匹配yolov5工程代码，将修改后的se代码贴出，se注意力的代码以下述为准：

class SE(nn.Module):
    def __init__(self, c1, c2, r=16):
        super(SE, self).__init__()
        self.avgpool = nn.AdaptiveAvgPool2d(1)
        self.l1 = nn.Linear(c1, c1 // r, bias=False)
        self.relu = nn.ReLU(inplace=True)
        self.l2 = nn.Linear(c1 // r, c1, bias=False)
        self.sig = nn.Sigmoid()

    def forward(self, x):
        print(x.size())
        b, c, _, _ = x.size()
        y = self.avgpool(x).view(b, c)
        y = self.l1(y)
        y = self.relu(y)
        y = self.l2(y)
        y = self.sig(y)
        y = y.view(b, c, 1, 1)
        return x * y.expand_as(x)

1.这里是SE注意力的代码段，同上一个注意力的加法一样，我喜欢加在C3后面。

2.在yolo.py中做改动。

def parse_model(d, ch):  # model_dict, input_channels(3)
    logger.info('\n%3s%18s%3s%10s  %-40s%-30s' % ('', 'from', 'n', 'params', 'module', 'arguments'))
    anchors, nc, gd, gw = d['anchors'], d['nc'], d['depth_multiple'], d['width_multiple']
    na = (len(anchors[0]) // 2) if isinstance(anchors, list) else anchors  # number of anchors
    no = na * (nc + 5)  # number of outputs = anchors * (classes + 5)

    layers, save, c2 = [], [], ch[-1]  # layers, savelist, ch out
    for i, (f, n, m, args) in enumerate(d['backbone'] + d['head']):  # from, number, module, args
        m = eval(m) if isinstance(m, str) else m  # eval strings
        for j, a in enumerate(args):
            try:
                args[j] = eval(a) if isinstance(a, str) else a  # eval strings
            except:
                pass

        n = max(round(n * gd), 1) if n > 1 else n  # depth gain
        if m in [Conv, GhostConv, Bottleneck, GhostBottleneck, SPP, DWConv, MixConv2d, Focus, CrossConv, BottleneckCSP,
                 C3, C3TR, CoordAtt, SELayer, eca_layer, CBAM]:
            c1, c2 = ch[f], args[0]
            if c2 != no:  # if not output
                c2 = make_divisible(c2 * gw, 8)

            args = [c1, c2, *args[1:]]
            if m in [BottleneckCSP, C3, C3TR]:
                args.insert(2, n)  # number of repeats
                n = 1
        elif m is nn.BatchNorm2d:
            args = [ch[f]]
        elif m is Concat:
            c2 = sum([ch[x] for x in f])
        elif m is Detect:
            args.append([ch[x] for x in f])
            if isinstance(args[1], int):  # number of anchors
                args[1] = [list(range(args[1] * 2))] * len(f)
        elif m is Contract:
            c2 = ch[f] * args[0] ** 2
        elif m is Expand:
            c2 = ch[f] // args[0] ** 2
        else:
            c2 = ch[f]

3.在你要用的yaml文件中做改动。

backbone:
  # [from, number, module, args]
  [[-1, 1, Focus, [64, 3]],  # 0-P1/2
   [-1, 1, Conv, [128, 3, 2]],  # 1-P2/4
   [-1, 3,C3, [128]],
   [-1, 1, Conv, [256, 3, 2]],  # 3-P3/8
   [-1, 9, C3, [256]],
   [-1, 1, Conv, [512, 3, 2]],  # 5-P4/16
   [-1, 9, C3, [512]],
   [-1, 1, Conv, [1024, 3, 2]],  # 7-P5/32
   [-1, 1, SPP, [1024, [5, 9, 13]]],
   [-1, 3, C3, [1024, False]],  # 9
   [-1, 1, SELayer, [1024, 4]]
  ]

 运行成功后是这样的

 应该能看到那个注意力加在哪里了吧，这就是用上了。

这是我用的另一种添加注意力的方法，这种方法会加载预训练权重，推荐大家使用这种方法。既然推荐大家使用这种方法，那我推荐添加CBAM注意力那种方法目的是啥呢？哈哈哈哈再往下看。

天池竞赛-布匹缺陷检测baseline提升过程-给yolov5模型添加注意力机制_pprp的博客-CSDN博客_yolov5注意力机制

这是我看的将SE注意力添加到 yolov5模型里的博客，我同样也是引用了这位博主的方法，感谢分享，侵删。

 ECA注意力

# class eca_layer(nn.Module):
#     """Constructs a ECA module.
#     Args:
#         channel: Number of channels of the input feature map
#         k_size: Adaptive selection of kernel size
#     """
#     def __init__(self, channel, k_size=3):
#         super(eca_layer, self).__init__()
#         self.avg_pool = nn.AdaptiveAvgPool2d(1)
#         self.conv = nn.Conv1d(1, 1, kernel_size=k_size, padding=(k_size - 1) // 2, bias=False)
#         self.sigmoid = nn.Sigmoid()
#
#     def forward(self, x):
#         # feature descriptor on the global spatial information
#         y = self.avg_pool(x)
#
#         # Two different branches of ECA module
#         y = self.conv(y.squeeze(-1).transpose(-1, -2)).transpose(-1, -2).unsqueeze(-1)
#
#         # Multi-scale information fusion
#         y = self.sigmoid(y)
#         x=x*y.expand_as(x)
#
#         return x * y.expand_as(x)

1.这里是注意力代码片段，放到自己的脚本里把注释取消掉就可以了，添加的位置同上，这里就不说了。 

2.改动yolo.py。看以下代码段。

      if m in [Conv, GhostConv, Bottleneck, GhostBottleneck, SPP, DWConv, MixConv2d, Focus, CrossConv, BottleneckCSP,
                 C3, C3TR]:
            c1, c2 = ch[f], args[0]
            if c2 != no:  # if not output
                c2 = make_divisible(c2 * gw, 8)

            args = [c1, c2, *args[1:]]
            if m in [BottleneckCSP, C3,eca_layer]:
                args.insert(2, n)  # number of repeats
                n = 1
        elif m is nn.BatchNorm2d:
            args = [ch[f]]
        elif m is Concat:
            c2 = sum([ch[x] for x in f])
        elif m is Detect:
            args.append([ch[x] for x in f])
            if isinstance(args[1], int):  # number of anchors
                args[1] = [list(range(args[1] * 2))] * len(f)
        elif m is Contract:
            c2 = ch[f] * args[0] ** 2
        elif m is Expand:
            c2 = ch[f] // args[0] ** 2
        elif m is eca_layer:
            channel=args[0]
            channel=make_divisible(channel*gw,8)if channel != no else channel
            args=[channel]
        else:
            c2 = ch[f]

 3.改动你要用的yaml文件。这里我要解释一下为什么交代了两种添加注意力的方法（第一种：将骨干里的C3全部替换掉；第二种：在骨干最后一层加注意力，做一个输出层）。第二种方法的模型目前还在跑，还没出结果，不过模型的结果也能猜个大概，有稳定的微小提升，detect效果不会提升太多；我在用第一种方法将ECA注意力全部替换掉骨干里的C3时，模型的p、r、map均出现了下降的情况，大概就是一个两个点，但是令人意外的是，他的检测效果很好，能够检测到未作改动前的模型很多检测不到的目标，当然也会比原模型出现更多的误检和漏检情况，手动改阈值后好了很多，因为数据集涉及到公司机密，所以这里就不放出来了，我做的是安全帽的检测，有兴趣的同学可以尝试一下这种添加注意力的方法。

看下其中一张的检测结果。

如果只是求提高模型准确率，推荐第二种方法。

 接下来就是发表在今年CVPR上的注意力了。

CoorAttention

# class h_sigmoid(nn.Module):
#     def __init__(self, inplace=True):
#         super(h_sigmoid, self).__init__()
#         self.relu = nn.ReLU6(inplace=inplace)
#
#     def forward(self, x):
#         return self.relu(x + 3) / 6
#
#
# class h_swish(nn.Module):
#     def __init__(self, inplace=True):
#         super(h_swish, self).__init__()
#         self.sigmoid = h_sigmoid(inplace=inplace)
#
#     def forward(self, x):
#         return x * self.sigmoid(x)


# class CoordAtt(nn.Module):
#     def __init__(self, inp, oup, reduction=32):
#         super(CoordAtt, self).__init__()
#         self.pool_h = nn.AdaptiveAvgPool2d((None, 1))
#         self.pool_w = nn.AdaptiveAvgPool2d((1, None))
#
#         mip = max(8, inp // reduction)
#
#         self.conv1 = nn.Conv2d(inp, mip, kernel_size=1, stride=1, padding=0)
#         self.bn1 = nn.BatchNorm2d(mip)
#         self.act = h_swish()
#
#         self.conv_h = nn.Conv2d(mip, oup, kernel_size=1, stride=1, padding=0)
#         self.conv_w = nn.Conv2d(mip, oup, kernel_size=1, stride=1, padding=0)
#
#     def forward(self, x):
#         identity = x
#
#         n, c, h, w = x.size()
#         x_h = self.pool_h(x)
#         x_w = self.pool_w(x).permute(0, 1, 3, 2)
#
#         y = torch.cat([x_h, x_w], dim=2)
#         y = self.conv1(y)
#         y = self.bn1(y)
#         y = self.act(y)
#
#         x_h, x_w = torch.split(y, [h, w], dim=2)
#         x_w = x_w.permute(0, 1, 3, 2)
#
#         a_h = self.conv_h(x_h).sigmoid()
#         a_w = self.conv_w(x_w).sigmoid()
#
#         out = identity * a_w * a_h
#
#         return out

 这是代码段，加在common.py的C3模块后面

 这里是改动yolo.py的部分，最后在yaml文件里的改动这里就不说了，前面提供了两种方法供大家使用，大家可以自行选择。

def parse_model(d, ch):  # model_dict, input_channels(3)
    logger.info('\n%3s%18s%3s%10s  %-40s%-30s' % ('', 'from', 'n', 'params', 'module', 'arguments'))
    anchors, nc, gd, gw = d['anchors'], d['nc'], d['depth_multiple'], d['width_multiple']
    na = (len(anchors[0]) // 2) if isinstance(anchors, list) else anchors  # number of anchors
    no = na * (nc + 5)  # number of outputs = anchors * (classes + 5)

    layers, save, c2 = [], [], ch[-1]  # layers, savelist, ch out
    for i, (f, n, m, args) in enumerate(d['backbone'] + d['head']):  # from, number, module, args
        m = eval(m) if isinstance(m, str) else m  # eval strings
        for j, a in enumerate(args):
            try:
                args[j] = eval(a) if isinstance(a, str) else a  # eval strings
            except:
                pass

        n = max(round(n * gd), 1) if n > 1 else n  # depth gain
        if m in [Conv, GhostConv, Bottleneck, GhostBottleneck, SPP, DWConv, MixConv2d, Focus, CrossConv, BottleneckCSP,
                 C3, C3TR,CBAMC3,CoordAtt]:#
            c1, c2 = ch[f], args[0]
            if c2 != no:  # if not output
                c2 = make_divisible(c2 * gw, 8)

            args = [c1, c2, *args[1:]]
            if m in [BottleneckCSP, C3, C3TR]:
                args.insert(2, n)  # number of repeats
                n = 1
        elif m is nn.BatchNorm2d:
            args = [ch[f]]
        elif m is Concat:
            c2 = sum([ch[x] for x in f])
        elif m is Detect:
            args.append([ch[x] for x in f])
            if isinstance(args[1], int):  # number of anchors
                args[1] = [list(range(args[1] * 2))] * len(f)
        elif m is Contract:
            c2 = ch[f] * args[0] ** 2
        elif m is Expand:
            c2 = ch[f] // args[0] ** 2
        # elif m is eca_layer:
        #     channel=args[0]
        #     channel=make_divisible(channel*gw,8)if channel != no else channel
        #     args=[channel]   
        elif m is CoordAtt:
            inp,oup,re = args[0],args[1],args[2]
            oup = make_divisible(oup * gw, 8) if oup != no else oup
            args = [inp,oup,re]
        else:
            c2 = ch[f]

后面的ECA和CA注意力添加方法是我对着前两位博主照葫芦画瓢，在我的本地运行多次，就俩字，好用，以后的注意力也可以按照这种方法去添加。

yolov5-6.0版本的注意力添加方法请移步这里

各种注意力的添加方法以及如何work，我都懂一些，如果有需要的朋友可以联系我，赚点生活费。

2022.2.14更：本人已实现使用densenet替换focus、neck中fpn结构改为bi-fpn代码，有需要的小伙伴请私聊，赚点生活费。可用于毕业以及硕士小论文发表的trick。 

 不胜感激，最后祝大家年薪百万。

扯完了。

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

深度学习

Pytorch

tensorflow

人工智能

目标检测

yolov5加入CBAM,SE,CA,ECA注意力机制，纯代码（22.3.1还更新） 的相关文章

随机推荐

  • python 批量创建文件夹

    批量创建文件夹 文件夹的名称如果在一个excel中 那就先获取excel中的数据 转成list 获取这个excel中的某一列的数据 使用pandas的情况注意数据格式是Dateframe 转成list import pandas as pd

  • 【Kubernetes系列】工作负载资源之Deployment

    文章目录 概述 Deployment用例 创建 Deployment Deployment 状态 更新 Deployment 回滚 Deployment Deployment 规约 Pod 模板 副本 选择算符 策略 进度期限秒数 最短就绪

  • java为什么还有基本数据类型

    Java既然是面向对象的 宣称一切都是对象 那为什么还有基础类型 基本数据类型是用的最频繁的类型 而且占用存储空间小 可以把它们存入栈中 实现快速的操作 而他们的封装类Integer等 必需创建实例 在堆中开辟内存 既消耗资源 又耗费时间

  • gitolite安装及配置教程centos7

    1 安装依赖包 yum install curl devel expat devel gettext devel openssl devel zlib devel perl devel y 2 安装 Git yum y install gi

  • linux编译命令——make -j8

    项目越来越大 每次需要重新编译整个项目都是一件很浪费时间的事情 Research了一下 找到以下可以帮助提高速度的方法 总结一下 1 tmpfs 有人说在Windows下用了RAMDisk把一个项目编译时间从4 5小时减少到了5分钟 也许这

  • 小知识点记录:(“字符“).equals(str)与str.equals(“字符“)的区别

    最近遇到这个知识点 字符 equals str 和 str equals 字符 的区别 之前比较常用 字符 equals str 但还是仔细区分一下 因为 如果传入的字符串str为null时 null的的引用类型变量来调用方法会抛出异常 先

  • 架构师成长之路-docker 搭建kibana可视化平台操作es索引

    什么是kibana Kibana 是一款免费开源的前端应用程序 其基础是 Elastic Stack 可以为 Elasticsearch 中索引的数据提供搜索和数据可视化功能 官方术语可以理解操作es的一个可视化工具 es封装了接口 而ki

  • 缺席一年后，谷歌I/O大会回来了！3D视频聊天，10倍性能TPU，还有Android 12重磅登场！...

    新智元报道 来源 Google Blog 编辑 yaxin 好困 新智元导读 5月19日凌晨1点 谷歌IO 2021开发者大会重新回归 谷歌可谓是厚积薄发 积攒2年创新技术轮番轰炸 3D视频聊天Starline 十倍性能TPU V4 聊天不

  • 浅谈小程序开源业务架构建设之路

    一 业务介绍 1 1 小程序开源整体介绍 百度从做智能小程序的第一天开始就打造真正开源开放的生态 我们的愿景是 定义移动时代最佳体验 建设智能小程序行业标准 打破孤岛 共建开源 开放 繁荣的小程序行业生态 百度智能小程序的生态玩家有三类 分

  • Java和Python读取文件总结

    public static ArrayList

  • 紫光电子档案管理系统存在SQL注入漏洞（漏洞复现）

    文章目录 紫光电子档案管理系统存在SQL注入漏洞 漏洞复现 0x01 前言 0x02 漏洞描述 0x03 影响范围 0x04 漏洞环境 0x05 漏洞复现 1 访问漏洞环境 2 构造POC 3 复现 紫光电子档案管理系统存在SQL注入漏洞

  • VMware如何导出和导入OVF文件

    开源虚拟化格式 OVF文件 是一种开源的文件规范 是一种开源 安全 有效 可拓展的便携式虚拟打包格式 由ovf文件 mf文件 cert文件 vmdk文件和iso文件等组成 可以用于虚拟机在不同虚拟化平台上的迁移 本文介绍VMware如何导出

  • Windows10访问共享总是提示输入网络凭证不正确

    场景 安装了windows10系统后 访问共享时总是提示输入网络凭证 输入什么都提示不正确 被访问机也是windows 10 操作系统 使用windows7不需要输入密码就可以访问 即使在被访问机上增加新的用户或者用guest账号去登录也会

  • GB9706.1-2007名词解释：电压

    电压 1 高电压 任何超过 1000V 交流或 1500V 直流或 1500V 峰值的电压 2 网电源电压 多相供电网中两相线之间的电压 或单相供电网中相线与中性线之间的电压 3 安全特低电压 在用安全特低电压变压器或等效隔离程度的装置与供

  • typora

    关于typora的一篇博客 https blog csdn net mingzhuo 126 article details 79941450

  • faceswap使用记录

    1 没有显示 fs cache文件夹 当时我是使用云gpu来运行文件代码的 里面提示我安装两个配置文件放置到 fs cache文件夹 但是当前文件夹里面并没有显示 fa cache文件夹 虽然不知道是什么原因 但这个文件夹其实是存在的 你下

  • java读取文件的方法是_java读取文件的方法有几种

    java读取文件的方法有几种 发布时间 2020 06 26 14 56 33 来源 亿速云 阅读 104 作者 Leah 这篇文章将为大家详细讲解有关java读取文件的方法 文章内容质量较高 因此小编分享给大家做个参考 希望大家阅读完这篇

  • 【python】Counter 函数的用法

    https docs python org 3 6 library collections html collections Counter 原文链接 https blog csdn net u010339879 article detai

  • 使用CocosBuilder2.1结合cocos2d-x2.0.3创建动画场景

    原文地址 http article ityran com archives 2140 本为由泰然教程组成员 浅底 原创 作为一位经验丰富的游戏开发人员 这次浅底将CocosBuilder经验分享给大家 希望大家喜欢 欢迎拍砖 转载请注明出处

  • yolov5加入CBAM,SE,CA,ECA注意力机制，纯代码（22.3.1还更新）

    本文所涉及到的yolov5网络为5 0版本 后续有需求会更新6 0版本 CBAM注意力 class ChannelAttention nn Module def init self in planes ratio 16 super Chan

热门标签