神经网络通俗讲，麻瓜变大神(一)-初识神经网络

本文主要是介绍神经网络通俗讲，麻瓜变大神(一)-初识神经网络，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

系列目录:
神经网络通俗讲，麻瓜变大神(一)-初识神经网络
神经网络通俗讲，麻瓜变大神(二)-解释非线性
神经网络通俗讲，麻瓜变大神(三)-卷积神经网络

理解神经网络，我们就从一个例子开始吧，该例子输入5个特征，然后输出这个人是美还是丑:
这里写图片描述
该神经网络结构包含三层，分别为:
1.输入层(input):5个特征，分别表示皮肤颜色，身高，体重，脸型，臀。
2.隐藏层(hidden):100个神经元,w1(5,100),可以理解为有100个国家同时对这个5个特征进行一个打分。有些国家就觉得臀部屁股大觉得好看，那这样权重w就会大一点,开玩笑。
3.输出层(output):2个神经元,分别表示美，丑，w2(100,2),可以理解为有个权威机构，对100个国家审美等级有个置信度，例如美国w=0.9,而韩国=0.3，就说美国对美和丑更有话语权。

这样一个网络，该怎么训练:

1.计算出美和丑的概率:
mul1 = w1 * x
add1 = mu1 + b1
score1 = max(0,add1) #使用Relu
mul2 = score1 * w2
score2 = mul2 +b2
prob = exp(score2[美])/sum(exp(score2[美])+exp(score[丑])) #soft分类器
2.计算损失值loss(计算得出的结果prob和原本标签label之间有多大区别):
loss = data_loss + reg_loss
data_loss = -np.log(prob[正确])
reg_loss = 0.5*reg*np.sum(W*W) + 0.5*reg*np.sum(W2*W2) #正则化惩罚项
其实以上整个就是一个前向传播，从x 到计算出loss的过程。
3.反向传播，目的是让loss不断减小，记住loss是一个方程，loss=data_loss + reg_loss,先求
在点w2,和点b2的梯度
dprob = prob
dprob = dprob[正确] - 1 #对dataloss进行softmax求导,也就是prob的求导
dw2 = np.dot(score1.T, dprob) #求得loss方程在点w2上的梯度
db2 = dscore #在点b2上的梯度
4.再求点w1,和点b1的梯度
dscore1 = np.dot(dprob, W2.T) #进行score1求导
if dscore1<0 : dscore1=0 #Relu
dw1 = np.dot(x.T, dscore1) #进行求得loss方程在点w1上的梯度
db1 = dscore1 #在点b1上的梯度
5.根据w1,b1,w2,b2的梯度进行修改
w1 = w1-学习率*dw1
b1 = b1-学习率*db1
w2 = w2-学习率*dw2
b2 = b2-学习率*db2

虽然计算过程已经给出，但是其实里面还有很多值得去讨论和解释的问题:
1.神经元怎么理解？
以上面的例子，我们可以理解为w1.shape = (5,100),可以理解为，100个不同的国家对这5个不同的特征进行评估,然后得出每个国家对这5个特征的得分值，这完全就是对这5个特征往上抽象了，神经元越多，隐藏层越多，就越抽象，到最后抽象成什么样子我自己都不知道，但方向就是这样。
2.神经元，和隐藏层是不是越多越好？
的确也可以这么说，以现在的例子，明明可以只对5个特征和权重相乘然后得出结果值，但这样肯定不会比我们综合100个国家，再加个权威机构认定来得准确吧。当然网上也会说神经元多，隐藏层多会出现过拟合，其实也可以理解，你综合的东西太多，看的角度太多，确实会发生这样的情况。
3.为什么再add1以后使用Relu非线性函数？
因为如果没有Relu，可以将整个score2看作 score2 = w2(w1*x+b1),这就是一种线性函数，类似y=4x。当加上Relu以后，score2 = w2 * max(0,w1*x+b1)，这就成了非线性。
4.为什么在计算概率中要使用exp指数函数？
只是为了让更大的值显得更大，这样显示更明显，这也是softmax分类器特点。
5.为啥使用-np.log(prob[正确])来计算损失值？
log函数图像大家也都知道，当prob[正确]=1的时候，log(1)=0，当下于1的时候-log
为正数，且prob[正确]值越小，-log得到的值也越大，也表示loss值也越大，这个使用log来作为计算loss值还有一个特点，就是这个函数是属于永不满足函数(不可能出现log(1))，所以会一直调整权值w。
6.为什么在loss方程中还有+个reg_loss正则化惩罚项R(w)?
这个正则化惩罚项R(w)，主要用于对当前权重w对模型好坏的一个评估。比方有:
这里写图片描述
通过计算可以知道score = w1 x = w2 x=1,得分值一摸一样，那么一般我们认为w2要比w1要好，因为w2 4个特征都有去考虑了，而w1只对一个特征考虑，所以这里就用到一个权重正则化惩罚项R(w)来评估一个权重的好坏。目前R(w)的计算公式有两种:L1和L2(例子中采用L2)，具体可参考Keras Dense层整理，其实这里也解释了网上说可以使用R(w)来防止模型过拟合，w1就是过拟合的表现，一刀切。还可以用通俗的方式来讲:就是说一个公司有4个领导，w1就是说决策只用1个领导说了算，而w2是综合了4个领导的意见才决定的，显然w2更好。
7.反向传播是如何体现的？
其实可以先不管反向传播这个名词。我们知道在计算得到loss值以后，loss是一个方程，然后我们想降低loss值，以让模型更好，那么我们就让w1,b1,w2,b2分别作为loss方程的变量，然后分别对它们进行求导，也就得到loss方程在点w1,b1,w2,b2的梯度，我们又知道梯度是方程变化最快的方向(注意，这里是变化最快的方向，而不是网上说的什么下降最快的方向)。计算dw1,db1,dw2,db2，根据链式法则如下:
这里写图片描述
往箭头方向看，这就是反向传播，至于对softmax求导得到prob[正确]-1,推到过程可以查看softmax求导推算。
8.往下坡路走方向最快是什么意思？
比方有 $y=x^2$ ,y’= dx = 2x,在点x = 1 的梯度为dx = 2,则说明x->2的方向变化最快，但x往2方向是y增大最快的方向，所以我们要往返方向走，而反方向走也是y下降最快的方向，所以在更新权重的时候才有w2 = w2 - 学习率 * dw2。这才是最快走下坡路。
9.学习率有什么作用？
学习率就是让下坡的步伐慢一点，假设以问题8的中的例子 $y=x^2$ ,大家都知道x=0的时候到达低谷，则现有 dx = 2x=2,,假设x往梯度的反方向走,f(1-dx) =f(-1)= 1,发现越过了低谷，而假设学习率=0.1，则有f(1-学习率*dx) = f(0.8)=0.64,这样看的话就发现往梯度dx反方向迈的步伐越小，就不会轻易错过低谷，所以学习率的作用就在此，慢慢的沿着函数曲线下坡。

