综述

论文题目：《Selective Sparse Sampling for Fine-grained Image Recognition》
论文地址：http://openaccess.thecvf.com/content_ICCV_2019/papers/Ding_Selective_Sparse_Sampling_for_Fine-Grained_Image_Recognition_ICCV_2019_paper.pdf
源码地址(PyTorch版本)：https://github.com/Yao-DD/S3N
针对领域：细粒度图像分类(FGVC)
关键词：细粒度识别、显著性采样

S3N网络整体结构

初始化阶段

def __init__(self, base_model, num_classes, task_input_size, base_ratio, radius, radius_inv):super(S3N, self).__init__()# 采用图的尺寸self.grid_size = 31# 用于对采样图的填充self.padding_size = 30# 采样图经过扩充后的长宽尺寸self.global_size = self.grid_size + 2*self.padding_size# 图片输入的尺寸，默认448self.input_size_net = task_input_size# 高斯核，对应论文公式(8)中的kgaussian_weights = torch.FloatTensor(makeGaussian(2*self.padding_size+1, fwhm = 13))# 基础的幅度self.base_ratio = base_ratio# radius与radius_inv为两个可学习的参数，对应论文中公式(5)里的β1,β2self.radius = ScaleLayer(radius)self.radius_inv = ScaleLayer(radius_inv)# 输入输出均为1的卷积运算，kernel_size为61*61，用于公式(7,8)的计算# 因为f,g中每个值都由原显著图每个点计算，并且求和得到self.filter = nn.Conv2d(1, 1, kernel_size=(2*self.padding_size+1,2*self.padding_size+1),bias=False)# 将卷积参数定义为高斯核参数，即公式中的kself.filter.weight[0].data[:,:,:] = gaussian_weights# 高斯核，对应论文中的距离核k，该卷积操作对应论文公式(8)，乘积+求和# 初始化梯度矩阵，两张梯度图，分别代表x的梯度和y的梯度# 数值从-1到2均匀变化self.P_basis = torch.zeros(2,self.grid_size+2*self.padding_size, self.grid_size+2*self.padding_size)for k in range(2):for i in range(self.global_size):for j in range(self.global_size):self.P_basis[k,i,j] = k*(i-self.padding_size)/(self.grid_size-1.0)+(1.0-k)*(j-self.padding_size)/(self.grid_size-1.0)# 定义特征提取网络self.features = base_model.features# 得到特征提取网络最后输出的特征数量self.num_features = base_model.num_features# 定义原始分支全连接层self.raw_classifier = nn.Linear(2048, num_classes)# 用于将经过采样得到的图像，特征提取后再经过一次卷积，比原始图像多一次卷积操作，这里用于判别分支self.sampler_buffer = nn.Sequential(nn.Conv2d(2048, 2048, kernel_size=3, stride=2, padding=1, bias=False),nn.BatchNorm2d(2048),nn.ReLU(),)# 定义判别分支的分类器self.sampler_classifier = nn.Linear(2048, num_classes)# 互补分支的卷积，原理同判别分支一样self.sampler_buffer1 = nn.Sequential(nn.Conv2d(2048, 2048, kernel_size=3, stride=2, padding=1, bias=False),nn.BatchNorm2d(2048),nn.ReLU(),)# 定义互补分支的分类器self.sampler_classifier1 = nn.Linear(2048, num_classes)# 用于最终分类的分类器，输入三组概率，输出一组分类概率self.con_classifier = nn.Linear(int(self.num_features*3), num_classes)# 全局平均池化self.avg = nn.AdaptiveAvgPool2d(1)# 全局最大池化self.max_pool = nn.AdaptiveMaxPool2d(1)# 用于计算权重与特征图做点乘(卷积核为1*1)，得到响应图self.map_origin = nn.Conv2d(2048, num_classes, 1, 1, 0)

前向传播阶段

参数解读：

input_x：输入的图像

x_sampled_zoom：判别分支图像

x_sampled_inv：互补分支图像

