神经网络

一开始学习深度学习的相关记录，涉及到前向传播和反向传播，看看最后的loss值是否会降低

#coding=utf-8
import numpy as np
from comtypes.npsupport import numpy
from __builtin__ import xrange
def Sigmod(x, diver = False):
    if(diver == True):
        return x*(1-x)
    return 1/(1 + np.exp(-x))

x_In = np.array([[0, 0, 1],
             [0, 1, 0],
             [0, 1, 1],
             [1, 0, 0],
             [1, 0, 1]])
print x_In.shape

y = np.array([[0],
              [1],
              [1],
              [0],
              [1]])
print y.shape

#np下随机初始化的种子1以内的正数
np.random.seed(1)

print '一个隐藏层的神经网络'
#两组权重参数
W1 = 2 * np.random.random((3, 4)) - 1
W2 = 2 * np.random.random((4, 1)) - 1
print 'w1:\n',W1
print 'W2:\n',W2

#神经网络如下
#in  L1  out
# o   o    o
# o   o
# o   o
#     o
for j in xrange(70000):
#激活函数就是上面定义的sigmod
    #输入层5*3 5个1*3
    L0 = x_In
    #隐藏层1  5*3  *  3*4 = 5*4
    #先点乘，在用激活函数
    L1 = Sigmod(np.dot(L0, W1))
    #输出层       5*4  *  4*1 = 5*1
    L2 = Sigmod(np.dot(L1, W2))
    #计算出LOSS = 1/2 * (y - y^)的平方，求导得到L2_error  
    L2_error = y - L2
#   print L2_error
    if (j%10000 == 0):
        print 'Error:' + str(np.mean(np.abs(L2_error)))
    #反向传播第一个delter = 上层梯度*当前梯度
    #计算出每一个对应位置的delter
    L2_delter = L2_error * Sigmod(L2, diver = True)
    #
    L1_error = L2_delter.dot(W2.T)
    L1_delter = L1_error * Sigmod(L1, diver = True)
    #权重更新，因为求导，所以需要转置矩阵
    W2 += L1.T.dot(L2_delter)
    W1 += L0.T.dot(L1_delter

最后的输出结果，可以看到error也就是loss是在不停的下降的

(5, 3)
(5, 1)
一个隐藏层的神经网络
w1:
 [[-0.16595599  0.44064899 -0.99977125 -0.39533485]
 [-0.70648822 -0.81532281 -0.62747958 -0.30887855]
 [-0.20646505  0.07763347 -0.16161097  0.370439  ]]
W2:
 [[-0.5910955 ]
 [ 0.75623487]
 [-0.94522481]
 [ 0.34093502]]
Error:0.499168606476
Error:0.00799855907793
Error:0.00553661821758
Error:0.00447721020333
Error:0.00385444061495
Error:0.0034331553887
Error:0.00312410499476