机器学习---CNN（创建和训练一个卷积神经网络并评估其性能）下

import numpy as np
import matplotlib.pyplot as plt
from cnn_operations import cnn_operations as cnn_opr

convolutional_neural_network模块：

1. 卷积神经网络类

    def __init__(self):
        # 网络的层数
        self.n_layers = 0
        # list，网络中的各层
        self.layers = []
        # array，网络的输出
        self.output = None
        # 网络的代价
        self.loss = None
        # 权值的学习率
        self.learning_rate_weight = 0.1
        # 偏置的学习率
        self.learning_rate_bias = 0.1

初始化网络结构相关属性,如层数、层列表；初始化输出、损失和学习率属性

层列表self.layers用于后续添加各层对象；输出self.output和损失self.loss记录训练过程中的值

    def config(self, args):
      
        self.n_layers = len(args)
        
        prior_layer = None
        for i in range(self.n_layers):
            # 配置网络的各层
            new_layer = cnn_layer(args[i][0])
            
            if i > 0:
                prior_layer = self.layers[-1]
                
                # 当前层设为上一层的next_layer
                self.layers[-1].next_layer = new_layer
                
            new_layer.config(args[i][1], self.learning_rate_weight, 
                             self.learning_rate_bias, prior_layer)
            
            self.layers.append(new_layer)
            
        return None

配置网络：

args: 元组，其中`args[i][0]`代表第i层的类型，类型包括 "input"（输入层）、"convoluting"（卷积

层）、"pooling"（池化层）、"full_connecting"（全连接层）和 "output"（输出层）。args[i][1]是一

个元组，包含第i层的配置参数。

函数的主要流程：

①获取args元组的长度，即网络的层数。

②进入循环，对每一层进行配置。先创建一个新的层new_layer，然后判断如果不是第一层，就把

前一层prior_layer设为新创建的层的前一层，并把前一层的`next_layer`设为新创建的层。

③配置新创建的层，参数包括第i层的配置参数，学习率，以及前一层的信息。

④将新创建的层添加到网络的层级列表中。

    def _feed_forward(self, x):

        # 输入层前向传播
        self.layers[0].feed_forward(x)
        # 其它各层前向传播
        for i in range(1, self.n_layers):
            self.layers[i].feed_forward(x)
            
        # self.layers[-1].n_nodes * size_batch array，网络的输出
        self.output = np.ndarray.flatten( \
                np.array(self.layers[-1].output)).reshape( \
                self.layers[-1].n_nodes, -1)
        
        return None

前向传播：

x: 是一个3维数组，表示一个批次（batch）的输入图像。每个通道的尺寸为x.shape[0] *

x.shape[1]，而x.shape[2]代表当前批次中图像的个数乘以每幅图像的通道数。

函数的主要流程：

①首先进行输入层的前向传播计算，输入参数为输入图像x。

②然后对从第二层开始的其他所有层进行前向传播计算，输入参数也为输入图像x。

③最后，将网络最后一层的输出进行降维处理，并保存到self.output中。这里，np.ndarray.flatten()

函数用于将一个多维数组转化为一维数组，np.reshape()函数用于改变数组的形状。

    def _back_propagate(self, y):

        # 输出层反向传播
        self.layers[-1].back_propagate(y)
        # 其它各层反向传播
        for i in range(self.n_layers - 2, 0, -1):
            self.layers[i].back_propagate()
        
        return None

反向传播：

y: 数组，表示输入样本对应的类别标签。

函数的主要流程：

①首先进行输出层的反向传播计算，输入参数为类别标签`y`。

②然后对从倒数第二层开始的其他所有层进行反向传播计算，无需传入参数。

反向传播是神经网络训练的核心部分，它的目标是通过计算损失函数关于网络参数的梯度，

然后根据这个梯度来更新网络的参数。具体来说，反向传播过程首先计算输出层的误差，然后依次

向前一层一层传递，直到输入层，每经过一层都会根据该层的误差来更新该层的参数。

    def fit(self, X, Y, size_batch=1, n_epochs=1):
    
        self.size_batch = size_batch
        # 训练样本个数 * 每幅图片的通道数
        len_X = X.shape[-1]
        len_Y = Y.shape[0]
        # 每个epoch中batch的个数
        n_batches = int(np.ceil(len_X / self.layers[0].n_nodes / size_batch))
        
        loss = np.empty(n_epochs * n_batches)
        
        for i_epoch in range(n_epochs):
            print("Epoch: ", end="")
            print(i_epoch)
            for i_batch in range(n_batches):
                print("\tBatch: ", end="")
                print(i_batch, end="\t")
                y_offset = i_batch * size_batch
                x_offset = y_offset * self.layers[0].n_nodes
                
                # 将类别标签转换为向量
                y = np.zeros([self.layers[-1].n_nodes, size_batch])
                for i in range(size_batch):
                    if i > len_Y - y_offset - 1:
                        y = y[:, :, : i]
                        
                        break
                    
                    y[Y[y_offset + i], i] = 1
                    
                self._feed_forward(X[:, :, x_offset: x_offset + size_batch * \
                                     self.layers[0].n_nodes])
                
                loss[i_epoch * n_batches + i_batch] = \
                        cnn_opr.calc_loss(y.T, self.output.T)
                print("loss = ", end="")
                print(loss[i_epoch * n_batches + i_batch])
                
                self._back_propagate(y)
                
        self.loss = loss
                
        plt.figure()
        plt.plot(loss, "r-")
        plt.xlabel("Batches")
        plt.ylabel("Loss")
        plt.grid()
        plt.show()
        
        return None

训练卷积神经网络：

X: 3维数组，表示训练集。其中，X[:, :, i: i + self.layers[0].n_nodes]表示一个训练样本（图

片），self.layers[0].n_nodes即为每幅图片的通道数。

Y: 数组，表示训练集对应的类别标签。

size_batch: 一个批次（batch）中训练样本的个数。

n_epochs: 训练的迭代次数。

函数的主要流程：

①计算每个周期（epoch）中批次的个数，并创建一个空的损失数组用于存储每个批次的损失值。

②开始训练，对每个周期和每个批次进行循环。

③对于每个批次，首先获取该批次的输入图像和对应的类别标签，然后将类别标签转换为向量形式

（one-hot encoding）。

④然后执行前向传播，计算网络的输出，并计算损失值。损失值是真实标签和网络输出之间的差

异，通常用于评估网络的性能。

⑤接着执行反向传播，更新网络的参数。

⑥最后，将每个批次的损失值存储起来，并在训练结束后绘制损失值的变化图。

使用随机梯度下降方法训练卷积神经网络，通过循环迭代和反向传播，逐渐优化网络的参

数，使得网络的输出能够尽可能接近真实的标签，从而提高网络的性能。

    def test(self, X, Y):
    
        n_correct = 0
        for i in range(0, X.shape[-1], self.layers[0].n_nodes):
            print("Test case: ", end="")
            print(i)
            y_predict = self.predict(X[:, :, i: i + self.layers[0].n_nodes])
            
            if y_predict == Y[i]:
                n_correct += 1
                
        correct_rate = n_correct / X.shape[-1]
        
        return correct_rate

用于测试卷积神经网络的性能：

X: 3维数组，表示测试集。其中，X[:, :, i: i + self.layers[0].n_nodes]表示一个测试样本（图

片），self.layers[0].n_nodes即为每幅图片的通道数。

Y: 数组，表示测试集对应的类别标签。

函数的主要流程：

①初始化正确分类的样本数为0。

②对每个测试样本进行循环，对每个样本进行预测，并与真实标签进行比较。如果预测正确，则正

确分类的样本数加1。

