0基础入门神经网络：神经网络简介

原文地址

这可能会让您感到惊讶：神经网络并不复杂！“神经网络”一词经常被用作流行语，但实际上，它们通常比人们想象的要简单得多。

这篇文章是针对初学者的，并假定机器学习基础为零。我们在Python中从头实现神经网络。

让我们开始吧！

构建基础：神经元（Neurons）

首先，我们必须引入神经元这个概念，这是神经网络的基本单位。神经元接受输入，并对它们进行一些数学运算，然后输出。下面是双输入神经元的模型：

这里发生了三件事：首先，每个输入都乘以相应的权重：

$$\begin{array} { l } { x _ { 1 } \rightarrow x _ { 1 } * w _ { 1 } } \\ { x _ { 2 } \rightarrow x _ { 2 } * w _ { 2 } } \end{array}$$

接着，加权输入之和与偏置（bias）b相加：

$$\left( x _ { 1 } * w _ { 1 } \right) + \left( x _ { 2 } * w _ { 2 } \right) + b$$

最后，总和通过激活函数（activation function）传递：

$$y = f \left( x _ { 1 } * w _ { 1 } + x _ { 2 } * w _ { 2 } + b \right)$$

激活函数用于将无界输入转换为具有良好的、可预测形式的输出。常用的激活函数是S型函数：

这个S函数将无界的输入（$-\infty ,\infty$）转化成有界的输出（$0,1$），无穷小输出0，无穷大输出1.

一个简单的例子

假设我们有一个双输入神经元，使用S函数并有以下参数：

$$\begin{array} { c } { w = [ 0,1 ] } \\ { b = 4 } \end{array}$$

其中，$w = [ 0,1]$仅仅是将w1=0,w2=1写成向量形式。现在，让我们给定神经元一个输入$x=[2,3]$，并用点积的形式更简洁地写公式：

$$\begin{aligned} ( w \cdot x ) + b & = \left( \left( w _ { 1 } * x _ { 1 } \right) + \left( w _ { 2 } * x _ { 2 } \right) \right) + b \\ & = 0 * 2 + 1 * 3 + 4 \\ & = 7 \\ y = f ( w \cdot x + b ) & = f ( 7 ) = 0.999 \end{aligned}$$

也就是说，给定输入$x=[2,3]$，输出0.999。这种将输入向前传递以获得输出的过程我们称之为前馈（feedforward）

神经元的代码实现

我们将使用numpy来进行数学运算。

import numpy as np

def sigmoid(x):
  # 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
    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

同样输出了0.999

将神经元组合成神经网络

神经网络无非就是一束连接在一起的神经元。一个典型的神经网络如下：

该网络有2个输入，一个包含2个神经元的隐藏层（h1和h2），以及一个带有1个神经元的输出层（o1）。注意o1的输入也就是h1,h2的输出，这也是它被称为神经网络的原因。

隐藏层是输入（第一）层和输出（最后一个）层之间的任何层。可以有多个隐藏层！
它的工作是将输入转换为输出层可以使用的东西。

例子：前馈神经网络

使用上图所示的网络，并假设所有神经元的权重相同 w = [0，1]，偏置也相同，b = 0，也有同样的S型激活函数。让h1,h2,o1表示它们所代表的神经元的输出。

如果我们输入x=[2,3]会怎么样？

$$\begin{aligned} h _ { 1 } = h _ { 2 } & = f ( w \cdot x + b ) \\ & = f ( ( 0 * 2 ) + ( 1 * 3 ) + 0 ) \\ & = f ( 3 ) \\ & = 0.9526 \\ \\ o _ { 1 } = & f \left( w \cdot \left[ h _ { 1 } , h _ { 2 } \right] + b \right) \\ & = f \left( \left( 0 * h _ { 1 } \right) + \left( 1 * h _ { 2 } \right) + 0 \right) \\ & = f ( 0.9526 ) \\ & = [ 0.7216 ] \end{aligned}$$

