学习记录_创建一个简单的神经网络

最新推荐文章于 2024-05-03 15:57:45 发布

爱吃芒果的小z

最新推荐文章于 2024-05-03 15:57:45 发布

阅读量61

点赞数 1

文章标签：学习神经网络人工智能

原文链接：https://victorzhou.com/blog/intro-to-neural-networks/

版权

学习过程基本上是对文档的翻译，参考视频讲解，此文为学习记录，方便日后回顾。大家可以直接看原文和视频讲解。侵权必删!

学习文档@Victor Zhou Machine Learning for Beginners: An Introduction to Neural Networks - victorzhou.com

学习视频@bilibili天外来课

【天外来课的个人空间-哔哩哔哩】 https://b23.tv/qzstdnb

一、构建模块

1.神经元输入x、权重W、偏置值b、激活函数f,一个完整的计算过程。

神经元，神经网络的基本单位。一个神经元接受输入，对它们进行一些计算，然后产生一个输出。这是一个双输入神经元的样子:

这个过程有三步计算。首先，每个输入乘以一个权重:

接下来，将所有加权输入与偏置b加在一起:

最后，这个和经过一个激活函数f得到y:

激活函数用于将无界输入转换为具有良好的可预测形式的输出。一个常用的激活函数是sigmoid函数:

2.前馈网络构建举例

一个简单的例子

假设我们有一个使用sigmoid激活函数的2个输入的神经元，并具有以下参数:

权重 w=[0,1]

偏置 b=4

W =[0,1]是w1=0， w2=1的向量形式。现在，给定神经元输入x=[2,3],x1=2,x2=3。用点积来把东西写得更简洁：

$(w\cdot x)+b=((w1\ast x1)+(w2\ast x2))+b =0\ast 2+1\ast 3+4 =7$

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

给定输入x=[2,3] 神经元输出0.999。这种将输入向前传递以获得输出的过程称为前馈。(之前一直不太懂什么是前向传播，什么是反向传播，看了这个例子后明白了什么是前向传播。反向传播后面也有说到。)

3.神经元的python代码实现

sigmoid(x)函数的计算公式如下：

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

import numpy as np


def sigmoid(x):  #定义激活函数sigmoid
  # Our activation function: 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):  #定义前向传播方法
    # Weight inputs, add bias, then use the activation function
    total = np.dot(self.weights, inputs) + self.bias  #对应公式 w·x+b
    return sigmoid(total)

#给定weights、bias，对Neuron类进行实例化
weights = np.array([0, 1]) # w1 = 0, w2 = 1
bias = 4                   # b = 4
n = Neuron(weights, bias)

#给定神经元输入x,将x传入并进行前向传播
x = np.array([2, 3])       # x1 = 2, x2 = 3
print(n.feedforward(x))    # 0.9990889488055994

二、将神经元组合成神经网络

神经网络是一堆连接在一起的神经元。下面是一个简单的神经网络的样子:

这个网络有2个输入(x1和x2)，一个隐藏层有2个神经元(h1和h2)，一个输出层有1个神经元(o1)。注意，o1的输入是h1和h2的输出——这就是使它成为一个网络的原因。(是因为通过O1把两个神经元连接起来了，所以成为了一个网络？)

隐藏层是介于输入(第一层)和输出(最后一层)之间的任何层。可以有多个隐藏层!（之前对于隐藏层的概念感知一直很模糊，现在明白了!）

示例:用上述网络实现前馈
让我们使用上图中的网络，并假设所有神经元具有相同的权重w=[0,1]（即h1和h2的权重都是w）,相同的偏差b=0（即h1和h2的偏差都是b=0），以及相同的sigmoid激活函数。设h1,h2,o1表示它们所代表的神经元的输出。

如果我们传入输入x=[2,3]x=[2,3]会发生什么?

对于输入x=[2,3]x=[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

    # The Neuron class here is from the previous section
    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)

    # The inputs for o1 are the outputs from h1 and 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