def forward(self, input_x, p):# 首先，获取全连接层的权重参数和偏置参数，加载到卷积核为1*1的卷积层中，便于实现公式(1)的计算self.map_origin.weight.data.copy_(self.raw_classifier.weight.data.unsqueeze(-1).unsqueeze(-1))self.map_origin.bias.data.copy_(self.raw_classifier.bias.data)# 经过特征提取feature_raw = self.features(input_x)# 再经过全连接层agg_origin = self.raw_classifier(self.avg(feature_raw).view(-1, 2048))# 求响应图的过程不是可导的过程with torch.no_grad():# 权重与原特征图做点乘运算，再求和得到200张(以CUB数据集为例)响应图，最方便的运算就是卷积运算(卷积核大小为1)# 得到响应图之后，再进行放大操作# 放大到N*C*31*31,C为分类数class_response_maps = F.interpolate(self.map_origin(feature_raw), size=self.grid_size, mode='bilinear', align_corners=True)# 输入响应图域原始图像，得到判别分支图像和互补分支图像x_sampled_zoom, x_sampled_inv = self.generate_map(input_x, class_response_maps, p)# 首先将判别分支经过特征提取以及全连接层，得到分类概率feature_D = self.sampler_buffer(self.features(x_sampled_zoom))agg_sampler = self.sampler_classifier(self.avg(feature_D).view(-1, 2048))# 再将互补分支经过特征提取以及全连接层，得到分类概率feature_C = self.sampler_buffer1(self.features(x_sampled_inv))agg_sampler1 = self.sampler_classifier1(self.avg(feature_C).view(-1, 2048))# 将三个分支得到的分类概率(原始图像、判别图像、互补图像)融合，一块传入分类器进行分类，得到最终的分类概率aggregation = self.con_classifier(torch.cat([self.avg(feature_raw).view(-1, 2048), self.avg(feature_D).view(-1, 2048), self.avg(feature_C).view(-1, 2048)], 1))# 模型最后返回四个预测概率return aggregation, agg_origin, agg_sampler, agg_sampler1

随机显著性采样

参数解读：

p：0为训练过程中的第一阶段，1为训练过程中的第二阶段或者测试过程中的第一阶段，2为测试过程中的第二阶段。第一阶段为训练初始阶段，第二阶段为训练后期。

xs：代表鉴别分支的采样图

xs_inv：代表互补分支的采样图

