一、搭建基本模块—神经元
在说神经网络之前，我们讨论一下神经元（Neurons），它是神经网络的基本单元。神经元先获得输入，然后执行某些数学运算后，再产生一个输出。下面是两个输入的神经元。
在这个神经元里，输入总共经历了3步数学运算，
先将输入乘以权重（weight）：
x1→x1∗w1
x2→x2∗w2
(x1∗w1)+(x2∗w2)+b
最后经过激活函数（activation function）处理得到输出：
y=f((x1∗w1)+(x2∗w2)+b)
激活函数的作用是将无限制的输入转换为可预测形式的输出。一种常用的激活函数是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=7
y=f(w∗X+b) = f(7) = 0.999
给定的输入x=[2,3] 到输出 0.999。即：将输入向前传递以获得输出的过程称为前馈。
是时候实现神经元了！ 我们将使用NumPy（一种流行且功能强大的Python计算库）来帮助我们进行数学运算：
以上步骤的Python代码是：
import numpy as np
def sigmoid(z):
"""
激活函数 f(z) = 1 / (1 * e^(-z))
:param z:
:return:
"""
return 1 / (1 + np.exp(-z))
class Neuron():
def __init__(self,weights,bias):
self.weights=weights
self.bias=bias
def feedforward(self,inputs):
z=np.dot(self.weights,inputs)+self.bias
return sigmoid(z)
weights=np.array([0,1])# w1 = 0, w2 = 1
bias=4
n=Neuron(weights,bias)
x=np.array([2,3])# inputs
print(n.feedforward(x))# 0.9990889488055994
二、搭建神经网络
神经网络就是把一堆神经元连接在一起，下面是一个神经网络的简单举例：
这个网络有2个输入、一个包含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
神经网络可以具有任意数量的层，这些层中可以具有任意数量的神经元。 基本思想保持不变：将输入通过网络中的神经元向前馈送，最后获得输出。 为简单起见，本文的其余部分将继续使用上图所示的网络。
以下是实现代码：
import numpy as np
def sigmoid(z):
"""
激活函数 f(z) = 1 / (1 * e^(-z))
:param z:
:return:
"""
return 1 / (1 + np.exp(-z))
class Neuron():
def __init__(self,weights,bias):
self.weights=weights
self.bias=bias
def feedforward(self,inputs):
z=np.dot(self.weights,inputs)+self.bias
return sigmoid(z)
weights=np.array([0,1])# w1 = 0, w2 = 1
bias=4
n=Neuron(weights,bias)
x=np.array([2,3])# inputs
print(n.feedforward(x))# 0.9990889488055994
class OurNeuralNetWorks():
"""
A neural network with:
- 2 inputs
- a hidden layer with 2 neurons (h1, h2)
- an output layer with 1 neuron (o1)
Each neural 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,z):
out_h1=self.h1.feedforward(z)
out_h2=self.h2.feedforward(z)
# 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=OurNeuralNetWorks()
x=np.array([2,3])
print(network.feedforward(x))# 0.7216325609518421
三、训练神经网络
现在我们已经学会了如何搭建神经网络，现在再来学习如何训练它，其实这是一个优化的过程。
假设有一个数据集，包含4个人的身高、体重和性别：
| Name | Weight (lb) | Height (in) | Gender |
|---|---|---|---|
| Alice | 133 | 65 | F |
| Bob | 160 | 72 | M |
| Charlie | 152 | 70 | M |
| Diana | 120 | 60 | F |
现在我们的目标是训练一个网络，根据体重和身高来推测某人的性别。
为了简便起见，我们将每个人的身高、体重减去一个固定数值（任意选择的135，66），把性别男定义为1、性别女定义为0。
以使数字看起来不错。 通常，可以选择每列的平均值。
| Name | Weight (减去135) | Height (减去66) | Gender |
|---|---|---|---|
| Alice | -2 | -1 | 0 |
| Bob | 25 | 6 | 1 |
| Charlie | 17 | 4 | 1 |
| Diana | -15 | -6 | 0 |
在训练神经网络之前，我们需要有一个标准定义它到底好不好，以便我们进行改进，这就是损失（loss）。
比如用均方误差（MSE）来定义损失：
n是样本的数量，在上面的数据集中是4；
y代表人的性别，男性是1，女性是0；
ytrue 是变量的真实值，ypred 是变量的预测值。
顾名思义，均方误差就是所有数据方差的平均值，我们不妨就把它定义为损失函数。预测结果越好，损失就越低，训练神经网络就是将损失最小化。
如果上面网络的输出一直是0，也就是预测所有人都是女性，那么损失是
MSE= 1/4 (1+0+0+1)=0.5
计算损失函数的代码如下：
四、减少神经网络损失
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
我们现在有一个明确的目标：最大程度地减少神经网络的损失。 我们知道我们可以改变网络的权重和偏见来影响其预测，但是我们如何以减少损失的方式做到这一点呢？
Note：本节使用了一些多变量演算。 如果您对微积分不满意，请随时跳过数学部分。
为了简单起见，我们把数据集缩减到只包含Alice一个人的数据。
| Name | Weight (minus 135) | Height (minus 66) | Gender |
|---|---|---|---|
| Alice | -2 | -1 | 1 |
于是损失函数就剩下Alice一个人的方差：
预测值是由一系列网络权重和偏置计算出来的：
所以损失函数实际上是包含多个权重、偏置的多元函数：
L(w1,w2,w3,w4,w5,w6,b1,b2,b3)
（注意！前方高能！需要你有一些基本的多元函数微分知识，比如偏导数、链式求导法则。我建议您随身携带一支笔和一支纸，它可以帮助您理解。）
如果调整一下w1，损失函数是会变大还是变小？我们需要知道偏导数 ∂L/∂w1 是正是负才能回答这个问题。
根据链式求导法则：
可以求得第一项偏导数：
接下来我们要想办法获得 ypred 和 w1 的关系，我们已经知道神经元h1、h2和o1的数学运算规则：
ypred = o1 = f(w5h1+w6h2+b3)
实际上只有神经元h1中包含权重w1，所以我们再次运用链式求导法则：
这种向后计算偏导数的系统称为反向传播（backpropagation）。
上面的数学符号太多，下面我们带入实际数值来计算一下。h1、h2和o1
h1 = f(x1w1+x2w2+b1) = 0.0474
h2 = f(x3w3+x4w4+b2) = 0.0474
o1 = f(h1w5+h2w6+b3) = f(0.0474+0.0474+0)=0.524
神经网络的输出y=0.524，没有显示出强烈的是男（1）是女（0）的证据。现在的预测效果还很不好。
这个结果告诉我们：如果增大w1，损失函数L会有一个非常小的增长。
五、随机梯度下降
下面将使用一种称为随机梯度下降（SGD）的优化算法，来训练网络。
经过前面的运算，我们已经有了训练神经网络所有数据。但是该如何操作？SGD定义了改变权重和偏置的方法：
η 是一个常数，称为学习率（learning rate），它决定了我们训练网络速率的快慢。将 
如果我们用这种方法去逐步改变网络的权重w和偏置b，损失函数会缓慢地降低，从而改进我们的神经网络。
训练流程如下：
- 从数据集中选择一个样本；
- 计算损失函数对所有权重和偏置的偏导数；
- 使用更新公式更新每个权重和偏置；
- 回到第1步。
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):
#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 intend 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, for example [input1, input2]
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 = # 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):
# - - -前馈计算
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 # 单个样本的预测值
# - - -反馈计算
# 计算偏导数
# 损失函数针对于预测结果求导 d_L / d_ypred
d_L_d_ypred = -2 * (y_true - y_pred)
# 神经元 o1
d_ypred_d_w5 = h1 * deriv_sigmoid(sum_o1) # ypred 函数针对于 w5 的导数
d_ypred_d_w6 = h2 * deriv_sigmoid(sum_o1) # ypred 函数针对于 w6 的导数
d_ypred_d_b3 = deriv_sigmoid(sum_o1) # ypred 函数针对于 b3 的导数
d_ypred_d_h1 = self.w5 * deriv_sigmoid(sum_o1) # ypred 函数针对于 h1 的导数
d_ypred_d_h2 = self.w6 * deriv_sigmoid(sum_o1) # ypred 函数针对于 h1 的导数
# 神经元 h1
d_h1_d_w1 = x[0] * deriv_sigmoid(sum_h1) # h1 函数针对于 w1 的导数
d_h1_d_w2 = x[1] * deriv_sigmoid(sum_h1) # h1 函数针对于 w2 的导数
d_h1_d_b1 = deriv_sigmoid(sum_h1) # h1 函数针对于 b1 的导数
# 神经元 h2
d_h2_d_w3 = x[0] * deriv_sigmoid(sum_h2) # h2 函数针对于 w3 的导数
d_h2_d_w4 = x[0] * deriv_sigmoid(sum_h2) # h2 函数针对于 w4 的导数
d_h2_d_b2 = deriv_sigmoid(sum_h2) # h2 函数针对于 b2 的导数
# - - - 更新权重和偏置
# 神经元 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
# 神经元 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
# 神经元 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
# - - - 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))
# 训练样本数据集
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
])
# 训练我们的神经网络
network = OurNeuralNetwork() # 初始化我们的权重和偏置
network.train(data, all_y_trues)
# 进行预测
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.968 - F
print("Frank: %.3f" % network.feedforward(frank)) # 0.039 - M
随着学习过程的进行，损失函数逐渐减小。
现在我们可以用它来推测出每个人的性别了：
# 进行预测
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.968 - F
print("Frank: %.3f" % network.feedforward(frank)) # 0.039 - M
5656
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
