神经网络变学习率算法代码_机器学习算法之神经网络

点击蓝字关注我哦

人工神经网络(Artificial Neural Networks，ANN)系统是 20 世纪 40 年代后出现的。它是由众多的神经元可调的连接权值连接而成，具有大规模并行处理、分布式信息存储、良好的自组织自学习能力等特点。人工神经网络是由大量的简单基本元件——神经元相互联接而成的自适应非线性动态系统。本次实验任务带领大家学习如何使用Python代码实现神经网络算法。通过本任务，您将掌握以下内容：1.掌握神经网络的结构。2.掌握神经网络算法的原理。3.掌握使用Python语言实现神经网络算法。

【实验目的】

1.掌握神经网络算法的原理。

2.掌握使用Python语言实现神经网络算法。

【实验原理】

在机器学习和认知科学领域，人工神经网络(artificial neural network，缩写ANN)，简称神经网络(neural network，缩写NN)或类神经网络，是一种模仿生物神经网络(动物的中枢神经系统，特别是大脑)的结构和功能的数学模型或计算模型，用于对函数进行估计或近似。神经网络由大量的人工神经元联结进行计算。大多数情况下人工神经网络能在外界信息的基础上改变内部结构，是一种自适应系统。现代神经网络是一种非线性统计性数据建模工具。我们来了解一下什么是神经元：

其中，x1、x2、x3代表输入，中间部分为神经元，而最后的hw,b(x)是神经元的输出。整个过程可以理解为输入——>处理——>输出。由多个神经元组成的就是神经网络，如下图所示，这是一个4层结构的神经网络，layer1为输入层，layer4为输出层，layer2，layer3为隐藏层，即神经网络的结构由输入层，隐藏层，输出层构成。其中除了输入层以外，每一层的输入都是上一层的输出。

典型的神经网络具有以下三个部分：

(1)结构 (Architecture) 结构指定了网络中的变量和它们的拓扑关系。例如，神经网络中的变量可以是神经元连接的权重(weights)和神经元的激励值(activities of the neurons)。

(2)激励函数(Activity Rule) 大部分神经网络模型具有一个短时间尺度的动力学规则，来定义神经元如何根据其他神经元的活动来改变自己的激励值。一般激励函数依赖于网络中的权重(即该网络的参数)。

(3)学习规则(Learning Rule)学习规则指定了网络中的权重如何随着时间推进而调整。这一般被看做是一种长时间尺度的动力学规则。一般情况下，学习规则依赖于神经元的激励值。它也可能依赖于监督者提供的目标值和当前权重的值。

【实验环境】

Ubuntu 16.04

Anaconda 4.3

python 3.6

Pycharm(Community)

【实验内容】

本次实验任务通过编写Python代码实现一个简单的2维平面神经网络分类器，去分割平面上的不同类别样本点。

【实验步骤】

1.打开Pycharm，新建项目，项目位置名称：/data/Test。

2.在项目名Test下，创建Python File文件。

3.创建以NN命名的文件。

4.在新创建的NN.py文件中，编写代码实现神经网络算法。

(1)首先准备数据，生成一份螺旋状分布的样本点。

view plain copy

N = 100
D = 2
K = 3
X = np.zeros((N*K,D))
y = np.zeros(N*K, dtype='uint8')
for j in range(K):
ix = range(N*j,N*(j+1))
r = np.linspace(0.0,1,N)
t = np.linspace(j*4,(j+1)*4,N) + np.random.randn(N)*0.2
X[ix] = np.c_[r*np.sin(t), r*np.cos(t)]
y[ix] = j

(2)单隐藏层的神经网络，2层权重和偏移量。

view plain copy

# 初始化参数
h = 100 # 隐层大小(神经元个数)
W1 = 0.01 * np.random.randn(D,h)
b1 = np.zeros((1,h))
W2 = 0.01 * np.random.randn(h,K)
b2 = np.zeros((1,K))

(3)2层神经网络的前向计算，使用ReLU神经单元。首先计算第一层神经网络结果，然后作为第二层的输入，计算最后的结果。

view plain copy

hidden_layer = np.maximum(0, np.dot(X, W1) + b1) # 用的 ReLU单元
scores = np.dot(hidden_layer, W2) + b2

