深度学习 计算机视觉中的注意力机制

发布时间：2023-12-20 11:00

计算机视觉中的注意力机制

  • 前言
  • self attention
  • 空间域注意力（spatial transformer network, STN）
  • 通道注意力（Channel Attention, CA）
    • SE-Net
    • ECA-Net
  • Non-Local
  • 位置注意力（position-wise attention）
  • 卷积注意力模块（Convolutional Block Attention Module, CBAM）
  • 应用经验

前言

本篇博客主要介绍计算机视觉中的注意力机制，在之前写过一篇transformer的博客：深度学习 Transformer机制，里面提到了一种注意力机制：self attention。除了self attention之外，还有其他应用于计算机直觉中的注意力机制，因此本篇博客对注意力机制进行梳理以及相关的源码，了解实现的机制。本篇博客主要参考：计算机视觉中的注意力机制。

self attention

在这里就不详细多讲了，详情可参考我之前的一篇博客，在此给出DETR的transformer的实现，代码地址：https://github.com/huggingface/transformers。

# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
\"\"\"
DETR Transformer class.

Copy-paste from torch.nn.Transformer with modifications:
    * positional encodings are passed in MHattention
    * extra LN at the end of encoder is removed
    * decoder returns a stack of activations from all decoding layers
\"\"\"
import copy
from typing import Optional, List

import torch
import torch.nn.functional as F
from torch import nn, Tensor


class Transformer(nn.Module):

    def __init__(self, d_model=512, nhead=8, num_encoder_layers=6,
                 num_decoder_layers=6, dim_feedforward=2048, dropout=0.1,
                 activation=\"relu\", normalize_before=False,
                 return_intermediate_dec=False):
        super().__init__()

        encoder_layer = TransformerEncoderLayer(d_model, nhead, dim_feedforward,
                                                dropout, activation, normalize_before)
        encoder_norm = nn.LayerNorm(d_model) if normalize_before else None
        self.encoder = TransformerEncoder(encoder_layer, num_encoder_layers, encoder_norm)

        decoder_layer = TransformerDecoderLayer(d_model, nhead, dim_feedforward,
                                                dropout, activation, normalize_before)
        decoder_norm = nn.LayerNorm(d_model)
        self.decoder = TransformerDecoder(decoder_layer, num_decoder_layers, decoder_norm,
                                          return_intermediate=return_intermediate_dec)

        self._reset_parameters()

        self.d_model = d_model
        self.nhead = nhead

    def _reset_parameters(self):
        for p in self.parameters():
            if p.dim() > 1:
                nn.init.xavier_uniform_(p)

    def forward(self, src, mask, query_embed, pos_embed):
        # flatten NxCxHxW to HWxNxC
        bs, c, h, w = src.shape
        src = src.flatten(2).permute(2, 0, 1)
        pos_embed = pos_embed.flatten(2).permute(2, 0, 1)
        query_embed = query_embed.unsqueeze(1).repeat(1, bs, 1)
        mask = mask.flatten(1)

        tgt = torch.zeros_like(query_embed)
        memory = self.encoder(src, src_key_padding_mask=mask, pos=pos_embed)
        hs = self.decoder(tgt, memory, memory_key_padding_mask=mask,
                          pos=pos_embed, query_pos=query_embed)
        return hs.transpose(1, 2), memory.permute(1, 2, 0).view(bs, c, h, w)


class TransformerEncoder(nn.Module):

    def __init__(self, encoder_layer, num_layers, norm=None):
        super().__init__()
        self.layers = _get_clones(encoder_layer, num_layers)
        self.num_layers = num_layers
        self.norm = norm

    def forward(self, src,
                mask: Optional[Tensor] = None,
                src_key_padding_mask: Optional[Tensor] = None,
                pos: Optional[Tensor] = None):
        output = src

        for layer in self.layers:
            output = layer(output, src_mask=mask,
                           src_key_padding_mask=src_key_padding_mask, pos=pos)

        if self.norm is not None:
            output = self.norm(output)

        return output


