C7 卷积神经网络
CNN中新增了Convolution层和Pooling层，其连接顺序是：Convolution-Relu-Pooling，靠近输出层使用Affine-ReLU组合
①全连接：相邻层的所有神经元之间都有连接
②卷积层：以多维的数据形式接收输入数据，其输入输出数据称为“特征图”
卷积运算：相当于图像处理中的滤波器运算；对于输入数据，以一定间隔滑动滤波器窗口进行运算，将各个位置上过滤的元素和输入的对应元素相乘，再求和，把结果保存到输入的对应位置（乘积累加运算）
偏置：在应用了滤波器的数据上加上偏置
填充：向数据周围填入固定数据，主要是为了调整输出的大小。如果每次进行卷积运算都会缩小空间，则在某个时刻输出大小就可能变为1，导致无法再应用卷积运算。为避免这样的情况，就要使用填充。
步幅：应用滤波器位置的间隔称为步幅
假设输入大小为(H,W)，滤波器大小为(FH,FW)，输出大小为(OH,OW)，填充为P，步幅为S
输出大小计算公式：
OH=(H+2P-FH)/S+1
OW=(W+2P-FW)/S+1

多维数据的卷积运算：对于多通道方向数据，当通道方向上有多个特征图时，会按照通道进行输入数据和滤波器的卷积运算，并将结果相加从而得到输出。输入数据和滤波器的通道数要设置为相同的值。
批处理：对神经网络的处理中进行输入数据的打包处理，能够实现处理的高效化和学习时对mini-batch的对应。
在卷积运算中同样对应批处理，需要将各层间传递的数据保存为4维数据，按照(batch_num,channel,height,width)顺序保存数据。批处理将n次处理汇总成1次进行。
池化层：是缩小高、长方向上的空间运算。有Average池化、Max池化
池化层特征：没有要学习的参数，通道数不发生变化，对于微小的位置变化具有鲁棒性。

卷积层与池化层实现
1、四维数组：对于CNN中各层间传递的四维数据，使用python实现
x=np.random.rand(10,1,28,28)
访问第一个数据：x[0]
x[0].shape #(1,28,28)

2、基于im2col的展开
如果老老实实地实现卷积运算，估计要重复好几层的for语句，这样的实现比较麻烦。而且NumPy中存在使用for语句后处理变慢的缺点。使用im2col这个不便利的函数进行简单实现。
im2col函数可以将输入数据展开以是和滤波器，对三维的输入数据应用im2col后，数据转换为二维矩阵
当滤波器的运用区域重叠的情况下，使用im2col展开以后，展开后的元素会多于原方块的元素个数；im2col实现存在比普通实现消耗更多内存的缺点，汇总成一个大矩阵进行计算，对计算机计算颇有益处。

使用im2col展开数据后，就只需将卷积层的滤波器纵向展开为1列，并且计算2个矩阵的乘积即可。与全连接层Affine层进行处理基本相同。

※卷积层实现
初始化方法将滤波器（权重）、偏置、步幅、填充作为参数接收。滤波器是(FN,C,FH,FW)的4维形状。
使用im2col展开输入数据，并用reshape将滤波器展开为二维数组。然后计算展开后的矩阵的乘积。
其中，通过使用reshape(FN,-1)，将参数指定为-1，reshape函数会自动计算-1维度上的元素个数，以使得多维数组元素个数前后一致
transpose：更改多维数组的轴的顺序，将输出大小转换为合适的形状。
卷积层进行反向转播时，必须进行im2col的逆处理

class Convolution:
    def __init__(self, W, b, stride=1, pad=0):
        self.W = W
        self.b = b
        self.stride = stride
        self.pad = pad
        
        # 中间数据（backward时使用）
        self.x = None   
        self.col = None
        self.col_W = None
        
        # 权重和偏置参数的梯度
        self.dW = None
        self.db = None

    def forward(self, x):
        FN, C, FH, FW = self.W.shape
        N, C, H, W = x.shape
        out_h = 1 + int((H + 2*self.pad - FH) / self.stride)
        out_w = 1 + int((W + 2*self.pad - FW) / self.stride)

        col = im2col(x, FH, FW, self.stride, self.pad)
        col_W = self.W.reshape(FN, -1).T

        out = np.dot(col, col_W) + self.b
        out = out.reshape(N, out_h, out_w, -1).transpose(0, 3, 1, 2)

        self.x = x
        self.col = col
        self.col_W = col_W

        return out

    def backward(self, dout):
        FN, C, FH, FW = self.W.shape
        dout = dout.transpose(0,2,3,1).reshape(-1, FN)

        self.db = np.sum(dout, axis=0)
        self.dW = np.dot(self.col.T, dout)
        self.dW = self.dW.transpose(1, 0).reshape(FN, C, FH, FW)

        dcol = np.dot(dout, self.col_W.T)
        dx = col2im(dcol, self.x.shape, FH, FW, self.stride, self.pad)

        return dx

 

 