(4)梯度回传与反向传播，对W2和b2的第一次计算。

view plain copy

dW2 = np.dot(hidden_layer.T, dscores)
db2 = np.sum(dscores, axis=0, keepdims=True)

(5)计算hidden_layer的梯度。

view plain copy

dhidden = np.dot(dscores, W2.T)

(6)梯度回传经过ReLU，回传的梯度大于0的时候，经过ReLU之后，保持原样；如果小于0，本次回传就到此结束。

view plain copy

dhidden[hidden_layer <= 0] = 0

(7)回到第一层，得到总的权重和偏移量的梯度。

view plain copy

dW = np.dot(X.T, dhidden)db = np.sum(dhidden, axis=0, keepdims=True)

(8)可视化数据和现在的决策边界。

view plain copy

h = 0.02
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
np.arange(y_min, y_max, h))
Z = np.dot(np.maximum(0, np.dot(np.c_[xx.ravel(), yy.ravel()], W1) + b1), W2) + b2
Z = np.argmax(Z, axis=1)
Z = Z.reshape(xx.shape)
fig = plt.figure()
plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral, alpha=0.8)
plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.Paired ,marker='*')
plt.xlim(xx.min(), xx.max())
plt.ylim(yy.min(), yy.max())
plt.show()

完整代码如下：

view plain copy

import numpy as np
import matplotlib.pyplot as plt
N = 100
D = 2
K = 3
X = np.zeros((N*K,D))
y = np.zeros(N*K, dtype='uint8')
for j in range(K):
ix = range(N*j,N*(j+1))
r = np.linspace(0.0,1,N)
t = np.linspace(j*4,(j+1)*4,N) + np.random.randn(N)*0.2
X[ix] = np.c_[r*np.sin(t), r*np.cos(t)]
y[ix] = j
plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.Paired ,marker='*')
plt.show()
h = 100
W1 = 0.01 * np.random.randn(D, h)
b1 = np.zeros((1, h))
W2 = 0.01 * np.random.randn(h, K)
b2 = np.zeros((1, K))
step_size = 1e-0
reg = 1e-3
num_examples = X.shape[0]
for i in range(10000):
hidden_layer = np.maximum(0, np.dot(X, W1) + b1)
scores = np.dot(hidden_layer, W2) + b2
exp_scores = np.exp(scores)
probs = exp_scores / np.sum(exp_scores, axis=1, keepdims=True)
corect_logprobs = -np.log(probs[range(num_examples), y])
data_loss = np.sum(corect_logprobs) / num_examples
reg_loss = 0.5 * reg * np.sum(W1 * W1) + 0.5 * reg * np.sum(W2 * W2)
loss = data_loss + reg_loss
if i % 1000 == 0:
print ("iteration %d: loss %f" % (i, loss))
dscores = probs
dscores[range(num_examples), y] -= 1
dscores /= num_examples
dW2 = np.dot(hidden_layer.T, dscores)
db2 = np.sum(dscores, axis=0, keepdims=True)
dhidden = np.dot(dscores, W2.T)
dhidden[hidden_layer <= 0] = 0
dW = np.dot(X.T, dhidden)
db = np.sum(dhidden, axis=0, keepdims=True)
dW2 += reg * W2
dW += reg * W1
W1 += -step_size * dW
b1 += -step_size * db
W2 += -step_size * dW2
b2 += -step_size * db2
hidden_layer = np.maximum(0, np.dot(X, W1) + b1)
scores = np.dot(hidden_layer, W2) + b2
predicted_class = np.argmax(scores, axis=1)
print('training accuracy: %.2f' % (np.mean(predicted_class == y)))
h = 0.02
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
np.arange(y_min, y_max, h))
Z = np.dot(np.maximum(0, np.dot(np.c_[xx.ravel(), yy.ravel()], W1) + b1), W2) + b2
Z = np.argmax(Z, axis=1)
Z = Z.reshape(xx.shape)
fig = plt.figure()
plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral, alpha=0.8)
plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.Paired ,marker='*')
plt.xlim(xx.min(), xx.max())
plt.ylim(yy.min(), yy.max())
plt.show()

4.右键，选择Run 'NN'，运行程序。

运行结果如下：

分类前散点图：

使用构建后的神经网络分类后的散点图：

end