神经网络相对位置神经网络相似度

转载

技术极客 2024-05-24 21:59:55

文章标签 神经网络相对位置卷积 ide 相似性度量 文章分类 神经网络人工智能

简要

与简单的加法运算相比，乘法运算具有更高的计算复杂度。深度神经网络中广泛使用的卷积正好是来度量输入特征和卷积滤波器之间的相似性，这涉及浮点值之间的大量乘法。现在作者提出了加法网络(AdderNets)来交换深度神经网络中的这些大规模乘法，特别是卷积神经网络(CNNs)，以获得更简易的加法以降低计算成本。

神经网络相对位置神经网络相似度_神经网络相对位置

在加法器网中，作者以滤波器与输入特征之间的L1范数距离作为输出响应。分析了这种新的相似性度量对神经网络优化的影响。为了获得更好的性能，通过研究全精度梯度开发了一种特殊的反向传播方法。然后，作者还提出了一种自适应学习率策略，根据每个神经元梯度的大小来增强加法网络的训练过程。

神经网络相对位置神经网络相似度_相似性度量_02

上图就是加法网络的特征可视化结果。

研究背景

虽然深度神经网络的二值化滤波器大大降低了计算成本，但原始识别精度往往无法保持。此外，二进制网络的训练过程不稳定，通常要求较慢的收敛速度和较小的学习速率。经典CNN中的卷积实际上是测量两个输入的相似性。研究人员和开发人员习惯于将卷积作为默认操作，从视觉数据中提取特征，并引入各种方法来加速卷积，即使存在牺牲网络能力的风险。但几乎没有人试图用另一种更有效的相似性度量来取代卷积。事实上，加法的计算复杂度要比乘法低得多。因此，作者有动机研究用卷积神经网络中的加法代替乘法的可行性。

实验

在MNIST、CIFAR及ImageNet数据集山验证了AdderNet的有效性，随后进行了消融实验以及对提取的特征进行可视化。

AdderNet使用L1距离来度量输入与filter之间的关系，而不是使用卷积的互相关。因此需要探究一些AdderNet与CNN特征空间上的差异。因此就在MNIST数据集上搭建了LeNet++：6conv+1fc,每层神经元数目依次为：32，32，64，64，128，128，2。同样其中的conv层用add filter替换可视化结果如图1所示，CNN的可视化结果为右侧，相似度通过cosin计算得到的，因此分类通过角度进行的分类。左侧是AdderNet的可视化结果，可以看到不同种类的聚类中心不同，这也验证了AdderNet具有同CNN相似的辨别能力。

神经网络相对位置神经网络相似度_卷积_06

对filter的可视化结果如上图所示，虽然AdderNet和CNN用的度量矩阵不同，但都具有特征提取的能力。

Learning curve of AdderNets using different optimization schemes

神经网络相对位置神经网络相似度_神经网络相对位置_07

权重分布的可视化

对LeNet-5-BN的第三层进行可视化，AdderNet权重更接近Laplace分布，CNN的权重近似高斯分布，分别对应L1-norm和L2-norm。

神经网络相对位置神经网络相似度_ide_08

注：左边是AdderNet，右边是CNNs

部分代码

不过，反向传播还没哟完全看懂。

点击查看代码

import torch
import torch.nn as nn
import numpy as np
from torch.autograd import Function
import math

def adder2d_function(X, W, stride=1, padding=0):
    # [output_channel,input_channel,kernel_size,kernel_size]
    n_filters, d_filter, h_filter, w_filter = W.size()
    n_x, d_x, h_x, w_x = X.size()

    h_out = (h_x - h_filter + 2 * padding) / stride + 1
    w_out = (w_x - w_filter + 2 * padding) / stride + 1

    # 得到输出大小h_out，w_out
    h_out, w_out = int(h_out), int(w_out)
    # X_col: [n_x, input_channel*kernel_size*kernel_size, h_out*w_out]
    X_col = torch.nn.functional.unfold(X.view(1, -1, h_x, w_x), h_filter, dilation=1, padding=padding, stride=stride).view(n_x, -1, h_out*w_out)
    # X_col: [input_channel*kernel_size*kernel_size, h_out*w_out*n_x]
    X_col = X_col.permute(1,2,0).contiguous().view(X_col.size(1),-1)
    W_col = W.view(n_filters, -1)   # [output_channel, input_channel*kernel_size*kernel_size] or [n_filtrs, d_filter*h_filter*w_filter]
    
    out = adder.apply(W_col,X_col)
    
    out = out.view(n_filters, h_out, w_out, n_x)
    out = out.permute(3, 0, 1, 2).contiguous()
    
    return out

class adder(Function):
    @staticmethod
    def forward(ctx, W_col, X_col):
        ctx.save_for_backward(W_col,X_col)
        # W_col:[output_channel, input_channel*kernel_size*kernel_size, ]
        # X_col:[ , input_channel*kernel_size*kernel_size, h_out*w_out*n_x]
        output = -(W_col.unsqueeze(2)-X_col.unsqueeze(0)).abs().sum(1)
        return output

    @staticmethod
    def backward(ctx,grad_output):
        # W_col:[output_channel, input_channel*kernel_size*kernel_size, ]
        # X_col:[ , input_channel*kernel_size*kernel_size, h_out*w_out*n_x]
        W_col,X_col = ctx.saved_tensors
        # grad_W_col:[output_channel, input_channel*kernel_size*kernel_size, h_out*w_out*n_x]  -->  [output_channel, ,1, ]
        grad_W_col = ((X_col.unsqueeze(0)-W_col.unsqueeze(2))*grad_output.unsqueeze(1)).sum(2)
        # compute local learning rate
        grad_W_col = grad_W_col/grad_W_col.norm(p=2).clamp(min=1e-12)*math.sqrt(W_col.size(1)*W_col.size(0))/5
        grad_X_col = (-(X_col.unsqueeze(0)-W_col.unsqueeze(2)).clamp(-1,1)*grad_output.unsqueeze(1)).sum(0)
        
        return grad_W_col, grad_X_col
    
class adder2d(nn.Module):

    def __init__(self,input_channel,output_channel,kernel_size, stride=1, padding=0, bias = False):
        super(adder2d, self).__init__()
        self.stride = stride
        self.padding = padding
        self.input_channel = input_channel
        self.output_channel = output_channel
        self.kernel_size = kernel_size
        self.adder = torch.nn.Parameter(nn.init.normal_(torch.randn(output_channel,input_channel,kernel_size,kernel_size)))
        self.bias = bias
        if bias:
            self.b = torch.nn.Parameter(nn.init.uniform_(torch.zeros(output_channel)))

    def forward(self, x):
        # 得到Adder的输出
        output = adder2d_function(x,self.adder, self.stride, self.padding)
        if self.bias:
            output += self.b.unsqueeze(0).unsqueeze(2).unsqueeze(3)
        
        return output

本地电脑显存不够，调试只能到forward.....

\(W_{col}:\)

144=1633

神经网络相对位置神经网络相似度_神经网络相对位置_09