反向传播算法带动了业界使用两层神经网络研究的热潮,反向传播神经网络基本原理
利用神经网络来预测学生录取情况我们基于以下三条数据预测了加州大学洛杉矶分校（加州大学洛杉矶分校)的研究生录取情况：
美国研究生入学考试(研究生入学考试)分数（测试)即美国研究生入学考试(Graduate Record Examination)成绩（测试)GPA分数（成绩)即平均积点分数（等级)评级(1-4)即班级排名(1-4)数据集来源：http://www.ats.ucla.edu/
加载数据为了加载数据并很好地进行格式化，我们将使用两个非常有用的包，即熊猫和Numpy。你可以在这里阅读文档：
https://pandas.pydata.org/pandas-docs/stable/https://docs.scipy.org/#进口熊猫和熊猫
进口熊猫作为螺纹中径
将数组作为铭牌导入
#将战斗支援车文件读入熊猫数据帧
数据=PD。read _ CSV( student _ data。CSV’)
#打印出我们数据的前10行
数据[:10]
承认
美国研究生入学考试(研究生入学考试)
平均分数
等级
0
0
380
3.61
3
一
一
660
3.67
3
2
一
800
4.00
一
3
一
640
3.19
四
四
0
520
2.93
四
5
一
760
3.00
2
6
一
560
2.98
一
七
0
400
3.08
2
8
一
540
3.39
3
9
0
700
3.92
2
绘制数据首先让我们对数据进行绘图，看看它是什么样的。为了绘制二维图，让我们先忽略评级（排名).
#导入绘制精美的图表
将matplotlib.pyplot作为血小板计数导入
%matplotlib内联
#帮助我们绘图的功能
定义绘图点（数据):
X=np.array(data[[gre ， gpa]])
y=np.array(data[admit])
录取=X[np.argwhere(y==1)]
rejected=X[np.argwhere(y==0)]
plt.scatter([s[0][0]表示被拒绝的s]，s[0][1]表示被拒绝的s)，s=25，color=red ，edgecolor=k )
plt.scatter([s[0][0]表示s被接纳]，s[0][1]表示s被接纳)，s=25，color=青色，edgecolor=k )
plt.xlabel(Test (GRE))
plt.ylabel(成绩(GPA))
#绘制这些点
绘图点（数据)
plt.show()
粗略来说，它看起来像是，成绩（成绩)和测试（测试)分数高的学生通过了，而得分低的学生却没有，但数据并没有如我们所希望的那样，很好地分离。也许将评级（排名)考虑进来会有帮助？接下来我们将绘制四个图，每个图代表一个级别。
#区分等级
数据秩1=数据[数据[秩]==1]
数据秩2=数据[数据[秩]==2]
数据秩3=数据[数据[秩]==3]
data _ rank 4=data[data[ rank ]==4]
#绘制图表
绘图点（数据等级1)
plt.title("排名1")
plt.show()
绘图点（数据等级2)
plt.title(等级2 )
plt.show()
绘图点（数据等级3)
plt.title(等级3 )
plt.show()
绘图点（数据等级4)
plt.title(排名4 )
plt.show()
现在看起来更棒啦，看上去评级越低，录取率越高。让我们使用评级（排名)作为我们的输入之一。为了做到这一点，我们应该对它进行一次一个热点编码。
将评级进行一个热点编码我们将在熊猫中使用获取_假人函数。
#为排名制作虚拟变量
one_hot_data=pd.concat([data，pd.get_dummies(data[rank]，prefix=rank ))，axis=1)
一个热数据[:10]
承认
美国研究生入学考试(研究生入学考试)
平均分数
等级
排名一
排名2
排名_3
排名_4
0
0
380
3.61
3
0
0
一
0
一
一
660
3.67
3
0
0
一
0
2
一
800
4.00
一
一
0
0
0
3
一
640
3.19
四
0
0
0
一
四
0
520
2.93
四
0
0
0
一
5
一
760
3.00
2
0
一
0
0
6
一
560
2.98
一
一
0
0
0
七
0
400
3.08
2
0
一
0
0
8
一
540
3.39
3
0
0
一
0
9
0
700
3.92
2
0
一
0
0
#删除以前的等级列
一个热数据=一个热数据。drop( rank ，轴=1)
#打印我们数据的前10行
一个热数据[:10]
承认
美国研究生入学考试(研究生入学考试)
平均分数
排名一
排名2
排名_3
排名_4
0
0
380
3.61
0
0
一
0
一
一
660
3.67
0
0
一
0
2
一
800
4.00
一
0
0
0
3
一
640
3.19
0
0
0
一
四
0
520
2.93
0
0
0
一
5
一
760
3.00
0
一
0
0
6
一
560
2.98
一
0
0
0
七
0
400
3.08
0
一
0
0
8
一
540
3.39
0
0
一
0
9
0
700
3.92
0
一
0
0
缩放数据下一步是缩放数据。我们注意到成绩（成绩)的范围是1.0-4.0,而测试分数（考试成绩)的范围大概是200-800,这个范围要大得多。这意味着我们的数据存在偏差，使得神经网络很难处理。让我们将两个特征放在0-1 的范围内，将分数除以4.0,将测试分数除以800。
#制作我们数据的副本
processed_data=one_hot_data[:]
# TODO:缩放列
已处理数据[gre]=已处理数据[gre]/800
已处理数据[gpa]=已处理数据[gpa]/800
#打印我们处理后数据的前10行
已处理数据[:10]
承认
美国研究生入学考试(研究生入学考试)
平均分数
排名一
排名2
排名_3
排名_4
0
0
0.475
0.004513
0
0
一
0
一
一
0.825
0.004587
0
0
一
0
2
一
1.000
0.005000
一
0
0
0
3
一
0.800
0.003987
0
0
0
一
四
0
0.650
0.003663
0
0
0
一
5
一
0.950
0.003750
0
一
0
0
6
一
0.700
0.003725
一
0
0
0
七
0
0.500
0.003850
0
一
0
0
8
一
0.675
0.004237
0
0
一
0
9
0
0.875
0.004900
0
一
0
0
将数据分成训练集和测试集为了测试我们的算法，我们将数据分为训练集和测试集。测试集的大小将占总数据的10%。
样本=NP。随机的。choice(processed _ data。index，size=int(len(processed _ data)* 0.9)，replace=False)
训练数据，测试数据=已处理数据。iloc[示例]，processed_data.drop(示例)
打印(训练样本数为，len(train_data))
打印(测试样本数为，len(test_data))
打印(训练数据[:10])
训练样本数为360
测试样本数量为40
录取gre gpa排名_1排名_2排名_3排名_4
7 0 0.500 0.003850 0 1 0 0
9 0 0.875 0.004900 0 1 0 0
165 0 0.875 0.005000 1 0 0 0
158 0 0.825 0.004363 0 1 0 0
211 0 0.725 0.003775 0 1 0 0
327 1 0.700 0.004350 0 1 0 0
132 0 0.725 0.004250 0 1 0 0
151 0 0.500 0.004225 0 1 0 0
78 0 0.675 0.003900 1 0 0 0
350 1 0.975 0.005000 0 1 0 0
录取gre gpa排名_1排名_2排名_3排名_4
13 0 0.875 0.003850 0 1 0 0
15 0 0.600 0.004300 0 0 1 0
18 0 1.000 0.004687 0 1 0 0
21 1 0.825 0.004537 0 1 0 0
30 0 0.675 0.004725 0 0 0 1
54 0 0.825 0.004175 0 0 1 0
55 1 0.925 0.005000 0 0 1 0
56 0 0.700 0.003987 0 0 1 0
66 0 0.925 0.004525 0 0 0 1
69 0 1.000 0.004662 1 0 0 0将数据分成特征和目标（标签)现在，在培训前的最后一步，我们将把数据分为特征（特性)(X)和目标（目标)(y)。
特征=训练数据。drop( admit ，轴=1)
targets=train_data[admit]
特征测试=测试数据。drop( admit ，轴=1)
targets _ test=test _ data[ admit ]
打印（功能[:10])
print(targets[:10])GRE GPA rank _ 1 rank _ 2 rank _ 3 rank _ 4
7 0.500 0.003850 0 1 0 0
9 0.875 0.004900 0 1 0 0
165 0.875 0.005000 1 0 0 0
158 0.825 0.004363 0 1 0 0
211 0.725 0.003775 0 1 0 0
327 0.700 0.004350 0 1 0 0
132 0.725 0.004250 0 1 0 0
151 0.500 0.004225 0 1 0 0
78 0.675 0.003900 1 0 0 0
350 0.975 0.005000 0 1 0 0
7 0
9 0
165 0
158 0
211 0
327 1
132 0
151 0
78 0
350 1
名称：承认，数据类型：int64训练二层神经网络已经准备数据，现在我们来训练一个简单的两层神经网络：
首先，我们将写一些助手函数。
#激活(乙状结肠)功能
定义乙状结肠(十):
return 1/(1 np.exp(-x))
def sigmoid_prime(x):
返回sigmoid(x) * (1-sigmoid(x))
定义错误_公式(y，输出):
return - y*np.log(输出)-(1-y)* NP。日志(1-输出)误差反向传播现在轮到你来练习，编写误差项。记住这是由方程
# TODO:编写错误术语公式
定义错误_术语_公式(y，输出):
return (y输出)#神经网络超参数
纪元=1000
learnrate=0.5
#培训功能
def train_nn(特征，目标，时期，学习率):
#使用相同的种子以使调试更容易
随机种子(42)
n_records，n _ features=features.shape
last_loss=无
#初始化权重
权重=NP。随机的。正常(比例=1/n个特征* * 5，大小=n个特征)
打印（重量。形状)
对于范围内的电子(历元):
del_w=np.zeros(weights.shape)
对于活力中的x，y(要素。值，目标):
#遍历所有记录，x是输入，y是目标
#输出单元的激活
#请注意，我们在这里将输入和权重相乘
#而不是将h存储为一个单独的变量
输出=sigmoid(np.dot(x，权重))
#误差，目标减去网络输出
误差=误差_公式(y，输出)
#误差项
#注意我们在这里计算f (高)而不是定义一个单独的
# sigmoid_prime函数。这只是让它更快，因为我们
#可以重复使用存储在中的乙状结肠的函数的结果
#输出变量
错误术语=错误术语公式(y，输出)
#打印(错误术语：,错误术语)
#梯度下降步骤，误差乘以梯度乘以输入
del_w=错误术语* x
#在此更新权重。学习率乘以
#重量变化，除以要平均的记录数
权重=学习率*删除记录/n记录
#打印出训练集上的错误
如果e %(历数/10)==0:
out=sigmoid(np.dot(特征，权重))
#打印（输出)
损失=np.mean超出目标)** 2)
打印(纪元：，e)
如果最后损失和最后损失损失：
打印("列车损失："、损失、"警告-损失增加")
否则：
打印(列车损失： ,损失)
last_loss=损失
打印(=========)
打印(完成培训!)
返回重量
权重=train_nn(特征，目标，时期，学习率)(6,)
纪元：0
列车损耗：0 .25660 .88888888861
=========
纪元：100年
列车损耗：0。58660 .68868686861
=========
纪元：200年
列车损耗：0。56860 .68886886861
=========
纪元：300年
列车损耗：0。36860 .68868686861
=========
纪元：400年
列车损耗：0。36860 .68868686861
=========
纪元：500年
列车损耗：0 .20100 .38686868661
=========
纪元：600年
列车损耗：0。36860 .68868686861
=========
纪元：700年
列车损耗：0 .20000 .38686886861
=========
纪元：800年
列车损耗：0.19986586861
=========
纪元：900年
列车损耗：0.19068586861
=========
训练完毕！计算测试（测试)数据的精确度#计算测试数据的准确性
tes _ out=sigmoid(NP。dot(特征_测试，权重))
预测值=tes_out 0.5
精确度=np .均值(预测==目标_测试)
打印(预测精度：{:3f} .格式（精度))预测精度：0.675对于深度神经网络（多层神经网络),原理相同，需要通过链式法则，将错误函数反向传播到每层网络的对应节点，调整参数
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。