记一次自己动手实现一个简单神经网络

之前一直调包，最近刷算法题，就突发奇想，想自己试一试实现一个简单的神经网络模型。
从简单的开始，先实现一个二分类模型，使用印第安人糖料病数据集，数据集合源码可直接在github获取：github

参数初始化

首先，初始化参数，这里直接使用用numpy的初始化数组，代码如下：

 # 参数初始化 def inital_parameters(self, m, n):   res = [] for i in range(m):       res.append(np.random.randn(n)) return np.array(res) 

定义激活函数

神经网络中，每个神经元都有激活前和激活后的值，也可以认为是神经元的输入和输出，所以我们首先定义激活函数。本模型中，在第一层全连接层中使用sigmoid激活函数，第二层使用softmax激活函数输出结果，这里都是用numpy的内置方法计算，实现矩阵的并行化计算，具体公式可百度，代码如下：

 # sigmoid def sigmoid(self, x): return 1 / (1 + np.exp(-x)) # softmax def softmax(self, x):   x_exp = np.exp(x)   x_sum = np.sum(x_exp, axis=1, keepdims=True)   s = x_exp / x_sum   return s 

前向传播

全连接层的前向传播，简单来说就是参数与输入数据线性组合和输入神经元，经过激活函数后输出，要注意矩阵运算时的维度，代码如下：

 # 全连接层前向传播 def fully_connected_layer(self, x, layer):         x, w, b = np.array(x), np.array(self.ws[layer]), np.array(self.bs[layer]) assert len(x[0]) == len(w[0]) assert len(w) == len(b[0])         self.input.append(x)         pre_activation = np.sum([np.matmul(x, w.T), b], axis=0)         post_activation = self.activate[layer](pre_activation) return post_activation 

损失函数

由于是二分类与问题，这里使用交叉熵来计算损失函数，并记录初始梯度，代码如下：

 # 交叉熵损失函数 def cross_entropy(self, y_, Y):         loss = 0 # 记录初始梯度         w_gradients = [[0, 0]] for i in range(len(y_)):             predict = y_[i] for j in range(len(predict)): # +0.001，避免除0                 w_gradients[0][j] -= 1 / (predict[j] + 0.0001) if j == Y[i]:                     loss -= np.log(predict[j]) break         loss /= len(y_)         w_gradients[0][0] /= len(y_)         w_gradients[0][1] /= len(y_)         self.w_gradient.append(np.array(w_gradients))         self.b_gradient.append(np.array(w_gradients)) return loss 

实现BP(Backward Propagation)算法

BP(Backward Propagation)算法，也是整个神经网络中的最复杂的部分，其核心在于计算梯度时求导的链式法则，从神经网络最顶层开始，逐步向下层计算梯度，从而得到loss对于每一层参数的梯度。这里使用mini_batch梯度下降法，加快计算，其中将mini_batch置为1时就是SGD了，代码如下：

# BP算法 def backward_propagation(self, learning_rate, Y, mini_batch_size): # mini_batch gradient_descent for i in range(len(self.ws) - 1, -1, -1):             wi = self.ws[i]             bi = self.bs[i] # 初始化当前层w的梯度             w_gradients = [[0 for _ in range(len(wi[0]))] for _ in range(len(wi))] # 初始化当前层b的梯度             b_gradients = [[0 for _ in range(len(bi[0]))]] # 上一层的w梯度             w_last_gradient = self.w_gradient[len(self.ws) - i - 1] # 上一层b梯度             b_last_gradient = self.b_gradient[len(self.bs) - i - 1]              a_f_gra = self.activate_gradient[i] # mini_batch sample             sample = np.random.randint(len(Y), size=mini_batch_size) # 计算当前层w的梯度 for l in range(len(wi)):                 w = wi[l] for j in range(len(w)): for k in sample: input = self.input[i][k] for m in range(len(w_last_gradient)):                             w_gradients[l][j] += learning_rate * w_last_gradient[m][l] * a_f_gra(input, j) * input[j] # 计算当前层b的梯度 for l in range(len(bi)):                 b = bi[l] for j in range(len(b)): for k in sample: input = self.input[i][k] for m in range(len(b_last_gradient)):                             b_gradients[l][j] += learning_rate * b_last_gradient[m][l] * a_f_gra(input, j)              self.w_gradient.append(np.array(w_gradients))             self.b_gradient.append(np.array(b_gradients)) # 把初始梯度删去，然后因为是倒着添加梯度的，所以要倒过来         self.w_gradient.pop(0)         self.w_gradient = self.w_gradient[::-1]          self.b_gradient.pop(0)         self.b_gradient = self.b_gradient[::-1] # w梯度下降 for i in range(len(self.ws)):             wi = self.ws[i] for j in range(len(wi)):                 w = wi[j] for k in range(len(w)):                     self.ws[i][j][k] -= self.w_gradient[i][j][k] # b梯度下降 for i in range(len(self.bs)):             bi = self.bs[i] for j in range(len(bi)):                 b = bi[j] for k in range(len(b)):                     self.bs[i][j][k] -= self.b_gradient[i][j][k] # 一轮梯度下降后清空         self.w_gradient = []         self.b_gradient = []         self.input = [] 

训练和测试

