神经网络的入门

到放弃（bushi）

本文主要内容参考：

https://zhuanlan.zhihu.com/p/58964140

https://victorzhou.com/blog/intro-to-neural-networks/

一、先做一个神经元

我们就先做一个最简单的神经元，这个神经元有两个输入，接受到输入后就会向前产生一个传递（在这里要说一句话，神经网络中我们把得到结果的方向叫做前，有的人可能习惯把得到结果的方向理解成向后，这个地方要稍微注意一下）

graph TD;
    输入1-->神经元
    输入2-->神经元
    神经元-->产生传递

按说神经元应该会有两个权值w1,w2，给输入加权相乘，然后加上一个偏差就可以了

比如：

输入为x1,x2

权值为w1,w2

偏移为b

我们可以得到一个激活函数的输入：x1*w1+x2*w2+b

然后得到激活函数的结果:y=f(x1*w1+x2*w2+b)

我们这样是为了将这个输出给压缩到(0,1)之间，至于为啥非要用sigmoid函数，我也不知道，人家就是这么用的，而且人家做出来就是有效，废物Rytter的编程法则，没必要了解为什么，只要会用并且能去解决问题就行。搞理论是天才该干的事，我们的任务是用好天才的理论。

然后我们创建一个神经元!

神经元代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import numpy as np


def sigmoid(x):
    # 这就是sigmoid函数，就是前几篇文章写的
    return 1 / (1 + np.exp(-x))


class Neuron:
    # 大家好老子TMD就是神经元，是你永远的梦魇
    def __init__(self, weights, bias):
        self.weights = weights
        self.bias = bias

    def feedforward(self, inputs):
        # 这个就是向前输出的函数
        total = np.dot(self.weights, inputs) + self.bias
        return sigmoid(total)

# 这是程序运行的入口
weights = np.array([0, 1])  # ww1=0,w2=1
bias = 4  # b=4
n = Neuron(weights, bias)

x = np.array([2, 3])  # x1=2,x2=3
print(n.feedforward(x))

上面我们简单做了一个神经元的代码，这个小东西就是神经网络的基础（也是你一切痛苦的源泉）

然后我们将神经元做成一个简单的神经网络

二、简单的神经网络

我们要做的其实很简单，我们只需要把三个神经元给结合起来，前两个输出作为后一个输入就行。

具体代码加注释在下面（我正常敲代码绝不会加这么详细的注释，我最讨厌的两件事：敲代码时加注释。看别人代码时别人没加注释）

神经网络代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
import numpy as np


def sigmoid(x):
    # 这就是sigmoid函数，就是前几篇文章写的
    return 1 / (1 + np.exp(-x))


class Neuron:
    # 大家好老子TMD就是神经元，是你永远的梦魇
    def __init__(self, weights, bias):
        self.weights = weights
        self.bias = bias

    def feedforward(self, inputs):
        # 这个就是向前输出的函数
        total = np.dot(self.weights, inputs) + self.bias
        return sigmoid(total)


class NeuralNetwork:
    # 这个类是神经网络类
    # 我们使用这个类来构建神经网络
    def __init__(self):
        weights = np.array([0, 1])  # 神经网络的权重
        bias = 0  # 神经网络的偏移

        # 我们先创建几个神经元，就是对神经元进行初始化
        self.h1 = Neuron(weights, bias)
        self.h2 = Neuron(weights, bias)
        self.o1 = Neuron(weights, bias)

    def feedforward(self,x):
        # 这是得到结果的函数
        out_h1 = self.h1.feedforward(x)
        out_h2 = self.h2.feedforward(x)

        # 前两个输出作为后一个的输入
        out_o1 = self.o1.feedforward(np.array([out_h1, out_h2]))
        # 返回最后的一个输出
        return out_o1

# 开始创建神经网络，并设置初始的输入
network = NeuralNetwork()
x = np.array([2, 3])

print(network.feedforward(x)) # 0.7216325609518421

很简单，不是吗

三、训练一个神经网络

那么神经网络到底有神马用处，不要急，这里就有一个例子

我们现在有这样一个数据

姓名 体重（磅） 身高(英寸) 性别
Alice 133 65 F
Bob 160 72 M
Charlie 152 70 M
Diana 120 60 F

然后我们以上面那个神经网络为基础进行训练，示意图如下

我们对上面的数据进行一下简单的处理，让它更好处理

姓名 体重（磅） 身高(英寸) 性别
Alice -2 -1 1
Bob 25 6 0
Charlie 17 4 0
Diana -15 -6 1

我们分别以135和66为基准进行操作（一般来说我们都会以平均值来操作）

损失计算，loss的计算

如果你想得到好的结果，你得先知道什么样的算好的结果，大概好到什么程度，最好是有一个东西能进行量化计算，这就是神经网络的一个重要的方面，损失的计算

我们可以使用平均方差（MSE）来计算损失：MSE=$\frac{1}{n} \sum_{i=1}^n (y_{true}-y_{pred})^2$,简单解释一下：

  1. n是总的个数
  2. $y_{true}$是真实值
  3. $y_{pred}$是预测值

然后我们就是通过这样一个公式来计算方差的平均值，预测的越好，loss越趋向于0

