Python 实现一个简单的神经网络（附代码）

大囚长

已于 2022-07-04 15:43:22 修改

阅读量4.2k

点赞数 13

分类专栏：机器学习黑客帝国文章标签： securecrt

于 2022-07-04 14:38:42 首次发布

原文链接：https://blog.csdn.net/weixin_43734080/article/details/122212654

版权

黑客帝国同时被 2 个专栏收录

67 篇文章 10 订阅

订阅专栏

机器学习

37 篇文章 4 订阅

订阅专栏

⭐前言⭐

以下内容我们用Python从头实现一个神经网络来理解神经网络的原理。

首先让我们看看神经网络的基本单位，神经元。神经元接受输入，对其做一些数据操作，然后产生输出。例如，这是一个2-输入神经元：

这里发生了三个事情。首先，每个输入都跟一个权重相乘（红色）：

$x_1\leftarrow x_1\times w_1$

$x_2\leftarrow x_2\times w_2$

然后，加权后的输入求和，加上一个偏差b（绿色）：

$(x_1\times w_1)+(x_2\times w_2)+b$

最后，这个结果传递给一个激活函数f：

$y=f(x_1\times w_1+x_2\times w_2+b)$

激活函数的用途是将一个无边界的输入，转变成一个可预测的形式。常用的激活函数就就是S型函数：

S型函数的值域是(0, 1)。简单来说，就是把(−∞, +∞)压缩到(0, 1) ，很大的负数约等于0，很大的正数约等于1。

📌一个简单的例子📌

假设我们有一个神经元，激活函数就是S型函数，其参数如下：

w=[0,1]，b=4

w=[0,1]就是以向量的形式表示w1=0，w2=1。现在，我们给这个神经元一个输入[2,3]。我们用点积来表示：

$y=f(w\cdot x+b)=f(7)=0.999$

当输入是[2, 3]时，这个神经元的输出是0.999。给定输入，得到输出的过程被称为前馈（feedforward）。

📌编码一个神经元 📌

让我们来实现一个神经元！用Python的NumPy库来完成其中的数学计算：

import numpy as np
 
def sigmoid(x):
  # 我们的激活函数: f(x) = 1 / (1 + e^(-x))
  return 1 / (1 + np.exp(-x))
 
class Neuron:
  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]) # w1 = 0, w2 = 1
bias = 4                   # b = 4
n = Neuron(weights, bias)
 
x = np.array([2, 3])       # x1 = 2, x2 = 3
print(n.feedforward(x))    # 0.9990889488055994

📌把神经元组装成网络 📌

所谓的神经网络就是一堆神经元。这就是一个简单的神经网络：

这个网络有两个输入，一个有两个神经元（ $h_1$ 和 $h_2$ ）的隐藏层，以及一个有一个神经元（ $o_1$ ) ）的输出层。要注意， $o_1$ 的输入就是 $h_1$ 和 $h_2$ 的输出，这样就组成了一个网络。

隐藏层就是输入层和输出层之间的层，隐藏层可以是多层的。

📌例子：前馈📌

我们继续用前面图中的网络，假设每个神经元的权重都是，截距项也相同，激活函数也都是S型函数。分别用表示相应的神经元的输出。

当输入 x=[2,3]时，会得到什么结果？

这个神经网络对输入[2,3]的输出是0.7216，很简单。

📌编码神经网络：前馈📌

import numpy as np
 
# ... code from previous section here
 
class OurNeuralNetwork:
  '''
  A neural network with:
    - 2 inputs
    - a hidden layer with 2 neurons (h1, h2)
    - an output layer with 1 neuron (o1)
  Each neuron has the same weights and bias:
    - w = [0, 1]
    - b = 0
  '''
  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)
 
    # o1的输入是h1和h2的输出
    out_o1 = self.o1.feedforward(np.array([out_h1, out_h2]))
 
    return out_o1
 
network = OurNeuralNetwork()
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