首先读取数据，这里读取印第安人糖尿病数据集，总共768条数据，取前700条作为训练数据，后68条作为测试数据，代码如下：

 # 读取数据     filename = 'data/pima_data.csv'     names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']     data = read_csv(filename, names=names)     array = data.values     X = np.array(array[:, 0:8])     Y = array[:, 8]     X_normed = X / X.max(axis=0)      X_train = X_normed[:700]     X_test = X_normed[701:]      Y_train = Y[:700]     Y_test = Y[701:] 

接下来就是模型搭建和训练了，这里搭建两个全连接层，进行训练，代码如下：

 # 模型参数初始化     nn = NerualNetwork()     sigmoid = ActivationFunction().sigmoid     softmax = ActivationFunction().softmax      sigmoid_gradient = ActivationFunction().sigmoid_gradient     softmax_gradient = ActivationFunction().softmax_gradient      w1, b1 = nn.inital_parameters(5, 8), nn.inital_parameters(1, 5)     w2, b2 = nn.inital_parameters(2, 5), nn.inital_parameters(1, 2) # 导入初始化参数     nn.ws = [w1, w2]     nn.bs = [b1, b2] # 导入激活函数及其导数     nn.activate = [sigmoid, softmax]     nn.activate_gradient = [sigmoid_gradient, softmax_gradient] # 训练     epoch = 500     learning_rate = 0.005     mini_batch_size = 1     plot_x = []     plot_y = [] for i in range(epoch):         f_c1 = nn.fully_connected_layer(X_train, 0)         y_ = nn.fully_connected_layer(f_c1, 1)         train_loss = nn.cross_entropy(y_, Y_train) print('Epoch:', i + 1, ', train_loss=', train_loss)         plot_x.append(i + 1)         plot_y.append(train_loss)         nn.backward_propagation(learning_rate, Y_train, mini_batch_size)      plt.xlabel('Epoch')     plt.ylabel('loss')     plt.plot(plot_x, plot_y)     plt.show() 

训练结果为：
Epoch: 500 , train_loss= 0.6623333458935591

loss趋势图为：

训练完成之后，将训练后的参数用于测试数据中进行测试，并计算准确率，代码如下：

 # 测试     f_c1 = nn.fully_connected_layer(X_test, 0)     y_ = nn.fully_connected_layer(f_c1, 1)     hit = 0 for i in range(len(y_)):         predict = list(y_[i])         pr = predict.index(max(predict)) if pr == Y_test[i]:             hit += 1     accuracy = hit / len(Y_test) print('accuracy=', accuracy) 

测试结果为：
accuracy= 0.5970149253731343

pytorch对比

自己写的也不确定准不准确，所以就用pytorch来对比一下吧，当然要使用同样的超参数，然后这里就不阐述了，直接上代码：

 # 读取数据     filename = 'data/pima_data.csv'     names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']     data = read_csv(filename, names=names)     array = data.values     X = np.array(array[:, 0:8])     Y = np.array(array[:, 8])     X_normed = X / X.max(axis=0)      X_train = X_normed[:700]     X_test = X_normed[701:]      Y_train = Y[:700]     Y_test = Y[701:]      X_train = torch.tensor(X_train).float()     Y_train = torch.tensor(Y_train).long()      X_test = torch.tensor(X_test).float()     Y_test = torch.tensor(Y_test).long() # 搭建网络     myNet = nn.Sequential(         nn.Linear(8, 5, bias=True),         nn.Sigmoid(),         nn.Linear(5, 2, bias=True),         nn.Softmax() ) # 设置优化器     optimzer = torch.optim.SGD(myNet.parameters(), lr=0.005)     loss_func = nn.CrossEntropyLoss()     plot_x = []     plot_y = [] for epoch in range(500):         out = myNet(X_train)         loss = loss_func(out, Y_train) print('Epoch=', epoch+1, ' train_loss=', loss)         plot_x.append(epoch + 1)         plot_y.append(loss)          optimzer.zero_grad()         loss.backward()         optimzer.step()      plt.xlabel('Epoch')     plt.ylabel('loss')     plt.plot(plot_x, plot_y)     plt.show()      y_ = np.array(myNet(X_test).data)      hit = 0 for i in range(len(y_)):         predict = list(y_[i])         pr = predict.index(max(predict)) if pr == Y_test[i]:             hit += 1     accuracy = hit / len(Y_test) print('accuracy=', accuracy) 

pytorch的训练结果：
Epoch= 500 train_loss= tensor(0.6753)

pytorch的loss趋势图为：

测试结果为：
accuracy= 0.5970149253731343

惊了，这里准确率的结果居然和我自己写的一模一样，绝对没有造假，不过应该是测试数据不够多的原因。

缺陷与不足

这里算是完整的自己手动实现了一个简单的神经网络，当然还存在很多缺陷与不足：
（1）参数的初始化不够好
（2）梯度下降时没有使用矩阵并行计算，这里怕写错，所以暂时直接用的for循环，之后再看看修改
（3）训练未设置收敛条件
（4）BP实现的比较仓促，肯定还有很多细节问题，导致我的loss比较陡峭
（5）肯定还有很多很多很多很多问题，请批评指正
（6）肯定还有很多很多很多很多问题，请批评指正
（7）肯定还有很多很多很多很多问题，请批评指正
。。。。。。

另外也是第一次写博客，写的不好请见谅，也请批评指正