※池化层实现
一样使用im2col展开输入数据，不过池化层中通道方向是独立的，池化的应用区域按照通道单独展开。
进行阶段：
①展开输入数据，②求各行的最大值，③转换为合适的输出大小

class Pooling:
    def __init__(self, pool_h, pool_w, stride=1, pad=0):
        self.pool_h = pool_h
        self.pool_w = pool_w
        self.stride = stride
        self.pad = pad
        
        self.x = None
        self.arg_max = None

    def forward(self, x):
        N, C, H, W = x.shape
        out_h = int(1 + (H - self.pool_h) / self.stride)
        out_w = int(1 + (W - self.pool_w) / self.stride)

        col = im2col(x, self.pool_h, self.pool_w, self.stride, self.pad)
        col = col.reshape(-1, self.pool_h*self.pool_w)

        arg_max = np.argmax(col, axis=1)
        out = np.max(col, axis=1)
        out = out.reshape(N, out_h, out_w, C).transpose(0, 3, 1, 2)

        self.x = x
        self.arg_max = arg_max

        return out

    def backward(self, dout):
        dout = dout.transpose(0, 2, 3, 1)
        
        pool_size = self.pool_h * self.pool_w
        dmax = np.zeros((dout.size, pool_size))
        dmax[np.arange(self.arg_max.size), self.arg_max.flatten()] = dout.flatten()
        dmax = dmax.reshape(dout.shape + (pool_size,)) 
        
        dcol = dmax.reshape(dmax.shape[0] * dmax.shape[1] * dmax.shape[2], -1)
        dx = col2im(dcol, self.x.shape, self.pool_h, self.pool_w, self.stride, self.pad)
        
        return dx

 

 

CNN的实现：
参数解释
①input_dim：输入数据的维度（通道，高，长）
②conv_param：卷积层的超参数（字典），字典的关键字如下：
filter_num：滤波器的数量
filter_size：滤波器的大小
stride：步幅，
pad：填充
③hidden_size：隐藏层（全连接）的神经元数量
④output_size：输出层（全连接）的神经元数量
⑤weight_int_std：初始化时权重的标准差

将由初始化参数传入的卷积层出号参数从字典中取了出来，计算卷积层输出大小，接下来是权重参数的初始化部分。
学习所需的参数是第一层的卷积层和剩余两个全连接的权重和偏置。这些参数保存在实例变量中params字典中。将第一层的卷积层权重设为关键字w1，偏置设定为关键字b1，分别使用关键字w2，b2和关键字w3，b3保存第二个和第三个全连接的权重与偏置。

然后按照顺序生成必要的层，向有序字典(orderedDict)的layers中添加层，只有最后的softmaxWithLoss层被添加到别的变量lastLayer中。

推理：predict方法，从头开始依次调用已经添加的层，将结果传递给下一个层。
在求损失函数函数的loss方法中，除了使用predict方法进行的forward处理以外，还会继续进行forward处理，知道到达最后的softmaxWithLoss层

接下来是基于误差反差传播法求梯度的代码实现
参数的梯度通过误差反向传播法（反向传播）求出，通过把正向传播和反向传播组装在一起完成。因为已经再各层中正确实现了正向传播和反向传播功能，这里只需要以合适的顺序调用即可。最后把各个权重参数梯度保存到grads字典中。

# coding: utf-8
import sys, os
sys.path.append(os.pardir)  # 为了导入父目录的文件而进行的设定
import pickle
import numpy as np
from collections import OrderedDict
from common.layers import *
from common.gradient import numerical_gradient