③计算并返回测试集的分类正确率，即正确分类的样本数除以总样本数。

    def predict(self, x):

        self._feed_forward(x.reshape(x.shape[0], x.shape[1], -1))
        
        # 根据网络输出层的类型，判定输入图像的类别
        if self.layers[-1].type_output is "softmax":
            y_predict = np.argmax(self.output[:, 0])
            
        elif self.layers[-1].type_output is "rbf":
            # TODO: 
            pass
        
        return y_predict

用于预测输入样本的类别：

x: 2维或3维数组，表示输入样本（图像）。

函数的主要流程：

①对输入样本进行前向传播计算，得到网络的输出。

②根据网络输出层的类型，判断输入图像的类别。如果输出层的类型是"softmax"，则选择输出向

量中值最大的元素对应的索引作为类别标签。如果输出层的类型是"rbf"，目前该部分还未实现，需

要补充相应的代码。

③函数返回预测出的输入样本的类别。

2. 卷积神经网络中的一层（类）cnn_layer

    def __init__(self, type_layer):
  
        
        # 当前层的类型
        self.type = type_layer
        # 当前层中神经元的个数
        self.n_nodes = 0
        # list，当前层中各神经元
        self.nodes = []
        # 当前层的上一层
        self.prior_layer = None
        # 当前层的下一层
        self.next_layer = None
        # list，当前层的输出
        self.output = []
        # 权值的学习率
        self.learning_rate_weight = 0.0
        # 偏置的学习率
        self.learning_rate_bias = 0.0
        
        if self.type is "input":
            # array，输入图像（每个通道）的尺寸
            self.size_input = None
            
        elif self.type is "convoluting":
            # 2-d array，当前层与上一层各神经元的连接矩阵
            self.connecting_matrix = None
            # array，卷积核尺寸
            self.size_conv_kernel = None
            # 卷积核步长
            self.stride_conv_kernel = 1
            # 边缘补零的宽度
            self.padding_conv = 0
            # 激活函数类型，{"relu", "sigmoid", "tanh", None}
            self.type_activation = None
            
        elif self.type is "pooling":
            # 池化核类型，{"max", "average"}
            self.type_pooling = "max"
            # array，池化核尺寸
            self.size_pool_kernel = np.array([2, 2])
            # 池化核步长
            self.stride_pool_kernel = 2
            # 边缘补零的宽度
            self.padding_pool = 0
            # 激活函数类型，{"relu", "sigmoid", "tanh", None}
            self.type_activation = None
            
        elif self.type is "full_connecting":
            # 激活函数类型，{"relu", "sigmoid", "tanh", None}
            self.type_activation = None
            
        elif self.type is "output":
            # 输出层类型，{"softmax", "rbf"}
            self.type_output = "softmax"

type_layer: 当前层的类型，可以是"input"（输入层）、"convoluting"（卷积

层）、"pooling"（池化层）、"full_connecting"（全连接层）或"output"（输出层）。

首先，根据层的类型初始化共享的属性，如神经元个数、神经元列表、前一层、后一层、输

出、权值学习率和偏置学习率等。

然后，根据层的类型初始化特定的属性。例如，如果层的类型是"input"，则初始化输入图像的

尺寸；如果层的类型是"convoluting"，则初始化连接矩阵、卷积核尺寸、卷积核步长、边缘补零的

宽度和激活函数类型等。

    def config(self, args, learning_rate_weight, learning_rate_bias, 
               prior_layer=None):

        self.prior_layer = prior_layer
        self.learning_rate_weight = learning_rate_weight
        self.learning_rate_bias = learning_rate_bias
        
        if self.type is "input":
            size_input, = args
            
            # 输入图像为单通道
            if size_input.shape[0] == 2:
                self.n_nodes = 1
                self.size_input = size_input
                
            # 输入图像为多通道
            elif size_input.shape[0] == 3:
                # 每个神经元一个通道
                self.n_nodes = size_input[-1]
                # 输入图像每个通道的尺寸
                self.size_input = size_input[ : 2]
                
            self._config_input(self.size_input)
            
        elif self.type is "convoluting":
            connecting_matrix, size_conv_kernel, \
                    stride_conv_kernel, padding_conv, type_activation = args
            
            self.connecting_matrix = connecting_matrix
            self.n_nodes = connecting_matrix.shape[1]
            self.size_conv_kernel = size_conv_kernel
            self.stride_conv_kernel = stride_conv_kernel
            self.padding_conv = padding_conv
            self.type_activation = type_activation
            
            self._config_convoluting(connecting_matrix, size_conv_kernel, 
                                     stride_conv_kernel, padding_conv, 
                                     type_activation)
            
        elif self.type is "pooling":
            type_pooling, size_pool_kernel, \
                    stride_pool_kernel, padding_pool, type_activation = args
                    
            # 池化层神经元个数与上一层卷积层（或激活层）神经元个数相同
            self.n_nodes = self.prior_layer.n_nodes
            self.type_pooling = type_pooling
            self.size_pool_kernel = size_pool_kernel
            self.stride_pool_kernel = stride_pool_kernel
            self.ppadding_pool = padding_pool
            self.type_activation = type_activation
            
            self._config_pooling(type_pooling, size_pool_kernel, 
                                 stride_pool_kernel, padding_pool, 
                                 type_activation)
            
        elif self.type is "full_connecting":
            n_nodes, type_activation = args
            
            self.n_nodes = n_nodes
            self.type_activation = type_activation
            
            self._config_full_connecting(n_nodes, type_activation)
            
        elif self.type is "output":
            n_nodes, type_output = args
            
            self.n_nodes = n_nodes
            self.type_output = type_output
            
            self._config_output(n_nodes, type_output)
            
        # 初始化权值
        self._initialize()
            
        return None

配置神经网络的各层：

args: 元组，包含当前层的配置参数。

learning_rate_weight: 权值的学习率。

learning_rate_bias: 偏置的学习率。

prior_layer: 当前层的上一层，默认值为None。

函数的主要流程：

①设置当前层的上一层以及权值和偏置的学习率。

②根据当前层的类型配置对应的参数。例如，如果当前层为"input"（输入层），则设置输入图像的

尺寸和通道数。如果当前层为"convoluting"（卷积层），则设置连接矩阵、卷积核尺寸和步长、边

缘补零的宽度以及激活函数类型等。

③调用_initialize()方法初始化权值。

    def _config_input(self, size_input):

        for i in range(self.n_nodes):
            new_node = cnn_node(self.type)
            
            args = (size_input,)
            new_node.config(args)
            
            self.nodes.append(new_node)
            
        return None

配置神经网络的输入层：

size_input: 数组，输入图像（每个通道）的尺寸。

函数的主要流程：

①通过遍历输入通道的数量，对每个通道创建一个新的神经元节点。

②使用输入尺寸参数调用每个节点的`config`方法进行配置。

③将配置好的节点添加到当前层的节点列表中。

    def _config_convoluting(self, connecting_matrix, size_conv_kernel, 
                            stride_conv_kernel, padding_conv, type_activation):
  
        for i in range(self.n_nodes):
            new_node = cnn_node(self.type)
            
            # 上一层中与当前神经元连接的神经元
            nodes_prior_layer = []
            for j in range(connecting_matrix.shape[0]):
                if connecting_matrix[j, i] == 1:
                    nodes_prior_layer.append(self.prior_layer.nodes[j])
                    
                    # 当前神经元添加至上一层中与之连接的神经元的nodes_next_layer
                    self.prior_layer.nodes[j].nodes_next_layer.append(new_node)
                    
            args = (nodes_prior_layer, size_conv_kernel, stride_conv_kernel, 
                    padding_conv, type_activation)
            new_node.config(args)
            
            self.nodes.append(new_node)
            
        return None

用于配置神经网络的卷积层：

connecting_matrix: M * N数组，M为上一层神经元个数，N为当前层神经元个数，

connecting_matrix[m, n]为1表示上一层第m个神经元与当前层第n个神经元连接，为0表示不连接。

size_conv_kernel: 数组，卷积核尺寸。

