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

点击蓝字关注我哦

人工神经网络(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

1. N = 100  

2. D = 2  

3. K = 3  

4. X = np.zeros((N*K,D))  

5. y = np.zeros(N*K, dtype='uint8')  

6. for j in range(K):  

7.   ix = range(N*j,N*(j+1))  

8.   r = np.linspace(0.0,1,N)  

9.   t = np.linspace(j*4,(j+1)*4,N) + np.random.randn(N)*0.2  

10.   X[ix] = np.c_[r*np.sin(t), r*np.cos(t)]  

11.   y[ix] = j  

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

view plain copy

1. # 初始化参数  

2. h = 100 # 隐层大小(神经元个数)  

3. W1 = 0.01 * np.random.randn(D,h)  

4. b1 = np.zeros((1,h))  

5. W2 = 0.01 * np.random.randn(h,K)  

6. b2 = np.zeros((1,K))  

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

view plain copy

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

2. scores = np.dot(hidden_layer, W2) + b2  

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

view plain copy

1. dW2 = np.dot(hidden_layer.T, dscores)  

2. db2 = np.sum(dscores, axis=0, keepdims=True)  

(5)计算hidden_layer的梯度。

view plain copy

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

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

view plain copy

1. dhidden[hidden_layer <= 0] = 0  

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

view plain copy

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

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

view plain copy

1. h = 0.02  

2. x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1  

3. y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1  

4. xx, yy = np.meshgrid(np.arange(x_min, x_max, h),  

5.                      np.arange(y_min, y_max, h))  

6. Z = np.dot(np.maximum(0, np.dot(np.c_[xx.ravel(), yy.ravel()], W1) + b1), W2) + b2  

7. Z = np.argmax(Z, axis=1)  

8. Z = Z.reshape(xx.shape)  

9. fig = plt.figure()  

10. plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral, alpha=0.8)  

11. plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.Paired ,marker='*')  

12. plt.xlim(xx.min(), xx.max())  

13. plt.ylim(yy.min(), yy.max())  

14. plt.show()  

完整代码如下：

view plain copy

1. import numpy as np  

2. import matplotlib.pyplot as plt  

3. N = 100  

4. D = 2  

5. K = 3  

6. X = np.zeros((N*K,D))  

7. y = np.zeros(N*K, dtype='uint8')  

8. for j in range(K):  

9.   ix = range(N*j,N*(j+1))  

10.   r = np.linspace(0.0,1,N)  

11.   t = np.linspace(j*4,(j+1)*4,N) + np.random.randn(N)*0.2  

12.   X[ix] = np.c_[r*np.sin(t), r*np.cos(t)]  

13.   y[ix] = j  

14. plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.Paired ,marker='*')  

15. plt.show()  

16. h = 100  

17. W1 = 0.01 * np.random.randn(D, h)  

18. b1 = np.zeros((1, h))  

19. W2 = 0.01 * np.random.randn(h, K)  

20. b2 = np.zeros((1, K))  

21. step_size = 1e-0  

22. reg = 1e-3  

23. num_examples = X.shape[0]  

24. for i in range(10000):  

25.     hidden_layer = np.maximum(0, np.dot(X, W1) + b1)  

26.     scores = np.dot(hidden_layer, W2) + b2  

27.     exp_scores = np.exp(scores)  

28.     probs = exp_scores / np.sum(exp_scores, axis=1, keepdims=True)  

29.     corect_logprobs = -np.log(probs[range(num_examples), y])  

30.     data_loss = np.sum(corect_logprobs) / num_examples  

31.     reg_loss = 0.5 * reg * np.sum(W1 * W1) + 0.5 * reg * np.sum(W2 * W2)  

32.     loss = data_loss + reg_loss  

33.     if i % 1000 == 0:  

34.         print ("iteration %d: loss %f" % (i, loss))  

35.     dscores = probs  

36.     dscores[range(num_examples), y] -= 1  

37.     dscores /= num_examples  

38.     dW2 = np.dot(hidden_layer.T, dscores)  

39.     db2 = np.sum(dscores, axis=0, keepdims=True)  

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

41.     dhidden[hidden_layer <= 0] = 0  

42.     dW = np.dot(X.T, dhidden)  

43.     db = np.sum(dhidden, axis=0, keepdims=True)  

44.     dW2 += reg * W2  

45.     dW += reg * W1  

46.     W1 += -step_size * dW  

47.     b1 += -step_size * db  

48.     W2 += -step_size * dW2  

49.     b2 += -step_size * db2  

50. hidden_layer = np.maximum(0, np.dot(X, W1) + b1)  

51. scores = np.dot(hidden_layer, W2) + b2  

52. predicted_class = np.argmax(scores, axis=1)  

53. print('training accuracy: %.2f' % (np.mean(predicted_class == y)))  

54. h = 0.02  

55. x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1  

56. y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1  

57. xx, yy = np.meshgrid(np.arange(x_min, x_max, h),  

58.                      np.arange(y_min, y_max, h))  

59. Z = np.dot(np.maximum(0, np.dot(np.c_[xx.ravel(), yy.ravel()], W1) + b1), W2) + b2  

60. Z = np.argmax(Z, axis=1)  

61. Z = Z.reshape(xx.shape)  

62. fig = plt.figure()  

63. plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral, alpha=0.8)  

64. plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.Paired ,marker='*')  

65. plt.xlim(xx.min(), xx.max())  

66. plt.ylim(yy.min(), yy.max())  

67. plt.show()  

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

 运行结果如下：

分类前散点图：

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

end