神经网络简介|极客教程

神经网络简介,适用于机器学习的初学者，假设你没有任何机器学习的知识。简单解释它们如何工作，以及如何在Python中从头实现一个神经网络。可能会让你大吃一惊的是:神经网络并没有那么复杂!“神经网络”这个词经常被用作流行语，但实际上它们往往比人们想象的要简单得多。

让我们开始吧！

构建块:神经元

首先，我们要讨论神经元，神经网络的基本单位。神经元接受输入，用它们做一些数学运算，然后产生一个输出。这是一个2-input neuron的样子:
神经网络简介

这里发生了三件事。首先，每个输入乘以一个权重:
$x_1$ $\rightarrow$ $x_1$ * $w_1$
$x_2$ $\rightarrow$ $x_2$ * $w_2$

然后将所有加权后的输入与偏置b相加:

$x_1$ * $w_1$ + $x_2$ * $w_2$ + b
最后，总和通过一个激活函数传递:
y = $f(x_1 * w_1 + x_2 * w_2 + b)$
激活函数用于将无界输入转换为具有良好的、可预测形式的输出。一个常用的激活函数是sigmoid函数:
神经网络简介

sigmoid函数只输出(0,1)范围内的数字。你可以把( $-\infty$ ， $+\infty$ )压缩到(0,1)-大负数变成~0，大正数变成~1。

一个简单的例子
假设我们有一个使用sigmoid激活函数的2-input神经元，其参数如下:
w=[0,1]
b = 4
w=[0,1]是向量形式 $w_1$ = 0, $w_2$ = 1的一种写法。现在，让神经元输入x = [2,3]。我们用点积来写得更简洁:
(w⋅x)+b =((w1∗x1)+(w2 ∗x 2))+b
=0∗2+1∗3+4
=7
y = f(w $\cdot$ x + b) = f(7) = $\boxed{0.999}$
给定输入x=[2,3]，神经元输出0.999。就是这样!将输入向前传递以获得输出的过程称为前馈(feedforward)。

编码一个神经元
是时候实现一个神经元了!我们将使用NumPy，一个流行而强大的Python计算库，来帮助我们做数学:

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个神经元( $h_1$ 和 $h_2$ )，一个输出层有1个神经元( $o_1$ )。注意 $o_1$ 的输入是 $h_1$ 和 $h_2$ 的输出——这就是网络的组成。
隐藏层是在输入(第一个)层和输出(最后一个)层之间的任何层。可以有多个隐藏层!

一个例子:前馈
让我们使用上图所示的网络，假设所有的神经元都具有相同的权值w =[0,1]，相同的偏差b = 0，以及相同的sigmoid激活函数。设 $h_1$ 、 $h_2$ 、 $o_1$ 表示它们所表示的神经元的输出。
如果我们输入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

我们得到0.7216 !看起来有用。

训练神经网络，第1部分

假设我们有以下测量值:
神经网络简介
让我们训练我们的网络，根据一个人的体重和身高来预测他的性别:

我们将用0表示男性，用1表示女性，我们还将改变数据，使其更容易使用:

随意选择了移位量(135和66)，以使数字看起来很漂亮。一般情况下，你会平移。

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

我们将使用均方误差(MSE)损失:
神经网络简介

让我们来分解一下:

n是样本数，也就是4(Alice, Bob, Charlie, Diana)
y表示预测的变量，即性别。
$$y_{true}$$是变量的真值(“正确答案”)。例如，Alice的$$y_{true}$$为1(女性)。
$$y_{pred}$$是变量的预测值。它是我们的网络输出。
$$(y_{true} – y_{pred})^2$$被称为平方误差。损失函数只是取所有平方误差的平均值(因此得名均方误差)。我们的预测越好，我们的损失就会越低!

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

损失计算实例
假设我们的网络总是输出 0 – 换句话说，它确信所有人类都是男性。我们的损失会是什么?
神经网络简介
代码: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 quickstart on数组操作。

好了。开始!

训练神经网络，第2部分

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

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

为了简单起见，假设我们的数据集中只有Alice:
神经网络简介
那么平均平方误差损失就是Alice的平方误差:

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

然后，我们可以将损失写成多元函数:
$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{∂L}{∂w_1}$ 可以回答的问题。我们怎么计算它?
这就是数学开始变得更加复杂的地方。不要气馁!我建议你带一支笔和一张纸，这样可以帮助你理解。

首先，我们把偏导写成 $\frac{∂y_{pred}}{∂w_1}$ 的形式:
神经网络简介
因为链式法则所以这样写是有效的。

因为我们先前计算了 $L=(1-y_{pred})^2$ ,所以我们可以计算 $\frac{∂L}{∂y_{pred}}$ :
神经网络简介

现在，我们来看看如何处理 $\frac{∂y_{pred}}{∂w_1}$ 。就像之前一样，让 $h_1,h_2,o_1$ 是它们所代表的神经元的输出,此时：
$y_{pred}=o_1=f(w_5h_1+w_6h_2+b3)$
f是sigmoid激活函数，记得吗?

因为 $w_1$ 仅仅影响了 $h_1$ (而非 $h_2$ ),所以我们可以这样写：
神经网络简介
更多的链式法则。

我们对 $\frac{∂h_1}{∂w_1}$ 做同样的事情：
神经网络简介
你猜对了，链式法则。

这里x1是重量，x2是高度。这是我们第二次看到f'(x) (sigmoid函数的导数)了!让我们推导:
神经网络简介

我们稍后会用这个形式来表示f'(x)。
我们完成了!我们已经把 $\frac{∂L}{∂w_1}$ 分解成几个部分，我们可以计算:
神经网络简介

这种通过逆向计算偏导数的系统称为反向传播，或“backprop”。

唷。有很多符号——如果你仍然有点困惑，也没关系。让我们做一个例子来看看它的实际效果!

例子:计算偏导数
我们将继续假装只有Alice在我们的数据集中:
神经网络简介
让我们初始化所有的权值为1，所有的偏差为0。如果我们做一个前馈通过网络，我们得到:

网络输出 $y_{pred}$ =0.524，这并不强烈支持男性(0)或女性(1)。让我们计算 $\frac{∂L}{∂w_1}$ :

提醒:我们推导了f'(x) = f(x) * (1 – f(x))用于之前的sigmoid激活函数。

我们做到了!这告诉我们，如果我们增加 $w_1, L$ 会增加一点点。

训练:随机梯度下降
我们现在有了训练神经网络所需的所有工具!我们将使用一种称为随机梯度下降(SGD)的优化算法，它告诉我们如何改变权重和偏差以最小化损失。基本上就是这个更新方程:
神经网络简介
η是一个常数,称为学习速率,用于控制我们训练速度。我们要做的就是从 $w_1$ 中减去 $η\frac{∂L}{∂w_1}$ :

如果 $\frac{∂L}{∂w_1}$ 是正的， $w_1$ 将减少，那么会导致L也减少;
如果 $\frac{∂L}{∂w_1}$ 是负的， $w_1$ 将增加，那么会导致L也增加;

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

我们的训练流程如下:

从数据集中选择一个示例。这就是随机梯度下降的原因——我们一次只对一个样本进行操作。
计算所有损失对权重或偏差的偏导数(例如 $\frac{∂L}{∂w_1}$ ， $\frac{∂L}{∂w_2}$ ，等等)
使用更新方程更新每个权重和偏差。
回到步骤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