stride_conv_kernel: 卷积核步长。

padding_conv: 边缘补零的宽度。

type_activation: 激活函数类型，可以是"relu"（修正线性单元）、"sigmoid"（S型曲

线）、"tanh"（双曲正切函数）或None。

函数的主要流程：

①遍历当前层的所有神经元。

②对于每个神经元，找出上一层与之连接的神经元，并将当前神经元添加到这些神经元的

nodes_next_layer列表中。

③调用每个神经元的`config`方法，使用给定的参数进行配置。

④将配置好的神经元添加到当前层的nodes列表中。

    def _config_pooling(self, type_pooling, size_pool_kernel, 
                        stride_pool_kernel, padding_pool, type_activation):
        
        for i in range(self.n_nodes):
            new_node = cnn_node(self.type)
            
            # 上一层中与当前神经元连接的神经元
            nodes_prior_layer = self.prior_layer.nodes[i]
            
            # 当前神经元添加至上一层中与之连接的神经元的nodes_next_layer
            self.prior_layer.nodes[i].nodes_next_layer.append(new_node)
            
            args = (nodes_prior_layer, type_pooling, size_pool_kernel, 
                    stride_pool_kernel, padding_pool, type_activation)
            new_node.config(args)
            
            self.nodes.append(new_node)
        
        return None

配置神经网络的池化层：

type_pooling: 池化核类型，可以是"max"（最大池化）或"average"（平均池化）。

size_pool_kernel: 数组，池化核尺寸。

stride_pool_kernel: 池化核步长。

padding_pool: 边缘补零的宽度。

type_activation: 激活函数类型，可以是"relu"（修正线性单元）、"sigmoid"（S型曲

线）、"tanh"（双曲正切函数）或None。

函数的主要流程：

①遍历当前层的所有神经元。

②对于每个神经元，找出上一层与之相对应的神经元，并将当前神经元添加到这个神经元的

nodes_next_layer列表中。

③调用每个神经元的config方法，使用给定的参数进行配置。

④将配置好的神经元添加到当前层的nodes列表中。

    def _config_full_connecting(self, n_nodes, type_activation):
  
        # 上一层中所有神经元与当前层中每个经元连接
        nodes_prior_layer = self.prior_layer.nodes
        args = (nodes_prior_layer, type_activation)
        
        # 上一层中神经元的个数
        n_nodes_prior_layer = len(nodes_prior_layer)
        
        for i in range(n_nodes):
            new_node = cnn_node(self.type)
            
            # 当前神经元添加至上一层中每个神经元的nodes_next_layer
            for j in range(n_nodes_prior_layer):
                self.prior_layer.nodes[j].nodes_next_layer.append(new_node)
                
            new_node.config(args)
            
            self.nodes.append(new_node)
            
        return None

配置神经网络的全连接层：

n_nodes: 全连接层中神经元的个数。

type_activation: 激活函数类型，可以是"relu"（修正线性单元）、"sigmoid"（S型曲

线）、"tanh"（双曲正切函数）或`None`。

函数的主要流程：

①获取上一层的所有神经元。

②对于全连接层中的每个神经元，将其添加到上一层每个神经元的`nodes_next_layer`列表中。

③调用每个神经元的`config`方法，使用给定的参数进行配置。

    def _config_output(self, n_nodes, type_output):

        # 上一层中所有神经元与当前层中每个经元连接
        nodes_prior_layer = self.prior_layer.nodes
        args = (nodes_prior_layer, type_output)
        
        # 上一层中神经元的个数
        n_nodes_prior_layer = len(nodes_prior_layer)
        
        for i in range(n_nodes):
            new_node = cnn_node(self.type)
            
            # 当前神经元添加至上一层中每个神经元的nodes_next_layer
            for j in range(n_nodes_prior_layer):
                self.prior_layer.nodes[j].nodes_next_layer.append(new_node)
                
            new_node.config(args)
            
            self.nodes.append(new_node)
            
        return None

配置神经网络的输出层：

n_nodes: 输出层中神经元的个数，也就是类别的数目。

type_output: 输出层的类型，可以是"softmax"或"rbf"（径向基函数）。

函数的主要流程：

①获取上一层的所有神经元。

②对于输出层中的每个神经元，将其添加到上一层每个神经元的nodes_next_layer列表中。

③调用每个神经元的config方法，使用给定的参数进行配置。

    def _initialize(self):

        if self.type is "convoluting":
            self._initialize_convoluting()
        elif self.type is "full_connecting":
            self._initialize_full_connecting()
        elif self.type is "output":
            self._initialize_output()
            
        return None

Xavier初始化方法：

检查当前层的类型，然后对该层进行相应的初始化操作。如果类型是"convoluting"，则调用

_initialize_convoluting方法进行卷积层的初始化。如果类型是"full_connecting"，则调用

_initialize_full_connecting方法进行全连接层的初始化。如果类型是"output"，则调用

_initialize_output方法进行输出层的初始化。

    def _initialize_convoluting(self):

        fan_out = self.n_nodes * np.prod(self.size_conv_kernel)
        
        if self.prior_layer.type is "input":
            fan_in = self.prior_layer.n_nodes * np.prod(self.size_conv_kernel)
            
            u = np.sqrt(6 / (fan_in + fan_out))
            
            for i in range(self.n_nodes):
                for j in range(self.nodes[i].n_conv_kernels):
                    self.nodes[i].conv_kernels[j] = u * 2 * \
                            (np.random.rand(self.size_conv_kernel[0], 
                                            self.size_conv_kernel[1]) - 0.5)
                            
        elif self.prior_layer.type is "pooling":
            for i in range(self.n_nodes):
                fan_in = np.sum(self.connecting_matrix[:, i]) * \
                        np.prod(self.size_conv_kernel)
                        
                u = np.sqrt(6 / (fan_in + fan_out))
                
                for j in range(self.nodes[i].n_conv_kernels):
                    self.nodes[i].conv_kernels[j] = u * 2 * \
                            (np.random.rand(self.size_conv_kernel[0], 
                                            self.size_conv_kernel[1]) - 0.5)
                            
        return None

初始化神经网络的卷积层：

计算出fan_out（输出值的个数）。

根据前一层的类型，分别计算出fan_in（输入值的个数）并初始化卷积核权重。如果前一层

是"input"，则直接用前一层的神经元个数和卷积核大小计算出fan_in。如果前一层是"pooling"，则

需要用连接矩阵和卷积核大小来计算fan_in。

根据Xavier初始化方法，用fan_in和fan_out来计算一个因子u，然后用这个因子u来初始化当

前层神经元的每个卷积核。

函数中用到的变量如下：

self.n_nodes：当前层神经元的个数。

self.size_conv_kernel：卷积核的大小。

self.prior_layer：前一层。

self.nodes：当前层的所有神经元。

self.connecting_matrix：当前层与前一层的连接矩阵。

    def _initialize_full_connecting(self):

        fan_in = self.prior_layer.n_nodes
        fan_out = self.n_nodes
        
        u = np.sqrt(6 / (fan_in + fan_out))
        
        for i in range(self.n_nodes):
            self.nodes[i].weights = u * 2 * (np.random.rand(fan_in) - 0.5)
            
        return None

初始化神经网络的全连接层：

计算fan_in（输入的数量），这个值等于前一层的神经元数量。计算fan_out（输出的数量），这个

值等于当前层的神经元数量。根据Xavier初始化方法，计算一个因子u，这个因子用来初始化当前

层神经元的权重。对于全连接层的每个神经元，都用这个因子u来初始化它的权重。

    def _initialize_output(self):
   
        self._initialize_full_connecting()
        
        return None