接下来我们用这个数据来训练神经网络的权重和截距项，从而可以根据身高体重预测性别：

我们用0和1分别表示男性（M）和女性（F），并对数值做了转化：

姓名	体重 (减 135)	身高 (减 66)	性别
Alice	-2	-1	1
Bob	25	6	0
Charlie	17	4	0
Diana	-15	-6	1

我这里是随意选取了135和66来标准化数据，通常会使用平均值。

📌损失📌

在训练网络之前，我们需要量化当前的网络是『好』还是『坏』，从而可以寻找更好的网络。这就是定义损失的目的。

我们在这里用平均方差（MSE）损失：，让我们仔细看看：

n是样品数，这里等于4（Alice、Bob、Charlie和Diana）。
y表示要预测的变量，这里是性别。
$y_{true}$ 是变量的真实值（『正确答案』）。例如，Alice的 $y_{true}$ 就是1（男性)。
$y_{pred}$ 变量的预测值。这就是我们网络的输出。

$(y_{true}-y_{pred})^{2}$ 被称为方差（squared error）。我们的损失函数就是所有方差的平均值。预测效果于浩，损失就越少。

更好的预测 = 更少的损失！

训练网络 = 最小化它的损失。

📌损失计算例子📌

假设我们的网络总是输出0，换言之就是认为所有人都是男性。损失如何？

Name	y_true	(y_true - y_pred)^2
Alice	1	1
Bob	0	0
Charlie	0	0
Diana	1	1

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

📌代码：MSE损失📌

下面是计算MSE损失的代码：

import numpy as np
 
def mse_loss(y_true, y_pred):
  # y_true and y_pred are numpy arrays of the same length.
  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

如果你不理解这段代码，可以看看NumPy的快速入门中关于数组的操作。

📌训练神经网络第二部分📌

现在我们有了一个明确的目标：最小化神经网络的损失。通过调整网络的权重和截距项，我们可以改变其预测结果，但如何才能逐步地减少损失？

这一段内容涉及到多元微积分，如果不熟悉微积分的话，可以跳过这些数学内容。

这一段内容涉及到多元微积分，如果不熟悉微积分的话，可以跳过这些数学内容。

为了简化问题，假设数据集中只有Alice，那均方差损失就只是Alice的方差：

$MSE=\frac{1}{1}\sum_{i=1}{1}(y_{true}-y_{pred}){2}=1$

也可以把损失看成是权重和截距项的函数。让我们给网络标上权重和截距项：

这样我们就可以把网络的损失表示为：

$L(w_1,w_2,w_3,w_4,w_5,w_6,b_1,b_2,b_3)$

假设我们要优化 $w_1$ ，当我们改变 $w_1$ 时，损失 $L$ 会怎么变化？可以用 $\frac{\partial L}{\partial w_1}$ 来回答这个问题，怎么计算？

首先，让我们用 $\frac{\partial y_{pred}}{\partial w_1}$ 来改写这个偏导数：

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

因为我们已经知道 $L=(1-y_{pred})^{2}$ ，所以我们可以计算 $\frac{\partial L}{\partial y_{pred}}$

$\frac{\partial L}{\partial y_{pred}}=\frac{\partial (1-y_{pred})^{2}}{\partial y_{pred}}=-2(1-y_{pred})$

现在让我们来搞定 $\frac{\partial y_{pred}}{\partial w_1}$ 。 $h_1,h_2,o_1$ 分别是其所表示的神经元的输出，我们有：

$y_{pred}=o_1=f(w_5h_1+w_6h_2)+b_3$

由于 $w_1$ 只会影响 $h_1$ （不会影响 $h_2$ )，所以：

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

$\frac{\partial y_{pred}}{\partial h_1}=w_5\ast f'{(w_5h_1+w_6h_2+b_3)}$

对 $\frac{\partial h_1}{\partial w_1}$ ，我们也可以这么做：