输出是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

    # 这里的Neuron类来自上一节的代码
    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) 
    # 并不是调用的OurNeuralNetwork().feedforward(),而是Neuron().feedforward()
    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

训练神经网络，第一部分

假设我们有以下数据：

让我们训练神经网络，以实现给定身高和体重的输入，来预测性别的效果。

用0代表男性，1代表女性，同时移动数据以便更容易处理：

我随意选择了移位量（135和66）使数字看起来不错。通常，您会平均地移动。

损失（loss）

在训练我们的网络之前，我们首先需要一种方法来量化其运行状况的“良好”程度，以便它可以尝试做到“更好”。这个指标就是损失。

我们使用均方误差（mean squared error，MSE）来衡量损失：

$$\mathrm { MSE } = \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \left( y _ { t r u e } - y _ { p r e d } \right) ^ { 2 }$$

让我们分解这个公式：

• n是样本数，即4（Alice, Bob, Charlie, Diana）。
• y表示要预测的变量，即性别。
• $y_{true}$是变量的真实值（“正确答案”）。例如，Alice的$y_{true}$是1。
• $y_ {pred}$是变量的预测值，即神经网络的输出值。

$(y _ { t r u e } - y _ { p r e d })^2$就是我们常说的方差，我们的损失函数取了方差的平均值，因此称其为均方误差，均方误差越小，代表模型的预测效果越好。

训练网络=尽量减少其损失。

损失计算示例

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

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

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快速入门。

Nice!继续

训练神经网络，第二部分

我们现在有一个明确的目标：最小化神经网络的损失。我们知道我们可以更改网络的权重和偏置以影响其预测，但是我们如何以减少损失的方式做到这一点呢？

本节使用了一些多元微分。如果您对微积分不熟，请随时跳过数学部分。

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

于是该模型的均方误差即Alice的方差：

$$\begin{aligned} \mathrm { MSE } & = \frac { 1 } { 1 } \sum _ { i = 1 } ^ { 1 } \left( y _ { t r u e } - y _ { p r e d } \right) ^ { 2 } \\ & = \left( y _ { t r u e } - y _ { p r e d } \right) ^ { 2 } \\ & = \left( 1 - y _ { p r e d } \right) ^ { 2 } \end{aligned}$$

考虑损失的另一种方法是权重和偏置的函数。让我们在网络中标记每个权重和偏置：

于是我们可以重写损失函数为一个多变量函数：

$$L \left( w _ { 1 } , w _ { 2 } , w _ { 3 } , w _ { 4 } , w _ { 5 } , w _ { 6 } , b _ { 1 } , b _ { 2 } , b _ { 3 } \right)$$

如果我们调整w1，那么损失L会如何变化？偏微分（partial derivative,$\frac { \partial L } { \partial w _ { 1 } }$）可以回答这个问题，我们怎么计算它呢？

这是数学开始变得更复杂的地方。不要气馁!！我建议您随身携带一支笔和纸-它会帮助您理解。

数学推导

首先，用$\frac { \partial y _ { p r e d } } { \partial w _ { 1 } }$的形式重写偏微分(链式法则)：

$$\frac { \partial L } { \partial w _ { 1 } } = \frac { \partial L } { \partial y _ { p r e d } } * \frac { \partial y _ { p r e d } } { \partial w _ { 1 } }$$

我们可以计算$\frac { \partial L } { \partial y _ { p r e d } }$，因为有$L = \left( 1 - y _ { p r e d } \right) ^ { 2 }$

$$\frac { \partial L } { \partial y _ { p r e d } } = \frac { \partial \left( 1 - y _ { p r e d } \right) ^ { 2 } } { \partial y _ { p r e d } } = - 2 \left( 1 - y _ { p r e d } \right)$$

