一篇文章让你彻底搞懂神经网络:从原理到优化如此简单

普林斯顿的华人小哥Victor Zhou写了篇神经网络入门教程受到广大神经网络入门人员的吹捧。网址:https://victorzhou.com/blog/intro-to-neural-networks/,演示在:https://repl.it/@vzhou842/An-Introduction-to-Neural-Networks.

0. 文章介绍了什么

  • 介绍了神经网络的基础单元--神经元neurons,
  • 在神经元中使用了常见的激活函数: sigmoid 
  • 神经网络中的神经元是如何连接和交互的
  • 创建了一个包含身高和体重(特征)作为输入和性别作为输出(标签)的数据集,或者说是训练集
  • 介绍了损失函数loss functions 和均方误差损失 mean squared error (MSE) loss.
  • 训练一个网络就等同于最小化损失
  • 使用反向传播backpropagation计算偏导数
  • 使用随机梯度下降 stochastic gradient descent (SGD) 训练网络.

完整代码:

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: p_L_p_w1 stands for "partial L partial w1"
        p_L_p_ypred = -2 * (y_true - y_pred)

        # Neuron o1
        p_ypred_p_w5 = h1 * deriv_sigmoid(sum_o1)
        p_ypred_p_w6 = h2 * deriv_sigmoid(sum_o1)
        p_ypred_p_b3 = deriv_sigmoid(sum_o1)

        p_ypred_p_h1 = self.w5 * deriv_sigmoid(sum_o1)
        p_ypred_p_h2 = self.w6 * deriv_sigmoid(sum_o1)

        # Neuron h1
        p_h1_p_w1 = x[0] * deriv_sigmoid(sum_h1)
        p_h1_p_w2 = x[1] * deriv_sigmoid(sum_h1)
        p_h1_p_b1 = deriv_sigmoid(sum_h1)

        # Neuron h2
        p_h2_p_w3 = x[0] * deriv_sigmoid(sum_h2)
        p_h2_p_w4 = x[1] * deriv_sigmoid(sum_h2)
        p_h2_p_b2 = deriv_sigmoid(sum_h2)

        # --- Update weights and biases
        # Neuron h1
        self.w1 -= learn_rate * p_L_p_ypred * p_ypred_p_h1 * p_h1_p_w1
        self.w2 -= learn_rate * p_L_p_ypred * p_ypred_p_h1 * p_h1_p_w2
        self.b1 -= learn_rate * p_L_p_ypred * p_ypred_p_h1 * p_h1_p_b1

        # Neuron h2
        self.w3 -= learn_rate * p_L_p_ypred * p_ypred_p_h2 * p_h2_p_w3
        self.w4 -= learn_rate * p_L_p_ypred * p_ypred_p_h2 * p_h2_p_w4
        self.b2 -= learn_rate * p_L_p_ypred * p_ypred_p_h2 * p_h2_p_b2

        # Neuron o1
        self.w5 -= learn_rate * p_L_p_ypred * p_ypred_p_w5
        self.w6 -= learn_rate * p_L_p_ypred * p_ypred_p_w6
        self.b3 -= learn_rate * p_L_p_ypred * p_ypred_p_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)

# 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),它是神经网络的基本单元。神经元先获得输入,然后执行某些数学运算后,再产生一个输出。比如一个2输入神经元的例子:

1.单个神经元的工作原理

在这个神经元中,输入总共经历了3步数学运算,简略地说就是:输入-->与权重向量相乘,乘后的结果相加,加后的结果作为激活函数的输入进行计算-->输出

(1)先将两个输入乘以权重w(weight)(图中棕色方块):

x1→x1 × w1

x2→x2 × w2

 

(2)把两个结果想加,再加上一个偏置b(bias)(图中绿色方块):

(x1 × w1)+(x2 × w2)+ b

(3)最后将它们经过激活函数f(activation function)处理得到输出(图中黄色方块):

y = f(x1 × w1 + x2 × w2 + b)

激活函数的作用是将无限制的输入转换为可预测形式的输出。

2.一种常用的激活函数:sigmoid函数

一篇文章让你彻底搞懂神经网络:从原理到优化如此简单_第1张图片

