从零起步(无需数学和Python基础)编码实现AI框架之第六节课：使用Matrix编写AI框架实战及测试

本节课使用Matrix编写AI框架实战：编码实现Forward Propagation、Back Propagation算法功能。

1，使用Forward Propagation、Back Propagation算法训练神经网络尝试着用输入去预测输出。

输入内容X：

X= np.array([[0,0,1],
	    [0,1,1],
	    [1,0,1],
	    [1,1,1]] )

输出内容：

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

这里通过神经网络去预测y的值。给定三列输入，试着去预测对应的一列输出。

2，神经元网络计算：

X 输入数据集，形式为矩阵，每 1 行代表 1 个训练样本。
y 输出数据集，形式为矩阵，每 1 行代表 1 个训练样本。
layer0 网络第 1 层，即网络输入层。
layer1 网络第 2 层，常称作隐藏层，这里只一个隐藏层，也作为输出层。
weights 第一层权值，连接 layer0 层与layer1 层。
* 元素相乘，故两等长向量相乘等同于其对等元素分别相乘，结果为同等长度的向量。
– 元素相减，故两等长向量相减等同于其对等元素分别相减，结果为同等长度的向量。
x.dot(y) 若 x 和 y 为向量，则进行点积操作；若均为矩阵，则进行矩阵相乘操作；若其中之一为矩阵，则进行向量与矩阵相乘操作。

在这里，激活函数使用“sigmoid” 非线性函数。Sigmoid 函数可以将任何值映射到一个位于 0 到 1 范围内的值。

当形参 deriv 为 True 时，对sigmod 函数进行求导计算。数学推导不做要求，了解求导计算的用途作用即可。

2 层神经网络：

ANN_V1代码：

import numpy as np

# sigmoid function
def nonlin(x,deriv=False):
    if(deriv==True): #在Backward Propagation的时候使用，来判断哪些Features对当前的误差结果负有更大的Responsibility
        return x*(1-x)
    return 1/(1+np.exp(-x)) #在Forward Propagation中的激活函数
    
# 凡是用Numpy定义的二维数组都是Matrix,但是你也可以使用Numpy声明最简单的Array一维数组。
# X是我们输入的Dataset，里面包含了4行数据，每一行数据都是一个Training Example
X = np.array([  [0,0,1],
                [0,1,1],
                [1,0,1],
                [1,1,1] ])
    
# 真实的输出值，因为我们Features一共有4条数据，所以这里使用Matrix的Transpose操作，这样就把Row变成了Column  
# 输出值，这里是Training Example对应的输出结果的比较值，也就是说我们使用y中的相应的每一个值来作为评判标准。         
y = np.array([[0,0,1,1]]).T

# seed random numbers to make calculation
# deterministic (just a good practice)
np.random.seed(1) #是的每次的随机值都是一样的，方便学习观察

# 初始化Weights，必须是矩阵，因为Input中的每一个Neuron中包含的元素值都是矩阵X中的当前训练的一条数据中的一列
#这里的*是指把2乘以随机产生的三行一列的矩阵中的每一个元素
#这里的-是指把这个三行一列的矩阵中的每一个元素都减1
weights = 2 * np.random.random((3,1)) - 1 
for iter in range(10000): #这里的10000是指10000个Epoch

    # forward propagation
    layer0 = X #layer0是整个Neuron Network的第一层，也就是Input Layer
    layer1 = nonlin(np.dot(layer0,weights)) #Hidden Layer，根据Dot的结果第一个Hidden Layer有4个Neurons

    # how much did we miss?
    l1_error = y - layer1 #求出每一个训练值的误差

    # multiply how much we missed by the 
    # slope of the sigmoid at the values in layer1
    l1_delta = l1_error * nonlin(layer1,True)

    # update weights
    weights += np.dot(layer0.T,l1_delta) #三行四列乘以四行一列就变成了三行一列，而这个和我们初始化后的Weights的三行一列是一致的，所以可以进行矩阵的加法操作
    

print ("Output After Training:")
print (layer1)

ANN_V1运行结果：

Output After Training:
[[0.00966449]
 [0.00786506]
 [0.99358898]
 [0.99211957]]

3 层神经网络：

ANN_V2.py

# -*- coding: utf-8 -*-
import numpy as np

def nonlin(x,deriv=False):
	if(deriv==True):
	    return x*(1-x)

	return 1/(1+np.exp(-x))
    
X = np.array([[0,0,1],
            [0,1,1],
            [1,0,1],
            [1,1,1]])
                
y = np.array([[0],
			[1],
			[1],
			[0]])

np.random.seed(1)

# randomly initialize our weights with mean 0
syn0 = 2*np.random.random((3,4)) - 1
syn1 = 2*np.random.random((4,1)) - 1

for j in range(60000):

	# Feed forward through layers 0, 1, and 2
    l0 = X
    l1 = nonlin(np.dot(l0,syn0))
    l2 = nonlin(np.dot(l1,syn1))

    # how much did we miss the target value?
    l2_error = y - l2
    
    if (j% 10000) == 0:
        print ("Error:" + str(np.mean(np.abs(l2_error))))
        
    # in what direction is the target value?
    # were we really sure? if so, don't change too much.
    l2_delta = l2_error*nonlin(l2,deriv=True)

    # how much did each l1 value contribute to the l2 error (according to the weights)?
    l1_error = l2_delta.dot(syn1.T)
    
    # in what direction is the target l1?
    # were we really sure? if so, don't change too much.
    l1_delta = l1_error * nonlin(l1,deriv=True)

    syn1 += l1.T.dot(l2_delta)
    syn0 += l0.T.dot(l1_delta)

print (l2)

ANN_V2.py运行结果：

Error:0.49641003190272537
Error:0.008584525653247159
Error:0.0057894598625078085
Error:0.004629176776769985
Error:0.003958765280273649
Error:0.0035101225678616766

[[0.00260572]
 [0.99672209]
 [0.99701711]
 [0.00386759]]