下面我们再来看一个网上经常能够看到的例子,我只对变量名进行修改，以方便对比:

import numpy as np
import matplotlib.pyplot as pltnp.random.seed(0)
N = 100 # number of points per class
D = 2 # dimensionality
K = 3 # number of classes
X = np.zeros((N*K,D))
y = np.zeros(N*K, dtype='uint8')
for j in xrange(K):ix = range(N*j,N*(j+1))r = np.linspace(0.0,1,N) # radiust = np.linspace(j*4,(j+1)*4,N) + np.random.randn(N)*0.2 # thetaX[ix] = np.c_[r*np.sin(t), r*np.cos(t)]y[ix] = jh = 100 # size of hidden layer
W1 = 0.01 * np.random.randn(D,h)# x:300*2  2*100
b1 = np.zeros((1,h))
W2 = 0.01 * np.random.randn(h,K)
b2 = np.zeros((1,K))# some hyperparameters
step_size = 1e-0
reg = 1e-3 # regularization strength# gradient descent loop
num_examples = X.shape[0]
#开始训练
for i in xrange(2000):# evaluate class scores, [N x K]score1 = np.maximum(0, np.dot(X, W1) + b1) # note, ReLU activation hidden_layer:300*100#print hidden_layer.shapescore2 = np.dot(score1, W2) + b2  #scores:300*3#print scores.shape# compute the class probabilitiesexp_scores = np.exp(score2)probs = exp_scores / np.sum(exp_scores, axis=1, keepdims=True) # [N x K]#print probs.shape# compute the loss: average cross-entropy loss and regularizationcorect_logprobs = -np.log(probs[range(num_examples),y])data_loss = np.sum(corect_logprobs)/num_examplesreg_loss = 0.5*reg*np.sum(W*W) + 0.5*reg*np.sum(W2*W2)loss = data_loss + reg_lossif i % 100 == 0:print "iteration %d: loss %f" % (i, loss)# compute the gradient on scores，开始反向传播dscore2 = probsdscore2[range(num_examples),y] -= 1dscore2 /= num_examples# backpropate the gradient to the parameters# first backprop into parameters W2 and b2dW2 = np.dot(score1.T, dscore2)db2 = np.sum(dscore2, axis=0, keepdims=True)# next backprop into hidden layerdscore1 = np.dot(dscore2, W2.T)# backprop the ReLU non-linearitydscore1[score1 <= 0] = 0# finally into W,bdW = np.dot(X.T, dscore1)db = np.sum(dscore1, axis=0, keepdims=True)# add regularization gradient contributiondW2 += reg * W2dW1 += reg * W1# perform a parameter updateW1 += -step_size * dW1b1 += -step_size * db1W2 += -step_size * dW2b2 += -step_size * db2
#后面这里只是用于画图了
hidden_layer = np.maximum(0, np.dot(X, W) + b)
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()], W) + b), 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.Spectral)
plt.xlim(xx.min(), xx.max())
plt.ylim(yy.min(), yy.max())
plt.show()

上面的例子和我前面举的例子有啥相同和不同？
相同:
1,都是三层全连接网络结构
2.激活函数都使用的relu函数
3.分类器和损失都使用的softmax
不同:
1.输入训练的数据量不一样，我开始举的例子使用的是batchsize=1,而网上的这个例子使用的整个数据集作为batchsize
2.因为batchsize不一样，这就在更新w的时候不一样，明显看到网上的例子都有一个/num_examples的操作，也就是说将整个数据集作为一次训练，然后在更新权重的时候才用平均梯度的方式；其实我使用的优化算法为SGB随机梯度下降算法，而网上使用的例子为BGD批量梯度下降算法，再具体一点可以去看下网上其它的资料。

这篇关于神经网络通俗讲，麻瓜变大神(一)-初识神经网络的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！