接下来考虑$\frac { \partial y _ { p r e d } } { \partial w _ { 1 } }$，和上面一样，h1,h2,o1代表相应神经元的输出，于是有：

$$y _ { p r e d } = o _ { 1 } = f \left( w _ { 5 } h _ { 1 } + w _ { 6 } h _ { 2 } + b _ { 3 } \right)$$

f是激活函数，还记得吗？

因为w1只影响h1（不是h2），那么有：

$$\begin{array} { c } { \frac { \partial y _ { p r e d } } { \partial w _ { 1 } } = \frac { \partial y _ { p r e d } } { \partial h _ { 1 } } * \frac { \partial h _ { 1 } } { \partial w _ { 1 } } } \\ { \frac { \partial y _ { p r e d } } { \partial h _ { 1 } } = w _ { 5 } * f ^ { \prime } \left( w _ { 5 } h _ { 1 } + w _ { 6 } h _ { 2 } + b _ { 3 } \right) } \end{array}$$

为$\frac { \partial h _ { 1 } } { \partial w _ { 1 } }$做同样的处理：

$$\begin{aligned} h _ { 1 } & = f \left( w _ { 1 } x _ { 1 } + w _ { 2 } x _ { 2 } + b _ { 1 } \right) \\ \\ \frac { \partial h _ { 1 } } { \partial w _ { 1 } } & = { x _ { 1 } * f ^ { \prime } \left( w _ { 1 } x _ { 1 } + w _ { 2 } x _ { 2 } + b _ { 1 } \right) } \end{aligned}$$
x1是体重，x2是身高，现在，让我们对f(x)求导：

$$\begin{array} { c } { f ( x ) = \frac { 1 } { 1 + e ^ { - x } } } \\ { f ^ { \prime } ( x ) = \frac { e ^ { - x } } { \left( 1 + e ^ { - x } \right) ^ { 2 } } = f ( x ) * ( 1 - f ( x ) ) } \end{array}$$

于是，我们将$\frac { \partial L } { \partial w _ { 1 } }$分解为一系列我们可以计算的值：

$$\frac { \partial L } { \partial w _ { 1 } } = \frac { \partial L } { \partial y _ { p r e d } } * \frac { \partial y _ { p r e d } } { \partial h _ { 1 } } * \frac { \partial h _ { 1 } } { \partial w _ { 1 } }$$

这种不断向后计算偏微分的方法叫做反向传播(Backpropagation)

例子：计算偏微分

我们仍然假设数据集中只有Alice

让我们初始化权重为1，偏置为0，如果我们通过神经网络做一个前馈，可以得到：

$$\begin{aligned} h _ { 1 } & = f \left( w _ { 1 } x _ { 1 } + w _ { 2 } x _ { 2 } + b _ { 1 } \right) \\ & = f ( - 2 + - 1 + 0 ) \\ & = 0.0474 \\ \\ h _ { 2 } = f & \left( w _ { 3 } x _ { 1 } + w _ { 4 } x _ { 2 } + b _ { 2 } \right) = 0.0474 \\ \\ o _ { 1 } & = f \left( w _ { 5 } h _ { 1 } + w _ { 6 } h _ { 2 } + b _ { 3 } \right) \\ & = f ( 0.0474 + 0.0474 + 0 ) \\ & = 0.524 \end{aligned}$$

网络预测结果为0.524，并不是强烈地说明了性别（0或1），让我们计算$\frac { \partial L } { \partial w _ { 1 } }$

$$\begin{aligned} \frac { \partial L } { \partial w _ { 1 } } = \frac { \partial L } { \partial y _ { p r e d } } * \frac { \partial y _ { p r e d } } { \partial h _ { 1 } } * \frac { \partial h _ { 1 } } { \partial w _ { 1 } } \\ \\ \frac { \partial L } { \partial y _ { p r e d } } = - 2 \left( 1 - y _ { p r e d } \right) = - 2 ( 1 - 0.524 ) = - 0.952 \end{aligned}$$