用于初始化神经网络的输出层。

    def feed_forward(self, inputs=None):
   
        if self.type is "input":
            self._feed_forward_input(inputs)
            
        elif self.type is "output":
            self._feed_forward_output()
            
        else:
            self.output = []
            for i in range(self.n_nodes):
                # 当前层中每个神经元前向传播
                self.nodes[i].feed_forward()
                
                self.output.append(self.nodes[i].output)
                
        return None

首先检查当前层的类型。如果当前层是输入层，调用_feed_forward_input方法进行前向传播。如

果当前层是输出层，调用_feed_forward_output方法进行前向传播。如果当前层既不是输入层也不

是输出层，那么对当前层的每个神经元进行前向传播，并将每个神经元的输出添加到self.output

列表中。

    def _feed_forward_input(self, inputs):

        self.output = []
        # 输入图像为单通道，此时inputs[:, :, i]为每幅图像
        if self.n_nodes == 1:
            self.nodes[0].feed_forward(inputs)
            
            self.output.append(self.nodes[0].output)
            
        # 输入图像为多通道，此时inputs[:, :, i: i + 3]为每幅图像
        elif self.n_nodes > 1:
            for i in range(self.n_nodes):
                self.nodes[i].feed_forward(inputs[:, :, i: : self.n_nodes])
                
                self.output.append(self.nodes[i].output)
                
        return None

初始化输出列表self.output，如果输入层神经元数量为1（即输入图像为单通道），那么直接对该

神经元进行前向传播，并将其输出添加到self.output列表中。如果输入层神经元数目大于1（即输

入图像为多通道），那么对每个神经元进行前向传播，并将每个神经元的输出添加到self.output

列表中。

    def _feed_forward_output(self):

        if self.type_output is "softmax":
            # 输出层第一个神经元前向传播
            self.nodes[0].feed_forward()
            
            # size_batch * self.n_nodes array
            combinations = np.empty([self.nodes[0].combination.shape[-1], 
                                     self.n_nodes])
            combinations[:, 0] = self.nodes[0].combination.reshape(-1)
            
            # 输出层其它神经元前向传播
            for i in range(1, self.n_nodes):
                self.nodes[i].feed_forward()
                combinations[:, i] = self.nodes[i].combination.reshape(-1)
                
            # $e^{w_j^T x}, \forall j$
            exp_combinations = np.exp(combinations)
            # $\sum_{j = 1}^n e^{w_j^T x}$
            sum_exp = np.sum(exp_combinations, axis=1)
            
            self.output = []
            for i in range(self.n_nodes):
                # 输出层神经元的output为size_batch array
                # $\frac{e^{w_i^T x}}{\sum_{j = 1}^n e^{w_j^T x}}$
                self.nodes[i].output = exp_combinations[:, i] / sum_exp
                
                self.output.append(self.nodes[i].output)
            
        elif self.type_output is "rbf":
            # TODO: 
            pass
        
        return None

检查输出层的类型，如果是"softmax"类型，执行以下步骤：

对输出层的第一个神经元进行前向传播。

初始化一个空数组combinations，用于存储输出层各神经元的组合值。

对输出层的其它神经元进行前向传播，并将每个神经元的组合值存储到combinations数组中。

计算exp_combinations，即对combinations中的每个元素求指数。

计算sum_exp，即exp_combinations中的元素按列求和。

最后，计算每个神经元的输出，公式为，并将每个神经元的输出添加到

self.output列表中。

    def back_propagate(self, y=None):

        if self.type is "convoluting":
            self._back_propagate_convoluting()
        elif self.type is "pooling":
            self._back_propagate_pooling()
        elif self.type is "full_connecting":
            self._back_propagate_full_connecting()
        elif self.type is "output":
            self._back_propagate_output(y)
        
        return None

首先检查当前层的类型。如果当前层是卷积层，调用_back_propagate_convoluting方法进行反向

传播。如果当前层是池化层，调用_back_propagate_pooling方法进行反向传播。如果当前层是全

连接层，调用_back_propagate_full_connecting方法进行反向传播。如果当前层是输出层，调用

_back_propagate_output方法进行反向传播。

    def _back_propagate_convoluting(self):

        if self.next_layer.type is "pooling":
            self._bp_pooling_to_convoluting()
            
        elif self.next_layer.type is "full_connecting":
            self._bp_full_connecting_to_convoluting()
            
        elif self.next_layer.type is "output":
            self._bp_output_to_convoluting()
        
        return None

首先检查当前层的下一层的类型。如果下一层是池化层，调用_bp_pooling_to_convoluting方法进

行反向传播。如果下一层是全连接层，调用_bp_full_connecting_to_convoluting方法进行反向传

播。如果下一层是输出层，调用_bp_output_to_convoluting方法进行反向传播。

    def _bp_pooling_to_convoluting(self):

        # TODO: 
        if self.type_activation is None:
            pass
        
        elif self.type_activation is "relu":
            pass
        
        elif self.type_activation is "sigmoid":
            for i in range(self.n_nodes):
                # 下一层（池化层）中与当前（卷积层）神经元连接的神经元只有一个
                node_next_layer = self.nodes[i].nodes_next_layer[0]
                # 池化层中一个神经元只有一个权值
                # TODO: 下一层池化类型为"max"时
                delta_padded = node_next_layer.weights[0] * \
                        cnn_opr.upsample_pool(node_next_layer.delta[:, :, 0], 
                                node_next_layer.type_pooling, 
                                node_next_layer.size_pool_kernel, 
                                node_next_layer.stride_pool_kernel)
                
                size_delta_padded = delta_padded.shape
                delta = np.zeros(self.nodes[i].output.shape)
                delta[ : size_delta_padded[0], : size_delta_padded[1], 0] = \
                        delta_padded
                
                for j in range(1, delta.shape[-1]):
                    delta[ : size_delta_padded[0], : size_delta_padded[1], j] = \
                        node_next_layer.weights[0] * \
                        cnn_opr.upsample_pool(node_next_layer.delta[:, :, j], 
                                node_next_layer.type_pooling, 
                                node_next_layer.size_pool_kernel, 
                                node_next_layer.stride_pool_kernel)
                
                self.nodes[i].delta = delta * \
                        (self.nodes[i].output - self.nodes[i].output**2)
                
                # 更新当前神经元的权值，即当前神经元的各卷积核
                for j in range(self.nodes[i].n_conv_kernels):
                    # 卷积层的上一层可能为池化层或输入层
                    delta_k = 0.0
                    for iter_in_batch in range(delta.shape[-1]):
                        delta_k += cnn_opr.inv_conv_2d( \
                                self.nodes[i].nodes_prior_layer[j].output[ \
                                :, :, iter_in_batch], 
                                self.size_conv_kernel, 
                                self.stride_conv_kernel, 
                                self.padding_conv, 
                                self.nodes[i].delta[:, :, iter_in_batch])
                    delta_k /= delta.shape[-1]
                    
                    self.nodes[i].conv_kernels[j] -= \
                            self.learning_rate_weight * delta_k
                    
                # 更新当前神经元的偏置
                self.nodes[i].bias -= self.learning_rate_bias * \
                        np.sum(self.nodes[i].delta) / delta.shape[-1]
                        
        elif self.type_activation is "tanh":
            pass
        
        return None

首先检查当前层的激活函数类型。如果激活函数类型是"sigmoid"，执行以下步骤：

对当前层的每个神经元进行处理。由于池化层中与当前卷积层神经元连接的神经元只有一个，所以

直接取出与之相连的池化层神经元node_next_layer。

对node_next_layer的误差进行上采样，将其扩大到与当前神经元输出相同的尺寸，得到

delta_padded。将delta_padded中的误差传播到当前神经元的误差delta中。

计算当前神经元的误差，公式为更新当前神经元

的权值，即卷积核的值。

对于每个卷积核，计算其对应的误差delta_k，然后根据学习率和delta_k更新卷积核的值。

更新当前神经元的偏置，公式为，其中n为

