devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

深度学习Python (三）使用Python实现简单的神经网络_ntru python实现

作者：从前慢现在也慢 | 2024-03-18 08:24:09

赞

踩

ntru python实现

一、搭建基本模块—神经元

在说神经网络之前，我们讨论一下神经元（Neurons），它是神经网络的基本单元。神经元先获得输入，然后执行某些数学运算后，再产生一个输出。下面是两个输入的神经元。

                                   神经元neuron

在这个神经元里，输入总共经历了3步数学运算，
先将输入乘以权重（weight）：

x1​→x1​∗w1

x2​→x2​∗w2​

(x1​∗w1​)+(x2​∗w2​)+b

最后经过激活函数（activation function）处理得到输出：
y=f((x1​∗w1​)+(x2​∗w2​)+b) 

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

                                            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代码是：

  1. import numpy as np
  2.  
  3. def sigmoid(z):
  4.     """
  5.     激活函数 f(z) = 1 / (1 * e^(-z))
  6.     :param z:
  7.     :return:
  8.     """
  9.     return 1 / (1 + np.exp(-z))
  10.  
  11. class Neuron():
  12.     def __init__(self,weights,bias):
  13.         self.weights=weights
  14.         self.bias=bias
  15.  
  16.     def feedforward(self,inputs):
  17.         z=np.dot(self.weights,inputs)+self.bias
  18.         return sigmoid(z)
  19.  
  20. weights=np.array([0,1])# w1 = 0, w2 = 1
  21. bias=4
  22. n=Neuron(weights,bias)
  23.  
  24. x=np.array([2,3])# inputs
  25. print(n.feedforward(x))# 0.9990889488055994
  26.

二、搭建神经网络

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

                                  network

这个网络有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

神经网络可以具有任意数量的层，这些层中可以具有任意数量的神经元。 基本思想保持不变：将输入通过网络中的神经元向前馈送，最后获得输出。 为简单起见，本文的其余部分将继续使用上图所示的网络。

以下是实现代码：

  1. import numpy as np
  2.  
  3. def sigmoid(z):
  4.     """
  5.     激活函数 f(z) = 1 / (1 * e^(-z))
  6.     :param z:
  7.     :return:
  8.     """
  9.     return 1 / (1 + np.exp(-z))
  10.  
  11. class Neuron():
  12.     def __init__(self,weights,bias):
  13.         self.weights=weights
  14.         self.bias=bias
  15.  
  16.     def feedforward(self,inputs):
  17.         z=np.dot(self.weights,inputs)+self.bias
  18.         return sigmoid(z)
  19.  
  20. weights=np.array([0,1])# w1 = 0, w2 = 1
  21. bias=4
  22. n=Neuron(weights,bias)
  23.  
  24. x=np.array([2,3])# inputs
  25. print(n.feedforward(x))# 0.9990889488055994
  26.  
  27.  
  28. class OurNeuralNetWorks():
  29.     """
  30.     A neural network with:
  31.       - 2 inputs
  32.       - a hidden layer with 2 neurons (h1, h2)
  33.       - an output layer with 1 neuron (o1)
  34.     Each neural has the same weights and bias:
  35.       - w = [0, 1]
  36.       - b = 0
  37.     """
  38.     def __init__(self):
  39.         weights=np.array([0,1])
  40.         bias=0
  41.  
  42.         # The Neuron class here is from the previous section
  43.         self.h1=Neuron(weights,bias)
  44.         self.h2=Neuron(weights,bias)
  45.         self.o1=Neuron(weights,bias)
  46.     def feedforward(self,z):
  47.         out_h1=self.h1.feedforward(z)
  48.         out_h2=self.h2.feedforward(z)
  49.         # The inputs for o1 are the outputs from h1 and h2
  50.         out_o1=self.o1.feedforward(np.array([out_h1,out_h2]))
  51.         return out_o1
  52.  
  53. network=OurNeuralNetWorks()
  54. x=np.array([2,3])
  55. print(network.feedforward(x))# 0.7216325609518421
  56.

 

三、训练神经网络

现在我们已经学会了如何搭建神经网络，现在再来学习如何训练它，其实这是一个优化的过程。
假设有一个数据集，包含4个人的身高、体重和性别：

NameWeight (lb)Height (in)Gender
Alice13365F
Bob16072M
Charlie15270M
Diana12060F

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

 
                                       network

为了简便起见，我们将每个人的身高、体重减去一个固定数值（任意选择的135，66），把性别男定义为1、性别女定义为0。

以使数字看起来不错。 通常，可以选择每列的平均值。

NameWeight (减去135)Height (减去66)Gender
Alice-2-10
Bob2561
Charlie1741
Diana-15-60

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

比如用均方误差（MSE）来定义损失：

n是样本的数量，在上面的数据集中是4；
y代表人的性别，男性是1，女性是0；
ytrue​  是变量的真实值，ypred 是变量的预测值。

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

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

MSE= 1/4 ​(1+0+0+1)=0.5

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

四、减少神经网络损失

  1. def mse_loss(y_true, y_pred):
  2.     # y_true and y_pred are numpy arrays of the same length
  3.     return ((y_true - y_pred) ** 2).mean()
  4.  
  5. y_true = np.array([1, 0, 0, 1])
  6. y_pred = np.array([0, 0, 0, 0])
  7.  
  8. print(mse_loss(y_true, y_pred)) # 0.5

我们现在有一个明确的目标：最大程度地减少神经网络的损失。 我们知道我们可以改变网络的权重和偏见来影响其预测，但是我们如何以减少损失的方式做到这一点呢？

Note：本节使用了一些多变量演算。 如果您对微积分不满意，请随时跳过数学部分。

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

NameWeight (minus 135)Height (minus 66)Gender
Alice-2-11

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

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

network2

所以损失函数实际上是包含多个权重、偏置的多元函数：
L(w1​,w2​,w3​,w4​,w5​,w6​,b1​,b2​,b3​)

（注意！前方高能！需要你有一些基本的多元函数微分知识，比如偏导数、链式求导法则。我建议您随身携带一支笔和一支纸，它可以帮助您理解。）
如果调整一下w1，损失函数是会变大还是变小？我们需要知道偏导数 ∂L/∂w1 是正是负才能回答这个问题。

根据链式求导法则：

可以求得第一项偏导数：

 

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

ypred​ = o1​ = f(w5​h1​+w6​h2​+b3​)

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

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

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

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

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

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

神经网络的输出y=0.524，没有显示出强烈的是男（1）是女（0）的证据。现在的预测效果还很不好。
这个结果告诉我们：如果增大w1，损失函数L会有一个非常小的增长。

五、随机梯度下降

下面将使用一种称为随机梯度下降（SGD）的优化算法，来训练网络。
经过前面的运算，我们已经有了训练神经网络所有数据。但是该如何操作？SGD定义了改变权重和偏置的方法：

η 是一个常数，称为学习率（learning rate），它决定了我们训练网络速率的快慢。将  

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

  • 从数据集中选择一个样本；
  • 计算损失函数对所有权重和偏置的偏导数；
  • 使用更新公式更新每个权重和偏置；
  • 回到第1步。

 

Python代码实现这个过程：

  1. import numpy as np
  2.  
  3.  
  4. def sigmoid(x):
  5.     # Sigmoid activation function: f(x) = 1 / (1 + e^(-x))
  6.     return 1 / (1 + np.exp(-x))
  7.  
  8.  
  9. def deriv_sigmoid(x):
  10.     #sigmoid函数的导数: f'(x) = f(x) * (1 - f(x))
  11.     fx = sigmoid(x)
  12.     return fx * (1 - fx)
  13.  
  14.  
  15. def mse_loss(y_true, y_pred):
  16.     # y_true and y_pred are numpy arrays of the same length
  17.     return ((y_true - y_pred) ** 2).mean()
  18.  
  19.  
  20. class OurNeuralNetwork():
  21.     """
  22.     A neural network with:
  23.       - 2 inputs
  24.       - a hidden layer with 2 neurons (h1, h2)
  25.       - an output layer with 1 neuron (o1)
  27.     *** DISCLAIMER ***
  28.     The code below is intend to be simple and educational, NOT optimal.
  29.     Real neural net code looks nothing like this. Do NOT use this code.
  30.     Instead, read/run it to understand how this specific network works.
  31.     """
  32.  
  33.     def __init__(self):
  34.         # weights
  35.         self.w1 = np.random.normal()
  36.         self.w2 = np.random.normal()
  37.         self.w3 = np.random.normal()
  38.         self.w4 = np.random.normal()
  39.         self.w5 = np.random.normal()
  40.         self.w6 = np.random.normal()
  41.         # biases
  42.         self.b1 = np.random.normal()
  43.         self.b2 = np.random.normal()
  44.         self.b3 = np.random.normal()
  45.  
  46.     def feedforward(self, x):
  47.         # x is a numpy array with 2 elements, for example [input1, input2]
  48.         h1 = sigmoid(self.w1 * x[0] + self.w2 * x[1] + self.b1)
  49.         h2 = sigmoid(self.w3 * x[0] + self.w4 * x[1] + self.b2)
  50.         o1 = sigmoid(self.w5 * h1 + self.w6 * h2 + self.b3)
  51.         return o1
  52.  
  53.     def train(self, data, all_y_trues):
  54.         """
  55.         - data is a (n x 2) numpy array, n = # samples in the dataset.
  56.         - all_y_trues is a numpy array with n elements.
  57.         Elements in all_y_trues correspond to those in data.
  58.         """
  59.         learn_rate = 0.1
  60.         epochs = 1000  # number of times to loop through the entire dataset
  61.  
  62.         for epoch in range(epochs):
  63.             for x, y_true in zip(data, all_y_trues):
  64.                 # - - -前馈计算
  65.                 sum_h1 = self.w1 * x[0] + self.w2 * x[1] + self.b1
  66.                 h1 = sigmoid(sum_h1)
  67.  
  68.                 sum_h2 = self.w3 * x[0] + self.w4 * x[1] + self.b2
  69.                 h2 = sigmoid(sum_h2)
  70.  
  71.                 sum_o1 = self.w5 * h1 + self.w6 * h2 + self.b3
  72.                 o1 = sigmoid(sum_o1)
  73.                 y_pred = o1 # 单个样本的预测值
  74.  
  75.                 # - - -反馈计算
  76.                 # 计算偏导数
  77.                 # 损失函数针对于预测结果求导 d_L / d_ypred
  78.                 d_L_d_ypred = -2 * (y_true - y_pred)
  79.  
  80.                 # 神经元 o1
  81.                 d_ypred_d_w5 = h1 * deriv_sigmoid(sum_o1) # ypred 函数针对于 w5 的导数
  82.                 d_ypred_d_w6 = h2 * deriv_sigmoid(sum_o1) # ypred 函数针对于 w6 的导数
  83.                 d_ypred_d_b3 = deriv_sigmoid(sum_o1) # ypred 函数针对于 b3 的导数
  84.  
  85.                 d_ypred_d_h1 = self.w5 * deriv_sigmoid(sum_o1) # ypred 函数针对于 h1 的导数
  86.                 d_ypred_d_h2 = self.w6 * deriv_sigmoid(sum_o1) # ypred 函数针对于 h1 的导数
  87.  
  88.                 # 神经元 h1
  89.                 d_h1_d_w1 = x[0] * deriv_sigmoid(sum_h1) # h1 函数针对于 w1 的导数
  90.                 d_h1_d_w2 = x[1] * deriv_sigmoid(sum_h1) # h1 函数针对于 w2 的导数
  91.                 d_h1_d_b1 = deriv_sigmoid(sum_h1) # h1 函数针对于 b1 的导数
  92.  
  93.                 # 神经元 h2
  94.                 d_h2_d_w3 = x[0] * deriv_sigmoid(sum_h2) # h2 函数针对于 w3 的导数
  95.                 d_h2_d_w4 = x[0] * deriv_sigmoid(sum_h2) # h2 函数针对于 w4 的导数
  96.                 d_h2_d_b2 = deriv_sigmoid(sum_h2) # h2 函数针对于 b2 的导数
  97.  
  98.                 # - - - 更新权重和偏置
  99.                 # 神经元 o1
  100.                 self.w5 -= learn_rate * d_L_d_ypred * d_ypred_d_w5
  101.                 self.w6 -= learn_rate * d_L_d_ypred * d_ypred_d_w6
  102.                 self.b3 -= learn_rate * d_L_d_ypred * d_ypred_d_b3
  103.  
  104.                 # 神经元 h1
  105.                 self.w1 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_w1
  106.                 self.w2 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_w2
  107.                 self.b1 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_b1
  108.  
  109.                 # 神经元 h2
  110.                 self.w3 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h2_d_w3
  111.                 self.w4 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h2_d_w4
  112.                 self.b2 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h2_d_b2
  113.  
  114.             # - - - Calculate total loss at the end of each epoch
  115.             if epoch % 10 == 0:
  116.                 y_preds = np.apply_along_axis(self.feedforward, 1, data)
  117.                 loss = mse_loss(all_y_trues, y_preds)
  118.                 print("Epoch %d loss: %.3f", (epoch, loss))
  119.  
  120.  
  121. # 训练样本数据集
  122. data = np.array([
  123.     [-2, -1],  # Alice
  124.     [25, 6],  # Bob
  125.     [17, 4],  # Charlie
  126.     [-15, -6]  # diana
  127. ])
  128. # 训练样本标签
  129. all_y_trues = np.array([
  130.     1,  # Alice
  131.     0,  # Bob
  132.     0,  # Charlie
  133.     1  # diana
  134. ])
  135.  
  136. # 训练我们的神经网络
  137. network = OurNeuralNetwork() # 初始化我们的权重和偏置
  138. network.train(data, all_y_trues)
  139.  
  140. # 进行预测
  141. emily = np.array([-7, -3]) # 128 pounds, 63 inches
  142. frank = np.array([20, 2])  # 155 pounds, 68 inches
  143. print("Emily: %.3f" % network.feedforward(emily)) # 0.968 - F
  144. print("Frank: %.3f" % network.feedforward(frank)) # 0.039 - M

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

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

  1. # 进行预测
  2. emily = np.array([-7, -3]) # 128 pounds, 63 inches
  3. frank = np.array([20, 2])  # 155 pounds, 68 inches
  4. print("Emily: %.3f" % network.feedforward(emily)) # 0.968 - F
  5. print("Frank: %.3f" % network.feedforward(frank)) # 0.039 - M

参考链接：https://victorzhou.com/blog/intro-to-neural-networks/

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/261668
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号