class TransformerDecoder(nn.Module):

    def __init__(self, decoder_layer, num_layers, norm=None, return_intermediate=False):
        super().__init__()
        self.layers = _get_clones(decoder_layer, num_layers)
        self.num_layers = num_layers
        self.norm = norm
        self.return_intermediate = return_intermediate

    def forward(self, tgt, memory,
                tgt_mask: Optional[Tensor] = None,
                memory_mask: Optional[Tensor] = None,
                tgt_key_padding_mask: Optional[Tensor] = None,
                memory_key_padding_mask: Optional[Tensor] = None,
                pos: Optional[Tensor] = None,
                query_pos: Optional[Tensor] = None):
        output = tgt

        intermediate = []

        for layer in self.layers:
            output = layer(output, memory, tgt_mask=tgt_mask,
                           memory_mask=memory_mask,
                           tgt_key_padding_mask=tgt_key_padding_mask,
                           memory_key_padding_mask=memory_key_padding_mask,
                           pos=pos, query_pos=query_pos)
            if self.return_intermediate:
                intermediate.append(self.norm(output))

        if self.norm is not None:
            output = self.norm(output)
            if self.return_intermediate:
                intermediate.pop()
                intermediate.append(output)

        if self.return_intermediate:
            return torch.stack(intermediate)

        return output


class TransformerEncoderLayer(nn.Module):

    def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1,
                 activation=\"relu\", normalize_before=False):
        super().__init__()
        self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
        # Implementation of Feedforward model
        self.linear1 = nn.Linear(d_model, dim_feedforward)
        self.dropout = nn.Dropout(dropout)
        self.linear2 = nn.Linear(dim_feedforward, d_model)

        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)
        self.dropout1 = nn.Dropout(dropout)
        self.dropout2 = nn.Dropout(dropout)

        self.activation = _get_activation_fn(activation)
        self.normalize_before = normalize_before

    def with_pos_embed(self, tensor, pos: Optional[Tensor]):
        return tensor if pos is None else tensor + pos

    def forward_post(self,
                     src,
                     src_mask: Optional[Tensor] = None,
                     src_key_padding_mask: Optional[Tensor] = None,
                     pos: Optional[Tensor] = None):
        q = k = self.with_pos_embed(src, pos)
        src2 = self.self_attn(q, k, value=src, attn_mask=src_mask,
                              key_padding_mask=src_key_padding_mask)[0]
        src = src + self.dropout1(src2)
        src = self.norm1(src)
        src2 = self.linear2(self.dropout(self.activation(self.linear1(src))))
        src = src + self.dropout2(src2)
        src = self.norm2(src)
        return src

    def forward_pre(self, src,
                    src_mask: Optional[Tensor] = None,
                    src_key_padding_mask: Optional[Tensor] = None,
                    pos: Optional[Tensor] = None):
        src2 = self.norm1(src)
        q = k = self.with_pos_embed(src2, pos)
        src2 = self.self_attn(q, k, value=src2, attn_mask=src_mask,
                              key_padding_mask=src_key_padding_mask)[0]
        src = src + self.dropout1(src2)
        src2 = self.norm2(src)
        src2 = self.linear2(self.dropout(self.activation(self.linear1(src2))))
        src = src + self.dropout2(src2)
        return src

    def forward(self, src,
                src_mask: Optional[Tensor] = None,
                src_key_padding_mask: Optional[Tensor] = None,
                pos: Optional[Tensor] = None):
        if self.normalize_before:
            return self.forward_pre(src, src_mask, src_key_padding_mask, pos)
        return self.forward_post(src, src_mask, src_key_padding_mask, pos)