delta的最后一个维度的大小。

    def _bp_full_connecting_to_convoluting(self):

        # TODO: 
        if self.type_activation is None:
            pass
        
        elif self.type_activation is "relu":
            pass
        
        elif self.type_activation is "sigmoid":
            for i in range(self.n_nodes):
                delta = 0.0
                for j in range(len(self.nodes[i].nodes_next_layer)):
                    # 全连接层神经元的delta为size_batch array
                    delta += self.nodes[i].nodes_next_layer[j].weights[i] * \
                            self.nodes[i].nodes_next_layer[j].delta
                            
                delta *= (self.nodes[i].output[0, 0, :] - 
                          self.nodes[i].output[0, 0, :]**2)
                delta = delta.reshape(1, 1, -1)
                self.nodes[i].delta = delta
                
                # 更新当前神经元的权值，即当前神经元的各卷积核
                for j in range(self.nodes[i].n_conv_kernels):
                    # 卷积层的上一层可能为池化层或输入层
                    delta_k = 0.0
                    for iter_in_batch in range(delta.shape[-1]):
                        delta_k += cnn_opr.inv_conv_2d( \
                                self.nodes[i].nodes_prior_layer[j].output[ \
                                :, :, iter_in_batch], 
                                self.size_conv_kernel, 
                                self.stride_conv_kernel, 
                                self.padding_conv, 
                                self.nodes[i].delta[:, :, iter_in_batch])
                    delta_k /= delta.shape[-1]
                    
                    self.nodes[i].conv_kernels[j] -= \
                            self.learning_rate_weight * delta_k
                    
                # 更新当前神经元的偏置
                # self.nodes[i].delta实际上为1 * 1 * size_batch array
                self.nodes[i].bias -= self.learning_rate_bias * \
                        np.sum(self.nodes[i].delta) / delta.shape[-1]
                
        elif self.type_activation is "tanh":
            pass
        
        return None

卷积层到全连接层的反向传播实现：

delta的计算:对每个卷积层神经元i,需要遍历全连接层所有的后继神经元j,将j的delta按权重回传,并结

合本层激活函数的导数计算delta。

卷积核的更新:对每个卷积核j,遍历每个样本,进行反卷积操作,并将所有样本的反卷积结果求平均作

为该卷积核的梯度,以此更新卷积核。

偏置的更新:将每个样本的delta求平均就可以得到偏置的梯度,以此更新偏置。

激活函数的处理:relu和sigmoid激活函数的导数计算不同,需要针对性实现。

reshape和维度对应:计算delta和更新参数时需要注意reshape,保证维度一致。

    def _bp_output_to_convoluting(self):

        self._bp_full_connecting_to_convoluting()
        
        return None
    
    
    def _back_propagate_pooling(self):

        if self.next_layer.type is "convoluting":
            self._bp_convoluting_to_pooling()
            
        elif self.next_layer.type is "full_connecting":
            self._bp_full_connecting_to_pooling()
            
        elif self.next_layer.type is "output":
            self._bp_output_to_pooling()
            
        return None

卷积层和池化层的反向传播实现：

_bp_output_to_convoluting()函数表示当前层为卷积层,下一层为输出层时的反向传播情况。

_back_propagate_pooling()函数实现了池化层的反向传播。它会根据池化层的下一层类型来调用

不同的反向传播函数:

如果下一层是卷积层,调用 _bp_convoluting_to_pooling()；如果下一层是全连接层,调用

_bp_full_connecting_to_pooling()，如果下一层是输出层,调用_bp_output_to_pooling(),实际上也

会调用到_bp_full_connecting_to_pooling()。

    def _bp_convoluting_to_pooling(self):

        # TODO: 
        if self.type_activation is None:
            pass
        
        elif self.type_activation is "relu":
            pass
        
        elif self.type_activation is "sigmoid":
            index_kernel = -1
            for j in range(self.next_layer.connecting_matrix.shape[0]):
                if self.next_layer.connecting_matrix[j, 0] == 1:
                    index_kernel += 1
                    
                    if index_kernel == 0:
                        delta_padded = cnn_opr.upsample_conv_2d( \
                            self.next_layer.nodes[0].delta[:, :, 0], 
                            self.next_layer.nodes[0].conv_kernels[index_kernel], 
                            self.next_layer.nodes[0].size_conv_kernel, 
                            self.next_layer.nodes[0].stride_conv_kernel)
                        
                        for n in range(self.n_nodes):
                            self.nodes[n].delta = np.zeros([ \
                                delta_padded.shape[0], 
                                delta_padded.shape[1], 
                                self.next_layer.nodes[0].delta.shape[-1]])
                            
                        self.nodes[j].delta[:, :, 0] = delta_padded
                        
                        for iter_in_batch in range(1, 
                                self.next_layer.nodes[0].delta.shape[-1]):
                            self.nodes[j].delta[:, :, iter_in_batch] += \
                                cnn_opr.upsample_conv_2d( \
                                self.next_layer.nodes[0].delta[ \
                                        :, :, iter_in_batch], 
                                self.next_layer.nodes[0].conv_kernels[ \
                                        index_kernel], 
                                self.next_layer.nodes[0].size_conv_kernel, 
                                self.next_layer.nodes[0].stride_conv_kernel)
                                
                    elif index_kernel > 0:
                        for iter_in_batch in range( \
                                self.next_layer.nodes[0].delta.shape[-1]):
                            self.nodes[j].delta[:, :, iter_in_batch] += \
                                cnn_opr.upsample_conv_2d( \
                                self.next_layer.nodes[0].delta[ \
                                        :, :, iter_in_batch], 
                                self.next_layer.nodes[0].conv_kernels[ \
                                        index_kernel], 
                                self.next_layer.nodes[0].size_conv_kernel, 
                                self.next_layer.nodes[0].stride_conv_kernel)
                                
            for i in range(1, self.next_layer.connecting_matrix.shape[1]):
                # 卷积层中每个神经元可能与上一层中多个神经元连接，
                # 即卷积层中的神经元可能有多个卷积核
                
                # 下一层（卷积层）中与当前神经元连接的神经元的卷积核的索引
                index_kernel = -1
                for j in range(self.next_layer.connecting_matrix.shape[0]):
                    # 下一层的第i个神经元与当前层的第j个神经元连接，
                    # 将下一层第i个神经元的delta传递至当前层第j个神经元
                    if self.next_layer.connecting_matrix[j, i] == 1:
                        index_kernel += 1
                        
                        for iter_in_batch in range( \
                                self.next_layer.nodes[i].delta.shape[-1]):
                            self.nodes[j].delta[:, :, iter_in_batch] += \
                                cnn_opr.upsample_conv_2d( \
                                self.next_layer.nodes[i].delta[ \
                                        :, :, iter_in_batch], 
                                self.next_layer.nodes[i].conv_kernels[ \
                                        index_kernel], 
                                self.next_layer.nodes[i].size_conv_kernel, 
                                self.next_layer.nodes[i].stride_conv_kernel)
                                
            for i in range(self.n_nodes):
                # 令delta与output尺寸相同
                delta = np.zeros(self.nodes[i].output.shape)
                size_delta_padded = self.nodes[i].delta.shape
                delta[ : size_delta_padded[0], : size_delta_padded[1], :] += \
                        self.nodes[i].delta
                
                self.nodes[i].delta = delta * \
                        (self.nodes[i].output - self.nodes[i].output**2)
                
                # 更新当前神经元的权值
                # $\frac{\partial loss}{\partial w} = \sum{\delta \dot z}$
                # 池化层中每个神经元只有一个权值
                self.nodes[i].weights[0] -= self.learning_rate_weight * \
                    np.sum(self.nodes[i].delta * self.nodes[i].combination) / \
                    self.nodes[i].delta.shape[-1]
                # 更新当前神经元的偏置
                # $\frac{\partial loss}{\partial b} = \sum{\delta}$
                self.nodes[i].bias -= self.learning_rate_bias * \
                    np.sum(self.nodes[i].delta) / self.nodes[i].delta.shape[-1]
                        
        elif self.type_activation is "tanh":
            pass
        
        return None

