X = np.atleast_2d(X)
		# 定义和数据集X 行数一样，列数比X多一列，用于bias偏向赋值
        temp = np.ones([X.shape[0], X.shape[1]+1])
		# adding the bias unit to the input layer
		# 完成了数据偏移量的赋值，全为 1 
        temp[:, 0:-1] = X  
        X = temp
        y = np.array(y)

5.4.1 初始化权重(weights)和偏向(bias): 随机初始化在-1到1之间，或者-0.5到0.5之间，每个单元有

一个偏向

self.weights = []

        for i in range(1, len(layers) - 1):
            self.weights.append((2*random((layers[i - 1] + 1, layers[i] + 1)) - 1)*0.25)
            self.weights.append((2*random((layers[i] + 1, layers[i + 1] + 1)) - 1)*0.25)
        # print(self.weights)

5.4.2 对于每一个训练实例X，执行以下步骤：

5.4.2.1：由输入层向前传送

# 随机抽取一行进行参数的更新
            i = np.random.randint(X.shape[0])
            a = [X[i]]

            # 接下来进行更新训练操作
			#going forward network, for each layer
			for l in range(len(self.weights)): 
				# Computer the node value for each layer (O_i) using activation function
				# 到这里已经完成了所有层的正向遍历，完成了权重相乘相加偏移量再经过激活函数的操作
                a.append(self.activation(np.dot(a[l], self.weights[l])))  
            #Computer the error at the top layer
			# a 是所有的计算过后的神经元
			error = y[i] - a[-1] 
			#For output layer, Err calculation (delta is updated error)
            deltas = [error * self.activation_deriv(a[-1])]

5.4.2.2 根据误差(error)反向传送

             # 根据误差反向传送
			#Staring backprobagation
			# we need to begin at the second to last layer
            # len(a) - 2：不算出、入层，从0第一次到-1最后一层回溯遍历 
			for l in range(len(a) - 2, 0, -1):
               deltas.append(deltas[-1].dot(self.weights[l].T)*self.activation_deriv(a[l]))
            deltas.reverse()
            for i in range(len(self.weights)):
                layer = np.atleast_2d(a[i])
				# delta：对应权重更新
				# deltas：存储所有层更新过后的误差
                delta = np.atleast_2d(deltas[i])
                self.weights[i] += learning_rate * layer.T.dot(delta)

6. Backpropagation 算法举例

二、手写神经网络模型

1.先了解激活函数tanh

2.1 神经网络的实现代码

import numpy as np

# 双曲函数
def tanh(x):
    return np.tanh(x)

# 更新权重 要求导数
def tanh_deriv(x):
    return 1.0 - np.tanh(x)*np.tanh(x)

# 定义逻辑函数表达式
def logistic(x):
    return 1/(1 + np.exp(-x))

# 逻辑函数求导之后的导数
def logistic_derivative(x):
    return logistic(x)*(1-logistic(x))

# 类的写法
class NeuralNetwork:
	# 实例化构造函数
	# self - this,  - 指向当前类的指针
	# layers : list :[10,2,2,4,5]:几每层里面有多少个神经元（输入层不算层数）
    # activation: 让用户指定使用的参数，默认值
	def __init__(self, layers, activation='tanh'):
        """
        :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
		# 在这个时候就已经初始化了一个成员变量
        self.weights = []
		# 【1】从第二层开始，【len(layers) - 1】去掉了输出层，它没有权重
		# 权重是两个神经元之间的一条线，所以会有两次赋值操作
        for i in range(1, len(layers) - 1):
			# 对第 i 层和 i-1 层之间的权重赋 -0.25 ~ 0.25之间的值
            self.weights.append((2*np.random.random((layers[i - 1] + 1, layers[i] + 1))-1)*0.25)
			# 对第 i 层和 i+1 层之间的权重赋 -0.25 ~ 0.25之间的值
            self.weights.append((2*np.random.random((layers[i] + 1, layers[i + 1]))-1)*0.25)

	# fit来回改变参数的训练过程
    # X: 输入集 ：二维矩阵：每一行对应一个实例，每一列对应多少维度特征值
	# y：标记【0，1】 【1，2，3，4，5，6，7】
	# learning_rate=0.2：对应学习率
	# epochs=10000 : 循环次数：训练时不使用全部数据，而是随机取一部分训练，取一次就是epochs-对应三个终止条件最后一个
	def fit(self, X, y, learning_rate=0.2, epochs=10000):
        # 确定其至少是一个二维的矩阵
		X = np.atleast_2d(X)
		# 定义和数据集X 行数一样，列数比X多一列，用于bias偏向赋值
        temp = np.ones([X.shape[0], X.shape[1]+1])
		# adding the bias unit to the input layer
		# 完成了数据偏移量的赋值，全为 1 
        temp[:, 0:-1] = X  
        X = temp
        y = np.array(y)

		# 抽样的次数，随机抽取一行
        for k in range(epochs):
			# 随机抽取一行进行参数的更新
            i = np.random.randint(X.shape[0])
            a = [X[i]]

            # 接下来进行更新训练操作
			#going forward network, for each layer
			for l in range(len(self.weights)): 
				# Computer the node value for each layer (O_i) using activation function
				# 到这里已经完成了所有层的正向遍历，完成了权重相乘相加偏移量再经过激活函数的操作
                a.append(self.activation(np.dot(a[l], self.weights[l])))  
            #Computer the error at the top layer
			# a 是所有的计算过后的神经元
			error = y[i] - a[-1] 
			#For output layer, Err calculation (delta is updated error)
            deltas = [error * self.activation_deriv(a[-1])] 

            # 根据误差反向传送
			#Staring backprobagation
			# we need to begin at the second to last layer
            # len(a) - 2：不算出、入层，从0第一次到-1最后一层回溯遍历 
			for l in range(len(a) - 2, 0, -1):
                #Compute the updated error (i,e, deltas) for each node going from top layer to input layer
                deltas.append(deltas[-1].dot(self.weights[l].T)*self.activation_deriv(a[l]))
            deltas.reverse()
            for i in range(len(self.weights)):
                layer = np.atleast_2d(a[i])
				# delta：对应权重更新
				# deltas：存储所有层更新过后的误差
                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

2.2 测试代码

from NN01 import NeuralNetwork
import numpy as np

nn = NeuralNetwork([2,2,1], 'tanh')
x = np.array([[0,0],[0,1],[1,0],[1,1]])
y = np.array([0,1,1,0])

nn.fit(x,y)
for i in [[0,0],[0,1],[1,0],[1,1]]:
    print(i, nn.predict(i))

码农公寓

一、神经网络理论

1. 背景:

2. 多层向前神经网络(Multilayer Feed-Forward Neural Network)

3. 设计神经网络结构

4. 交叉验证方法(Cross-Validation)

二、手写神经网络模型

1.先了解激活函数tanh

2.1 神经网络的实现代码

2.2 测试代码

相关文章