def generate_map(self, input_x, class_response_maps, p):# 得到尺寸N, C, H, W = class_response_maps.size()# class_response_maps求全局平均，再经过softmax就相当于得到了预测概率(和原来相比，只是换了个顺序，最后的结果是一样的)# 再将预测分数排序score_pred, sort_number = torch.sort(F.softmax(F.adaptive_avg_pool2d(class_response_maps, 1), dim=1), dim=1, descending=True)# 前五名预测概率做一个求交叉熵，得到H，对应论文公式(2)# H相当于是预测结果的可信度gate_score = (score_pred[:, 0:5]*torch.log(score_pred[:, 0:5])).sum(1)xs = []xs_inv = []# 按batch_size遍历for idx_i in range(N):# 根据H来判断，最终选择哪种计算方式，用于计算最终的响应图，对应论文公式(3)# 如果gate_score大，则说明最终的预测概率最大值非常大，即预测的可信度非常高# 代表第一张响应图就可以覆盖原图的有区分度的部分# 得到的decide_map维数为两维if gate_score[idx_i] > -0.2:decide_map = class_response_maps[idx_i, sort_number[idx_i, 0],:,:]# 否则，说明预测概率最大值不高，可信度不高# 第一张响应图不足以覆盖原图的有区分度的部分，用前五张图的均值替代else:decide_map = class_response_maps[idx_i, sort_number[idx_i, 0:5],:,:].mean(0)# 求得响应图的最大值和最小值点，用于归一化操作min_value, max_value = decide_map.min(), decide_map.max()# 响应图的归一化# 此时在每个批次中，decide_map代表一张图，大小为31*31，之前定义的decide_map = (decide_map-min_value)/(max_value-min_value)# _mean_filter相当于一个平均值运算，对输入的部分图像求平均值# peak_stimulation的作用是寻找峰值点，输入响应图与，具体解读见方法函数小节# peak_list为峰值点坐标，aggregation为峰值响应的平均值peak_list, aggregation = peak_stimulation(decide_map, win_size=3, peak_filter=_mean_filter)# 对每个响应图做压缩操作，压缩无用的维度，得到尺寸为31*31的二维响应图decide_map = decide_map.squeeze(0).squeeze(0)# 得到响应图的峰值点的数据大小，根据坐标点进行定位score = [decide_map[item[2], item[3]] for item in peak_list]# x是所有峰值响应点的横坐标x = [item[3] for item in peak_list]# y是所有峰值响应点的纵坐标y = [item[2] for item in peak_list]if score == []:# 如果没有峰值相应点，则无法计算Qd与Qc# 则他们均变为默认值temp = torch.zeros(1, 1, self.grid_size,self.grid_size).cuda()temp += self.base_ratio# xs与x_inv分别代表Qd与Qc的集合xs.append(temp)xs_inv.append(temp)continue# 峰值响应数量peak_num = torch.arange(len(score))# 下面的操作对应论文中的公式(4)(5)(6)# temp对应Qd,temp_w对应Qc# 均预设为基础的幅度temp = self.base_ratiotemp_w = self.base_ratioif p == 0:# 当刚开始训练的时候(训练次数小于20)p=0，此时区域响应还不是很明显# 图像的响应值并不能确定信息是否丰富，因此不设置阈值加以区分# 求Qd、Qc的时候用所有的响应图求for i in peak_num:# 首先求取A，即论文中公式(5)，然后再做一个求和操作# self.radius(torch.sqrt(score[i]))表示将输入(响应值)与一个可学习的参数相乘# kernel_generate即高斯核的计算，输入可学习的参数、响应图大小、峰值响应坐标点，得到Ai# 得到Ai后，再进行求和操作，将利用所有峰值得到的Ai进行求和,最终得到Q，即得到采样图temp += score[i] * kernel_generate(self.radius(torch.sqrt(score[i])), H, (x[i].item(), y[i].item())).unsqueeze(0).unsqueeze(0).cuda()temp_w += 1/score[i] * \kernel_generate(self.radius_inv(torch.sqrt(score[i])), H, (x[i].item(), y[i].item())).unsqueeze(0).unsqueeze(0).cuda()elif p == 1:for i in peak_num:# 随机在0,1内选一个阈值，进行对Td、Tc的分类# 由于阈值的随机引入，可以让训练过程保持动态化，提高了模型的稳定性rd = random.uniform(0, 1)# 如果大于阈值，代表为高响应区域的点，属于Td,否则属于Tc，对应论文中的公式(4)# 求Ai,和求Q的过程与p=0过程类似if score[i] > rd:temp += score[i] * kernel_generate(self.radius(torch.sqrt(score[i])), H, (x[i].item(), y[i].item())).unsqueeze(0).unsqueeze(0).cuda()else:temp_w += 1/score[i] * \kernel_generate(self.radius_inv(torch.sqrt(score[i])), H, (x[i].item(), y[i].item())).unsqueeze(0).unsqueeze(0).cuda()# 测试阶段由于只需要保证预测概率最高# 因此需要直接取两个极端值，将响应值最高的部分当成有区分度的部分，将响应值最低的部分当成补充部分# 这里与训练过程不同，训练过程的随机选择阈值是为了让训练保持动态化，提高模型稳定性，但测试阶段只要保持预测精度最高即可# 该部分只用于测试过程elif p == 2:# 得到响应值最高点处的索引，便于下面直接定位index = score.index(max(score))temp += score[index] * kernel_generate(self.radius(score[index]), H, (x[index].item(), y[index].item())).unsqueeze(0).unsqueeze(0).cuda()# 同上，得到响应值最低点处的索引index = score.index(min(score))temp_w += 1/score[index] * \kernel_generate(self.radius_inv(torch.sqrt(score[index])), H, (x[index].item(), y[index].item())).unsqueeze(0).unsqueeze(0).cuda()if type(temp) == float:# 如果是一个值(没计算高斯核，即没有峰值响应)，则初始化一个矩阵，此时矩阵里的值全是基础值temp += torch.zeros(1, 1, self.grid_size,self.grid_size).cuda()# 存储得到的Qdxs.append(temp)# 下次操作类似if type(temp_w) == float:temp_w += torch.zeros(1, 1, self.grid_size,self.grid_size).cuda()xs_inv.append(temp_w)# 将所有batch的图像合并，得到所有的判别分支xs = torch.cat(xs, 0)# 将采样图做一个填充，便于下面对f,v的计算xs_hm = nn.ReplicationPad2d(self.padding_size)(xs)# 通过采样图，得到采样网格图，网格图具体生成过程的解读见显著采样小节grid = self.create_grid(xs_hm).to(input_x.device)# 利用得到的网格图对输入图像做一个网格采样，即显著采样过程x_sampled_zoom = F.grid_sample(input_x, grid)# 下面计算互补分支，与判别分支过程类似xs_inv = torch.cat(xs_inv, 0)xs_hm_inv = nn.ReplicationPad2d(self.padding_size)(xs_inv)grid_inv = self.create_grid(xs_hm_inv).to(input_x.device)x_sampled_inv = F.grid_sample(input_x, grid_inv)# 将经过显著采样得到的图像返回return x_sampled_zoom, x_sampled_inv