class SimpleConvNet:
    """简单的ConvNet

    conv - relu - pool - affine - relu - affine - softmax
    
    Parameters
    ----------
    input_size : 输入大小（MNIST的情况下为784）
    hidden_size_list : 隐藏层的神经元数量的列表（e.g. [100, 100, 100]）
    output_size : 输出大小（MNIST的情况下为10）
    activation : 'relu' or 'sigmoid'
    weight_init_std : 指定权重的标准差（e.g. 0.01）
        指定'relu'或'he'的情况下设定“He的初始值”
        指定'sigmoid'或'xavier'的情况下设定“Xavier的初始值”
    """
    def __init__(self, input_dim=(1, 28, 28), 
                 conv_param={'filter_num':30, 'filter_size':5, 'pad':0, 'stride':1},
                 hidden_size=100, output_size=10, weight_init_std=0.01):
        filter_num = conv_param['filter_num']
        filter_size = conv_param['filter_size']
        filter_pad = conv_param['pad']
        filter_stride = conv_param['stride']
        input_size = input_dim[1]
        conv_output_size = (input_size - filter_size + 2*filter_pad) / filter_stride + 1
        pool_output_size = int(filter_num * (conv_output_size/2) * (conv_output_size/2))

        # 初始化权重
        self.params = {}
        self.params['W1'] = weight_init_std * \
                            np.random.randn(filter_num, input_dim[0], filter_size, filter_size)
        self.params['b1'] = np.zeros(filter_num)
        self.params['W2'] = weight_init_std * \
                            np.random.randn(pool_output_size, hidden_size)
        self.params['b2'] = np.zeros(hidden_size)
        self.params['W3'] = weight_init_std * \
                            np.random.randn(hidden_size, output_size)
        self.params['b3'] = np.zeros(output_size)

        # 生成层
        self.layers = OrderedDict()
        self.layers['Conv1'] = Convolution(self.params['W1'], self.params['b1'],
                                           conv_param['stride'], conv_param['pad'])
        self.layers['Relu1'] = Relu()
        self.layers['Pool1'] = Pooling(pool_h=2, pool_w=2, stride=2)
        self.layers['Affine1'] = Affine(self.params['W2'], self.params['b2'])
        self.layers['Relu2'] = Relu()
        self.layers['Affine2'] = Affine(self.params['W3'], self.params['b3'])

        self.last_layer = SoftmaxWithLoss()

    def predict(self, x):
        for layer in self.layers.values():
            x = layer.forward(x)

        return x

    def loss(self, x, t):
        """求损失函数
        参数x是输入数据、t是教师标签
        """
        y = self.predict(x)
        return self.last_layer.forward(y, t)

    def accuracy(self, x, t, batch_size=100):
        if t.ndim != 1 : t = np.argmax(t, axis=1)
        
        acc = 0.0
        
        for i in range(int(x.shape[0] / batch_size)):
            tx = x[i*batch_size:(i+1)*batch_size]
            tt = t[i*batch_size:(i+1)*batch_size]
            y = self.predict(tx)
            y = np.argmax(y, axis=1)
            acc += np.sum(y == tt) 
        
        return acc / x.shape[0]

    def numerical_gradient(self, x, t):
        """求梯度（数值微分）

        Parameters
        ----------
        x : 输入数据
        t : 教师标签

        Returns
        -------
        具有各层的梯度的字典变量
            grads['W1']、grads['W2']、...是各层的权重
            grads['b1']、grads['b2']、...是各层的偏置
        """
        loss_w = lambda w: self.loss(x, t)

        grads = {}
        for idx in (1, 2, 3):
            grads['W' + str(idx)] = numerical_gradient(loss_w, self.params['W' + str(idx)])
            grads['b' + str(idx)] = numerical_gradient(loss_w, self.params['b' + str(idx)])

        return grads

    def gradient(self, x, t):
        """求梯度（误差反向传播法）

        Parameters
        ----------
        x : 输入数据
        t : 教师标签

        Returns
        -------
        具有各层的梯度的字典变量
            grads['W1']、grads['W2']、...是各层的权重
            grads['b1']、grads['b2']、...是各层的偏置
        """
        # forward
        self.loss(x, t)

        # backward
        dout = 1
        dout = self.last_layer.backward(dout)

        layers = list(self.layers.values())
        layers.reverse()
        for layer in layers:
            dout = layer.backward(dout)

        # 设定
        grads = {}
        grads['W1'], grads['b1'] = self.layers['Conv1'].dW, self.layers['Conv1'].db
        grads['W2'], grads['b2'] = self.layers['Affine1'].dW, self.layers['Affine1'].db
        grads['W3'], grads['b3'] = self.layers['Affine2'].dW, self.layers['Affine2'].db

        return grads
        
    def save_params(self, file_name="params.pkl"):
        params = {}
        for key, val in self.params.items():
            params[key] = val
        with open(file_name, 'wb') as f:
            pickle.dump(params, f)

    def load_params(self, file_name="params.pkl"):
        with open(file_name, 'rb') as f:
            params = pickle.load(f)
        for key, val in params.items():
            self.params[key] = val

        for i, key in enumerate(['Conv1', 'Affine1', 'Affine2']):
            self.layers[key].W = self.params['W' + str(i+1)]
            self.layers[key].b = self.params['b' + str(i+1)]

 

 

CNN的可视化
学习前的滤波器是随机进行初始化的 所以在黑白的浓淡上没有规律可循，但学习后的滤波器变成了有规律的图像。对于有规律的滤波器是在观察边缘和斑块，会对图中对应方向的边缘有响应。
卷积层的滤波器会提取边缘或者斑块等原始信息，刚才实现的CNN会将这些原始信息传递给后面的层

具有代表性的CNN
1、LeNet
具有连续的卷积层和池化层，最后经过全连接层输出结果。使用sigmoid函数，原始的LeNet中使用子采样缩小中间数据的大小。
2、AlexNet
有多个卷积层和池化层，最后经由全连接层输出结果。激活函数使用ReLU，使用进行局部正规化的LRN，使用Dropout层