当前层为池化层,下一层为卷积层时的反向传播逻辑：

①根据下一层(卷积层)的delta,通过上采样进行反卷积,得到本层的delta。

②将得到的delta调整形状匹配本层输出,然后乘以激活函数的导数。

③使用delta和combination更新当前层神经元的权重和偏置。

④对不同的激活函数类型(ReLU、sigmoid、tanh),计算delta时有略微不同。

具体来说：通过遍历下一层的连接矩阵,确定下一层每个神经元对应的卷积核，对下一层每个

神经元的delta进行上采样反卷积,得到与当前层形状匹配的delta，将delta乘以激活函数的导数作为

当前层的delta，使用delta更新当前层中每个神经元的权重和偏置。

    def _bp_full_connecting_to_pooling(self):

        # TODO: 
        if self.type_activation is None:
            pass
        
        elif self.type_activation is "relu":
            pass
        
        elif self.type_activation is "sigmoid":
            for i in range(self.n_nodes):
                delta = 0.0
                for j in range(len(self.nodes[i].nodes_next_layer)):
                    delta += self.nodes[i].nodes_next_layer[j].weights[i] * \
                            self.nodes[i].nodes_next_layer[j].delta
                            
                delta *= (self.nodes[i].output[0, 0, :] - \
                          self.nodes[i].output[0, 0, :]**2)
                self.nodes[i].delta = delta.reshape(1, 1, -1)
                
                # 更新当前神经元的权值
                self.nodes[i].weights[0] -= self.learning_rate_weight * \
                    np.sum(self.nodes[i].delta * self.nodes[i].combination) / \
                    self.nodes[i].shape[-1]
                # 更新当前神经元的偏置
                self.nodes[i].bias -= self.learning_rate_bias * \
                    np.sum(self.nodes[i].delta) / self.nodes[i].delta.shape[-1]
                    
        elif self.type_activation is "tanh":
            pass
        
        return None

当前层为池化层,下一层为全连接层时的反向传播实现:

①初始化当前层每个节点的delta为0

②遍历当前层每个节点:对下一层每个连接到当前节点的全连接层节点,累加其权重与delta的乘积到

当前节点的delta；将delta乘以当前节点激活函数的导数作为当前节点的最终delta；将delta调整形

状为1×1×batch_size。

③使用计算得到的delta更新当前节点的权重和偏置

④对不同的激活函数,计算delta时略有不同

主要思路是：利用全连接层传入的delta,计算当前池化层节点的delta，更新当前池化层节点的参

数，依据不同的激活函数计算delta的细节不同。

    def _bp_output_to_pooling(self):

        self._bp_full_connecting_to_pooling()
        
        return None
    
    
    def _back_propagate_full_connecting(self):

        # TODO: 
        if self.type_activation is None:
            pass
        
        elif self.type_activation is "relu":
            pass
        
        elif self.type_activation is "sigmoid":
            for i in range(self.n_nodes):
                # 计算当前神经元的灵敏度
                delta = 0.0
                for j in range(len(self.nodes[i].nodes_next_layer)):
                    # （认为全连接层的下一层为全连接层或输出层）
                    delta += self.nodes[i].nodes_next_layer[j].weights[i] * \
                            self.nodes[i].nodes_next_layer[j].delta
                # 对于sigmoid，$f'(z) = f(z) (1 - f(z))$
                delta *= (self.nodes[i].output[0, 0, :] - \
                          self.nodes[i].output[0, 0, :]**2)
                self.nodes[i].delta = delta
                
                # 更新当前神经元的权值
                for j in range(len(self.nodes[i].nodes_prior_layer)):
                    # 全连接层的上一层（卷积层）的输出为一个向量，
                    # 即上一层中每个神经元的output为1 * 1 * size_batch array
                    self.nodes[i].weights[j] -= \
                            self.learning_rate_weight * \
                            np.mean(self.nodes[i].delta * \
                            self.nodes[i].nodes_prior_layer[j].output[0, 0, :])
                # 更新当前神经元的偏置
                self.nodes[i].bias -= \
                        self.learning_rate_bias * np.mean(self.nodes[i].delta)
                        
        elif self.type_activation is "tanh":
            pass
        
        return None

全连接层的反向传播实现:

①初始化每个节点的delta为0

②遍历每个节点：累加连接到下一层每个节点的delta乘以权重,计算当前节点的delta，对sigmoid,

将delta乘以激活函数的导数f'(z) = f(z)(1-f(z))。

③使用计算得到的delta更新当前节点：对连接到上一层每个节点,使用delta和上一层节点output更

新权重，使用delta更新偏置。

④对tanh激活,计算delta的方式稍有不同

    def _back_propagate_output(self, y):

        if self.type_output is "softmax":
            # self.n_nodes * size_batch array
            delta_y = np.array(self.output).reshape(self.n_nodes, -1) - y
            
            # 计算输出层各神经元的灵敏度，并更新权值和偏置
            for i in range(self.n_nodes):
                # $\delta_i^{(L)} = (\tilde{y}_i - y_i) f'(z_i^{(L)})$
                # $z_i^{(L)} = (w_i^{(L)})^T x^{(L - 1)} + b_i^{(L)}$
                
                # 对于softmax，$f'(z) = f(z) (1 - f(z))$
                # 输出层各神经元的output实际上为$f(z)$
                self.nodes[i].delta = \
                        delta_y[i, :] * (self.output[i] - self.output[i]**2)
                
                # 更新输出层当前神经元的权值
                # $w' = w - \eta \frac{\partial loss}{\partial w}$
                # $\frac{\partial loss}{\partial w} = \delta z^{(L - 1)}$
                for j in range(len(self.nodes[i].nodes_prior_layer)):
                    # 输出层的上一层为全连接层
                    # 全连接层的output为1 * 1 * size_batch array
                    self.nodes[i].weights[j] -= \
                            self.learning_rate_weight * \
                            np.mean(self.nodes[i].delta * \
                            self.nodes[i].nodes_prior_layer[j].output[0, 0, :])
                # 更新输出层当前神经元的偏置
                self.nodes[i].bias -= \
                        self.learning_rate_bias * np.mean(self.nodes[i].delta)
            
        elif self.type_output is "rbf":
            # TODO: 
            pass
        
        return None

输出层使用softmax的反向传播实现：

①计算预测类别与真实类别的差异delta_y

②遍历每个输出节点：计算节点的delta: 将delta_y与激活函数的导数相乘，对连接的全连接层,用

delta和上一层节点output更新权重，用delta更新偏置。