$h_1=f(w_1x_1+w_2h_2+b_1)$

$\frac{\partial h_1}{\partial w_1}=x_1\ast f'({w_1x_1+w_2x_2+b_1})$

在这里， $x_1$ 是身高， $x_2$ 是体重。这是我们第二次看到 $f{}'(x)$ （S型函数的导数)了。求解：

$f(x)=\frac{1}{1-e^{-x}}$

$f{}'(x)=\frac{e{-x}}{(1-e{-x})^{2}}=f(x)\ast (1-f(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}$

这种计算偏导的方法叫『反向传播算法』(backpropagation)。

好多数学符号，如果你还没搞明白的话，我们来看一个实际例子。

📌例子：计算偏导数📌

我们还是看数据集中只有Alice的情况：

把所有的权重和截距项都分别初始化为1和0。在网络中做前馈计算：

$h_1=f(w_1x_1+w_2x_2+b_1)=f(-2+-1+0)=0.0474$

$h_1=f(w_3x_1+w_4x_2+b_2)=f(-2+-1+0)=0.0474$

$o_1=f(w_5h_1+w_6h_2+b_3)=f(0.0474+0.0474+0)=0.524$

网络的输出是 $pred=0.524$ ，对于Male(0)或者Female(1)都没有太强的倾向性。算一下 $\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}$

$\frac{\partial L}{\partial y_{pred}}=\frac{\partial (1-y_{pred})^{2}}{\partial y_{pred}}=-2(1-y_{pred})=-2(1-0.524)=-0.952$

$\frac{\partial y_{pred}}{\partial h_1}=1\ast f'{(w_5h_1+w_6h_2+b_3)}=w_5\ast f'{(0.0474+0.0474+0)}$

$=f(0.0948)f(1-f(0.0948))=0.249$

$\frac{\partial h_1}{\partial w_1}=x_1\ast f'({w_1x_1+w_2x_2+b_1})=-2f{}'({-2+-1+0})$

$=-2f(-3)(1-f(-3))=-0.0904$

$\frac{\partial L}{\partial w_1}=-0.952\ast 0.249\ast (-0.0904)=0.0214$

提示：前面已经得到了S型激活函数的导数 $f{}'(x)=f(x)\cdot (1-f(x))$ 。

搞定！这个结果的意思就是增加 $w_1$ ， $L$ 也会随之轻微上升。

现在训练神经网络已经万事俱备了！我们会使用名为随机梯度下降法的优化算法来优化网络的权重和截距项，实现损失的最小化。核心就是这个更新公式：

$w_1\leftarrow w_1-\eta \frac{\partial L}{\partial w_1}$

$\eta$ 是一个常数，被称为学习率，用于调整训练的速度。我们要做的就是用 $w_1$ 减去 $\eta \frac{\partial L}{\partial w_1}$

我们的训练过程是这样的：

从我们的数据集中选择一个样本，用随机梯度下降法进行优化——每次我们都只针对一个样本进行优化；
计算每个权重或截距项对损失的偏导（例如 $\frac{\partial L}{\partial w_1}$ 、 $\frac{\partial L}{\partial w_2}$ 等)；
用更新等式更新每个权重和截距项；
重复第一步；

📌代码：一个完整的神经网络📌

我们终于可以实现一个完整的神经网络了：

姓名	身高 (减 135)	体重 (减 66)	Gender
Alice	-2	-1	1
Bob	25	6	0
Charlie	17	4	0
Diana	-15	-6	1

总体代码

import numpy as np
 
def sigmoid(x):
  # Sigmoid activation function: f(x) = 1 / (1 + e^(-x))
  return 1 / (1 + np.exp(-x))
 
def deriv_sigmoid(x):
  # Derivative of sigmoid: f'(x) = f(x) * (1 - f(x))
  fx = sigmoid(x)
  return fx * (1 - fx)
 