sigmoid函数的输出介于0和1,我们可以理解为它把 (−∞,+∞) 范围内的数压缩到 (0, 1)以内。正值越大输出越接近1,负向数值越大输出越接近0。

举个例子,上面神经元里的权重和偏置取如下数值:

w=[0,1]

b = 4

w=[0,1]是w1=0、w2=1的向量形式写法。给神经元一个输入x=[2,3],可以用向量点积的形式把神经元的输出计算出来:

w·x+b =(x1 × w1)+(x2 × w2)+ b = 0×2+1×3+4=7

y=f(w⋅X+b)=f(7)=0.999

上述单个神经元计算对应的python代码:

import numpy as np #调用强大的Python数学函数库NumPy
def sigmoid(x):
 return 1 / (1 + np.exp(-x)) # 激活函数: f(x) = 1 / (1 + e^(-x))
class Neuron:#定义神经元
 def __init__(self, weights, bias):#神经元包含2个变量,权重和偏置
 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

 二. 神经网络

神经网络就是把一堆神经元连接在一起,下面是一个神经网络的简单举例:

 

这个网络有2个输入(x1和x2)、一个包含2个神经元的隐藏层(h1和h2)、包含1个神经元的输出层o1。

隐藏层是夹在输入输入层和输出层之间的部分,一个神经网络可以有多个隐藏层。

把神经元的输入向前传递获得输出的过程称为前馈(feedforward)。

我们假设上面的网络里所有神经元都具有相同(实际上每条边的权重可能都不一样)的权重w=[0,1]和偏置b=0,激活函数都是sigmoid,那么我们会得到什么输出呢?

h1=h2=f(w⋅x+b)=f((0×2)+(1×3)+0)

=f(3)

=0.9526

o1=f(w⋅[h1,h2]+b)=f((0∗h1)+(1∗h2)+0)

=f(0.9526)

=0.7216

一篇文章让你彻底搞懂神经网络:从原理到优化如此简单_第2张图片

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

三. 训练神经网络

现在我们已经学会了如何搭建神经网络,现在我们来学习如何训练它,其实这就是一个优化的过程。

假设有一个数据集,包含4个人的身高、体重和性别:

一篇文章让你彻底搞懂神经网络:从原理到优化如此简单_第3张图片

现在我们的目标是训练一个网络,根据体重和身高来推测某人的性别。

为了简便起见,我们将每个人的身高、体重减去一个固定数值,把性别男定义为1、性别女定义为0。

一篇文章让你彻底搞懂神经网络:从原理到优化如此简单_第4张图片

在训练神经网络之前,我们需要有一个标准定义它到底好不好,以便我们进行改进,这就是损失(loss)。

比如用均方误差(MSE)来定义损失:

一篇文章让你彻底搞懂神经网络:从原理到优化如此简单_第5张图片

n是样本的数量,在上面的数据集中是4;

y代表人的性别,男性是1,女性是0;

y_true是变量的真实值,y_pred是变量的预测值。

顾名思义,均方误差就是所有数据方差的平均值,我们不妨就把它定义为损失函数。预测结果越好,损失就越低,训练神经网络就是将损失最小化。

如果上面网络的输出一直是0,也就是预测所有人都是男性,那么损失是:

一篇文章让你彻底搞懂神经网络:从原理到优化如此简单_第6张图片

计算损失函数的代码如下:

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

 

四. 训练神经网络(二)--减少神经网络损失

这个神经网络不够好,还要不断优化,尽量减少损失。我们知道,改变网络的权重和偏置可以影响预测值,但我们应该怎么做呢?

为了简单起见,我们把数据集缩减到只包含Alice一个人的数据。

 于是损失函数就剩下Alice一个人的方差:

一篇文章让你彻底搞懂神经网络:从原理到优化如此简单_第7张图片

预测值是由一系列网络权重和偏置计算出来的:

一篇文章让你彻底搞懂神经网络:从原理到优化如此简单_第8张图片

 

所以损失函数实际上是包含多个权重、偏置的多元函数:

(注意!前方高能!需要你有一些基本的多元函数微分知识,比如偏导数、链式求导法则。)

1. 示例:如果调整一下w1,损失函数是会变大还是变小?

