maxpooling和avgpooling

时间: 2023-05-31 20:20:28 浏览: 42
### 回答1: maxpooling和avgpooling是深度学习中常用的池化操作,用于减小特征图的尺寸和提取特征。 maxpooling是取池化窗口内的最大值作为输出,通常用于提取图像中的边缘和纹理等细节特征。 avgpooling是取池化窗口内的平均值作为输出,通常用于提取图像中的整体特征,如物体的大小和形状等。 两种池化操作都可以减小特征图的尺寸,减少计算量和参数数量,同时也可以提取特征,有助于提高模型的性能。 ### 回答2: Maxpooling和Avgpooling是卷积神经网络中常用的两种池化(pooling)方法。池化层是一种用于降低特征图纬度的操作,通过将大的特征图变成小的特征图,可以减少参数数量,提高计算速度,并有助于防止过拟合。 Maxpooling是一种取最大值的池化方法。具体来说,对于每个池化窗口(通常大小为2×2),Maxpooling会在窗口中选取最大的数值,将其作为缩小后特征图的值。该方法可以保留最重要的特征,抑制噪声,并在一定程度上实现平移不变性,对于图像中的目标检测和分类任务都有较好的效果。 相对而言,Avgpooling则是一种将池化窗口内所有数值的平均值作为特征图值的池化方法。其对特征信息的保留相对于Maxpooling而言略微减少,但是具有更好的平移不变性,对于图像中的目标检测和分类任务也有一定的效果。此外,Avgpooling比Maxpooling更加平滑,能够有效减小特征图中不必要的信息。 总体来说,选择Maxpooling还是Avgpooling要根据具体问题而定。在特征图尺寸减小的情况下,选择Maxpooling可以更好地保留最重要的特征,而选择Avgpooling则可以更好地在不同位置处理相似的特征。因此,在设计深度学习模型时,可以根据具体的任务类型和数据集特点来灵活选择不同的池化方法。 ### 回答3: 池化层是深度学习中一层非常重要的网络层,常见的池化操作包括MaxPooling和AvgPooling两种方式。池化层可以有效地减少输入数据的维度,一方面降低了计算量和参数个数,另一方面还可以提高模型的鲁棒性和泛化能力。 MaxPooling层是指对输入矩阵中的每个子块,取该子块中的最大值作为输出值。这种池化层的作用是提取矩阵中最具代表性的特征,同时也可以减小输入数据的尺寸。它的主要优点在于池化后可以减小输入数据的像素数量,还可以减小特征图中的噪声。 AvgPooling层是指对输入矩阵中的每个子块,取该子块中所有值的平均值作为输出值。这种池化层的作用是减少输入特征图尺寸,平滑输入特征图中的噪声,提高特征图的鲁棒性和泛化性。 两种池化方式的本质区别在于特征表示的方式不同。MaxPooling层相当于对特征图做了一个高度抽象的处理,提取了特征图中最具有区分性的点。而AvgPooling层则可以将各个特征点的信息进行平滑处理,使得神经网络对变化和噪声的容忍度更高。 在使用池化层的时候,需要根据具体的数据情况和任务需求来选择合适的池化方式。如果需要提取的特征比较突出,可以选择MaxPooling层;如果需要较好的平滑效果,可以选择AvgPooling层。但无论使用哪种池化方式,在一定程度上都可以起到减少计算量和提高特征鲁棒性的作用。

相关推荐

