前言

本篇博客主要介绍计算机视觉中的注意力机制，在之前写过一篇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, Listimport torch
import torch.nn.functional as F
from torch import nn, Tensorclass 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 Noneself.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_modelself.nhead = nheaddef _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 HWxNxCbs, c, h, w = src.shapesrc = 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_layersself.norm = normdef forward(self, src,mask: Optional[Tensor] = None,src_key_padding_mask: Optional[Tensor] = None,pos: Optional[Tensor] = None):output = srcfor 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 outputclass 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_layersself.norm = normself.return_intermediate = return_intermediatedef 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 = tgtintermediate = []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 outputclass 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 modelself.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_beforedef with_pos_embed(self, tensor, pos: Optional[Tensor]):return tensor if pos is None else tensor + posdef 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 srcdef 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 srcdef 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 modelself.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_beforedef with_pos_embed(self, tensor, pos: Optional[Tensor]):return tensor if pos is None else tensor + posdef 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 tgtdef 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 tgtdef 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.reluif activation == "gelu":return F.geluif activation == "glu":return F.gluraise 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 = input1self.input2 = input2self.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 = -1self.device_c[0] = self.deviceif 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 outputdef 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 = 7cbam_feature = input_featureavg_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操作
  将各通道的全局空间特征作为该通道的表示，使用全局平均池化生成各通道的统计量。zc=Fsq(uc)=1H×W∑i=1H∑j=1Wuc(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=Fex(z,W)=σ(g(z,W))=σ(W2δ(W1z))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 + 1avg_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×33\times33×3，5×55\times55×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):@staticmethoddef forward(ctx, t, f):# Save contextn, 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)# Outputctx.save_for_backward(t, f)return weight@staticmethod@once_differentiabledef backward(ctx, dw):t, f = ctx.saved_tensorsdt = 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, dfclass CA_Map(autograd.Function):@staticmethoddef forward(ctx, weight, g):# Save contextout = torch.zeros_like(g)_ext.ca_map_forward_cuda(weight, g, out)# Outputctx.save_for_backward(weight, g)return out@staticmethod@once_differentiabledef backward(ctx, dout):weight, g = ctx.saved_tensorsdw = 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, dgca_weight = CA_Weight.apply
ca_map = CA_Map.applyclass CrissCrossAttention(nn.Module):""" Criss-Cross Attention Module"""def __init__(self,in_dim):super(CrissCrossAttention,self).__init__()self.chanel_in = in_dimself.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 + xreturn 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）如果添加注意力模块之前，模型的感受野是不足的，甚至理论感受都达不到目标的大小（实际感受野大小<理论感受野大小），那么这个时候添加注意力模块就可以起到非常好的作用，性能可能会有一定幅度提升

深度学习 计算机视觉中的注意力机制相关推荐

1. 计算机视觉中的注意力机制的学习笔记

   1 介绍 关于注意力机制(Attension)的综述请参考博文<综述|计算机视觉中的注意力机制> 关于Attention机制,我总觉得是一个很有趣的话题,因为根据"万能拟合器&q ...

2. 综述：计算机视觉中的注意力机制

   作者|xys430381_1 https://blog.csdn.net/xys430381_1/article/details/89323444 本文仅作学术分享,著作权归作者所有,如有侵权,请联系 ...

3. 计算机视觉中的注意力机制--attention mechanism

   转载:https://zhuanlan.zhihu.com/p/56501461 张戎 引言 在机器翻译(Machine Translation)或者自然语言处理(Natural Language P ...

4. 计算机视觉中的注意力机制（Visual Attention）

   ,欢迎关注公众号:论文收割机(paper_reader) 原文链接:计算机视觉中的注意力机制(Visual Attention) 本文将会介绍计算机视觉中的注意力(visual attention)机 ...

5. 万字长文解读计算机视觉中的注意力机制（附论文和代码链接）

   文中论文和代码已经整理,如果需要,点击下方公号关注,领取,持续传达瓜货 所向披靡的张大刀 注意力机制是机器学习中嵌入的一个网络结构,主要用来学习输入数据对输出数据贡献:注意力机制在NLP和CV中均有使 ...

6. 论文--计算机视觉中的注意力机制

   目录 引言 2022-04-09 update 2022-02-02 update 2021-12-15 update CV注意力机制资源汇总 Attention Mechanisms in Comp ...

7. 综述｜计算机视觉中的注意力机制

   点击上方"小白学视觉",选择加"星标"或"置顶" 重磅干货,第一时间送达 作者丨HUST小菜鸡@知乎 来源丨https://zhuanlan ...

8. Stanford CS230深度学习（九）注意力机制和语音识别

   在CS230的lecture 9中主要讲了深度强化学习(Deep Reinforcement Learning)大体上是如何实施的,以及一些应用场景.课后coursera上遗留的最后C5M3的课程及其 ...

9. 2021综述：计算机视觉中的注意力机制(续四）：分支注意力

   3.5 Branch Attention Branch attention 可以看成是一种动态的分支选择机制:要注意哪个,与多分支结构一起使用. 3.5.1 Highway networks 受长短期 ...

最新文章

1. SQL Server ：理解数据记录结构
2. 一题多解 —— 二项式分布的期望和方差的计算
3. 解决办法：configure后，没有更新Makefile
4. 操作系统形式化验证实践教程(1) - 证明第一个定理
5. 实时音频编解码之十一Opus编码
6. 如何向面试官介绍你的项目（面试技巧）
7. Shell中的while用法
8. Visual Studio 2008 测试版 2 自述文件
9. 统信UOS系统安装mysql_统信UOS系统手动安装分区方案
10. 整型转换为32位二进制字符串
11. linux虚拟光驱挂载教程,VMWare 挂载虚拟光驱及制作floppy linux
12. Google GWT
13. 项目管理资格认证PMP考前培训班
14. 安卓手机获取IP地址
15. PMP项目管理—质量情景题
16. 无需埋点,使用App渠道统计SDK进行收集数据
17. SUSE系统关闭防火墙的命令
18. 教程：Win10移动User文件夹到其他位置（多图）
19. 飞旭体质健康测试云平台学生体质测试管理系统
20. android textview椭圆,Android TextView 因为特殊字符（半角圆角等问题）在折行的时候各种不爽 ，不规则折行...

热门文章

1. WOS（六）——导出数据格式及处理
2. k8s----------各种证书配置参数
3. jme-旋转的双子星
4. python中的subprocess.Popen（）使用
5. 说说如何安装与配置 jBPM4 开发环境
6. 磁盘管理关于磁盘的概念
7. 市场调研报告-全球与中国教育互动白板市场现状及未来发展趋势
8. 网页表格线框html,网页表格中单元格线条及边框的设置
9. 谁是合约届「技术之王」？
10. 自我总结--测试面试常见问题（二）