跟上面公式计算的一样，用代码实现得到了相同的结果。

三、训练神经网络

1.第一部分

假设我们有这样的测量值：

（作者使用的是英制单位。1 磅（lb）约等于 0.45359237 千克（kg）1 英寸（in）约等于 2.54 厘米（cm））

训练我们的网络，根据一个人的体重和身高来预测他的性别:

因为神经网络最后输出的结果一般是一个数字，所以我们对上文中的表格信息进行处理，用0表示男性，用1表示女性，方便后续计算。我随意选择了移位量(135和66，用体重减去135，身高减去66)，以使数字看起来更美观。通常，会按均值平移。

2.损失Loss

在我们训练我们的网络之前，我们首先需要一种方法来量化它做得有多“好”，这样它就可以尝试做得“更好”。这就是损失。

我们将使用均方误差(MSE)损失:

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

公式中每个字母的含义:

n是样本数，即4(Alice, Bob, Charlie, Diana)。

y表示被预测的变量，即性别（我们用1代表女性，0代表男性）。

$y_{true}$ 是变量的真实值(“正确答案”)。例如，爱丽丝的 $y_{true}$ 为1(女性)。

$y_{pred}$ 是变量的预测值。它是我们网络的输出。

$(y_{true}-y{_{pred}})^{2}$ 称为平方误差。我们的损失函数只是取所有平方误差的平均值(因此称为均方误差)。我们的预测越准确，我们的损失就越小!

更好的预测=更少的损失。训练一个网络也就是尽量减少它的损失。

3.损失计算示例

假设我们的网络总是输出0——换句话说，它确信所有的人都是男性。我们的损失是什么?

代码:MSE Loss 下面是一些为我们计算损失的代码:

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

4.训练一个神经网络

我们现在有一个明确的目标:最小化神经网络的损失。我们知道我们可以改变神经网络的权重和偏差来影响它的预测，但我们如何以减少损失的方式这样做呢?

本节使用了一些多变量演算。如果你对微积分不熟悉，可以跳过数学部分。

为了简单起见，让我们假设我们的数据集中只有Alice:

均方误差损失就是Alice的平方误差：

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

那么，我们可以将损失写成一个多变量函数:

$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}}$ 可以回答。怎么计算呢?这就是数学开始变得更复杂的地方。不要气馁!我建议你准备好笔和纸来跟着读——这会帮助你理解。

这种通过向后工作来计算偏导数的系统被称为反向传播。之前总是不太理解反向传播，感觉比较抽象，自己动手推了一下好多了。建议大家也去跟着作者@Machine Learning for Beginners: An Introduction to Neural Networks - victorzhou.com的文档推一下。或者看得清我写的直接跟着推也行，太多公式了写起来快一点就没一个一个敲。

5.示例：计算偏导数

继续假设只有Alice在我们的数据集中:

初始化所有权重为1，所有偏差为0。如果在网络中进行前馈传递，会得到:

网络输出 $y_{pred}=0.524$ ，介于0和1之间，没有办法明显地看出来是男性还是女性。因为Male(0)或Female(1)。我们来计算 $\frac{\partial L }{\partial w_{1}}$ :