class TransformerDecoderLayer(nn.Module):

    def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1,
                 activation=\"relu\", normalize_before=False):
        super().__init__()
        self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
        self.multihead_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
        # Implementation of Feedforward model
        self.linear1 = nn.Linear(d_model, dim_feedforward)
        self.dropout = nn.Dropout(dropout)
        self.linear2 = nn.Linear(dim_feedforward, d_model)

        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)
        self.norm3 = nn.LayerNorm(d_model)
        self.dropout1 = nn.Dropout(dropout)
        self.dropout2 = nn.Dropout(dropout)
        self.dropout3 = nn.Dropout(dropout)

        self.activation = _get_activation_fn(activation)
        self.normalize_before = normalize_before

    def with_pos_embed(self, tensor, pos: Optional[Tensor]):
        return tensor if pos is None else tensor + pos

    def forward_post(self, tgt, memory,
                     tgt_mask: Optional[Tensor] = None,
                     memory_mask: Optional[Tensor] = None,
                     tgt_key_padding_mask: Optional[Tensor] = None,
                     memory_key_padding_mask: Optional[Tensor] = None,
                     pos: Optional[Tensor] = None,
                     query_pos: Optional[Tensor] = None):
        q = k = self.with_pos_embed(tgt, query_pos)
        tgt2 = self.self_attn(q, k, value=tgt, attn_mask=tgt_mask,
                              key_padding_mask=tgt_key_padding_mask)[0]
        tgt = tgt + self.dropout1(tgt2)
        tgt = self.norm1(tgt)
        tgt2 = self.multihead_attn(query=self.with_pos_embed(tgt, query_pos),
                                   key=self.with_pos_embed(memory, pos),
                                   value=memory, attn_mask=memory_mask,
                                   key_padding_mask=memory_key_padding_mask)[0]
        tgt = tgt + self.dropout2(tgt2)
        tgt = self.norm2(tgt)
        tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt))))
        tgt = tgt + self.dropout3(tgt2)
        tgt = self.norm3(tgt)
        return tgt

    def forward_pre(self, tgt, memory,
                    tgt_mask: Optional[Tensor] = None,
                    memory_mask: Optional[Tensor] = None,
                    tgt_key_padding_mask: Optional[Tensor] = None,
                    memory_key_padding_mask: Optional[Tensor] = None,
                    pos: Optional[Tensor] = None,
                    query_pos: Optional[Tensor] = None):
        tgt2 = self.norm1(tgt)
        q = k = self.with_pos_embed(tgt2, query_pos)
        tgt2 = self.self_attn(q, k, value=tgt2, attn_mask=tgt_mask,
                              key_padding_mask=tgt_key_padding_mask)[0]
        tgt = tgt + self.dropout1(tgt2)
        tgt2 = self.norm2(tgt)
        tgt2 = self.multihead_attn(query=self.with_pos_embed(tgt2, query_pos),
                                   key=self.with_pos_embed(memory, pos),
                                   value=memory, attn_mask=memory_mask,
                                   key_padding_mask=memory_key_padding_mask)[0]
        tgt = tgt + self.dropout2(tgt2)
        tgt2 = self.norm3(tgt)
        tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt2))))
        tgt = tgt + self.dropout3(tgt2)
        return tgt

    def forward(self, tgt, memory,
                tgt_mask: Optional[Tensor] = None,
                memory_mask: Optional[Tensor] = None,
                tgt_key_padding_mask: Optional[Tensor] = None,
                memory_key_padding_mask: Optional[Tensor] = None,
                pos: Optional[Tensor] = None,
                query_pos: Optional[Tensor] = None):
        if self.normalize_before:
            return self.forward_pre(tgt, memory, tgt_mask, memory_mask,
                                    tgt_key_padding_mask, memory_key_padding_mask, pos, query_pos)
        return self.forward_post(tgt, memory, tgt_mask, memory_mask,
                                 tgt_key_padding_mask, memory_key_padding_mask, pos, query_pos)


def _get_clones(module, N):
    return nn.ModuleList([copy.deepcopy(module) for i in range(N)])


def build_transformer(args):
    return Transformer(
        d_model=args.hidden_dim,
        dropout=args.dropout,
        nhead=args.nheads,
        dim_feedforward=args.dim_feedforward,
        num_encoder_layers=args.enc_layers,
        num_decoder_layers=args.dec_layers,
        normalize_before=args.pre_norm,
        return_intermediate_dec=True,
    )