def mse_loss(y_true, y_pred):
  # y_true和y_pred是相同长度的numpy数组。
  return ((y_true - y_pred) ** 2).mean()
 
class OurNeuralNetwork:
  '''
  A neural network with:
    - 2 inputs
    - a hidden layer with 2 neurons (h1, h2)
    - an output layer with 1 neuron (o1)
  *** 免责声明 ***:
    下面的代码是为了简单和演示，而不是最佳的。
    真正的神经网络代码与此完全不同。不要使用此代码。
    相反，读/运行它来理解这个特定的网络是如何工作的。
  '''
  def __init__(self):
    # 权重，Weights
    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):
    # X是一个有2个元素的数字数组。
    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):
    '''
    - data is a (n x 2) numpy array, n = # of samples in the dataset.
    - all_y_trues is a numpy array with n elements.
      Elements in all_y_trues correspond to those in data.
    '''
    learn_rate = 0.1
    epochs = 1000 # 遍历整个数据集的次数
 
    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
 
        # --- 计算偏导数。
        # --- Naming: d_L_d_w1 represents "partial L / partial w1"
        d_L_d_ypred = -2 * (y_true - y_pred)
 
        # Neuron o1
        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)
 
        # Neuron h1
        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)
 
        # Neuron h2
        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)
 
        # --- 更新权重和偏差
        # Neuron h1
        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
 
        # Neuron h2
        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
 
        # Neuron o1
        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
 
      # --- 在每次epoch结束时计算总损失 
      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],  # Alice
  [25, 6],   # Bob
  [17, 4],   # Charlie
  [-15, -6], # Diana
])
all_y_trues = np.array([
  1, # Alice
  0, # Bob
  0, # Charlie
  1, # Diana
])
 
# 训练我们的神经网络!
network = OurNeuralNetwork()
network.train(data, all_y_trues)

随着网络的学习，损失在稳步下降。

现在我们可以用这个网络来预测性别了：

# 做一些预测
emily = np.array([-7, -3]) # 128 磅, 63 英寸
frank = np.array([20, 2])  # 155 磅, 68 英寸
print("Emily: %.3f" % network.feedforward(emily)) # 0.951 - F
print("Frank: %.3f" % network.feedforward(frank)) # 0.039 - M

📌后话📌

搞定了一个简单的神经网络，快速回顾一下：

介绍了神经网络的基本结构——神经元；
在神经元中使用S型激活函数；
神经网络就是连接在一起的神经元；
构建了一个数据集，输入（或特征）是体重和身高，输出（或标签）是性别；
学习了损失函数和均方差损失；
训练网络就是最小化其损失；
用反向传播方法计算偏导；
用随机梯度下降法训练网络；

接下来你还可以：

用机器学习库实现更大更好的神经网络，例如TensorFlow、Keras和PyTorch；
在浏览器中实现神经网络；
其他类型的激活函数；
其他类型的优化器；
学习卷积神经网络，这给计算机视觉领域带来了革命；
学习递归神经网络，常用语自然语言处理；

附加一段代码

#!/usr/bin/pyton3

import numpy as np
import matplotlib.pyplot as plt
 
 
# Activation Function
def sigmoid(x):
    return 1 / (1 + np.exp(-x))
 
 
# Neural Unit
class Perceptron(object):
    def __init__(self, input_size: int, initializer: list = None, activation_func: str = None):
        # W[0] is the bias
        self.input_size = input_size
        # W is parameters of Perceptron
        self.n_W = self.input_size + 1
        self.W = np.random.uniform(low=0.0, high=1.0, size=self.n_W)
        # X is the input vector of Perceptron
        self.X = None
 
        self.output = 0.0
        self.delta_W = np.array([0] * self.n_W, dtype=np.float)
        self.delta_X = np.array([0] * input_size, dtype=np.float)
        self.activation_func = activation_func
        if initializer:
            assert len(initializer) == self.n_W
            self.W = initializer
 
    def forward(self, X):
        assert len(X) == self.input_size
        self.X = np.array(X, dtype=float)
        y = np.sum(self.W[1:] * self.X) + self.W[0]
        if self.activation_func == 'sigmoid':
            self.output = sigmoid(y)
        else:
            self.output = y
        return self.output
 
    def update(self, lr):
        self.W = self.W + lr * self.delta_W
        self.delta_W = np.array([0] * self.n_W, dtype=np.float)
 
    def __call__(self, X):
        return self.forward(X)
 
 