3. 卷积神经网络的一个神经元类cnn_node

    def __init__(self, type_node):

        # 神经元类型
        self.type = type_node
        # 上一层中与当前神经元连接的神经元
        self.nodes_prior_layer = None
        # 下一层中与当前神经元连接的神经元
        self.nodes_next_layer = []
        # 神经元的输出
        self.output = None
        # 神经元的灵敏度，
        # 当前神经元为全连接层或输出层神经元时，灵敏度为标量，
        # 当前神经元为卷积层或池化层神经元时，灵敏度为2-d array，尺寸与output相同
        # （实际上卷积层和池化层输出特征图中的每一个点为一个“神经元”）
        self.delta = 0.0
        
        if self.type is "input":
            # array，输入图像（每个通道）的尺寸
            self.size_input = None
            
        elif self.type is "convoluting":
            # 卷积核个数
            self.n_conv_kernels = 0
            # array，卷积核尺寸
            self.size_conv_kernel = None
            # list，卷积核
            self.conv_kernels = []
            # 卷积核步长
            self.stride_conv_kernel = 1
            # 边缘补零的宽度
            self.padding_conv = 0
            # 偏置
            self.bias = 0.0
            # 2-d array，卷积后（未经过激活函数）的特征图
            self.combination = None
            # 激活函数类型，{"relu", "sigmoid", "tanh", None}
            self.type_activation = None
            
        elif self.type is "pooling":
            # 池化核类型，{"max", "average"}
            self.type_pooling = "max"
            # array，池化核尺寸
            self.size_pool_kernel = np.array([2, 2])
            # 池化核步长
            self.stride_pool_kernel = 2
            # 边缘补零的宽度
            self.padding_pool = 0
            # array，权值
            self.weights = np.array([0.0])
            # 偏置
            self.bias = 0.0
            # 2-d array，池化后（未经过激活函数）的特征图
            self.combination = None
            # 激活函数类型，{"relu", "sigmoid", "tanh", None}
            self.type_activation = None
            
        elif self.type is "full_connecting":
            # array，权值
            self.weights = np.array([], dtype="float64")
            # 偏置
            self.bias = 0.0
            # array，$(w^{(l)})^T x^{(l - 1)} + b^{(l)}$
            self.combination = None
            # 激活函数类型，{"relu", "sigmoid", "tanh", None}
            self.type_activation = None
            
        elif self.type is "output":
            # 输出层类型，{"softmax", "rbf"}
            self.type_output = "softmax"
            # array，权值
            self.weights = np.array([], dtype="float64")
            # 偏置
            self.bias = 0.0
            # $(w^{(L)})^T x^{(L - 1)} + b^{(L)}$
            self.combination = 0.0

type - 节点的类型,包括输入层、卷积层、池化层、全连接层、输出层

nodes_prior_layer - 连接到当前节点的上一层节点

nodes_next_layer - 当前节点连接的下一层节点

output - 节点的输出值

delta - 节点的误差项,用于反向传播计算

对于不同类型的节点,定义了其特有的属性,如卷积层的卷积核、激活函数等。

combination表示节点的线性变换输出,即在激活函数之前的输出值。例如对于全连接层节

点,combination = w^T * x + b。

    def config(self, args):

        if self.type is "input":
            size_input, = args
            
            self._config_input(args)
            
        elif self.type is "convoluting":
            nodes_prior_layer, size_kernel, \
                    stride, padding, type_activation = args
            
            self._config_convoluting(nodes_prior_layer, size_kernel, 
                                     stride, padding, type_activation)
            
        elif self.type is "pooling":
            nodes_prior_layer, type_pooling, size_kernel, \
                    stride, padding, type_activation = args
                    
            self._config_pooling(nodes_prior_layer, type_pooling, size_kernel, 
                                 stride, padding, type_activation)
            
        elif self.type is "full_connecting":
            nodes_prior_layer, type_activation = args
            
            self._config_full_connecting(nodes_prior_layer, type_activation)
            
        elif self.type is "output":
            nodes_prior_layer, type_output = args
            
            self._config_output(nodes_prior_layer, type_output)
            
        return None

配置不同类型节点的参数,主要步骤是:

根据节点类型,提取传入的参数args；

根据节点类型,调用相应的配置方法:_config_input、_config_convoluting等。

这些配置方法应该会设置节点的各种属性,比如:

输入层:设置size_input；卷积层:设置卷积核大小、步长、padding等参数；池化层:设置池化类型、

池化核大小等；全连接层:无特殊参数；输出层:设置输出类型(softmax/rbf)。

    def _config_input(self, size_input):
      
        self.size_input = size_input
        
        return None
    
    
    def _config_convoluting(self, nodes_prior_layer, size_kernel, 
                            stride, padding, type_activation):
 
        self.nodes_prior_layer = nodes_prior_layer
        self.n_conv_kernels = len(self.nodes_prior_layer)
        self.size_conv_kernel = size_kernel
        self.conv_kernels = [np.zeros(self.size_conv_kernel) \
                             for i in range(self.n_conv_kernels)]
        self.stride_conv_kernel = stride
        self.padding_conv = padding
        self.type_activation = type_activation
        
        return None

配置输入层节点和卷积层节点的参数：

_config_input方法用于配置输入层节点。方法参数size_input是一个数组，表示输入图像的尺寸。

这个方法将输入参数`size_input`设置为节点的size_input属性。

_config_convoluting方法用于配置卷积层节点。这个方法的参数包括：

nodes_prior_layer：上一层中与当前神经元连接的神经元列表（可以有一个或多个）。

size_kernel：卷积核的尺寸，是一个数组。

stride：卷积核的步长。

padding：边缘补零的宽度。

type_activation：激活函数的类型，可以是"relu"、"sigmoid"、"tanh"或者None。

_config_convoluting方法将这些参数设置为节点相应的属性，并且为每个卷积核初始化一个全零的

数组。

    def _config_pooling(self, nodes_prior_layer, type_pooling, size_kernel, 
                        stride, padding, type_activation):

        self.nodes_prior_layer = nodes_prior_layer
        self.type_pooling = type_pooling
        self.size_pool_kernel = size_kernel
        self.stride_pool_kernel = stride
        self.padding_pool = padding
        self.type_activation = type_activation
        
        # 初始化权值
        if self.type_pooling is "max":
            self.weights[0] = 1.0
        elif self.type_pooling is "average":
            self.weights[0] = 1 / np.prod(self.size_pool_kernel)
        
        return None
    
    
    def _config_full_connecting(self, nodes_prior_layer, type_activation):

        self.nodes_prior_layer = nodes_prior_layer
        self.weights = np.zeros(len(self.nodes_prior_layer))
        self.type_activation = type_activation
        
        return None
    
    
    def _config_output(self, nodes_prior_layer, type_output):

        self.nodes_prior_layer = nodes_prior_layer
        self.weights = np.zeros(len(self.nodes_prior_layer))
        self.type_output = type_output
        
        return None

配置池化层节点，全连接层节点，和输出层节点：

_config_pooling方法用于配置池化层节点。这个方法的参数包括：

nodes_prior_layer：上一层中与当前神经元连接的神经元列表（仅有一个）。

type_pooling：池化核的类型，可以是"max"或"average"。

size_kernel：池化核的尺寸，是一个数组。

stride：池化核的步长。

padding：边缘补零的宽度。

type_activation：激活函数的类型，可以是"relu"、"sigmoid"、"tanh"或者None。

_config_pooling方法将这些参数设置为节点相应的属性，并且根据池化类型初始化权重：如果

是"max"池化，权重设置为1.0；如果是"average"池化，权重设置为1除以池化核尺寸的元素乘积。

_config_full_connecting方法用于配置全连接层节点。这个方法的参数包括：

nodes_prior_layer：上一层中的所有神经元。

type_activation：激活函数的类型，可以是"relu"、"sigmoid"、"tanh"或者None。

_config_full_connecting方法将这些参数设置为节点相应的属性，并且初始化权重为一个全零的数

组，数组长度等于上一层神经元的数量。

_config_output方法用于配置输出层节点。这个方法的参数包括：

nodes_prior_layer：上一层中的所有神经元。

type_output：输出层的类型，可以是"softmax"或"rbf"。

_config_output方法将这些参数设置为节点相应的属性，并且初始化权重为一个全零的数组，数组

长度等于上一层神经元的数量。

    def feed_forward(self, inputs=None):
   
        if self.type is "input":
            self._feed_forward_input(inputs)
        elif self.type is "convoluting":
            self._feed_forward_convoluting()
        elif self.type is "pooling":
            self._feed_forward_pooling()
        elif self.type is "full_connecting":
            self._feed_forward_full_connecting()
        elif self.type is "output":
            self._feed_forward_output()
        
        return None
    
    
    def _feed_forward_input(self, inputs):

        self.output = inputs
        
        return None

神经元前向传播：

feed_forward方法是对所有类型的神经元进行前向传播的通用方法，其参数inputs只在当前神经元

