神经网络的入门
到放弃(bushi)
本文主要内容参考:
https://zhuanlan.zhihu.com/p/58964140
欢迎来我网站: www.xuanworld.top
一、先做一个神经元
我们就先做一个最简单的神经元,这个神经元有两个输入,接受到输入后就会向前产生一个传递(在这里要说一句话,神经网络中我们把得到结果的方向叫做前,有的人可能习惯把得到结果的方向理解成向后,这个地方要稍微注意一下)
按说神经元应该会有两个权值w1,w2,给输入加权相乘,然后加上一个偏差就可以了
比如:
输入为x1,x2
权值为w1,w2
偏移为b
我们可以得到一个激活函数的输入:x1*w1+x2*w2+b
然后得到激活函数的结果:y=f(x1*w1+x2*w2+b)
我们这样是为了将这个输出给压缩到(0,1)之间,至于为啥非要用sigmoid函数,我也不知道,人家就是这么用的,而且人家做出来就是有效,废物Rytter的编程法则,没必要了解为什么,只要会用并且能去解决问题就行。搞理论是天才该干的事,我们的任务是用好天才的理论。
然后我们创建一个神经元!
神经元代码
import numpy as np
def sigmoid(x):
# 这就是sigmoid函数,就是前几篇文章写的
return 1 / (1 + np.exp(-x))
class Neuron:
# 大家好老子TMD就是神经元,是你永远的梦魇
def __init__(self, weights, bias):
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]) # ww1=0,w2=1
bias = 4 # b=4
n = Neuron(weights, bias)
x = np.array([2, 3]) # x1=2,x2=3
print(n.feedforward(x))
上面我们简单做了一个神经元的代码,这个小东西就是神经网络的基础(也是你一切痛苦的源泉)
然后我们将神经元做成一个简单的神经网络
二、简单的神经网络
我们要做的其实很简单,我们只需要把三个神经元给结合起来,前两个输出作为后一个输入就行。
具体代码加注释在下面(我正常敲代码绝不会加这么详细的注释,我最讨厌的两件事:敲代码时加注释。看别人代码时别人没加注释)
神经网络代码
import numpy as np
def sigmoid(x):
# 这就是sigmoid函数,就是前几篇文章写的
return 1 / (1 + np.exp(-x))
class Neuron:
# 大家好老子TMD就是神经元,是你永远的梦魇
def __init__(self, weights, bias):
self.weights = weights
self.bias = bias
def feedforward(self, inputs):
# 这个就是向前输出的函数
total = np.dot(self.weights, inputs) + self.bias
return sigmoid(total)
class NeuralNetwork:
# 这个类是神经网络类
# 我们使用这个类来构建神经网络
def __init__(self):
weights = np.array([0, 1]) # 神经网络的权重
bias = 0 # 神经网络的偏移
# 我们先创建几个神经元,就是对神经元进行初始化
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)
# 前两个输出作为后一个的输入
out_o1 = self.o1.feedforward(np.array([out_h1, out_h2]))
# 返回最后的一个输出
return out_o1
# 开始创建神经网络,并设置初始的输入
network = NeuralNetwork()
x = np.array([2, 3])
print(network.feedforward(x)) # 0.7216325609518421
很简单,不是吗
三、训练一个神经网络
那么神经网络到底有神马用处,不要急,这里就有一个例子
我们现在有这样一个数据
姓名 | 体重(磅) | 身高(英寸) | 性别 |
---|---|---|---|
Alice | 133 | 65 | F |
Bob | 160 | 72 | M |
Charlie | 152 | 70 | M |
Diana | 120 | 60 | F |
然后我们以上面那个神经网络为基础进行训练,示意图如下
我们对上面的数据进行一下简单的处理,让它更好处理
姓名 | 体重(磅) | 身高(英寸) | 性别 |
---|---|---|---|
Alice | -2 | -1 | 1 |
Bob | 25 | 6 | 0 |
Charlie | 17 | 4 | 0 |
Diana | -15 | -6 | 1 |
我们分别以135和66为基准进行操作(一般来说我们都会以平均值来操作)
损失计算,loss的计算
如果你想得到好的结果,你得先知道什么样的算好的结果,大概好到什么程度,最好是有一个东西能进行量化计算,这就是神经网络的一个重要的方面,损失的计算
我们可以使用平均方差(MSE)来计算损失:MSE= 1 n ∑ i = 1 n ( y t r u e − y p r e d ) 2 \frac{1}{n} \sum_{i=1}^n (y_{true}-y_{pred})^2 n1∑i=1n(ytrue−ypred)2,简单解释一下:
- n是总的个数
- y t r u e y_{true} ytrue是真实值
- y p r e d y_{pred} ypred是预测值
然后我们就是通过这样一个公式来计算方差的平均值,预测的越好,loss越趋向于0
我们训练的目的就是找到更好的一个权值与偏移使最终的loss最小。
我们举个例子,加入我们最终的结果是预测出来是[0,0,0,0],那么最终的结果损失是
M S E = 1 4 ( 1 + 0 + 0 + 1 ) = 0.5 MSE=\frac{1}{4}(1+0+0+1)=0.5 MSE=41(1+0+0+1)=0.5
MSE计算代码
import numpy as np
def mse_loss(y_true, y_pred):
# y_true 和y_pred 是结果的数组
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
对权值和截距项进行改变
老逼登握拳-大的要来了。
之前我们说过,训练神经网路的办法就是想办法改变权值和截距项,减少损失,让神经网络更加匹配真实的结果。
这个的方法其实很简答,我并不打算具体去给数学公式去讲,如果有人想看数学公式的话可以去这篇文章看一下,做的特别详细,传送门:https://zhuanlan.zhihu.com/p/58964140
我就在这个地方简单讲一下基本的原理以及使用的方法,
首先根据上式,我们可以得到最终的loss与y_pred的一个关系,通过求导就能得到loss与y_pred的一个导数关系,然后y_pred又跟 w i w_i wi与 b i b_i bi有函数关系,进而我们可以得到y_pred和 w i a n d b i w_i \ and \ b_i wi and bi的导数关系,有了导数关系,我们就可以得到y_pred跟截距与权值是怎么的一个变化关系,我们就可以根据这样的变化关系来确定截距和权值的值,然后进行更新,使损失函数最小,结果更加精准。
根据求导规则,sigmoid函数的导数为 σ ′ ( x ) = σ ( x ) ∗ ( 1 − σ ( x ) ) \sigma'(x)=\sigma(x)*(1-\sigma(x)) σ′(x)=σ(x)∗(1−σ(x))。
我们就举个例子来计算一下 ∂ L ∂ w 1 \frac{\partial L}{\partial w_1} ∂w1∂L:
∂ L ∂ w 1 = ∂ L ∂ y p r e d ∂ y p r e d ∂ h 1 ∂ h 1 ∂ w 1 \frac{\partial L}{\partial w_1}=\frac{\partial L}{\partial y_{pred}}\frac{\partial y_{pred}}{\partial h_1}\frac{\partial h_1}{\partial w_1} ∂w1∂L=∂ypred∂L∂h1∂ypred∂w1∂h1
例子就举完了(好像有点短),不过问题不大,因为没有多少人喜欢去看着数学公式去具体理解,我们是程序员,不是数学家,我们是要会用,不一定要完全理解学会。
接下来就是训练的代码了
训练神经网络的代码
import numpy as np
def sigmoid(x):
# 这是sigmoid函数
return 1 / (1 + np.exp(-x))
def deriv_sigmoid(x):
# 这是sigmoid函数的导数
fx = sigmoid(x)
return fx * (1 - fx)
def mse_loss(y_true, y_pred):
# 这是计算损失函数的
return ((y_true - y_pred) ** 2).mean()
class NeuralNetwork:
def __init__(self):
# 开始设置权重,刚开始就随机设置就行了
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):
# 输入的数据是身高体重,是两个数据
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):
learn_rate = 0.1 # 这个是学习率
epochs = 1000 # 这是我们的训练次数
for epoch in range(epochs):
for x, y_true in zip(data, all_y_trues):
# zip函数是一个打包的函数,就是让x,y_true分别是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 = -2 * (y_true - y_pred)
# 神经元1号
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)
# 神经元1号
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)
# 神经元2号
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)
# 更新数据
# 神经元1
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
# 神经元2
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
# 神经元输出
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
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], [25, 6], [17, 4], [-15, -6]])
all_y_trues = np.array([1, 0, 0, 1])
# 开始进行神经网络的训练
network = NeuralNetwork()
network.train(data, all_y_trues)
训练完成后我们就可以进行一个预测了,只需要在最后加上这样一段代码
rytter=np.array([你的身高与体重信息])
print("Rytter:%.3f" % network.feedforward(rytter))
事实上由于训练样本太少,所以训练的结果会有点偏差,比如有时它会把瘦高的rytter识别成女生(本人身高185,是真的,体重不到130)
好!这就是本文的全部内容了,喜欢的朋友可以点个赞,本人网站:www.xuanworld.top
all_y_trues = np.array([1, 0, 0, 1])
开始进行神经网络的训练
network = NeuralNetwork()
network.train(data, all_y_trues)
训练完成后我们就可以进行一个预测了,只需要在最后加上这样一段代码
```python
rytter=np.array([你的身高与体重信息])
print("Rytter:%.3f" % network.feedforward(rytter))
事实上由于训练样本太少,所以训练的结果会有点偏差,比如有时它会把瘦高的rytter识别成女生(本人身高185,是真的,体重不到130)
好!这就是本文的全部内容了,喜欢的朋友可以点个赞。