def MEAN_Spot(opt): # channel 1 inputs1 = layers.Input(shape=(42,42,1)) conv1 = layers.Conv2D(3, (5,5), padding='same', activation='relu', kernel_regularizer=l2(0.001))(inputs1) bn1 = layers.BatchNormalization()(conv1) pool1 = layers.MaxPooling2D(pool_size=(3, 3), padding='same', strides=(3,3))(bn1) do1 = layers.Dropout(0.3)(pool1) # channel 2 inputs2 = layers.Input(shape=(42,42,1)) conv2 = layers.Conv2D(3, (5,5), padding='same', activation='relu', kernel_regularizer=l2(0.001))(inputs2) bn2 = layers.BatchNormalization()(conv2) pool2 = layers.MaxPooling2D(pool_size=(3, 3), padding='same', strides=(3,3))(bn2) do2 = layers.Dropout(0.3)(pool2) # channel 3 inputs3 = layers.Input(shape=(42,42,1)) conv3 = layers.Conv2D(8, (5,5), padding='same', activation='relu', kernel_regularizer=l2(0.001))(inputs3) bn3 = layers.BatchNormalization()(conv3) pool3 = layers.MaxPooling2D(pool_size=(3, 3), padding='same', strides=(3,3))(bn3) do3 = layers.Dropout(0.3)(pool3) # merge 1 merged = layers.Concatenate()([do1, do2, do3]) # interpretation 1 merged_conv = layers.Conv2D(8, (5,5), padding='same', activation='relu', kernel_regularizer=l2(0.1))(merged) merged_pool = layers.MaxPooling2D(pool_size=(2, 2), padding='same', strides=(2,2))(merged_conv) flat = layers.Flatten()(merged_pool) flat_do = layers.Dropout(0.2)(flat) # outputs outputs = layers.Dense(1, activation='linear', name='spot')(flat_do) #Takes input u, v, os model = keras.models.Model(inputs=[inputs1, inputs2, inputs3], outputs=[outputs]) model.compile( loss={'spot':'mse'}, optimizer=opt, metrics={'spot':tf.keras.metrics.MeanAbsoluteError()}, ) return model 如何先Concatenate输入图像,然后加入CBAM

