关于 神经网络 的理解

首语：

-学了一个多月的机器学习，对于神经网络才刚刚接触，感知机的实现相对好理解，但神经网络的逻辑较为复杂，在这做一个总结和思考。希望能得到各位大佬的指正。

感知机（神经元）

适合做简单的分类或线性方程， 如判断是不是正数， 无法处理复杂的多维特征
实现：参考

关键的感知机的参数优化方法：
wi = w + n(y- y_pre)xi
bi = b + n(y- y_pre)

神经网络的结构

多个神经元组成

正向传播

h = wi xi + bi

下面进行正向传播的代码实现

def sigmoid(x):
	return 1/(1 + np.exp(-x))
def loss_mse(y_true, y_pred):
	return ((y_true - y_pred) ** 2).mean()	
def re_sigmoid(x):
	fx = sigmoid(x)
	return fx * (1 - fx)
class Neural(object):
	def feed_forwad(self, x):
		h1 = sigmoid(w1 * x[0] + w2 * x[1] + b1)
		h2 = sigmoid(w2 * x[0] + w4 * x[1] + b2)
		o1 = sigmoid(h1 * w5 + h2 * w6 + b3)
		return o1
	

而反向传播的实现比较复杂，解释下， 我们要计算出Loss 对于所有参数的导数，即每个参数会影响到Loss 的变化大小， 然后不断调整参数大小，达到降低loss 的效果。

比如， 影响到打篮球的属性有身高和速度，我们想设计一个算法， 用来判断每个人的打篮球天赋，
通过导数得到 关于身高的比例为0.7， 速度为0.3， 不断调整参数，使得 准确度达到最高。

我们现在的目的就是求出所有的导数，先列出所有的关系函数