类型为输入层时有效。该方法会根据神经元的类型调用相应的前向传播方法，比如

_feed_forward_input，_feed_forward_convoluting，_feed_forward_pooling，

_feed_forward_full_connecting，_feed_forward_output。

_feed_forward_input`方法是针对输入层神经元的前向传播方法。其参数inputs是一个3维数组，表

示一个batch的输入图像（或其中一个通道）。输入图像的尺寸为inputs.shape[0] * inputs.shape[1]

（即self.size_input），inputs.shape[2]则表示当前batch中图像的个数。这个方法将inputs设置为

神经元的output属性。这个方法也没有返回值。

    def _feed_forward_convoluting(self):

        # 每一批中训练样本的个数
        size_batch = self.nodes_prior_layer[0].output.shape[-1]
        
        # 当前batch中第一个样本前向传播
        combination = 0.0
        for i in range(self.n_conv_kernels):
            combination += cnn_opr.convolute_2d( \
                    self.nodes_prior_layer[i].output[:, :, 0], 
                    self.conv_kernels[i], self.size_conv_kernel, 
                    self.stride_conv_kernel, self.padding_conv)
        combination += self.bias
        
        # 根据当前batch中第一个样本确定self.combination、self.output的大小
        size_combination = combination.shape
        self.combination = np.empty([size_combination[0], size_combination[1], 
                                     size_batch])
        self.output = np.empty([size_combination[0], size_combination[1], 
                                size_batch])
        
        self.combination[:, :, 0] = combination
        self.output[:, :, 0] = \
                cnn_opr.activate(combination, self.type_activation)
        
        # 当前batch中其它样本前向传播
        for iter_in_batch in range(1, size_batch):
            combination = 0.0
            for i in range(self.n_conv_kernels):
                combination += cnn_opr.convolute_2d( \
                        self.nodes_prior_layer[i].output[:, :, iter_in_batch], 
                        self.conv_kernels[i], self.size_conv_kernel, 
                        self.stride_conv_kernel, self.padding_conv)
            combination += self.bias
            
            self.combination[:, :, iter_in_batch] = combination
            self.output[:, :, iter_in_batch] = \
                    cnn_opr.activate(combination, self.type_activation)
        
        return None

卷积层神经元的前向传播：

①获取从前一层传入的每一批训练样本的个数，然后对第一个样本进行卷积操作。这个操作涉及

到的参数包括前一层的输出、卷积核、卷积核大小、步长和边缘填充，卷积操作完成后，将偏置加

到结果上，得到的结果是卷积和偏置组合的结果。

②根据第一个样本的卷积结果确定self.combination和self.output的大小，并存储第一个样本的

卷积结果和激活函数处理后的结果。

③对当前批次中的其它样本进行类似的操作：每个样本都进行卷积，加上偏置，然后通过激活

函数处理。卷积结果被存入self.combination，激活函数处理后的结果被存入self.output。

    def _feed_forward_pooling(self):
        
        size_batch = self.nodes_prior_layer.output.shape[-1]
        
        combination = cnn_opr.pool(self.nodes_prior_layer.output[:, :, 0], 
                                   self.type_pooling, self.size_pool_kernel, 
                                   self.stride_pool_kernel, self.padding_pool)
        combination *= self.weights
        combination += self.bias
        
        size_combination = combination.shape
        self.combination = np.empty([size_combination[0], size_combination[1], 
                                     size_batch])
        self.output = np.empty([size_combination[0], size_combination[1], 
                                size_batch])
        
        self.combination[:, :, 0] = combination
        self.output[:, :, 0] = \
                cnn_opr.activate(combination, self.type_activation)
                
        for iter_in_batch in range(1, size_batch):
            combination = cnn_opr.pool( \
                    self.nodes_prior_layer.output[:, :, iter_in_batch], 
                    self.type_pooling, self.size_pool_kernel, 
                    self.stride_pool_kernel, self.padding_pool)
            combination *= self.weights
            combination += self.bias
            
            self.combination[:, :, iter_in_batch] = combination
            self.output[:, :, iter_in_batch] = \
                    cnn_opr.activate(combination, self.type_activation)
        
        # 灵敏度map置零
        self.delta = 0.0
        
        return None

池化层神经元的前向传播：

①获取前一层输出的每个批次样本的数量，然后对第一个样本进行池化操作。这个操作采用的参数

包括前一层的输出，池化类型，池化核大小，步长和边缘填充，得到的结果乘以权重并加上偏置。

然后，基于第一个样本的池化结果设置self.combination和self.output的大小，并存储第一个样本的

池化结果以及激活函数处理后的输出。

②对当前批次中的其他样本进行类似的操作：每个样本都进行池化，乘以权重并加上偏置，然后通

过激活函数处理。池化结果被存入self.combination，激活函数处理后的结果被存入self.output。

③将self.delta（灵敏度图）置零。这个属性在反向传播过程中用来存储误差。

    def _feed_forward_full_connecting(self):

        size_batch = self.nodes_prior_layer[0].output.shape[2]
        
        self.combination = np.empty([1, 1, size_batch])
        self.output = np.empty([1, 1, size_batch])
        
        for iter_in_batch in range(size_batch):
            combination = 0.0
            for i in range(len(self.nodes_prior_layer)):
                # 全连接层的上一层输出为一维向量，
                # 即上一层每个神经元输出的特征图尺寸为1 * 1
                combination += self.weights[i] * \
                        self.nodes_prior_layer[i].output[0, 0, iter_in_batch]
            combination += self.bias
        
            # combination为标量
            self.combination[0, 0, iter_in_batch] = combination
            self.output[:, :, iter_in_batch] = \
                    cnn_opr.activate(self.combination[:, :, iter_in_batch], 
                                     self.type_activation)
        
        return None

全连接层神经元的前向传播：

①该方法获取前一层输出中每个批次样本的数量，然后创建self.combination和self.output数组用于

存储计算结果。

②对于当前批次中的每个样本，该方法通过循环访问前一层的每个神经元，将每个神经元的输出乘

以相应的权重并累加，最后加上偏置，得到全连接层的组合结果。

③存储这个组合结果，并对其应用激活函数，将结果存储到self.output中。

需要注意的是，全连接层的输入（即前一层的输出）是一维向量，即每个神经元输出的特征图尺寸

为1 * 1。此外，self.combination的结果是一个标量，这意味着在全连接层，每个神经元只有一个

输出单元。

    def _feed_forward_output(self):
 
        if self.type_output is "softmax":
            size_batch = self.nodes_prior_layer[0].output.shape[2]
            
            self.combination = np.empty([1, 1, size_batch])
            self.output = np.empty([1, 1, size_batch])
            
            for iter_in_batch in range(size_batch):
                # $softmax(w_i) = 
                #     \frac{e^{w_i^T x}}{\sum_{j = 1}^n e^{w_j^T x}}$
                # 此处只计算$w_i^T x$，其余运算在cnn_layer.feed_forward()中进行
                combination = 0.0
                for i in range(len(self.nodes_prior_layer)):
                    combination += self.weights[i] * \
                        self.nodes_prior_layer[i].output[0, 0, iter_in_batch]
                combination += self.bias
                
                # 输出层combination为标量
                self.combination[0, 0, iter_in_batch] = combination
            
        elif self.type_output is "rbf":
            # TODO: 
            pass
        
        return None

输出层神经元的前向传播：这个方法考虑了两种可能的输出层类型：softmax和rbf。

①如果输出层类型是softmax，该方法首先获取前一层输出中每个批次样本的数量，然后创建

self.combination和self.output数组用于存储计算结果。

②对于批次中的每个样本，该方法通过循环访问前一层的每个神经元，将每个神经元的输出乘以相

应的权重并累加，最后加上偏置，得到组合结果。这个结果是softmax函数的输入的一部分，即