# Neural Layer
class Layer(object):
    def __init__(self, input_size: int, output_size: int, activation_func='sigmoid', lr=0.1):
        self.input_size = input_size
        self.output_size = output_size
        self.net = np.array(
            [Perceptron(input_size=input_size, activation_func=activation_func) for _ in range(output_size)])
        self.activation_func = activation_func
        self.inputs = np.array([0] * input_size, dtype=np.float)
        self.lr = lr
        self.outputs = np.array([0] * output_size, dtype=np.float)
 
    def forward(self, X):
        self.inputs = np.array(X, dtype=np.float)
        self.outputs = np.array([p(X) for p in self.net])
        return self.outputs
 
    def __call__(self, X):
        return self.forward(X)
 
    def backward(self, delta_outputs):
        assert len(delta_outputs) == len(self.net)
        for idx in range(self.output_size):
            delta_output = delta_outputs[idx]
            p = self.net[idx]
            o = self.outputs[idx]
            if self.activation_func == 'sigmoid':
                # W0 is the bias
                p.delta_W = delta_output * o * (1 - o) * np.array([1] + list(p.X))  # expand X for W_0
                p.delta_X = delta_output * o * (1 - o) * p.W[1:]
            else:
                # linear
                p.delta_W = delta_output * np.array([1] + list(p.X))
                # W0 is the bias
                p.delta_X = delta_output * p.W[1:]
 
    def update(self):
        for p in self.net:
            p.update(self.lr)
 
 
if __name__ == '__main__':
    # standard version ============================
    samples = [[[-2, -1], 1],
               [[25, 6], 0],
               [[17, 4], 0],
               [[-15, -6], 1]]
 
    # training
    layer1 = Layer(2, 10)
    layer2 = Layer(10, 1, activation_func='')
    for i in range(1000):
        # iteration
        print(f'iteration {i}')
        text_X = samples[3][0]
        text_y_d = samples[3][1]
        test_y = layer2(layer1((samples[3][0])))[0]
        print(f'X:{text_X}, y_d:{text_y_d}, y:{test_y}')
        for X, y_d in samples:
            # forward
            y = layer2(layer1(X))[0]
            # backward layer2 -> layer1
            err = y_d - y   # delta_outputs of layer 2
            layer2.backward([err])
 
            delta_outputs = np.array([0.0] * layer2.input_size, dtype=np.float)  # delta_outputs of layer 1
            for p in layer2.net:
                delta_outputs += p.delta_X
            layer1.backward(delta_outputs)
 
            # update gradient
            layer2.update()
            layer1.update()
 
    # result
    for X, y_d in samples:
        y = layer2(layer1(X))[0]
        print(f'The final result: X:{X}, y_d:{y_d}, y:{y}')
 
    # # simple version ============================
    # samples = [[[0, 1], 1],
    #            [[1, 0], -1]]
    # # training
    # layer1 = Layer(2, 1, activation_func='')
    # for i in range(100):
    #     # iteration
    #     print(f'iteration {i}')
    #     for X, y_d in samples:
    #         # forward
    #         y = layer1(X)[0]
    #         # backward
    #         err = y_d - y
    #         layer1.backward([err])
    #         print(f'W：{layer1.net[0].W}')
    #         print(f'delta_W：{layer1.net[0].delta_W}')
    #         layer1.update()
    #         print(f'X:{X}, y_d:{y_d}, y:{y}')