NN

前向传播

简单神经网络结构

简单神经网络整体结构

  • 每一层由单元组成
  • 输入层是由训练集的实例特征向量传入
  • 经过链接点的权重传入下一层,一层的输出是下一层的输入
  • 隐藏层的个数是任意的,输入层有一层,输出层有一层
  • 每个单元也可以称作神经节点,根据生物学来源定义
  • 以上层数为2层的神经元(输入层不算)
  • 一层加权求和,然后根据非线性方程转化输出
  • 作为多层向前神经网络,理论上,如果有足够的隐藏层和足够大的训练集,可以模拟任何方程

单个神经元结构

单个神经元

  • 单个神经元由 输入项乘以权重加上偏置,最后经过激活函数得到输入
  • 以采用sigmod函数作为激活为例
  • s i g m o d ( ∑ i = 1 n w i ∗ x i + b ) sigmod(\sum_{i=1}^{n}w_i * x_i + b) sigmod(i=1nwixi+b
  • Sigmod函数:
  • 1 1 + e − x \frac{1}{1+e^{-x}} 1+ex1

后向传播算法

  • 通过迭代性的来处理训练集中的实例。
  • 对比经过神经网络输入层预测值与真实值之间
  • 反向来以最小化误差来更新每个链接的权重
  • 算法详细介绍
    • 输入:数据集| 学习率,一个多层前向神经网络
    • 输出:一个训练好的神经网络
    • 初始化权重和偏向:随机初始化在-1到1之间,或者-0.5 到0.5之间每个单元有一个偏向

根据误差反向传送计算过程

  • 对于输出层
  • E r r i = O j ( 1 − O j ) ( T j − O j ) Err_i=O_j(1-O_j)(T_j-O_j) Erri=Oj(1Oj)(TjOj)
  • 因为 sigmod 函数s(x)的求导的导数为
  • δ s ( x ) δ x = s ( x ) ( 1 − s ( x ) ) \frac{\delta s(x)}{\delta x} = s(x)(1-s(x)) δxδs(x)=s(x)(1s(x))
  • 对于掩藏层
  • E r r j = O j ( 1 − O j ) ∑ k E r r k w j k Err_j=O_j(1-O_j)\sum_kErr_{k}w_{jk} Errj=Oj(1Oj)kErrkwjk
  • 权重更新
  • Δ W i j = η E r r j O i w i j = w i j + Δ w i j η 为 学 习 了 率 \Delta W_{ij}=\eta Err_jO_i \\ w_{ij} = w_{ij} + \Delta w_{ij} \\ \eta 为学习了率 ΔWij=ηErrjOiwij=wij+Δwijη
  • 偏向更新
  • Δ θ j = η E r r j θ j = θ j + Δ j \Delta\theta_j = \eta Err_j \\ \theta_j = \theta_j + \Delta_j Δθj=ηErrjθj=θj+Δj

终止条件

  • 权重更新低于某个阈值
  • 预测的错误率低于某个阈值
  • 达到预设一定的循环函数

举一个例子

神经网络例子

前向传播计算

输入层

x = [1, 0, 1]

掩藏层的权重

  • 神经元4对应的权重与偏置
    w4 = [0.2, 0.4, -0.5]
    b4 = -0.4
  • 神经元5对应的权重与偏置
    w5 = [-0.3, 0.1, 0.2]
    b5 = 0.2
  • 掩藏层的输出结果计算
    O 4 = 1 1 + e − ( 0.2 ∗ 1 + 0.4 ∗ 0 + ( − 0.5 ) ∗ 1 + ( − 0.4 ) ) = 1 1 + e 0.7 = 0.33181 O_4 = \frac{1}{1+e^{-(0.2*1 + 0.4*0 + (-0.5) * 1 + (-0.4))}} = \frac{1}{1+e^{0.7}} = 0.33181 O4=1+e(0.21+0.40+(0.5)1+(0.4))1=1+e0.71=0.33181
    O 5 = 1 1 + e − ( − 0.3 ∗ 1 + 0.1 ∗ 0 + 1 ∗ 0.2 + 0.2 ) = 1 1 + e − 0.1 = 0.52498 O_5=\frac{1}{1+e^{-(-0.3*1 + 0.1*0 +1*0.2+0.2)}} = \frac{1}{1+e^{-0.1}} = 0.52498 O5=1+e(0.31+0.10+10.2+0.2)1=1+e0.11=0.52498

同理演算输出层结果

x = [0.33181 , 0.52498]

  • 输出层权重与偏置
    w6 = [-0.3, -0.2]
    b6 = 0.1
  • 输出层演算结果
    O 6 = 1 1 + e − ( 0.33181 ∗ ( − 0.3 ) + ( − 0.2 ) ∗ 0.52498 + 0.1 ) = 1 1 + e 0.10454 = 0.47389 O_6 = \frac{1}{ 1 + e^{-(0.33181 * (-0.3) + ( -0.2) * 0.52498 + 0.1)}} = \frac{1}{1+e^{0.10454}}=0.47389 O6=1+e(0.33181(0.3)+(0.2)0.52498+0.1)1=1+e0.104541=0.47389

误差反向传播计算

首先假设真实的结果为
T = 1 η = 0.9 T = 1 \\ \eta = 0.9 T=1η=0.9

  • 那神经元6的误差为:
    E r r 6 = 0.47389 ∗ ( 1 − 0.47389 ) ( 1 − 0.47389 ) = 0.13117 Err_6 = 0.47389 * (1-0.47389)(1 - 0.47389)= 0.13117 Err6=0.4738910.4738910.47389=0.13117
  • 神经元4的误差为:
    E r r 4 = 0.33181 ∗ ( 1 − 0.33181 ) ∗ ( − 0.3 ) ∗ 0.13117 = − 0.0087246 Err_4 = 0.33181 * (1-0.33181)* (-0.3) * 0.13117 = -0.0087246 Err4=0.3318110.33181(0.3)0.13117=0.0087246
  • 神经元5的误差为:
    E r r 5 = 0.52498 ∗ ( 1 − 0.52498 ) ∗ ( − 0.2 ) ∗ 0.13117 = − 0.0065421 Err_5 = 0.52498 * (1-0.52498)* (-0.2) * 0.13117 = -0.0065421 Err5=0.5249810.52498(0.2)0.13117=0.0065421

对神经元 4-6 与神经元5-6的更新

w 46 = − 0.3 + 0.9 ∗ 0.13117 ∗ 0.33181 = − 0.26083 w_{46} = -0.3 + 0.9 * 0.13117 * 0.33181 = -0.26083 w46=0.3+0.90.131170.33181=0.26083
w 56 = − 0.2 + 0.9 ∗ 0.13117 ∗ 0.52498 = − 0.13802 w_{56} = -0.2 + 0.9 * 0.13117 * 0.52498 = -0.13802 w56=0.2+0.90.131170.52498=0.13802
b 6 = 0.1 + 0.9 ∗ 0.13117 b_{6} = 0.1 + 0.9 * 0.13117 b6=0.1+0.90.13117
反向更新

### PyTorch 中 `nn.Module` 的使用方法与实例 #### 什么是 `nn.Module` `nn.Module` 是 PyTorch 中用于构建神经网络的核心组件之一。它是所有神经网络模型的基类,所有的自定义层或模型都需要继承这个类并重写其方法[^4]。 #### 如何创建一个简单的 `nn.Module` 下面是一个基本的例子,展示如何通过继承 `nn.Module` 来创建自己的神经网络: ```python import torch from torch import nn class SimpleNet(nn.Module): def __init__(self, input_size, hidden_size, output_size): super(SimpleNet, self).__init__() self.fc1 = nn.Linear(input_size, hidden_size) # 定义全连接层 self.relu = nn.ReLU() # 非线性激活函数 self.fc2 = nn.Linear(hidden_size, output_size) def forward(self, x): out = self.fc1(x) out = self.relu(out) out = self.fc2(out) return out # 初始化网络参数 input_size = 10 hidden_size = 20 output_size = 5 model = SimpleNet(input_size, hidden_size, output_size) print(model) ``` 上述代码展示了如何定义一个具有两层全连接层的小型神经网络,并使用 ReLU 激活函数作为非线性变换[^3]。 #### 使用预定义模块组合复杂结构 除了手动编写每一层外,还可以利用 PyTorch 提供的各种内置模块快速搭建复杂的网络架构。例如,在 YOLO 或 Transformer 等高级框架中,通常会涉及多个子模块的嵌套调用[^2]。 以下是如何在一个更大的网络中集成多个子模块的一个例子: ```python class ComplexModel(nn.Module): def __init__(self): super(ComplexModel, self).__init__() # 子模块初始化 self.feature_extractor = nn.Sequential( nn.Conv2d(in_channels=3, out_channels=64, kernel_size=3), nn.ReLU(), nn.MaxPool2d(kernel_size=2) ) self.classifier = nn.Sequential( nn.Linear(64 * 16 * 16, 128), # 假设输入图像大小为 (3, 32, 32) nn.ReLU(), nn.Dropout(p=0.5), nn.Linear(128, 10) ) def forward(self, x): features = self.feature_extractor(x) flattened = torch.flatten(features, start_dim=1) logits = self.classifier(flattened) return logits complex_model = ComplexModel() print(complex_model) ``` 在这个例子中,我们先通过卷积操作提取特征图,再将其展平并通过多层感知机完成分类任务[^1]。 #### 关于 `nn.Linear()` 函数的具体说明 `nn.Linear()` 是一种实现矩阵乘法的操作,常用来表示全连接层(Fully Connected Layer)。它的主要作用是对输入数据应用线性变换 \( y = Wx + b \),其中 \(W\) 和 \(b\) 分别代表权重和偏置向量。 以下是单独测试 `nn.Linear()` 功能的一段简单脚本: ```python linear_layer = nn.Linear(in_features=4, out_features=2) input_tensor = torch.tensor([[1., 2., 3., 4.]]) output_tensor = linear_layer(input_tensor) print(f'Input Tensor:\n{input_tensor}') print(f'Output Tensor after Linear Transformation:\n{output_tensor}') ``` 这段代码演示了一个四维输入被映射成二维输出的过程。 --- ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值