用Python实现一个基础的神经网络模型

这篇具有很好参考价值的文章主要介绍了用Python实现一个基础的神经网络模型。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录

前言

一、神经元

1.1一个简单的例子 

1.2编码一个神经元

1.3把神经元组装成网络

二、前馈 

三、训练神经网络

四、总结


 文章来源地址https://www.toymoban.com/news/detail-413503.html

前言

        可能一提到神经网络,许多小伙伴就会感觉头大,不知道看眼前的你又是怎样的感受呢?【神经网络】这个词听起来让人觉得很高大上,但实际上神经网络算法要比人们想象的简单。今天我将手把手教你用Python来实现一个基础的神经网络模型,理解其背后的原理。

 

一、神经元

        首先让我们看看神经网络的基本单位,神经元。神经元接受输入,对其做一些数据操作,然后产生输出。例如,这是一个2-输入神经元:

用Python实现一个基础的神经网络模型

 这里发生了三个事情。首先,每个输入都跟一个权重相乘(红色):

用Python实现一个基础的神经网络模型

 然后,加权后的输入求和,加上一个偏差b(绿色):

用Python实现一个基础的神经网络模型

 激活函数的用途是将一个无边界的输入,转变成一个可预测的形式。常用的激活函数就就是S型函数:

用Python实现一个基础的神经网络模型

S型函数的值域是(0, 1)。简单来说,就是把(−∞, +∞)压缩到(0, 1) ,很大的负数约等于0,很大的正数约等于1。

1.1一个简单的例子 

假设我们有一个神经元,激活函数就是S型函数,其参数如下:

用Python实现一个基础的神经网络模型

 

w=[0,1] 就是以向量的形式表示w1=0,w2=1。现在,我们给这个神经元一个输入x=[2.3]。我们用点积来表示:

用Python实现一个基础的神经网络模型

 当输入是[2, 3]时,这个神经元的输出是0.999。给定输入,得到输出的过程被称为前馈。

1.2编码一个神经元

让我们来实现一个神经元!用Python的NumPy库来完成其中的数学计算:

import numpy as np

def sigmoid(x):
  # 我们的激活函数: f(x) = 1 / (1 + e^(-x))
  return 1 / (1 + np.exp(-x))

class Neuron:
  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]) # 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

还记得这个数字吗?就是我们前面算出来的例子中的0.999。

1.3把神经元组装成网络

所谓的神经网络就是一堆神经元。这就是一个简单的神经网络:

用Python实现一个基础的神经网络模型

这个网络有两个输入,一个有两个神经元( h1和h2 )的隐藏层,以及一个有一个神经元(o1)的输出层。要注意,o1的输入就是h1和h2的输出,这样就组成了一个网络。 

隐藏层就是输入层和输出层之间的层,隐藏层可以是多层的。

二、前馈 

        我们继续用前面图中的网络,假设每个神经元的权重都是w=[0,1]截距项也相同b=0,激活函数也都是S型函数。分别用h1,h2表示相应的神经元的输出。

当输入x=[2,3时,会得到什么结果?这个神经网络对输入的输出是0.7216,很简单。

        一个神经网络的层数以及每一层中的神经元数量都是任意的。基本逻辑都一样:输入在神经网络中向前传输,最终得到输出。接下来,我们会继续使用前面的这个网络。

接下来我们实现这个神经网络的前馈机制,还是这个图:

用Python实现一个基础的神经网络模型

import numpy as np


class OurNeuralNetwork:
  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)

    # o1的输入是h1和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

 结果正确,看上去没问题。

三、训练神经网络

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和y_pred是相同长度的numpy数组。
  return ((y_true - y_pred) ** 2).mean()

class OurNeuralNetwork:
  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是一个有2个元素的数字数组。
    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 # 遍历整个数据集的次数

    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

        # --- 计算偏导数。
        # --- 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)

        # --- 更新权重和偏差
        # 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

      # --- 在每次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)

 随着网络的学习,损失在稳步下降。

用Python实现一个基础的神经网络模型

现在我们可以用这个网络来预测性别了:

# 做一些预测
emily = np.array([-7, -3]) # 128 磅, 63 英寸
frank = np.array([20, 2])  # 155 磅, 68 英寸
print("Emily: %.3f" % network.feedforward(emily)) # 0.951 - F
print("Frank: %.3f" % network.feedforward(frank)) # 0.039 - M

四、总结

搞定了一个简单的神经网络,快速回顾一下:

  • 介绍了神经网络的基本结构——神经元;

  • 在神经元中使用S型激活函数;

  • 神经网络就是连接在一起的神经元;

  • 构建了一个数据集,输入(或特征)是体重和身高,输出(或标签)是性别;

  • 学习了损失函数和均方差损失;

  • 训练网络就是最小化其损失;

  • 用反向传播方法计算偏导;

  • 用随机梯度下降法训练网络;

接下来你还可以:

  • 用机器学习库实现更大更好的神经网络,例如TensorFlow、Keras和PyTorch;

  • 在浏览器中实现神经网络;

  • 其他类型的激活函数;

  • 其他类型的优化器;

  • 学习卷积神经网络,这给计算机视觉领域带来了革命;

  • 学习递归神经网络,常用语自然语言处理;

 