采样网格图的生成

def create_grid(self, x):# 输入：x 扩充后的采样图# 预先定义一个和采样图尺寸相同的全零矩阵P = torch.autograd.Variable(torch.zeros(1,2,self.grid_size+2*self.padding_size, self.grid_size+2*self.padding_size).cuda(),requires_grad=False)# 初始化为均匀的网格图P[0,:,:,:] = self.P_basis# 将P扩展维度，第一维度大小从1扩展到batch_size，即将所有batch的梯度图都做一个初始化P = P.expand(x.size(0),2,self.grid_size+2*self.padding_size, self.grid_size+2*self.padding_size)# 将输入进行堆叠，变成两张图，此时x_cat的尺寸为batch*2*91*91x_cat = torch.cat((x,x),1)# 卷积后得到的尺寸为batch*1*31*31，卷积核尺寸为61*61，这里卷积核参数被设置为高斯核，即公式(7,8)中的距离核k# 这里的卷积相当于论文中的公式(7,8)中的分母，采样图与距离核乘积再求和p_filter = self.filter(x)# 这里得到(2*batch)*1*91*91的矩阵，初始化的均匀网格图与采样图做点乘，相当于公式(7,8)中分子的一部分x_mul = torch.mul(P,x_cat).view(-1,1,self.global_size,self.global_size)# 这里得到batch*2*31*31的矩阵，再次利用卷积操作实现求和再相加，最终得到公式(7,8)中的分子all_filter = self.filter(x_mul).view(-1,2,self.grid_size,self.grid_size)# 将all_filter分离，分出x方向和y方向x_filter = all_filter[:,0,:,:].contiguous().view(-1,1,self.grid_size,self.grid_size)y_filter = all_filter[:,1,:,:].contiguous().view(-1,1,self.grid_size,self.grid_size)# 将结果相除，分别得到f与vx_filter = x_filter/p_filtery_filter = y_filter/p_filterxgrids = x_filter*2-1ygrids = y_filter*2-1# 范围控制到-1到1之间xgrids = torch.clamp(xgrids,min=-1,max=1)ygrids = torch.clamp(ygrids,min=-1,max=1)xgrids = xgrids.view(-1,1,self.grid_size,self.grid_size)ygrids = ygrids.view(-1,1,self.grid_size,self.grid_size)# 此时grid为batch*2*31*31，为采样网格grid = torch.cat((xgrids,ygrids),1)# 上采样，将梯度图放大grid = F.interpolate(grid, size=(self.input_size_net,self.input_size_net), mode='bilinear', align_corners=True)# 最终变成batch*448*448*2grid = torch.transpose(grid,1,2)grid = torch.transpose(grid,2,3)return grid

方法函数

生成高斯核

def makeGaussian(size, fwhm = 3, center=None):# x为0到60，一共61个数x = np.arange(0, size, 1, float)# np.newaxis表示增加一个维度# 此时y的维度为(61,1)y = x[:,np.newaxis]# 是否输入中心if center is None:x0 = y0 = size // 2else:x0 = center[0]y0 = center[1]# 计算高斯核return np.exp(-4*np.log(2) * ((x-x0)**2 + (y-y0)**2) / fwhm**2)

计算稀疏注意力