$f^{'}(x)=f(x)*(1-f(x))$ 上文手写推倒过。因为 $\frac{\partial L}{\partial w1}$ 偏导大于0，所以我们可以知道如果我们增加 $w_{1}$ ，结果 $L$ 会增加一点点。(L是损失，应该越小越好，所以应该要减小W1,不过实际训练过程中要考虑的参数不止W1一个，所以也不能单纯减小W1,应该综合考虑，找到W1的最佳值)

6.训练:随机梯度下降

我们现在有了训练神经网络所需的所有工具!我们将使用一种称为随机梯度下降(SGD)的优化算法，它告诉我们如何改变权重和偏差以最小化损失。基本上就是这个更新方程:

$w{_{1}}\leftarrow w_{1}-\eta \frac{\partial L}{\partial w_{1}}$

$\eta$ 是一个常数，叫做学习率，它控制着我们训练的速度。我们所做的就是从 $w_{1}$ 中减去 $\eta \frac{\partial L}{\partial w_{1}}$ :

如果 $\eta \frac{\partial L}{\partial w_{1}}$ 为正，则 $w{_{1}}$ 将减小，从而使 $L$ 减小。

如果 $\eta \frac{\partial L}{\partial w_{1}}$ 为负，则 $w{_{1}}$ 将增加，从而使 $L$ 减小。

这个是个很巧妙的方程

如果我们对网络中的每个权重和偏差都这样做，损失将慢慢减少，我们的网络将得到改善。

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

1.从我们的数据集中选择一个样本。这就是为什么它是随机梯度下降——我们一次只操作一个样本。

2.计算关于权重或偏置的所有损失的偏导数(例如 $\frac{\partial L }{\partial w_{1}}$ ， $\frac{\partial L }{\partial w_{2}}$ 等)。

3.使用更新方程来更新每个权重和偏差。

4.回到步骤1。

（关于这个过程我还没有特别清晰明了的理解，先继续往下学，等有理解再回来补充。）

7.代码:完整的神经网络

最后，一个完整的神经网络的实现。

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 and y_pred are numpy arrays of the same length.
  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)

  *** DISCLAIMER ***:
       免责声明
下面的代码旨在简单和教育，而不是最佳的。
真正的神经网络代码不是这样的。不要使用这个代码。
相反，阅读/运行它来理解这个特定的网络是如何工作的。
  '''
  def __init__(self):
    # Weights
    self.w1 = np.random.normal() #赋一个随机生成的服从标准正态分布（均值为0，标准差为1）的值。
    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 is a numpy array with 2 elements.
    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 # number of times to loop through the entire dataset

    for epoch in range(epochs):
        # zip() 函数来同时遍历两个列表 data 和 all_y_trues 中相应位置的元素。
      for x, y_true in zip(data, all_y_trues):
        # --- Do a feedforward (we'll need these values later)
        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

        # --- Calculate partial derivatives.
        # --- Naming: d_L_d_w1 represents "partial L / partial w1"
        #求的是L对ypred的偏导值
        d_L_d_ypred = -2 * (y_true - y_pred)

        # Neuron o1
        #求的是ypred对w5,w6,b3,h1,h2的偏导值
        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
        #求的是h1对w1,w2,b1的偏导值
        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
        #求的是h2对w3, w4, b2的偏导值
        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)

        # --- Update weights and biases
        # Neuron h1
        #就是刚刚的SGD梯度下降,w1=w1-learn_rate*L对变量的偏导
        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

      # --- Calculate total loss at the end of each epoch
      if epoch % 10 == 0:
        #这里是在计算预测值 y_preds,实际计算预测值还是self.feedforward前向传播，就跟之前举得例子一样。
        #反向传播只是为了更新w,b等参数以获得更加低的损失，更好的预测结果
        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))

# Define dataset
#给定数据集
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
])

# Train our neural network!
#OurNeuralNetwork()类的实例化
network = OurNeuralNetwork()
#调用类的train方法进行训练
network.train(data, all_y_trues)

代码和部分输出结果，代码里面对一些关键步骤做了注释，以便和上文推导过程进行对应。欢迎大家指正讨论。主要是为了记录学习过程，方便后续回顾，梳理写下来也有助于理解。全文基本上是翻译@Machine Learning for Beginners: An Introduction to Neural Networks - victorzhou.com的原文。因为自己英文水平有限，看英文就顾着翻译了没法好好思考，所以才写成中文方便回顾。另外

@【天外来课的个人空间-哔哩哔哩】 https://b23.tv/qzstdnb有关于这个的讲解。两位都很优秀的创作者，解答了我很多疑惑。本文只是学习记录，大家可以去看原文和视频讲解。