到了这里,关于用Python实现一个基础的神经网络模型的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Python实现PSO粒子群优化算法优化BP神经网络回归模型(BP神经网络回归算法)项目实战

    说明:这是一个机器学习实战项目(附带数据+代码+文档+视频讲解),如需数据+代码+文档+视频讲解可以直接到文章最后获取。 PSO是粒子群优化算法(Particle Swarm Optimization)的英文缩写,是一种基于种群的随机优化技术,由Eberhart和Kennedy于1995年提出。粒子群算法模仿昆虫、

    2024年02月13日
    浏览(50)
  • Python实现猎人猎物优化算法(HPO)优化BP神经网络回归模型(BP神经网络回归算法)项目实战

    说明:这是一个机器学习实战项目(附带 数据+代码+文档+视频讲解 ),如需 数据+代码+文档+视频讲解 可以直接到文章最后获取。 猎人猎物优化搜索算法(Hunter–prey optimizer, HPO)是由Naruei Keynia于2022年提出的一种最新的优化搜索算法。受到捕食动物(如狮子、豹子和狼)和猎物

    2024年02月09日
    浏览(49)
  • Python基于PyTorch实现循环神经网络回归模型(LSTM回归算法)项目实战

    说明:这是一个机器学习实战项目(附带 数据+代码+文档+视频讲解 ),如需 数据+代码+文档+视频讲解 可以直接到文章最后获取。 LSTM网络是目前更加通用的循环神经网络结构,全称为Long Short-Term Memory,翻译成中文叫作“长‘短记忆’”网络。读的时候,“长”后面要稍

    2024年02月16日
    浏览(54)
  • Python基于PyTorch实现循环神经网络分类模型(LSTM分类算法)项目实战

    说明:这是一个机器学习实战项目(附带 数据+代码+文档+视频讲解 ),如需 数据+代码+文档+视频讲解 可以直接到文章最后获取。 LSTM网络是目前更加通用的循环神经网络结构,全称为Long Short-Term Memory,翻译成中文叫作“长‘短记忆’”网络。读的时候,“长”后面要稍

    2024年02月16日
    浏览(49)
  • Python基于PyTorch实现卷积神经网络分类模型(CNN分类算法)项目实战

    说明:这是一个机器学习实战项目(附带 数据+代码+文档+视频讲解 ),如需 数据+代码+文档+视频讲解 可以直接到文章最后获取。 卷积神经网络,简称为卷积网络,与普通神经网络的区别是它的卷积层内的神经元只覆盖输入特征局部范围的单元,具有稀疏连接(sparse connec

    2024年02月15日
    浏览(47)
  • Python基于PyTorch实现卷积神经网络回归模型(CNN回归算法)项目实战

    说明:这是一个机器学习实战项目(附带 数据+代码+文档+视频讲解 ),如需 数据+代码+文档+视频讲解 可以直接到文章最后获取。 卷积神经网络,简称为卷积网络,与普通神经网络的区别是它的卷积层内的神经元只覆盖输入特征局部范围的单元,具有稀疏连接(sparse connec

    2024年02月15日
    浏览(45)
  • python开发构建轻量级卷积神经网络模型实现手写甲骨文识别系统

    手写汉字、手写数字、手写字母识别模型都已经做过很多了,但是手写甲骨文识别这个应该都是很少有听说过的吧,今天也是看到这个数据集就想着基于这批手写甲骨文数据集开发构建识别模型,首先来看下效果图: 接下来看下对应使用的数据集:  共包含40个不同类别对象

    2024年02月08日
    浏览(52)
  • Python实现GA遗传算法优化循环神经网络分类模型(LSTM分类算法)项目实战

    说明:这是一个机器学习实战项目(附带数据+代码+文档+视频讲解),如需数据+代码+文档+视频讲解可以直接到文章最后获取。 遗传算法(Genetic Algorithm,GA)最早是由美国的 John holland于20世纪70年代提出,该算法是根据大自然中生物体进化规律而设计提出的。是模拟达尔文生

    2024年02月15日
    浏览(189)
  • Python实现人工神经网络回归模型(MLPRegressor算法)并基于网格搜索(GridSearchCV)进行优化项目实战

    说明:这是一个机器学习实战项目(附带 数据+代码+文档+视频讲解 ),如需 数据+代码+文档+视频讲解 可以直接到文章最后获取。 1.项目背景 经济广告是指以营利为目的的广告,通常是商业广告,它是为推销商品或提供服务,以付费方式通过广告媒体向消费者或用户传播商

    2023年04月08日
    浏览(82)
  • Python实现ACO蚁群优化算法优化卷积神经网络回归模型(CNN回归算法)项目实战

    说明:这是一个机器学习实战项目(附带数据+代码+文档+视频讲解),如需数据+代码+文档+视频讲解可以直接到文章最后获取。 蚁群优化算法(Ant Colony Optimization, ACO)是一种源于大自然生物世界的新的仿生进化算法,由意大利学者M. Dorigo, V. Maniezzo和A.Colorni等人于20世纪90年代初

    2024年02月05日
    浏览(41)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包