第一次简单实现神经网络

最新推荐文章于 2023-07-07 10:44:28 发布

Hellsegamosken

最新推荐文章于 2023-07-07 10:44:28 发布

阅读量663

点赞数 5

分类专栏：算法解析实践记录文章标签：神经网络机器学习 python

本文链接：https://blog.csdn.net/DT_Kang/article/details/109078018

版权

算法解析同时被 2 个专栏收录

53 篇文章 0 订阅

订阅专栏

实践记录

14 篇文章 2 订阅

订阅专栏

好久不见！
推荐知乎上的三篇回答：一二三
 关于反向传播

搞了一下午终于搞懂了神经网络的基本基本基本原理。上面说的 45 分钟搞懂真的是太搞了。于是临摹了某位大神的代码（一模一样）并做了些解释。这个两层的网络主要任务是根据读入的身高体重来判断男女。

我们都知道，神经网络的每个节点的输出是前一层的每个节点的输出的加权和，加上某个偏置，再经过激活函数得到的。经过激活函数的目的是使运算变得不再线性，否则无论多少层的神经网络都可以简化为一层。这个函数有很多种，这里用 sigmoid 函数，并且在后面还需要用到它的导数：

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def deriv_sigmoid(x):
    y = sigmoid(x)
    return y * (1 - y)

我们还知道，神经网络分为训练和使用部分。而训练则可以看做不断使用+调整参数（权重和偏置）的过程。

神经网络的使用相对简单，将每一层的点值看做一个向量的话，层于层之间的转移就可以利用矩阵乘法实现。但初学 python 还不清楚矩阵和向量的写法，就手动展开了。为了方便，我们写成一个类。这个类包含 __init__ feedforward train 三个函数，后面会一一提到。

class NeuralNetwork:
    '''
    the network includes:
    - 2 inputs
    - 1 hidden layer with 2 neurons (h1, h2)
    - 1 output layer with 1 neurons (o1)
    '''
    def __init__(self):
        # later maybe it will be rewrite by the use of vector
        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()
        
        self.b1 = np.random.normal()
        self.b2 = np.random.normal()
        self.b3 = np.random.normal()
        
    def feedforward(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

这里要注意，这个代码中输出层仅有一个节点，而大多数神经网络中往往有多个输出节点。为了获得某个点成为答案的概率，我们需要对输出正规化。第 k 个点成为答案的概率为：
$p_k=\frac{e^{o_k}}{\sum_i e^{o_i}}$
这个式子的来源和合理性我并不清楚…

如果是使用的话，根据返回的 pi 最大的点就可以得出结果了。如果是训练，我们还要根据这个结果对网络进行修正。设我们得出的 p 为 p_pred，正确的概率为 p_true（p_pred，p_true 都是向量），对于某个测试集，定义平均方差 MSE 为：
$\frac 1n \sum(p_{pred_i}-p _{true_i})^2$
为了使我们的网络更准确，我们希望最小化这个式子，方法是调整权重 w 和偏置 b，因为只有 w 和 b 使我们设定的。

事实上，MSE 函数可以看做是一个多元函数 $F(w_1,w_2,...,b_1,b_2,...)$ ，为了得知每个元的改变对整体的影响情况，可以分别对每个元求偏导。具体的链式求导过程在上面反向传播的链接里讲得很清楚，就不多赘述了。根据求导的结果对每个参数进行修改，这样迭代多次，就完成了对神经网络的训练。这个过程成为反向传播，我认为是一个神经网络的灵魂。因为没有用矩阵，代码十分繁琐。


    def train(self, data, all_y_trues):
        learn_rate = 0.3
        epochs = 1000 # number of iteration

        for epoch in range(epochs):
            for x, y_true in zip(data, all_y_trues):
                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)
                y_pred = o1

                dl_dypred = -2 * (y_true - y_pred)

                # o1
                # dy_dx means dy/dx
                dypred_dw5 = h1 * deriv_sigmoid(sum_o1)
                dypred_dw6 = h2 * deriv_sigmoid(sum_o1)
                dypred_db3 = deriv_sigmoid(sum_o1)

                dypred_dh1 = self.w5 * deriv_sigmoid(sum_o1)
                dypred_dh2 = self.w6 * deriv_sigmoid(sum_o1)

                # h1
                dh1_dw1 = x[0] * deriv_sigmoid(sum_h1)
                dh1_dw2 = x[1] * deriv_sigmoid(sum_h1)
                dh1_db1 = deriv_sigmoid(sum_h1)

                # h2
                dh2_dw3 = x[0] * deriv_sigmoid(sum_h2)
                dh2_dw4 = x[1] * deriv_sigmoid(sum_h2)
                dh2_db2 = deriv_sigmoid(sum_h2)

                # update
                # h1
                self.w1 -= learn_rate * dl_dypred * dypred_dh1 * dh1_dw1
                self.w2 -= learn_rate * dl_dypred * dypred_dh1 * dh1_dw2
                self.b1 -= learn_rate * dl_dypred * dypred_dh1 * dh1_db1

                # h2
                self.w3 -= learn_rate * dl_dypred * dypred_dh2 * dh2_dw3
                self.w4 -= learn_rate * dl_dypred * dypred_dh2 * dh2_dw4
                self.b2 -= learn_rate * dl_dypred * dypred_dh2 * dh2_db2

                # o1
                self.w5 -= learn_rate * dl_dypred * dypred_dw5
                self.w6 -= learn_rate * dl_dypred * dypred_dw6
                self.b3 -= learn_rate * dl_dypred * dypred_db3

            if epoch % 10 == 0:	# to see the process of training
                y_preds = np.apply_along_axis(self.feedforward, 1, data)
                loss = mse_loss(all_y_trues, y_preds)
                print("Epoch %d loss: %.3f" % (epoch, loss))