您可以使用以下代码来加入CBAM: python from tensorflow.keras import layers def conv_block(inputs, filters): x = layers.Conv2D(filters, kernel_size=3, padding='same', use_bias=False)(inputs) x = layers.BatchNormalization()(x) x = layers.ReLU()(x) return x def channel_attention(inputs, ratio=8): channels_axis = 3 channels = inputs.shape[channels_axis] shared_layer_one = layers.Dense(channels//ratio, activation='relu', use_bias=True, kernel_initializer='he_normal') shared_layer_two = layers.Dense(channels, activation='sigmoid', use_bias=True, kernel_initializer='he_normal') avg_pool = layers.GlobalAveragePooling2D()(inputs) avg_pool = layers.Reshape((1,1,channels))(avg_pool) assert avg_pool.shape[1:] == (1,1,channels) avg_pool = shared_layer_one(avg_pool) assert avg_pool.shape[1:] == (1,1,channels//ratio) avg_pool = shared_layer_two(avg_pool) assert avg_pool.shape[1:] == (1,1,channels) return layers.multiply([inputs, avg_pool]) def spatial_attention(inputs): kernel_size = 7 channels = inputs.shape[3] x = layers.Conv2D(channels, kernel_size, padding='same', use_bias=False)(inputs) x = layers.BatchNormalization()(x) x = layers.ReLU()(x) avg_pool = layers.Lambda(lambda x: tf.reduce_mean(x, axis=3, keepdims=True))(x) max_pool = layers.Lambda(lambda x: tf.reduce_max(x, axis=3, keepdims=True))(x) concat = layers.Concatenate(axis=3)([avg_pool, max_pool]) assert concat.shape[1:] == (inputs.shape[1], inputs.shape[2], 2) x = layers.Conv2D(1, kernel_size, padding='same', use_bias=False, activation='sigmoid')(concat) assert x.shape[1:] == (inputs.shape[1], inputs.shape[2], 1) return layers.multiply([inputs, x]) def cbam_block(inputs, ratio=8): x = channel_attention(inputs, ratio) x = spatial_attention(x) return x def MEAN_Spot(opt): # channel 1 inputs1 = layers.Input(shape=(42,42,1)) conv1 = conv_block(inputs1, 3) pool1 = layers.MaxPooling2D(pool_size=(3, 3), padding='same', strides=(3,3))(conv1) do1 = layers.Dropout(0.3)(pool1) # channel 2 inputs2 = layers.Input(shape=(42,42,1)) conv2 = conv_block(inputs2, 3) pool2 = layers.MaxPooling2D(pool_size=(3, 3), padding='same', strides=(3,3))(conv2) do2 = layers.Dropout(0.3)(pool2) # channel 3 inputs3 = layers.Input(shape=(42,42,1)) conv3 = conv_block(inputs3, 8) pool3 = layers.MaxPooling2D(pool_size=(3, 3), padding='same', strides=(3,3))(conv3) do3 = layers.Dropout(0.3)(pool3) # merge 1 merged = layers.Concatenate()([do1, do2, do3]) cbam = cbam_block(merged) # interpretation 1 merged_conv = conv_block(cbam, 8) merged_pool = layers.MaxPooling2D(pool_size=(2, 2), padding='same', strides=(2,2))(merged_conv) flat = layers.Flatten()(merged_pool) flat_do = layers.Dropout(0.2)(flat) # outputs outputs = layers.Dense(1, activation='linear', name='spot')(flat_do) #Takes input u, v, os model = keras.models.Model(inputs=[inputs1, inputs2, inputs3], outputs=[outputs]) model.compile( loss={'spot':'mse'}, optimizer=opt, metrics={'spot':tf.keras.metrics.MeanAbsoluteError()}, ) return model 这里定义了conv_block函数来构建卷积块,同时定义了channel_attention和spatial_attention函数来构建CBAM的通道注意力和空间注意力模块,最后用cbam_block函数将两个注意力模块组合起来,加入到模型中。在MEAN_Spot函数中,先将输入图像进行Concatenate,然后加入CBAM模块,最后继续进行后续的卷积、池化和全连接层操作。
以下是一个示例代码,展示了如何在CNN的pooling层后加入SENet模块,并通过conv与deconv特征融合: python import torch.nn as nn class SENet(nn.Module): def __init__(self, in_channels, reduction=16): super(SENet, self).__init__() self.avg_pool = nn.AdaptiveAvgPool2d(1) self.fc1 = nn.Conv2d(in_channels, in_channels // reduction, kernel_size=1, bias=False) self.relu = nn.ReLU(inplace=True) self.fc2 = nn.Conv2d(in_channels // reduction, in_channels, kernel_size=1, bias=False) self.sigmoid = nn.Sigmoid() def forward(self, x): out = self.avg_pool(x) out = self.fc1(out) out = self.relu(out) out = self.fc2(out) out = self.sigmoid(out) return x * out class MyModel(nn.Module): def __init__(self): super(MyModel, self).__init__() # Define your CNN layers here self.pool = nn.MaxPool2d(kernel_size=2, stride=2) # Add SENet module self.senet = SENet(in_channels=64) # Define your conv and deconv layers here self.conv = nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1) self.deconv = nn.ConvTranspose2d(64, 64, kernel_size=2, stride=2) def forward(self, x): x = self.pool(x) x = self.senet(x) x = self.conv(x) x = self.deconv(x) return x 在这个示例代码中,我们首先定义了一个SENet类,它接受输入信道数和降维因子作为参数。在forward方法中,我们将输入数据进行平均池化,然后通过两个卷积层进行特征压缩和特征扩张,并使用Sigmoid函数对特征图进行缩放,最后将原始特征图和缩放后的特征图相乘。这个SENet模块可以插入到CNN的任意层后面,以增强CNN的特征表示能力。 在MyModel中,我们首先定义了CNN的一些层,然后在pooling层后面加入了SENet模块。最后我们定义了conv和deconv层,以实现特征融合。在forward方法中,我们首先进行pooling操作,然后通过SENet模块进行特征缩放,然后进行conv和deconv操作,最终输出特征融合后的结果。
最大池化和平均池化是深度学习中常用的特征提取方法,以下是它们的代码实现: 最大池化: python import numpy as np def max_pooling(input, pool_size=(2, 2)): # 计算输出矩阵的大小 output_shape = (input.shape[0] // pool_size[0], input.shape[1] // pool_size[1]) # 初始化输出矩阵 output = np.zeros(output_shape) # 对于每个输出矩阵中的元素 for i in range(output_shape[0]): for j in range(output_shape[1]): # 找到输入矩阵中对应的子矩阵 sub_matrix = input[i*pool_size[0]:i*pool_size[0]+pool_size[0], j*pool_size[1]:j*pool_size[1]+pool_size[1]] # 将子矩阵中的最大值作为输出矩阵中的对应元素 output[i][j] = np.max(sub_matrix) return output 平均池化: python import numpy as np def avg_pooling(input, pool_size=(2, 2)): # 计算输出矩阵的大小 output_shape = (input.shape[0] // pool_size[0], input.shape[1] // pool_size[1]) # 初始化输出矩阵 output = np.zeros(output_shape) # 对于每个输出矩阵中的元素 for i in range(output_shape[0]): for j in range(output_shape[1]): # 找到输入矩阵中对应的子矩阵 sub_matrix = input[i*pool_size[0]:i*pool_size[0]+pool_size[0], j*pool_size[1]:j*pool_size[1]+pool_size[1]] # 将子矩阵中的平均值作为输出矩阵中的对应元素 output[i][j] = np.mean(sub_matrix) return output 其中,input 为输入矩阵,pool_size 为池化窗口大小。两种池化方法都是从输入矩阵中提取窗口内的特征,然后进行相应的操作得到输出矩阵。在这里,我们使用了 numpy 库,它提供了很方便的数组操作方法,如 np.zeros、np.max 和 np.mean。
以下是使用PyTorch实现添加CA和SA双重注意力机制的代码: python import torch import torch.nn as nn import torch.nn.functional as F class CA(nn.Module): def __init__(self, in_channels, reduction=16): super(CA, self).__init__() self.avg_pool = nn.AdaptiveAvgPool2d(1) self.conv1 = nn.Conv2d(in_channels, in_channels // reduction, kernel_size=1, stride=1, padding=0, bias=False) self.relu = nn.ReLU(inplace=True) self.conv2 = nn.Conv2d(in_channels // reduction, in_channels, kernel_size=1, stride=1, padding=0, bias=False) self.sigmoid = nn.Sigmoid() def forward(self, x): y = self.avg_pool(x) y = self.conv1(y) y = self.relu(y) y = self.conv2(y) y = self.sigmoid(y) return x * y class SA(nn.Module): def __init__(self, in_channels, reduction=16): super(SA, self).__init__() self.conv1 = nn.Conv2d(in_channels, in_channels // reduction, kernel_size=1, stride=1, padding=0, bias=False) self.conv2 = nn.Conv2d(in_channels // reduction, in_channels // reduction, kernel_size=1, stride=1, padding=0, bias=False) self.conv3 = nn.Conv2d(in_channels // reduction, in_channels, kernel_size=1, stride=1, padding=0, bias=False) self.gamma = nn.Parameter(torch.zeros(1)) def forward(self, x): batch_size, channels, height, width = x.size() y = self.conv1(x) y = F.relu(y, inplace=True) y = self.conv2(y) y = F.relu(y, inplace=True) y = self.conv3(y) y = F.avg_pool2d(y, kernel_size=(height, width)) y = y.view(batch_size, channels, 1, 1) y = self.gamma * y return x + y class Net(nn.Module): def __init__(self): super(Net, self).__init__() self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1) self.ca = CA(64) self.sa = SA(64) self.conv2 = nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1) self.conv3 = nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1) self.fc1 = nn.Linear(256 * 8 * 8, 512) self.fc2 = nn.Linear(512, 10) def forward(self, x): x = self.conv1(x) x = self.ca(x) x = self.sa(x) x = F.relu(x, inplace=True) x = F.max_pool2d(x, kernel_size=2, stride=2) x = self.conv2(x) x = self.ca(x) x = self.sa(x) x = F.relu(x, inplace=True) x = F.max_pool2d(x, kernel_size=2, stride=2) x = self.conv3(x) x = self.ca(x) x = self.sa(x) x = F.relu(x, inplace=True) x = x.view(-1, 256 * 8 * 8) x = self.fc1(x) x = F.relu(x, inplace=True) x = self.fc2(x) return x 在上面的代码中,我们首先定义了CA和SA两个注意力模块,然后在Net模型中添加了这两个模块。在forward函数中,我们先将输入的x通过conv1卷积层进行特征提取,然后分别通过CA和SA模块进行注意力加权,再通过ReLU激活函数和max pooling操作进行特征提取和压缩,最后通过全连接层输出分类结果。
下面是一个基于 TextCNN 和 LSTM 的招聘简历自动筛选系统的 Python 代码示例: python import numpy as np from tensorflow.keras.preprocessing.text import Tokenizer from tensorflow.keras.preprocessing.sequence import pad_sequences from tensorflow.keras.layers import Dense, Input, LSTM, Embedding, Dropout, Activation, Conv1D, GRU, CuDNNGRU, CuDNNLSTM, BatchNormalization from tensorflow.keras.layers import Bidirectional, GlobalMaxPool1D, MaxPooling1D, Add, Flatten from tensorflow.keras.layers import GlobalAveragePooling1D, GlobalMaxPooling1D, concatenate, SpatialDropout1D from tensorflow.keras.models import Model, load_model from tensorflow.keras import initializers, regularizers, constraints, optimizers, layers, callbacks from tensorflow.keras import backend as K from tensorflow.keras.engine import InputSpec, Layer from tensorflow.keras.optimizers import Adam # 读取数据 resumes = [] labels = [] with open("resumes.txt", "r") as f: for line in f: resumes.append(line.strip().split("\t")[0]) labels.append(int(line.strip().split("\t")[1])) # 划分训练集和测试集 X_train, X_test, y_train, y_test = train_test_split(resumes, labels, test_size=0.2, random_state=42) # 数据预处理 max_features = 20000 maxlen = 100 tokenizer = Tokenizer(num_words=max_features) tokenizer.fit_on_texts(X_train) X_train = tokenizer.texts_to_sequences(X_train) X_test = tokenizer.texts_to_sequences(X_test) x_train = pad_sequences(X_train, maxlen=maxlen) x_test = pad_sequences(X_test, maxlen=maxlen) # 构建模型 def build_model(): inp = Input(shape=(maxlen,)) x = Embedding(max_features, 128)(inp) x = SpatialDropout1D(0.2)(x) x = Bidirectional(CuDNNLSTM(64, return_sequences=True))(x) y = Bidirectional(CuDNNGRU(64, return_sequences=True))(x) avg_pool1 = GlobalAveragePooling1D()(y) max_pool1 = GlobalMaxPooling1D()(y) conc = concatenate([avg_

class PointnetSAModuleMSG(_PointnetSAModuleBase): """ Pointnet set abstraction layer with multiscale grouping and attention mechanism """ def init(self, *, npoint: int, radii: List[float], nsamples: List[int], mlps: List[List[int]], bn: bool = True, use_xyz: bool = True, pool_method='max_pool', instance_norm=False): """ :param npoint: int :param radii: list of float, list of radii to group with :param nsamples: list of int, number of samples in each ball query :param mlps: list of list of int, spec of the pointnet before the global pooling for each scale :param bn: whether to use batchnorm :param use_xyz: :param pool_method: max_pool / avg_pool :param instance_norm: whether to use instance_norm """ super().init() assert len(radii) == len(nsamples) == len(mlps) self.npoint = npoint self.groupers = nn.ModuleList() self.mlps = nn.ModuleList() # Add attention module self.attentions = nn.ModuleList() for i in range(len(radii)): radius = radii[i] nsample = nsamples[i] self.groupers.append( pointnet2_utils.QueryAndGroup(radius, nsample, use_xyz=use_xyz) if npoint is not None else pointnet2_utils.GroupAll(use_xyz) ) mlp_spec = mlps[i] if use_xyz: mlp_spec[0] += 3 # Add attention module for each scale self.attentions.append(Attention(mlp_spec[-1])) self.mlps.append(pt_utils.SharedMLP(mlp_spec, bn=bn, instance_norm=instance_norm)) self.pool_method = pool_method def forward(self, xyz, features): """ :param xyz: (B, N, 3) xyz coordinates of the points :param features: (B, N, C) input features :return: (B, npoint, mlp[-1]) tensor """ new_features_list = [] for i in range(len(self.groupers)): grouper = self.groupers[i] mlp = self.mlps[i] attention = self.attentions[i] # Group points and features grouped_xyz, grouped_features = grouper(xyz, features) # Apply MLP to each group grouped_features = mlp(grouped_features) # Apply attention mechanism to the features of each group grouped_features = attention(grouped_features) # Perform pooling over each group if self.pool_method == 'max_pool': pooled_features = torch.max(grouped_features, dim=2)[0] else: pooled_features = torch.mean(grouped_features, dim=2) new_features_list.append(pooled_features) # Concatenate features from different scales new_features = torch.cat(new_features_list, dim=1) return new_features在该类中使用的QueryAndGroup类会主动将该类所继承的父类的返回值传入QueryAndGroup类中的forward函数吗

最新推荐

三极管放大电路之单管放大器的仿真设计

三极管放大电路

Zabbix-agent端自动安装

# File Name: zabbix.sh # Version: V1.0 # Introduce:该脚本用于搭建zabbix-server与zabbix-agent,适配centos7与ubuntu(14,16,18,20) 检测到xx系统 安装zabbix-server,请输入1,安装zabbix-agent,请输入2:xx ……

[Java算法练习]-数组重新排序.java

[Java算法练习]-数组重新排序.java

毕设课设-ssh购物商城java鲜花电商.zip

毕设课设-ssh购物商城java鲜花电商

[Java算法练习]-数组交换.java

[Java算法练习]-数组交换.java

代码随想录最新第三版-最强八股文

这份PDF就是最强⼋股⽂! 1. C++ C++基础、C++ STL、C++泛型编程、C++11新特性、《Effective STL》 2. Java Java基础、Java内存模型、Java面向对象、Java集合体系、接口、Lambda表达式、类加载机制、内部类、代理类、Java并发、JVM、Java后端编译、Spring 3. Go defer底层原理、goroutine、select实现机制 4. 算法学习 数组、链表、回溯算法、贪心算法、动态规划、二叉树、排序算法、数据结构 5. 计算机基础 操作系统、数据库、计算机网络、设计模式、Linux、计算机系统 6. 前端学习 浏览器、JavaScript、CSS、HTML、React、VUE 7. 面经分享 字节、美团Java面、百度、京东、暑期实习...... 8. 编程常识 9. 问答精华 10.总结与经验分享 ......

无监督视觉表示学习中的时态知识一致性算法

无监督视觉表示学习中的时态知识一致性维信丰酒店1* 元江王2*†马丽华2叶远2张驰2北京邮电大学1旷视科技2网址:fengweixin@bupt.edu.cn,wangyuanjiang@megvii.com{malihua,yuanye,zhangchi} @ megvii.com摘要实例判别范式在无监督学习中已成为它通常采用教师-学生框架,教师提供嵌入式知识作为对学生的监督信号。学生学习有意义的表征,通过加强立场的空间一致性与教师的意见。然而,在不同的训练阶段,教师的输出可以在相同的实例中显著变化,引入意外的噪声,并导致由不一致的目标引起的灾难性的本文首先将实例时态一致性问题融入到现有的实例判别范式中 , 提 出 了 一 种 新 的 时 态 知 识 一 致 性 算 法 TKC(Temporal Knowledge Consis- tency)。具体来说,我们的TKC动态地集成的知识的时间教师和自适应地选择有用的信息,根据其重要性学习实例的时间一致性。

create or replace procedure这句语句后面是自定义么

### 回答1: 是的,"create or replace procedure"语句后面应该跟着自定义的存储过程名。例如: ```sql create or replace procedure my_procedure_name ``` 这里"my_procedure_name"是你自己定义的存储过程名,可以根据具体需求进行命名。 ### 回答2: 不完全是自定义。在Oracle数据库中,"CREATE OR REPLACE PROCEDURE"是一条SQL语句,用于创建或替换一个存储过程。关键词"CREATE"表示创建新的存储过程,关键词"OR REPLACE"表示如果该存储过程

数据结构1800试题.pdf

你还在苦苦寻找数据结构的题目吗?这里刚刚上传了一份数据结构共1800道试题,轻松解决期末挂科的难题。不信?你下载看看,这里是纯题目,你下载了再来私信我答案。按数据结构教材分章节,每一章节都有选择题、或有判断题、填空题、算法设计题及应用题,题型丰富多样,共五种类型题目。本学期已过去一半,相信你数据结构叶已经学得差不多了,是时候拿题来练练手了,如果你考研,更需要这份1800道题来巩固自己的基础及攻克重点难点。现在下载,不早不晚,越往后拖,越到后面,你身边的人就越卷,甚至卷得达到你无法想象的程度。我也是曾经遇到过这样的人,学习,练题,就要趁现在,不然到时你都不知道要刷数据结构题好还是高数、工数、大英,或是算法题?学完理论要及时巩固知识内容才是王道!记住!!!下载了来要答案(v:zywcv1220)。

基于对比检测的高效视觉预训练

10086⇥⇥⇥⇥基于对比检测的高效视觉预训练Ol i vierJ. He´naf f SkandaKoppula Jean-BaptisteAlayracAaronvandenOord OriolVin yals JoaoCarreiraDeepMind,英国摘要自我监督预训练已被证明可以为迁移学习提供然而,这些性能增益是以大的计算成本来实现的,其中最先进的方法需要比监督预训练多一个数量级的计算。我们通过引入一种新的自监督目标,对比检测,任务表示与识别对象级功能跨增强来解决这个计算瓶颈。该目标可提取每幅图像的丰富学习信号,从而在各种下游任务上实现最先进的传输精度,同时需要高达10少训练特别是,我们最强的ImageNet预训练模型的性能与SEER相当,SEER是迄今为止最大的自监督系统之一,它使用了1000多个预训练数据。最后,我们的目标无缝地处理更复杂图像的预训练,例如COCO中的图像,缩小了从COCO到PASCAL的监督迁移学习的差距1. 介绍自从Al