Loss = loss_mes = ((y - y') ** 2).mean() #y 和y '是矩阵形式
# dL/dy' = -2 (y - y')
# 往前推
y' = f(w5 * h1+ w6 * h2 + b3) # f为激活函数 h1, h2 为上个神经节点的输出
# dy'/dw5 = h1 * f'(x) 
# dy'/dw6 = h2 * f'(x) 
# dy'/db3 = f'(x) 
# dL/dw5 = dL/dy' * dy'/dw5 
# dL/dw6 = dL/dy' * dy'/dw6 
# dL/db3 = dL/dy' * dy'/db3

相同的 可以得出

h1 = f(w1 * x[0] + w2 * x[1] + b1)
h2 = f(w3 * x[0] + w4 * x[1] + b2)
dL/dw1 = dL/dy' * dy'/dh1 * dh1/dw1 
dh1/dw1 = x[0] * f'(x)
dh1/dw2 = x[1] * f'(x)
dh1/db1 = * f'(x)
dL/dw2 = dL/dy' * dy'/dh2 * dh2/dw2
dh2/dw3 = x[0] * f'(x)
dh2/dw4 = x[1] * f'(x)
dh1/db2 = * f'(x)

接下来 ，直接进行更新
wi = wi - rate * dwi

w1 -= rate * dl/dw1
.....

完整代码如下：

# 訓練神经网络进行性别的判定
import numpy as np
data = np.array([
  [-2, -1],  # Alice
  [25, 6],   # Bob
  [17, 4],   # Charlie
  [-15, -6], # Diana
])
all_y_trues = np.array([
  1, # Alice
  0, # Bob
  0, # Charlie
  1, # Diana
])
# 激活函数
def sigmoid(x):
    return 1/(1+np.exp(-x))

def deriv_sigmoid(x):
    fx = sigmoid(x)
    return fx * (1 - fx)
def loss_mse(y_true, y_pred):
# 均方误差 损失函数
    return  ((y_true - y_pred) ** 2).mean()
    
class Neural(object):
    def __init__(self):
        
        self.w1 = np.random.normal()
        self.w2 = np.random.normal()
        self.w3 = np.random.normal()
        self.w4 = np.random.normal()
        self.w5 = np.random.normal()
        self.w6 = np.random.normal()

        # 截距项，Biases
        self.b1 = np.random.normal()
        self.b2 = np.random.normal()
        self.b3 = np.random.normal()
        self.rate = 0.1
    def feed_forward(self, x):
        # 正向传播， 用于评估 损失函数
        h1 = sigmoid(self.w1 * x[0] + self.w2 * x[1] + self.b1)
        h2 = sigmoid(self.w3 * x[0] + self.w4 * x[1] + self.b2)
        o1 = sigmoid((self.w5 * h1 + self.w6 * h2 + self.b3))
        return o1
    def train(self, data, y_labels):
        learn_rate = 0.1
        epochs = 1000
        # 每次训练，将先正向传播，在计算损失函数， 然后反向传播，更新参数， ，在正向传播 目的就是为了降低损失函数的值
        for i in range(epochs):
            for (x, y_label) in zip(data, y_labels):
            #1、正向传播
                sum_h1 = self.w1 * x[0] + self.w2 * x[1] + self.b1
                h1 = sigmoid(sum_h1)

                sum_h2 = self.w3 * x[0] + self.w4 * x[1] + self.b2
                h2 = sigmoid(sum_h2)

                sum_o1 = self.w5 * h1 + self.w6 * h2 + self.b3
                o1 = sigmoid(sum_o1)
                
            #2、计算损失函数
                # 损失函数求导 1/n(y_true - y_pred) ** 2 = 0 + (-1) * 2 * (y_true - y_pred)
                dL_j = -2 * (y_label - o1)
            #3、 反向传播
                #dw1... dw6 
                #求j 的值
                #j = f(w5h1 + w6h2 + b3)
                #dj/dw5 = h1 * f' dj/dw6 = h2 * f'
                #dL/w5 = dL/j * dj/w5
                dl_w5 = dL_j * h1 * deriv_sigmoid(o1)
                dl_w6 = dL_j * h2 * deriv_sigmoid(o1)
                dl_b3 = dL_j * deriv_sigmoid(o1)
                #dl/h1 = dL/dj * dj/dh1 = da_j * w5
                dl_h1 = dL_j * self.w5 * deriv_sigmoid(o1)
                dl_h2 = dL_j * self.w6 * deriv_sigmoid(o1)
                
                #h1 = f(w1* x1 + w2 * x2 + b1)
                #h2 = f(w3 * x1 + w4 * x2 + b2)
                #dl/w1 = dl/j * dj/h1 * dh1/dw1
                dl_w1 = dL_j * dl_h1 * x[0] * deriv_sigmoid(h1)
                dl_w2 = dL_j * dl_h1 * x[1] * deriv_sigmoid(h1)
                dl_b1 = dL_j * dl_h1 * deriv_sigmoid(h1)
                dl_w3 = dL_j * dl_h2 * x[0] * deriv_sigmoid(h2)
                dl_w4 = dL_j * dl_h2 * x[1] * deriv_sigmoid(h2)
                dl_b2 = dL_j * dl_h2 * deriv_sigmoid(h2)
                #注： 因为b的求导都为1 所以直接更新为rate * b
                #4、 更新w, b
                self.w1 -= dl_w1 * learn_rate 
                self.w2 -= dl_w2 * learn_rate
                self.w3 -= dl_w3 * learn_rate
                self.w4 -= dl_w4 * learn_rate
                self.w5 -= dl_w5 * learn_rate
                self.w6 -= dl_w6 * learn_rate
                self.b1 -= dl_b1 * learn_rate
                self.b2 -= dl_b2 * learn_rate
                self.b3 -= dl_b3 * learn_rate
            if i % 10 == 0:
                y_preds = np.apply_along_axis(self.feed_forward, 1, data)
                loss = loss_mse(y_labels, y_preds)
                print("Epoch %d loss: %.3f" % (i, loss))
    # def __str__(self):
        # pass
       # return 'weights\t:%s\nbias\t:%f\n' % (np.array([self.w1, self.w2, self.w3, self.w4, self.w5, self.w6]), np.array([self.b1, self.b2, self.b3]))
                
neural = Neural()
neural.train(data, all_y_trues)
print(neural)
emily = np.array([-7, -3]) # 128 pounds, 63 inches
frank = np.array([20, 2])  # 155 pounds, 68 inches
print("Emily: %.3f" % neural.feed_forward(emily)) # 0.951 - F
print("Frank: %.3f" % neural.feed_forward(frank)) # 0.039 - M