def _get_activation_fn(activation):
    \"\"\"Return an activation function given a string\"\"\"
    if activation == \"relu\":
        return F.relu
    if activation == \"gelu\":
        return F.gelu
    if activation == \"glu\":
        return F.glu
    raise RuntimeError(F\"activation should be relu/gelu, not {activation}.\")

空间域注意力（spatial transformer network, STN）

空间域注意力机制的论文：Spatial Transformer Networks， pytorch实现：https://github.com/fxia22/stn.pytorch。李弘毅讲 STN 网络：https://www.youtube.com/watch?v=SoCywZ1hZak。空间域注意力可以理解为让网络看哪里。CNN具有平移不变性，但是不一定具有缩放不变性，旋转不变性等。因此空间域注意力通过显示的方式使得图像具有一些“不变性”，空间域的变换主要涉及到仿射变换、投影变换和薄板调样变换。

  • 仿射变换
    \"深度学习

  • 投影变换
    \"深度学习

  • 薄板样条变换（TPS）
    \"深度学习
    STN的网络结构如下图所示：
    \"深度学习
    代码实现：

class STN(Module):
    def __init__(self, layout = \'BHWD\'):
        super(STN, self).__init__()
        if layout == \'BHWD\':
            self.f = STNFunction()
        else:
            self.f = STNFunctionBCHW()
    def forward(self, input1, input2):
        return self.f(input1, input2)


class STNFunction(Function):
    def forward(self, input1, input2):
        self.input1 = input1
        self.input2 = input2
        self.device_c = ffi.new(\"int *\")
        output = torch.zeros(input1.size()[0], input2.size()[1], input2.size()[2], input1.size()[3])
        #print(\'decice %d\' % torch.cuda.current_device())
        if input1.is_cuda:
            self.device = torch.cuda.current_device()
        else:
            self.device = -1
        self.device_c[0] = self.device
        if not input1.is_cuda:
            my_lib.BilinearSamplerBHWD_updateOutput(input1, input2, output)
        else:
            output = output.cuda(self.device)
            my_lib.BilinearSamplerBHWD_updateOutput_cuda(input1, input2, output, self.device_c)
        return output

    def backward(self, grad_output):
        grad_input1 = torch.zeros(self.input1.size())
        grad_input2 = torch.zeros(self.input2.size())
        #print(\'backward decice %d\' % self.device)
        if not grad_output.is_cuda:
            my_lib.BilinearSamplerBHWD_updateGradInput(self.input1, self.input2, grad_input1, grad_input2, grad_output)
        else:
            grad_input1 = grad_input1.cuda(self.device)
            grad_input2 = grad_input2.cuda(self.device)
            my_lib.BilinearSamplerBHWD_updateGradInput_cuda(self.input1, self.input2, grad_input1, grad_input2, grad_output, self.device_c)
        return grad_input1, grad_input2

def spatial_attention(input_feature, name=\"\"):
	kernel_size = 7

	cbam_feature = input_feature
	
	avg_pool = Lambda(lambda x: K.mean(x, axis=3, keepdims=True))(cbam_feature)
	max_pool = Lambda(lambda x: K.max(x, axis=3, keepdims=True))(cbam_feature)
	concat = Concatenate(axis=3)([avg_pool, max_pool])

	cbam_feature = Conv2D(filters = 1,
					kernel_size=kernel_size,
					strides=1,
					padding=\'same\',
					kernel_initializer=\'he_normal\',
					use_bias=False,
					name = \"spatial_attention_\"+str(name))(concat)	
	cbam_feature = Activation(\'sigmoid\')(cbam_feature)
		
	return multiply([input_feature, cbam_feature])

通道注意力（Channel Attention, CA）

通道注意力有SE-Net，ECA-Net机制，可以理解为让网络在看什么。

SE-Net

论文：Squeeze-and-Excitation Networks。代码：https://github.com/moskomule/senet.pytorch
SE-Net引入了注意力模块，对每个通道，用一个权重来表示该通道在下一个阶段的重要性，同时该模块即插即用，非常方便。SE模块包含两个步骤：Squeeze操作和Excitation操作，如下图所示。
\"深度学习

  • Squeeze操作
    将各通道的全局空间特征作为该通道的表示，使用全局平均池化生成各通道的统计量。 z c = F s q ( u c ) = 1 H × W ∑ i = 1 H ∑ j = 1 W u c ( i , j ) z_c=F_{sq}(u_c) = \\frac{1}{H\\times W}\\sum^H_{i=1}\\sum^W_{j=1}u_c(i, j) zc​=Fsq​(uc​)=H×W1​i=1∑H​j=1∑W​uc​(i,j)
  • Excitation操作
    学习各通道的依赖程度，并根据依赖程度对不同的特征图进行调整，得到最后的输出，需要考察各通道的依赖程度。该操作是：FC-->Relu--->FC--->Sigmoid。选择全连接层是因为全连接层能够很好地融合全部的输入特征信息，Sigmoid能够将数值映射到0~1区间。 s = F e x ( z , W ) = σ ( g ( z , W ) ) = σ ( W 2 δ ( W 1 z ) ) s=F_{ex}(z, W) = \\sigma(g(z, W)) = \\sigma(W_2\\delta(W_1z)) s=Fex​(z,W)=σ(g(z,W))=σ(W2​δ(W1​z))
  • 融合操作

\"深度学习

代码实现：

def se_block(input_feature, ratio=16, name=\"\"):
	channel = K.int_shape(input_feature)[-1]

	se_feature = GlobalAveragePooling2D()(input_feature)
	se_feature = Reshape((1, 1, channel))(se_feature)

	se_feature = Dense(channel // ratio,
					   activation=\'relu\',
					   kernel_initializer=\'he_normal\',
					   use_bias=False,
					   name = \"se_block_one_\"+str(name))(se_feature)
					   
	se_feature = Dense(channel,
					   kernel_initializer=\'he_normal\',
					   use_bias=False,
					   name = \"se_block_two_\"+str(name))(se_feature)
	se_feature = Activation(\'sigmoid\')(se_feature)

	se_feature = multiply([input_feature, se_feature])
	return se_feature

ECA-Net

论文：ECA-Net: Efficient Channel Attention for Deep Convolutional Neural Networks
代码：https://github.com/BangguWu/ECANet

ECA-Net是SE-Net的扩展，为了降低SE-Net的参数量
\"深度学习

代码实现：
\"深度学习

def eca_block(input_feature, b=1, gamma=2, name=\"\"):
	channel = K.int_shape(input_feature)[-1]
	kernel_size = int(abs((math.log(channel, 2) + b) / gamma))
	kernel_size = kernel_size if kernel_size % 2 else kernel_size + 1
	
	avg_pool = GlobalAveragePooling2D()(input_feature)
	
	x = Reshape((-1,1))(avg_pool)
	x = Conv1D(1, kernel_size=kernel_size, padding=\"same\", name = \"eca_layer_\"+str(name), use_bias=False,)(x)
	x = Activation(\'sigmoid\')(x)
	x = Reshape((1, 1, -1))(x)

	output = multiply([input_feature,x])
	return output

Non-Local

Local这个词主要是针对感受野(receptive field)来说的。以单一的卷积操作为例，它的感受野大小就是卷积核大小，而我们一般都选用 3 × 3 3\\times3 3×3， 5 × 5 5\\times5 5×5之类的卷积核，它们只考虑局部区域，因此都是local的运算。同理，池化(Pooling)也是。相反的，non-local指的就是感受野可以很大，而不是一个局部领域。全连接就是non-local的，而且是global的。但是全连接带来了大量的参数，给优化带来困难。卷积层的堆叠可以增大感受野，但是如果看特定层的卷积核在原图上的感受野，它毕竟是有限的。这是local运算不能避免的。然而有些任务，它们可能需要原图上更多的信息，比如attention。如果在某些层能够引入全局的信息，就能很好地解决local操作无法看清全局的情况，为后面的层带去更丰富的信息。
论文：
代码：https://github.com/AlexHex7/Non-local_pytorch

\"深度学习

位置注意力（position-wise attention）

论文地址：CCNet: Criss-Cross Attention for Semantic Segmentation
代码地址：https://github.com/speedinghzl/CCNet

def _check_contiguous(*args):
    if not all([mod is None or mod.is_contiguous() for mod in args]):
        raise ValueError(\"Non-contiguous input\")


class CA_Weight(autograd.Function):
    @staticmethod
    def forward(ctx, t, f):
        # Save context
        n, c, h, w = t.size()
        size = (n, h+w-1, h, w)
        weight = torch.zeros(size, dtype=t.dtype, layout=t.layout, device=t.device)

        _ext.ca_forward_cuda(t, f, weight)

        # Output
        ctx.save_for_backward(t, f)

        return weight

    @staticmethod
    @once_differentiable
    def backward(ctx, dw):
        t, f = ctx.saved_tensors

        dt = torch.zeros_like(t)
        df = torch.zeros_like(f)

        _ext.ca_backward_cuda(dw.contiguous(), t, f, dt, df)

        _check_contiguous(dt, df)

        return dt, df

class CA_Map(autograd.Function):
    @staticmethod
    def forward(ctx, weight, g):
        # Save context
        out = torch.zeros_like(g)
        _ext.ca_map_forward_cuda(weight, g, out)

        # Output
        ctx.save_for_backward(weight, g)

        return out

    @staticmethod
    @once_differentiable
    def backward(ctx, dout):
        weight, g = ctx.saved_tensors

        dw = torch.zeros_like(weight)
        dg = torch.zeros_like(g)

        _ext.ca_map_backward_cuda(dout.contiguous(), weight, g, dw, dg)

        _check_contiguous(dw, dg)

        return dw, dg

ca_weight = CA_Weight.apply
ca_map = CA_Map.apply


class CrissCrossAttention(nn.Module):
    \"\"\" Criss-Cross Attention Module\"\"\"
    def __init__(self,in_dim):
        super(CrissCrossAttention,self).__init__()
        self.chanel_in = in_dim

        self.query_conv = nn.Conv2d(in_channels = in_dim , out_channels = in_dim//8 , kernel_size= 1)
        self.key_conv = nn.Conv2d(in_channels = in_dim , out_channels = in_dim//8 , kernel_size= 1)
        self.value_conv = nn.Conv2d(in_channels = in_dim , out_channels = in_dim , kernel_size= 1)
        self.gamma = nn.Parameter(torch.zeros(1))

    def forward(self,x):
        proj_query = self.query_conv(x)
        proj_key = self.key_conv(x)
        proj_value = self.value_conv(x)

        energy = ca_weight(proj_query, proj_key)
        attention = F.softmax(energy, 1)
        out = ca_map(attention, proj_value)
        out = self.gamma*out + x

        return out



__all__ = [\"CrissCrossAttention\", \"ca_weight\", \"ca_map\"]

卷积注意力模块（Convolutional Block Attention Module, CBAM）

论文：CBAM: Convolutional Block Attention Module

\"深度学习

从上图可以看出CBAM是融合了Channel Attention Module和Spatial Attention Module。

\"深度学习

应用经验

  1. 大部分注意力模块都是有参数的，添加注意力模块会导致模型的复杂度增加：
    （1）如果添加attention前模型处于欠拟合状态，那么增加参数是有利于模型学习的，性能会提高。
    （2）如果添加attention前模型处于过拟合状态，那么增加参数可能加剧过拟合问题，性能可能保持不变或者下降。

  2. vision transormer在小数据集上性能不好（个人经验），因为太关注于全局性，并且参数量比较大，非常容易过拟合，其记忆数据集的能力也非常强，所以在大规模数据集预训练下才能取到更好的成绩。

  3. 注意力模块对感受野的影响，直观上来讲是会增加模型的感受野大小。理论上最好的情况应该是模型的实际感受野(不是理论感受野)和目标的尺寸大小相符。
    （1）如果添加注意力模块之前，模型的感受野已经足够拟合数据集中的目标，那么如果再添加注意力模块有些画蛇添足，但是由于实际感受野是会变化的，所以可能即便加了注意力模块也可以自调节实际感受野在目标大小附近，这样模型可能保持性能不变。
    （2）如果添加注意力模块之前，模型的感受野是不足的，甚至理论感受都达不到目标的大小（实际感受野大小<理论感受野大小），那么这个时候添加注意力模块就可以起到非常好的作用，性能可能会有一定幅度提升

相关推荐

Linux 系统动态追踪技术介绍

【二叉树初阶】前中后序遍历+层序遍历+基础习题

【从零开始学zabbix】一丶Zabbix的介绍与部署Zabbix

超级炫酷的3D旋转美女图——Python实现

MindSpore报错 `half_pixel_centers`=True only support in Ascend

【Yolov7】 从搭配环境到训练自己的数据集

JAVA中stacksize是什么意思_深入理解JS函数stack size计算方法

小满Vue3第三十六章（Vue如何开发移动端）

Go 临界资源的安全问题（引入同步异步处理）

JAVA基础day05-实用类

利用vue-3d-loader同时加载多个3D模型

HIPPO-4J 1.3.0 正式发布：支持 Dubbo、RibbitMQ、RocketMQ 框架线程池

vue实现移动端拖拽悬浮按钮

中国报表漫谈

Redis是单线程还是多线程？为何速度快？

前端进阶JS数组高级用法大全教程示例

FCOS代码（一） (demo过程)骨干网络结构详解，mask-rcnn ResNet+fpn

微信小程序-全局配置-pages/window

MemSeg 半监督工业图像表面缺陷检测

pyqt5之QTableWidget相关开发笔记

ItVuer - 免责声明 - 关于我们 - 联系我们

本网站信息来源于互联网，如有侵权请联系：561261067@qq.com

桂ICP备16001015号