(2条消息) 一篇文章让你彻底搞懂神经网络：从原理到优化如此简单
0. 文章介绍了什么
介绍了神经网络的基础单元--神经元neurons,
在神经元中使用了常见的激活函数： sigmoid
神经网络中的神经元是如何连接和交互的
创建了一个包含身高和体重（特征）作为输入和性别作为输出（标签）的数据集，或者说是训练集
介绍了损失函数loss functions 和均方误差损失 mean squared error (MSE) loss.
训练一个网络就等同于最小化损失
使用反向传播backpropagation计算偏导数
使用随机梯度下降 stochastic gradient descent (SGD) 训练网络.
完整代码：
import numpy as npdef 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):# Weightsself.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()# Biasesself.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 o1def 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.1epochs = 1000 # number of times to loop through the entire datasetfor 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.b1h1 = sigmoid(sum_h1)sum_h2 = self.w3 * x[0] + self.w4 * x[1] + self.b2h2 = sigmoid(sum_h2)sum_o1 = self.w5 * h1 + self.w6 * h2 + self.b3o1 = 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 o1p_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 h1p_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 h2p_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 h1self.w1 -= learn_rate * p_L_p_ypred * p_ypred_p_h1 * p_h1_p_w1self.w2 -= learn_rate * p_L_p_ypred * p_ypred_p_h1 * p_h1_p_w2self.b1 -= learn_rate * p_L_p_ypred * p_ypred_p_h1 * p_h1_p_b1# Neuron h2self.w3 -= learn_rate * p_L_p_ypred * p_ypred_p_h2 * p_h2_p_w3self.w4 -= learn_rate * p_L_p_ypred * p_ypred_p_h2 * p_h2_p_w4self.b2 -= learn_rate * p_L_p_ypred * p_ypred_p_h2 * p_h2_p_b2# Neuron o1self.w5 -= learn_rate * p_L_p_ypred * p_ypred_p_w5self.w6 -= learn_rate * p_L_p_ypred * p_ypred_p_w6self.b3 -= learn_rate * p_L_p_ypred * p_ypred_p_b3# --- Calculate total loss at the end of each epochif 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 datasetdata = np.array([[-2, -1], # Alice[25, 6], # Bob[17, 4], # Charlie[-15, -6], # Diana])all_y_trues = np.array([1, # Alice0, # Bob0, # Charlie1, # Diana])# Train our neural network!network = OurNeuralNetwork()network.train(data, all_y_trues)# Make some predictionsemily = np.array([-7, -3]) # 128 pounds, 63 inchesfrank = np.array([20, 2]) # 155 pounds, 68 inchesprint("Emily: %.3f" % network.feedforward(emily)) # 0.951 - Fprint("Frank: %.3f" % network.feedforward(frank)) # 0.039 - M
一. 基本模块--神经元
在说神经网络之前，我们讨论一下神经元（Neurons），它是神经网络的基本单元。神经元先获得输入，然后执行某些数学运算后，再产生一个输出。比如一个2输入神经元的例子：
1.单个神经元的工作原理
在这个神经元中，输入总共经历了3步数学运算，简略地说就是：输入-->与权重向量相乘，乘后的结果相加，加后的结果作为激活函数的输入进行计算-->输出
（1）先将两个输入乘以权重w（weight）（图中棕色方块）：
x1→x1 × w1x2→x2 × w2
（2）把两个结果想加，再加上一个偏置b（bias）（图中绿色方块）：
（x1 × w1）+（x2 × w2）+ b
（3）最后将它们经过激活函数f（activation function）处理得到输出（图中黄色方块）：
y = f(x1 × w1 + x2 × w2 + b)
激活函数的作用是将无限制的输入转换为可预测形式的输出。
2.一种常用的激活函数:sigmoid函数
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=7y=f(w⋅X+b)=f(7)=0.999
上述单个神经元计算对应的python代码：
import numpy as np #调用强大的Python数学函数库NumPydef sigmoid(x):return 1 / (1 + np.exp(-x)) # 激活函数: f(x) = 1 / (1 + e^(-x))class Neuron:#定义神经元def __init__(self, weights, bias):#神经元包含2个变量，权重和偏置self.weights = weightsself.bias = biasdef feedforward(self, inputs):# 输入乘以权重，然后加上偏置，然后作为输入传给激活函数进行计算total = np.dot(self.weights, inputs) + self.biasreturn sigmoid(total)weights = np.array([0, 1]) # 示例定义权重w1 = 0, w2 = 1bias = 4 # 示例定义偏置b = 4n = Neuron(weights, bias)#定义一个神经元，并进行初始化x = np.array([2, 3]) #定义输入 x1 = 2, x2 = 3print(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.9526o1=f(w⋅[h1,h2]+b)=f((0∗h1)+(1∗h2)+0)=f(0.9526)=0.7216
import numpy as np# ... code from previous section hereclass 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 sectionself.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 h2out_o1 = self.o1.feedforward(np.array([out_h1, out_h2]))return out_o1network = OurNeuralNetwork()x = np.array([2, 3])print(network.feedforward(x)) # 0.7216325609518421
三. 训练神经网络
现在我们已经学会了如何搭建神经网络，现在我们来学习如何训练它，其实这就是一个优化的过程。
假设有一个数据集，包含4个人的身高、体重和性别：
现在我们的目标是训练一个网络，根据体重和身高来推测某人的性别。
为了简便起见，我们将每个人的身高、体重减去一个固定数值，把性别男定义为1、性别女定义为0。
在训练神经网络之前，我们需要有一个标准定义它到底好不好，以便我们进行改进，这就是损失（loss）。
比如用均方误差（MSE）来定义损失：
n是样本的数量，在上面的数据集中是4；
y代表人的性别，男性是1，女性是0；
y_true是变量的真实值，y_pred是变量的预测值。
顾名思义，均方误差就是所有数据方差的平均值，我们不妨就把它定义为损失函数。预测结果越好，损失就越低，训练神经网络就是将损失最小化。
如果上面网络的输出一直是0，也就是预测所有人都是男性，那么损失是：
计算损失函数的代码如下：
import numpy as npdef 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一个人的方差：
预测值是由一系列网络权重和偏置计算出来的：
所以损失函数实际上是包含多个权重、偏置的多元函数：
（注意！前方高能！需要你有一些基本的多元函数微分知识，比如偏导数、链式求导法则。）
1. 示例：如果调整一下w1，损失函数是会变大还是变小？
我们需要知道偏导数∂L/∂w1是正是负才能回答这个问题。
根据链式求导法则：
而L=(1-y_pred)^2，可以求得第一项偏导数：
接下来我们要想办法获得y_pred和w1的关系，我们已经知道神经元h1、h2和o1的数学运算规则：
实际上只有神经元h1中包含权重w1，所以我们再次运用链式求导法则：
然后求∂h1/∂w1：
我们在上面的计算中遇到了2次激活函数sigmoid的导数f′(x)，sigmoid函数的导数很容易求得：
总的链式求导公式：
这种向后计算偏导数的系统称为反向传播（backpropagation）。
上面的数学符号太多，下面我们带入实际数值来计算一下。h1、h2和o1
h1=f(x1⋅w1+x2⋅w2+b1)=0.0474h2=f(w3⋅x3+w4⋅x4+b2)=0.0474o1=f(w5⋅h1+w6⋅h2+b3)=f(0.0474+0.0474+0)=f(0.0948)=0.524
神经网络的输出y=0.524，没有显示出强烈的是男（1）是女（0）的证据。现在的预测效果还很不好。
我们再计算一下当前网络的偏导数∂L/∂w1：
这个结果告诉我们：如果增大w1，损失函数L会有一个非常小的增长。
2.随机梯度下降
下面将使用一种称为随机梯度下降（SGD）的优化算法，来训练网络。
经过前面的运算，我们已经有了训练神经网络所有数据。但是该如何操作？SGD定义了改变权重和偏置的方法：
η是一个常数，称为学习率（learning rate），它决定了我们训练网络速率的快慢。将w1减去η·∂L/∂w1，就等到了新的权重w1。
当∂L/∂w1是正数时，w1会变小；当∂L/∂w1是负数 时，w1会变大。
如果我们用这种方法去逐步改变网络的权重w和偏置b，损失函数会缓慢地降低，从而改进我们的神经网络。
训练流程如下：
（1）从数据集中选择一个样本；
（2）计算损失函数对所有权重和偏置的偏导数；
（3）使用更新公式更新每个权重和偏置；
（4）回到第1步。
我们用Python代码实现这个过程：
import numpy as npdef 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):# Weightsself.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()# Biasesself.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 o1def 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.1epochs = 1000 # number of times to loop through the entire datasetfor 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.b1h1 = sigmoid(sum_h1)sum_h2 = self.w3 * x[0] + self.w4 * x[1] + self.b2h2 = sigmoid(sum_h2)sum_o1 = self.w5 * h1 + self.w6 * h2 + self.b3o1 = 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 o1d_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 h1d_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 h2d_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 h1self.w1 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_w1self.w2 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_w2self.b1 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_b1# Neuron h2self.w3 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h2_d_w3self.w4 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h2_d_w4self.b2 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h2_d_b2# Neuron o1self.w5 -= learn_rate * d_L_d_ypred * d_ypred_d_w5self.w6 -= learn_rate * d_L_d_ypred * d_ypred_d_w6self.b3 -= learn_rate * d_L_d_ypred * d_ypred_d_b3# --- Calculate total loss at the end of each epochif 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 datasetdata = np.array([[-2, -1], # Alice[25, 6], # Bob[17, 4], # Charlie[-15, -6], # Diana])all_y_trues = np.array([1, # Alice0, # Bob0, # Charlie1, # Diana])# Train our neural network!network = OurNeuralNetwork()network.train(data, all_y_trues)
随着学习过程的进行，损失函数逐渐减小。
现在我们可以用它来推测出每个人的性别了：
# Make some predictionsemily = np.array([-7, -3]) # 128 pounds, 63 inchesfrank = np.array([20, 2]) # 155 pounds, 68 inchesprint("Emily: %.3f" % network.feedforward(emily)) # 0.951 - Fprint("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/