class KernelGenerator(nn.Module):def __init__(self, size, offset=None):super(KernelGenerator, self).__init__()# 响应图尺寸self.size = self._pair(size)# 生成网格点坐标矩阵xx, yy = np.meshgrid(np.arange(0, size), np.arange(0, size))if offset is None:# offset是响应值坐标点offset_x = offset_y = size // 2# 如果未指定坐标点，即无峰值的话，就以中心点为相应点else:offset_x, offset_y = self._pair(offset)# power指数计算，np.power(a,b)，返回a^bself.factor = torch.from_numpy(-(np.power(xx - offset_x, 2) + np.power(yy - offset_y, 2)) / 2).float()# 求得相应点与周围点的距离，代表论文公式(5)中e的指数上分子的结果@staticmethoddef _pair(x):return (x, x) if isinstance(x, int) else xdef forward(self, theta):# 这里theta即可学习的参数，pow2代表e的指数上的分母pow2 = torch.pow(theta * self.size[0], 2)# kernel尺寸为31*31,为最终计算得到的Aikernel = 1.0 / (2 * np.pi * pow2) * torch.exp(self.factor.to(theta.device) / pow2)return kernel / kernel.max()

峰值响应点的计算

class PeakStimulation(Function):@staticmethoddef forward(ctx, input, return_aggregation, win_size, peak_filter):ctx.num_flags = 4# 窗口大小必须是奇数assert win_size % 2 == 1, 'Window size for peak finding must be odd.'# offset表示填充宽度，具体用法见下面调用过程offset = (win_size - 1) // 2# 定义二维填充函数padding = torch.nn.ConstantPad2d(offset, float('-inf'))# 对原图进行填充padded_maps = padding(input)# 得到填充图像后的尺寸batch_size, num_channels, h, w = padded_maps.size()# long()方法表示将数据转为in64型(长整型)# 先定义一个与扩充后图像大小相同的数组，然后再取出之间的元素视图(该视图指向元素，忽略扩充的部分)element_map = torch.arange(0, h * w).long().view(1, 1, h, w)[:, :, offset: -offset, offset: -offset]# 将数据放入和输入一样的地方中(同一个显卡，便于多卡训练)element_map = element_map.to(input.device)_, indices = F.max_pool2d(# indices大小为31*31，储存着周围极大值点的位置(该位置正好与之前创建的数组对应)padded_maps,kernel_size = win_size,stride = 1,return_indices = True)peak_map = (indices == element_map)# 找出局部最大值，即当前点就是周围的最大值点，也就是峰值点，计算方法很巧妙# 保存位置点if peak_filter:# 如果指定peak_filter为均值计算# 则下述操作代表峰值响应必须大于输入图片的均值mask = input >= peak_filter(input)peak_map = (peak_map & mask)# 返回peak_map非零元素的坐标,二维数组，第一维度大小是坐标点个数，第二维度是原数组的维数，在这里第二维度尺寸是4peak_list = torch.nonzero(peak_map)# mark_non_differentiable将输出标记为不可微# 即peak_list不可微ctx.mark_non_differentiable(peak_list)# 是否做一个聚集，默认是if return_aggregation:peak_map = peak_map.float()# 转化成0-1数，True对应1，False代表0# save_for_backward保存给定的张量，便于将来调用函数的反向传播ctx.save_for_backward(input, peak_map)# 第一返回峰值点的坐标，第二返回所有峰值点响应的平均值return peak_list, (input * peak_map).view(batch_size, num_channels, -1).sum(2) / \peak_map.view(batch_size, num_channels, -1).sum(2)else:return peak_list@staticmethoddef backward(ctx, grad_peak_list, grad_output):# 将之前存储的响应图和转化为0-1矩阵的峰值图提取出来，用于本阶段反向传播的计算input, peak_map, = ctx.saved_tensorsbatch_size, num_channels, _, _ = input.size()# 梯度与峰值图做点乘，得到峰值处的梯度，然后再除以峰值点的个数？grad_input = peak_map * grad_output.view(batch_size, num_channels, 1, 1)/ \(peak_map.view(batch_size, num_channels, -1).sum(2).view(batch_size, num_channels, 1, 1) + 1e-6)return (grad_input,) + (None,) * ctx.num_flags

均值滤波

def _mean_filter(input):batch_size, num_channels, h, w = input.size()# 求平均值threshold = torch.mean(input.view(batch_size, num_channels, h * w), dim=2)# contiguous返回连续的张量return threshold.contiguous().view(batch_size, num_channels, 1, 1)  

以上仅是笔者的个人见解，若有错误，欢迎大家批评指正