Python手动搭建神经网络
用基本的numpy库实现一个模拟神经元的或非门和异或门。
先随机对网络神经元权重赋值，一开始输出数据杂乱无章，但是在训练过程中不断匹配希望得到的输出，通过梯度下降算法，以降低误差，减小损失函数为目的，调整权重值，迭代一千次运算之后可以得到精准的或非门输出。通过各种组合可以实现各种数字电路的搭建。
输入对应输出分别如下：
或非门
:
异或门
:
代码中可以使用了四种激活函数，分别是双曲正切函数tanh（x），sigmoid函数，relu函数，Leaky ReLU函数。只需要在主函数中输入对应想要用的激活函数即可调用。对比不同的激活函数可以自己看训练效果。
损失函数采用两种可选，分别是：
平方损失函数 :
交叉熵损失函数 ：
代码如下：
import numpy as np
# 定义激活函数和他们的导数
####################################################
def tanh(x): #双曲正切函数
return np.tanh(x)
def tanh_deriv(x): #双曲正切函数的导数
return 1.0 - np.tanh(x) ** 2
####################################################
def Leaky_ReLU(x): #双曲正切函数
return np.maximum(0.01*x, x)
def Leaky_ReLU_deriv(x): #双曲正切函数的导数
if x < 0:
return 0.01
else:
return 1
####################################################
def logistic(x): #sigmoid函数
return 1 / (1 + np.exp(-x))
def logistic_derivative(x): #sigmoid函数导数
return logistic(x) * (1 - logistic(x))
####################################################
def Relu(x):
return np.maximum(0, x)
def Relu_derivative(x):
return np.maximum(0, 1)
####################################################
# 定义损失函数和他们的导数
####################################################
#平方损失函数
def Square_cost(y , a):
return 0.5 * pow((y - a),2)
def Square_cost_deriv(y , a):
return (y - a)
####################################################
#交叉熵损失函数
def cross_entropy(y,a):
return -(y*np.log(a)+(1-y)*np.log(1-a))
def cross_entropy_deriv(y,a):
return ( (-y/a)+(1-y)/(1-a) )
# 定义NeuralNetwork 神经网络算法
class NeuralNetwork:
# 初始化，layes表示的是一个list，eg[10,10,3]表示第一层10个神经元，第二层10个神经元，第三层3个神经元
def __init__(self, layers, activation, error_fun):
"""
:param layers: A list containing the number of units in each layer.
Should be at least two values
:param activation: The activation function to be used. Can be
"logistic" or "tanh"
"""
if activation == 'logistic':
self.activation = logistic
self.activation_deriv = logistic_derivative
elif activation == 'tanh':
self.activation = tanh
self.activation_deriv = tanh_deriv
elif activation == 'Relu':
self.activation = Relu
self.activation_deriv = Relu_derivative
elif activation == 'Leaky_ReLU':
self.activation = Leaky_ReLU
self.activation_deriv = Leaky_ReLU_deriv
if error_fun =="Square_cost":
self.error_fun = Square_cost
self.error_fun_deriv = Square_cost_deriv
elif error_fun == "cross_entropy":
self.error_fun = cross_entropy
self.error_fun_deriv = cross_entropy_deriv
self.weights = []
# 三层网络权重初始化。循环从1开始，相当于以第二层为基准，进行权重的初始化
for i in range(1, len(layers) - 1):
# 对当前神经节点的前驱(权重)赋值，np.random.random 生成-0.25到+0.25之间的随机浮点数float
self.weights.append((2 * np.random.random( (layers[i - 1] + 1, layers[i] + 1) ) - 1) * 0.25) #第一级
# 对当前神经节点的后继赋值
self.weights.append((2 * np.random.random((layers[i] + 1, layers[i + 1])) - 1) * 0.25) #第二级
# 训练函数 ，X矩阵，每行是一个实例 ，y是每个实例对应的结果，learning_rate 学习率，
# epochs，表示抽样的方法对神经网络进行更新的最大次数
def fit(self, X, y, learning_rate=0.1, epochs=10000): #修改epoch的值可以修改迭代训练样本的次数，理论上越高越准确
X = np.atleast_2d(X) # 确定X至少是二维的数据
temp = np.ones([X.shape[0], X.shape[1] + 1]) # 初始化矩阵
temp[:, 0:-1] = X # adding the bias unit to the input layer
X = temp #在矩阵X之后又加了一列数组
y = np.array(y) # 把list转换成array的形式，输出
for k in range(epochs): #k从0到9999
# 随机选取 00，01，10，11 一组二维向量作为输入，对神经网络进行更新
i = np.random.randint(X.shape[0]) #随机从X中抽取 i是输入的二维向量
a = [X[i]] #给到a，作为神经网络的输入
# 完成所有正向的更新
for l in range(len(self.weights)): #注意，这里是字母l不是1，将l从0到weights长度-1循环 ，这里是全连接，所以每一个下层网络都是有
# len(self.weights)个权重与下级神经元连接
a.append(self.activation(np.dot(a[l], self.weights[l]))) #a1与对应权重相乘之后作为激活函数的输入，并且加到a数组的最后一行
error = y[i] - a[-1]
error_deriv_a = self.error_fun_deriv(y[i],a[-1])
deltas = [error_deriv_a * self.activation_deriv(a[-1])] #残差就是最后一层神经元激活值a乘上损失函数对a的导数
if k % 1000 == 0: # 其实是刚好损失函数求导就是误差
print(k, '...', 0.5 * error * error) # 如果选用了别的损失函数，就应该要改变上面的[error * self.activation_deriv(a[-1])]
# 开始反向计算误差，更新权重 # 因为求导之后不一定就刚好是error
for l in range(len(a) - 2, 0, -1): # we need to begin at the second to last layer 步长为-1，从倒数第二层个数开始，激活神经元个数len（a）
deltas.append( np.dot( deltas[-1] , ((self.weights[l].T) * self.activation_deriv(a[l])) ) ) # . T是转置操作 下一层残差乘权重的和
deltas.reverse() #将残差里面的元素颠倒，最后输出层残差放在第一个元素，方面矩阵运算 运行梯度下降算法 #， 再乘上激活函数对a的导数 是上一层的残差
for i in range(len(self.weights)): # 其实这里activation_deriv(a[l]))应该是a
layer = np.atleast_2d(a[i])
delta = np.atleast_2d(deltas[i])
self.weights[i] += learning_rate * layer.T.dot(delta)
# 预测函数
def predict(self, x):
x = np.array(x)
temp = np.ones(x.shape[0] + 1)
temp[0:-1] = x
a = temp
for l in range(0, len(self.weights)):
a = self.activation(np.dot(a, self.weights[l]))
return a
huofei = NeuralNetwork([2, 10,1], 'logistic','Square_cost')
yihuo = NeuralNetwork([2, 10,1], 'logistic','Square_cost') #神经网络三层，每一层神经元数量分别是2 10 1
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]]) #创建4行2列二维数组
y = np.array([1, 0, 0, 0]) #X和y定义输入和输出的对应关系，修改可以第定义成不同的门电路
Z = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
w = np.array([0, 1, 1, 0])
huofei.fit(X, y)
yihuo.fit(Z, w)
print("或非门电路：")
for i in [[0, 0], [0, 1], [1, 0], [1, 1]]:
print("模拟输入:",i, ", 模拟输出-->",huofei.predict(i))
print("异或门电路：")
for i in [[0, 0], [0, 1], [1, 0], [1, 1]]:
print("模拟输入:",i,", 模拟输出-->", yihuo.predict(i))
输出结果如下：
D:\Anaconda_setup\python.exe G:/Deeplearning_code/DIY/BPNN_DIY.py
0 ... [0.12179908]
1000 ... [0.02503359]
2000 ... [0.17474842]
3000 ... [0.00093653]
4000 ... [9.31449645e-05]
5000 ... [1.1357721e-05]
6000 ... [0.00083786]
7000 ... [8.64692404e-07]
8000 ... [3.28111191e-07]
9000 ... [0.00011373]
0 ... [0.12548975]
1000 ... [0.12068519]
2000 ... [0.13938873]
3000 ... [0.10389508]
4000 ... [0.10021494]
5000 ... [0.10193966]
6000 ... [0.10975672]
7000 ... [0.12099792]
8000 ... [0.15410592]
9000 ... [0.11279369]
或非门电路：
模拟输入: [0, 0] , 模拟输出--> [0.96165333]
模拟输入: [0, 1] , 模拟输出--> [0.01301775]
模拟输入: [1, 0] , 模拟输出--> [0.01169065]
模拟输入: [1, 1] , 模拟输出--> [0.00043309]
异或门电路：
模拟输入: [0, 0] , 模拟输出--> [0.43879153]
模拟输入: [0, 1] , 模拟输出--> [0.43959247]
模拟输入: [1, 0] , 模拟输出--> [0.43743751]
模拟输入: [1, 1] , 模拟输出--> [0.43827793]
Process finished with exit code 0