我们训练的目的就是找到更好的一个权值与偏移使最终的loss最小。

我们举个例子，加入我们最终的结果是预测出来是[0，0，0，0]，那么最终的结果损失是

$MSE=\frac{1}{4}(1+0+0+1)=0.5$

MSE计算代码

1
2
3
4
5
6
7
8
9
10
11
12
import numpy as np


def mse_loss(y_true, y_pred):
    # y_true 和y_pred 是结果的数组
    return ((y_true - y_pred) ** 2).mean()


y_true = np.array([1, 0, 0, 1]) # 产生实际的数组
y_pred = np.array([0, 0, 0, 0]) # 产生结果的数组

print(mse_loss(y_true, y_pred))

运行结果

0.5

对权值和截距项进行改变

老逼登握拳-大的要来了。

之前我们说过，训练神经网路的办法就是想办法改变权值和截距项，减少损失，让神经网络更加匹配真实的结果。

这个的方法其实很简答，我并不打算具体去给数学公式去讲，如果有人想看数学公式的话可以去这篇文章看一下，做的特别详细，传送门：https://zhuanlan.zhihu.com/p/58964140

我就在这个地方简单讲一下基本的原理以及使用的方法，

首先根据上式，我们可以得到最终的loss与y_pred的一个关系，通过求导就能得到loss与y_pred的一个导数关系，然后y_pred又跟$w_i$与$b_i$有函数关系，进而我们可以得到y_pred和$w_i \ and \ b_i$的导数关系，有了导数关系，我们就可以得到y_pred跟截距与权值是怎么的一个变化关系，我们就可以根据这样的变化关系来确定截距和权值的值，然后进行更新，使损失函数最小，结果更加精准。

根据求导规则，sigmoid函数的导数为$\sigma’(x)=\sigma(x)*(1-\sigma(x))$。

我们就举个例子来计算一下$\frac{\partial L}{\partial w_1}$:

$\frac{\partial L}{\partial w_1}=\frac{\partial L}{\partial y_{pred}}\frac{\partial y_{pred}}{\partial h_1}\frac{\partial h_1}{\partial w_1}$

例子就举完了（好像有点短），不过问题不大，因为没有多少人喜欢去看着数学公式去具体理解，我们是程序员，不是数学家，我们是要会用，不一定要完全理解学会。

接下来就是训练的代码了

训练神经网络的代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
import numpy as np



def sigmoid(x):
    # 这是sigmoid函数
    return 1 / (1 + np.exp(-x))


def deriv_sigmoid(x):
    # 这是sigmoid函数的导数
    fx = sigmoid(x)
    return fx * (1 - fx)


def mse_loss(y_true, y_pred):
    # 这是计算损失函数的
    return ((y_true - y_pred) ** 2).mean()


class NeuralNetwork:
    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()

    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.1  # 这个是学习率
        epochs = 1000  # 这是我们的训练次数

        for epoch in range(epochs):
            for x, y_true in zip(data, all_y_trues):
                # zip函数是一个打包的函数，就是让x,y_true分别是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

                d_L_d_ypred = -2 * (y_true - y_pred)
                # 神经元1号
                d_ypred_d_w5 = h1 * deriv_sigmoid(sum_o1)
                d_ypred_d_w6 = h2 * deriv_sigmoid(sum_o1)
                d_ypred_d_b3 = deriv_sigmoid(sum_o1)

                d_ypred_d_h1 = self.w5 * deriv_sigmoid(sum_o1)
                d_ypred_d_h2 = self.w6 * deriv_sigmoid(sum_o1)

                # 神经元1号
                d_h1_d_w1 = x[0] * deriv_sigmoid(sum_h1)
                d_h1_d_w2 = x[1] * deriv_sigmoid(sum_h1)
                d_h1_d_b1 = deriv_sigmoid(sum_h1)

                # 神经元2号
                d_h2_d_w3 = x[0] * deriv_sigmoid(sum_h2)
                d_h2_d_w4 = x[1] * deriv_sigmoid(sum_h2)
                d_h2_d_b2 = deriv_sigmoid(sum_h2)

                # 更新数据
                # 神经元1
                self.w1 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_w1
                self.w2 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_w2
                self.b1 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_b1

                # 神经元2
                self.w3 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h2_d_w3
                self.w4 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h2_d_w4
                self.b2 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h2_d_b2

                # 神经元输出
                self.w5 -= learn_rate * d_L_d_ypred * d_ypred_d_w5
                self.w6 -= learn_rate * d_L_d_ypred * d_ypred_d_w6
                self.b3 -= learn_rate * d_L_d_ypred * d_ypred_d_b3

            if epoch % 10 == 0:
                # 每十次输出一次
                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)

训练完成后我们就可以进行一个预测了，只需要在最后加上这样一段代码

1
2
rytter=np.array([你的身高与体重信息])
print("Rytter:%.3f" % network.feedforward(rytter))

事实上由于训练样本太少，所以训练的结果会有点偏差，比如有时它会把瘦高的rytter识别成女生（本人身高185，是真的，体重不到130）

好！这就是本文的全部内容了，喜欢的朋友可以点个赞，本人网站：www.xuanworld.top

欢迎一起来玩