1.算法原理就是FP和BP算法，采用的梯度下降更新梯度。
2.算法的loss函数还是交叉熵函数，也是常用的分类loss函数。
3.训练数据集是使用的mnist数据集28*28的手写数字灰度图片，用csv文件保存的结构数据，格式如下，第一个列是label，后面784个列是每个像素的值。
4.目前没有写算法说明，回头再更吧，算法有详细的注释。
import numpy as np
# 基于交叉熵的loss函数计算和梯度
class CrossEntropy():
# 正向计算
def forward(self, input, y):
'''
正向计算成本函数的残熵结果值，注意input和y都是概率值在[0, 1]之间,
:param input: 预测的分类结果，是个向量，存放的是各分类结果的概率，
例如：[0.5, 0.8, 1, 0.3, 0.1]
:param y: 实际分类结果，例如：[0,1,0,0,0]
:return: 返回一条训练数据的交叉熵成本值
'''
# 公式 ce = -sum(y*log(p) + (1 - y)*log(1 - p))
# 为了规避是0 为了规避log出现负数，先计算log然后代入公式
m = [np.log(x) if x >0 else 0 for x in input]
n = [np.log(1 - x) if 1 - x > 0 else 0 for x in input]
result = - np.sum(y * m + (1 - y) * n)
return result
pass
def backward(self, input, y):
'''
# 反向计算损失函数的梯度
:param input: 预测的分类结果，是个向量，存放的是各分类结果的概率，
例如：[0.5, 0.8, 1, 0.3, 0.1]
:param y: 实际分类结果，例如：[0,1,0,0,0]
:return: 返回的是成本函数计算出来的梯度值
'''
# input是神经网络的分类结果
return (input - y)/(input * (1 - y))
pass
pass
# sigmoid激活函数和梯度计算
class Sigmoid():
def forward(self, input):
'''
正向计算求值
:param input: 输入是个向量，一次计算多个输入
:return:
'''
return 1.0 / (1.0 + np.exp(-input))
pass
# 基于sigmoid函数的梯度公式：g'(x) = g(x)*(1 - g(x))，g是sigmoid函数g(x) = 1/(1+e^(-x))
def backward(self, output):
'''
反向计算求梯度
:param output: 是正向计算的结果，output其实是forward的计算结果
:return:
'''
return output * (1 - output)
pass
pass
# 定义了神经网络层的正向计算和梯度计算
class Dense():
def __init__(self, inputSize=0, outputSize=0, activator=Sigmoid()):
'''
对于一个神经网络层来说，需要知道输入的神经元个数和输出的神经元个数
:param inputSize: 输入神经元的个数
:param outputSize: 输出神经元的个数
:param activator: 当前层的激活函数
:return:
'''
self.inputSize = inputSize
self.outputSize = outputSize
self.activator = activator
# 定义和初始化权重矩阵 基于公式 f(Wx) = W.dot(x) + b W是系数矩阵 x是输入的神经元，
# b是截距项 x和b都是列向量
self.W = np.random.uniform(-0.1, 0.1, (outputSize, inputSize))
# 定义截距项数组，初始化为全0
self.b = np.zeros((outputSize,))
# 定义输出数组
self.output = np.zeros((outputSize,))
pass
def forward(self, inputArray):
'''
定义当前层的正向计算
:param inputArray: 输入是一个列向量
:return:
'''
# 当前层的神经元
self.input = inputArray
# 基于公式 f(Wx) = W.dot(x) + b 然后使用激活 h(f(Wx)) = h(W.dot(x) + b)
# 计算出的是下一个层的神经元
self.output = self.activator.forward(self.W.dot(self.input) + self.b)
# 输出其实就是下一层的输入
return self.output
pass
def backward(self, inputDelta):
'''
反向计算梯度
:param inputDelta:是反向传播时的上一层，其实是当前层的后一层的delta值
:return:
'''
# 计算当前层的delta，detla其实计算的是神经元的梯度
self.delta = self.W.T.dot(inputDelta) * self.activator.backward(self.input)
# 通过神经元的梯度计算出当前层权重的梯度
# 梯度计算注意：inputDelta 和 self.input 是两个向量，
# 例如假设：inputDelta=[1,2,3,4] input=[1,3,2,4]
# inputDelta通过nputDelta[:,np.newaxis]后，扩展了列变为二维：[[1],[2],[3],[4]]
# input通过self.input[np.newaxis,:]后，扩展了行变为：[[1,3,2,4]]
# 这样就是一个4*1 的矩阵和 一个1*4的矩阵点积运算，得到一个4*4的矩阵
self.WGrad = np.dot(inputDelta[:,np.newaxis], self.input[np.newaxis,:])
# 因为b值是做加法，所以他的梯度就是后一次计算的梯度Delta
self.bGrad = inputDelta
pass
def update(self, learningRate):
'''
根据学习速率和已经获得的梯度，更新权重系数和截距项的梯度
:param learningRate:
:return:
'''
self.W -= self.WGrad * learningRate
self.b -= self.bGrad * learningRate
pass
def verbose(self, verbose=0):
'''
:param verbose: 0不显示梯度变化信息， 1显示
:return:
'''
if verbose:
print("Grandient update now:")
print("W:", self.W)
print("b:", self.b)
pass
pass
class Model(object):
def __init__(self):
self.layers = [] # 保存层对象，一个三层网络，只需要来个层对象
self.loss = None
pass
def predict(self, input):
'''
正向计算，预测结果
:param input: 是一个向量
:return:
'''
output = input
for layer in self.layers:
output = layer.forward(output)
pass
return output
pass
def add(self, layer):
'''
向神经网络添加层
:return:
'''
self.layers.append(layer)
pass
def compile(self):
'''
构建神经网络模型，初始化模型相关的参数
:return:
'''
pass
def optimizor(self, y, loss=None, learningRate=0.005):
'''
优化器,计算梯度和更新梯度
:return:
'''
# 当使用交叉熵作为损失函数的时候
if loss == None or loss == 'CrossEntropy':
# 最后的delta计算其实是基于交叉熵成本函数公式求导的梯度
# ce = -sum(y*log(p) + (1 - y)*log(1 - p))
# self.layers[-1].activator.backward(self.layers[-1].output)得到的是激活函数的梯度
# 对于sigmoid其实就是output*（1 - output)
delta = self.layers[-1].activator.backward(self.layers[-1].output) * \
(self.layers[-1].output - y) / (self.layers[-1].output * (1 - self.layers[-1].output))
# 计算其他层的delta和梯度
for layer in self.layers[:: -1]:
layer.backward(delta)
delta = layer.delta
pass
# 梯度更新，每一条数据都要产生梯度影响
for layer in self.layers:
# print(layer.W)
layer.update(learningRate)
pass
pass
def trainOneSample(self, x, y, loss=None, learningRate=0.005):
'''
注意本例子使用的每次计算一条样本
:param x: 一条样本数据
:param y: 样本的实际结果
:return:
'''
# 正向计算得到结果
output = self.predict(x)
self.optimizor(y, loss, learningRate)
pass
def fit(self, X, Y, loss=None, epochs=1000, learningRate=0.1):
'''
训练模型
:param X: 样本
:param Y: 标签
:param loss: 成本函数
:return:
'''
for i in range(epochs):
# epochs
print("epochs:", i)
for x, y in zip(X, Y):
self.trainOneSample(x, y, learningRate=0.01)
pass
pass
pass
pass
if __name__ == "__main__":
# 定义模型
model = Model()
# 一个三层的网络input->hidden->output，只需要两个计算层
model.add(Dense(inputSize=784, outputSize=64, activator=Sigmoid()))
model.add(Dense(inputSize=64, outputSize=10, activator=Sigmoid()))
# 加载数据
# 5.1 读取训练数据，训练的是处理好的mnist数据集，就是手写数字图片
trainData = np.loadtxt('digits_training.csv', delimiter=',', skiprows=1)
# 将样本数据X和y
xTrain = trainData[:, 1:]
yTrain = trainData[:, 0]
# 正则化
# xTrain = (xTrain - np.mean(xTrain, axis=0))/np.std(xTrain, axis=0)
xTrain = xTrain / np.max(xTrain)
# 优化出10组w，第一组w识别是0，还是不是0，第二组w识别是1还是不是1
# 处理yTrain，变为二维数组oneHot编码
y = np.zeros(shape=(len(yTrain), 10))
# print(y)
for m, row in zip(yTrain, y):
row[int(m)] = 1
pass
# print(xTrain)
# print(y)
model.fit(xTrain, y, epochs=100)
print("预测和原始值：")
print("原始结果：", np.argmax(y[0]), '预测结果：', np.argmax(model.predict(xTrain[0])), '预测值：',model.predict(xTrain[0]))
print("原始结果：", np.argmax(y[1]), '预测结果：', np.argmax(model.predict(xTrain[1])), '预测值：',model.predict(xTrain[1]))
print("原始结果：", np.argmax(y[2]), '预测结果：', np.argmax(model.predict(xTrain[2])), '预测值：',model.predict(xTrain[2]))
pass
5.训练100轮的预测结果
人工智能神经网络：200行代码手写了一个全连接神经网络（NN），基于单条数据计算更新梯度，速度比较慢，计划改为批量计算，代码详细注释
2489
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