这里也有两个需要注意的地方。
一是代码中的learn_rate，指的是学习速率。如果不加以限制，对参数的改变很可能“过火”，导致直接越过更优的取值。
二是这个代码没有加入正则化的过程。正则化的存在是为了防止网络过度拟合。因为用来训练的数据集大小是有限的，如果不加入正则化很有可能导致训练出来的网络只对这个单一训练集拟合得很好，但对于普通的数据拟合效果不佳。然而具体如何正则化我还没有搞懂。

到这里，一个最简单的神经网络类就构建完成了。接下来的事情就非常轻松了。

完整代码：

import numpy as np

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def deriv_sigmoid(x):
    y = sigmoid(x)
    return y * (1 - y)

def mse_loss(y_true, y_pred):
    return ((y_true - y_pred)**2).mean()

class NeuralNetwork:
    '''
    the network includes:
    - 2 inputs
    - 1 hidden layer with 2 neurons (h1, h2)
    - 1 output layer with 1 neurons (o1)
    '''
    def __init__(self):
        # later maybe we can use vector to rewrite
        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()
        
        self.b1 = np.random.normal()
        self.b2 = np.random.normal()
        self.b3 = np.random.normal()
        

    def feedforward(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, all_y_trues):
        learn_rate = 0.3
        epochs = 1000 # number of iteration

        for epoch in range(epochs):
            for x, y_true in zip(data, all_y_trues):
                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)
                y_pred = o1

                dl_dypred = -2 * (y_true - y_pred)

                # o1
                # dy_dx means dy/dx
                dypred_dw5 = h1 * deriv_sigmoid(sum_o1)
                dypred_dw6 = h2 * deriv_sigmoid(sum_o1)
                dypred_db3 = deriv_sigmoid(sum_o1)

                dypred_dh1 = self.w5 * deriv_sigmoid(sum_o1)
                dypred_dh2 = self.w6 * deriv_sigmoid(sum_o1)

                # h1
                dh1_dw1 = x[0] * deriv_sigmoid(sum_h1)
                dh1_dw2 = x[1] * deriv_sigmoid(sum_h1)
                dh1_db1 = deriv_sigmoid(sum_h1)

                # h2
                dh2_dw3 = x[0] * deriv_sigmoid(sum_h2)
                dh2_dw4 = x[1] * deriv_sigmoid(sum_h2)
                dh2_db2 = deriv_sigmoid(sum_h2)

                # update
                # h1
                self.w1 -= learn_rate * dl_dypred * dypred_dh1 * dh1_dw1
                self.w2 -= learn_rate * dl_dypred * dypred_dh1 * dh1_dw2
                self.b1 -= learn_rate * dl_dypred * dypred_dh1 * dh1_db1

                # h2
                self.w3 -= learn_rate * dl_dypred * dypred_dh2 * dh2_dw3
                self.w4 -= learn_rate * dl_dypred * dypred_dh2 * dh2_dw4
                self.b2 -= learn_rate * dl_dypred * dypred_dh2 * dh2_db2

                # o1
                self.w5 -= learn_rate * dl_dypred * dypred_dw5
                self.w6 -= learn_rate * dl_dypred * dypred_dw6
                self.b3 -= learn_rate * dl_dypred * dypred_db3

            if epoch % 10 == 0:	# to see the process of training
                y_preds = np.apply_along_axis(self.feedforward, 1, data)
                loss = mse_loss(all_y_trues, y_preds)
                print("Epoch %d loss: %.3f" % (epoch, loss))


data = np.array([
    [-2, -1],
    [25, 6],
    [17, 4],
    [-15, -6],
])
all_y_trues = np.array([
    1,
    0,
    0,
    1,
])  

network = NeuralNetwork()
network.train(data, all_y_trues)

kang = np.array([15, 5])    # myself
tmp = network.feedforward(kang)
gender = 'Male'
if tmp > 0.5: 
    gender = 'Female'
print('Kang:',gender)

Hellsegamosken

关注

5
点赞
踩
3

收藏

觉得还不错? 一键收藏
1
评论
第一次简单实现神经网络

好久不见！推荐知乎上的三篇回答：一二三关于反向传播：https://my.oschina.net/90888/blog/1584009搞了一下午终于搞懂了神经网络的基本基本基本原理。上面说的 45 分钟搞懂真的是太搞了。于是临摹了某位大神的代码（一模一样）并做了些解释。这个两层的网络主要任务是根据读入的身高体重来判断男女。我们都知道，神经网络的每个节点的输出是前一层的每个节点的输出的加权和，加上某个偏置，再经过激活函数得到的。经过激活函数的目的是使运算变得不再线性，否则无论多少层的神经网络都可以
复制链接

扫一扫