我们需要知道偏导数∂L/∂w1是正是负才能回答这个问题。

根据链式求导法则:

而L=(1-y_pred)^2,可以求得第一项偏导数:

接下来我们要想办法获得y_pred和w1的关系,我们已经知道神经元h1、h2和o1的数学运算规则:

实际上只有神经元h1中包含权重w1,所以我们再次运用链式求导法则:

 

一篇文章让你彻底搞懂神经网络:从原理到优化如此简单_第9张图片

然后求∂h1/∂w1:

一篇文章让你彻底搞懂神经网络:从原理到优化如此简单_第10张图片

 

我们在上面的计算中遇到了2次激活函数sigmoid的导数f′(x),sigmoid函数的导数很容易求得:

一篇文章让你彻底搞懂神经网络:从原理到优化如此简单_第11张图片

总的链式求导公式:

 

这种向后计算偏导数的系统称为反向传播(backpropagation)。

上面的数学符号太多,下面我们带入实际数值来计算一下。h1、h2和o1

h1=f(x1⋅w1+x2⋅w2+b1)=0.0474

h2=f(w3⋅x3+w4⋅x4+b2)=0.0474

o1=f(w5⋅h1+w6⋅h2+b3)=f(0.0474+0.0474+0)=f(0.0948)=0.524

神经网络的输出y=0.524,没有显示出强烈的是男(1)是女(0)的证据。现在的预测效果还很不好。

我们再计算一下当前网络的偏导数∂L/∂w1:

一篇文章让你彻底搞懂神经网络:从原理到优化如此简单_第12张图片

这个结果告诉我们:如果增大w1,损失函数L会有一个非常小的增长。

2.随机梯度下降

下面将使用一种称为随机梯度下降(SGD)的优化算法,来训练网络。

经过前面的运算,我们已经有了训练神经网络所有数据。但是该如何操作?SGD定义了改变权重和偏置的方法:

 

η是一个常数,称为学习率(learning rate),它决定了我们训练网络速率的快慢。将w1减去η·∂L/∂w1,就等到了新的权重w1。

当∂L/∂w1是正数时,w1会变小;当∂L/∂w1是负数 时,w1会变大。

如果我们用这种方法去逐步改变网络的权重w和偏置b,损失函数会缓慢地降低,从而改进我们的神经网络。

训练流程如下:

(1)从数据集中选择一个样本;

(2)计算损失函数对所有权重和偏置的偏导数;

(3)使用更新公式更新每个权重和偏置;

(4)回到第1步。

一篇文章让你彻底搞懂神经网络:从原理到优化如此简单_第13张图片

我们用Python代码实现这个过程:

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)

随着学习过程的进行,损失函数逐渐减小。

一篇文章让你彻底搞懂神经网络:从原理到优化如此简单_第14张图片

现在我们可以用它来推测出每个人的性别了:

# 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

更多

这篇教程只是万里长征第一步,后面还有很多知识需要学习:

1、用更大更好的机器学习库搭建神经网络,如Tensorflow、Keras、PyTorch

2、在浏览器中的直观理解神经网络:https://playground.tensorflow.org/

3、学习sigmoid以外的其他激活函数:https://keras.io/activations/

4、学习SGD以外的其他优化器:https://keras.io/optimizers/

5、学习卷积神经网络(CNN)

6、学习递归神经网络(RNN)

这些都是Victor给自己挖的“坑”。他表示自己未来“可能”会写这些主题内容,希望他能陆续把这些坑填完。如果你想入门神经网络,不妨去订阅他的博客。

关于这位小哥

Victor Zhou是普林斯顿2019级CS毕业生,已经拿到Facebook软件工程师的offer,今年8月入职。他曾经做过JS编译器,还做过两款页游,一个仇恨攻击言论的识别库。

最后附上小哥的博客链接:

https://victorzhou.com/

 一篇文章让你彻底搞懂神经网络:从原理到优化如此简单_第15张图片

参考:https://www.toutiao.com/a6668491982555316750/?tt_from=weixin&utm_campaign=client_share&wxshare_count=1×tamp=1553137961&app=news_article&utm_source=weixin&utm_medium=toutiao_ios&group_id=6668491982555316750

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

你可能感兴趣的:(Python,AI)