$$\begin{aligned} \frac { \partial y _ { p r e d } } { \partial h _ { 1 } } = w _ { 5 } * f ^ { \prime } \left( w _ { 5 } h _ { 1 } + w _ { 6 } h _ { 2 } + b _ { 3 } \right) \\ = 1 * f ^ { \prime } ( 0.0474 + 0.0474 + 0 ) \\ = f ( 0.0948 ) * ( 1 - f ( 0.0948 ) ) \\ = 0.249 \\ \frac { \partial h _ { 1 } } { \partial w _ { 1 } } = - 2 * f ^ { \prime } ( - 2 + - 1 + 0 ) \\ = - 2 * f ( - 3 ) * ( 1 - f ( - 3 ) ) \\ = - 0.0904 \\ \frac { \partial L } { \partial w _ { 1 } } = - 0.952 * 0.249 * - 0.0904 = 0.0214 \end{aligned}$$

记住我们先前得到了$f ^ { \prime } ( x ) = f ( x ) * ( 1 - f ( x ) )$

这个结果告诉我们，如果w1增加，那么损失L也会增加一点点。

训练：随机梯度下降（Stochastic Gradient Descent）

我们现在拥有训练神经网络所需的所有工具！接下来我们将使用一种称为随机梯度下降（SGD）的优化算法，该算法可以告诉我们如何更改权重和偏置以最大程度地减少损失。基本上就是这个更新方程：

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

η是一个常数，称为学习率( learning rate)，它控制我们训练的速度。我们要做的就是从w1中减去$\eta \frac { \partial L } { \partial w _ { 1 } }$

• 如果$\frac { \partial L } { \partial w _ { 1 } }$是正的，那么w1会降低，L也会降低
• 如果$\frac { \partial L } { \partial w _ { 1 } }$是负的，那么w1会增加，L也会增加

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

我们的训练过程将如下所示：

1. 从我们的数据集中选择一个样本。这就是它导致随机梯度下降的原因-我们一次只能处理一个样本。
2. 计算所有关于权重或偏置的损失偏导数（例如$\frac { \partial L } { \partial w _ { 1 } }$,$\frac { \partial L } { \partial w _ { 2 } }$等）。
3. 使用更新方程更新每个权重和偏置。
4. 返回步骤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 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 ***:
  The code below is intended to be simple and educational, NOT optimal.
  Real neural net code looks nothing like this. DO NOT use this code.
  Instead, read/run it to understand how this specific network works.
  '''
  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 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):
      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"
        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)

        # --- Update weights and biases
        # 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

      # --- Calculate total loss at the end of each 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))

# 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!
network = OurNeuralNetwork()
network.train(data, all_y_trues)

该代码同时可以在github上找到

随着网络的学习，我们的损失稳步减少：

现在，我们可以使用神经网络来预测性别：

# Make some predictions
emily = np.array([-7, -3]) # 128 pounds, 63 inches
frank = np.array([20, 2])  # 155 pounds, 68 inches
print("Emily: %.3f" % network.feedforward(emily)) # 0.951 - F
print("Frank: %.3f" % network.feedforward(frank)) # 0.039 - M

总结

你做到了！快速回顾一下我们所做的事情：

• 引入了神经元（neurons），这是神经网络的基础。
• 在我们的神经元中使用了S型激活函数（sigmoid activation function）。
• 连接神经元使其成为神经网络（neural networks）。
• 创建了一个数据集，其中“体重”和“身高”作为输入（或特征，features），而“性别”作为输出（或标签， label）。
• 了解损失函数（loss functions）和均方误差（MSE）。
• 意识到神经网络训练只是将其损失降到最低。
• 使用反向传播（Backpropagation）来计算偏导数。
• 使用随机梯度下降（SGD）训练我们的网络。

版权属于：作者名称

本文链接：https://www.sitstars.com/archives/44/

转载时须注明出处及本声明