当前位置: 首页 > article >正文

PyTorch 全连接层(Fully Connected Layer)详解

全连接层(Fully Connected Layer),也被称为密集层(Dense Layer)或线性层(Linear Layer),是神经网络中最基本也是最重要的层之一。它在各种神经网络模型中扮演着关键角色,广泛应用于图像分类、文本处理、回归分析等各类任务中。本文将详细介绍全连接层的基本概念、PyTorch中的实现、输入和输出维度的变化、主要解决的问题以及最典型的应用场景。

基本概念

在全连接层中,每一个输入节点与输出节点之间都存在连接。假设有一个输入向量 x \mathbf{x} x 和一个输出向量 y \mathbf{y} y,全连接层的计算过程可以表示为:

y = W x + b \mathbf{y} = \mathbf{W} \mathbf{x} + \mathbf{b} y=Wx+b

其中:

  • W \mathbf{W} W 是权重矩阵,包含了所有连接的权重。
  • b \mathbf{b} b 是偏置向量,通常用于调整输出的线性变换。

权重矩阵 W \mathbf{W} W

  • 权重矩阵 W \mathbf{W} W 的维度为 D o u t × D i n D_{out} \times D_{in} Dout×Din,其中 D i n D_{in} Din 是输入特征的数量, D o u t D_{out} Dout 是输出特征的数量。
  • 每个元素 W i j W_{ij} Wij 表示输入特征 x j x_j xj 对输出特征 y i y_i yi 的影响程度。
  • 在训练过程中,权重矩阵 W \mathbf{W} W 是通过反向传播算法进行更新的,目标是最小化损失函数,使得模型的预测结果尽可能接近真实值。

偏置向量 b \mathbf{b} b

  • 偏置向量 b \mathbf{b} b 的维度为 D o u t D_{out} Dout
  • 每个元素 b i b_i bi 用于调整输出特征 y i y_i yi 的线性变换,确保模型具有更好的拟合能力。
  • 偏置项的引入可以帮助模型更好地适应数据的分布,尤其是在输入特征为零时,偏置项可以提供非零的输出。

全连接层通过线性变换和非线性激活函数,对输入特征进行变换和抽象,提取更高层次、更有代表性的特征。

PyTorch 中的 nn.Linear

在PyTorch中,nn.Linear 是一个用于创建全连接层的类。它的构造函数如下:

class torch.nn.Linear(in_features, out_features, bias=True)
参数说明
  • in_features: 输入特征的数量,即输入向量的维度。
  • out_features: 输出特征的数量,即输出向量的维度。
  • bias(可选,默认为True):是否包含偏置项 b \mathbf{b} b
示例

以下是一个简单的示例,展示了如何在PyTorch中使用 nn.Linear 来创建和使用全连接层。

import torch
import torch.nn as nn

# 定义输入和输出的维度
input_dim = 4
output_dim = 2

# 创建一个全连接层
fc_layer = nn.Linear(input_dim, output_dim)

# 打印初始化的权重和偏置
print("Initial weights:", fc_layer.weight)
print("Initial bias:", fc_layer.bias)

# 创建一个输入向量
input_vector = torch.randn(1, input_dim)

# 通过全连接层计算输出
output_vector = fc_layer(input_vector)

print("Input vector:", input_vector)
print("Output vector:", output_vector)
输出结果

以下是对输出结果的详细解释:

权重矩阵和偏置向量

首先,让我们查看初始化的权重矩阵 W \mathbf{W} W 和偏置向量 b \mathbf{b} b

Initial weights: Parameter containing:
tensor([[ 0.1385, -0.3149, -0.2930, -0.1360],
        [-0.4598,  0.4449,  0.2633,  0.2245]], requires_grad=True)
Initial bias: Parameter containing:
tensor([-0.0132, -0.4703], requires_grad=True)
  • 权重矩阵 W \mathbf{W} W 的形状是 2 × 4 2 \times 4 2×4,表示有两个输出特征(每个输出特征对应一行),四个输入特征(每个输入特征对应一列)。
  • 偏置向量 b \mathbf{b} b 的形状是 2 2 2,表示每个输出特征有一个偏置。
输入向量

输入向量 x \mathbf{x} x 如下:

Input vector: tensor([[ 0.6784, -0.5674, -0.5408, -0.0243]])
  • 输入向量 x \mathbf{x} x 的形状是 1 × 4 1 \times 4 1×4,表示一个样本(批大小为1),包含四个特征。
输出向量

输出向量 y \mathbf{y} y 如下:

Output vector: tensor([[ 0.4212, -1.1824]], grad_fn=<AddmmBackward0>)
  • 输出向量 y \mathbf{y} y 的形状是 1 × 2 1 \times 2 1×2,表示一个样本(批大小为1),包含两个输出特征。
计算过程解析

全连接层的计算过程可以表示为:

y = W x + b \mathbf{y} = \mathbf{W} \mathbf{x} + \mathbf{b} y=Wx+b

让我们逐步计算:

  1. 矩阵乘法 W x \mathbf{W} \mathbf{x} Wx
    • 首先将权重矩阵 W \mathbf{W} W 与输入向量 x \mathbf{x} x 相乘。

W = [ 0.1385 − 0.3149 − 0.2930 − 0.1360 − 0.4598 0.4449 0.2633 0.2245 ] \mathbf{W} = \begin{bmatrix} 0.1385 & -0.3149 & -0.2930 & -0.1360 \\ -0.4598 & 0.4449 & 0.2633 & 0.2245 \end{bmatrix} W=[0.13850.45980.31490.44490.29300.26330.13600.2245]

x = [ 0.6784 − 0.5674 − 0.5408 − 0.0243 ] \mathbf{x} = \begin{bmatrix} 0.6784 \\ -0.5674 \\ -0.5408 \\ -0.0243 \end{bmatrix} x= 0.67840.56740.54080.0243

计算:

W x = [ 0.1385 × 0.6784 + ( − 0.3149 ) × ( − 0.5674 ) + ( − 0.2930 ) × ( − 0.5408 ) + ( − 0.1360 ) × ( − 0.0243 ) − 0.4598 × 0.6784 + 0.4449 × ( − 0.5674 ) + 0.2633 × ( − 0.5408 ) + 0.2245 × ( − 0.0243 ) ] \mathbf{W} \mathbf{x} = \begin{bmatrix} 0.1385 \times 0.6784 + (-0.3149) \times (-0.5674) + (-0.2930) \times (-0.5408) + (-0.1360) \times (-0.0243) \\ -0.4598 \times 0.6784 + 0.4449 \times (-0.5674) + 0.2633 \times (-0.5408) + 0.2245 \times (-0.0243) \end{bmatrix} Wx=[0.1385×0.6784+(0.3149)×(0.5674)+(0.2930)×(0.5408)+(0.1360)×(0.0243)0.4598×0.6784+0.4449×(0.5674)+0.2633×(0.5408)+0.2245×(0.0243)]

计算结果:

W x = [ 0.4344 − 0.7121 ] \mathbf{W} \mathbf{x} = \begin{bmatrix} 0.4344 \\ -0.7121 \end{bmatrix} Wx=[0.43440.7121]

  1. 加上偏置向量 b \mathbf{b} b

b = [ − 0.0132 − 0.4703 ] \mathbf{b} = \begin{bmatrix} -0.0132 \\ -0.4703 \end{bmatrix} b=[0.01320.4703]

加上偏置项:

y = W x + b = [ 0.4344 − 0.0132 − 0.7121 − 0.4703 ] = [ 0.4212 − 1.1824 ] \mathbf{y} = \mathbf{W} \mathbf{x} + \mathbf{b} = \begin{bmatrix} 0.4344 - 0.0132 \\ -0.7121 - 0.4703 \end{bmatrix} = \begin{bmatrix} 0.4212 \\ -1.1824 \end{bmatrix} y=Wx+b=[0.43440.01320.71210.4703]=[0.42121.1824]

这与输出向量 y \mathbf{y} y 的结果完全一致:

Output vector: tensor([[ 0.4212, -1.1824]], grad_fn=<AddmmBackward0>)

维度变化

torch.nn.Linear 的输入和输出维度是通过权重矩阵 W \mathbf{W} W 和偏置向量 b \mathbf{b} b 进行线性变换的结果。理解这些维度变化对构建和调试神经网络模型非常重要。

  1. 输入维度

    • 输入可以是一个二维张量(矩阵),其形状为 (N, D_in),其中 N 是批量大小(batch size),D_in 是输入特征的数量。
    • 输入也可以是一个一维张量(向量),其形状为 (D_in,),即单个样本的输入。
  2. 输出维度

    • 对于二维输入张量,输出将是一个二维张量,其形状为 (N, D_out),其中 D_out 是输出特征的数量。
    • 对于一维输入张量,输出将是一个一维张量,其形状为 (D_out,)
示例

以下是一个具体的示例,展示了如何使用 nn.Linear 以及输入和输出的维度变化。

import torch
import torch.nn as nn

# 定义输入和输出的特征维度
input_dim = 4
output_dim = 2

# 创建一个全连接层
fc_layer = nn.Linear(input_dim, output_dim)

# 打印初始化的权重和偏置
print("Initial weights:", fc_layer.weight)
print("Initial bias:", fc_layer.bias)

# 创建一个输入向量(单个样本)
input_vector = torch.randn(input_dim)
print("Input vector shape:", input_vector.shape)

# 通过全连接层计算输出
output_vector = fc_layer(input_vector)
print("Output vector shape:", output_vector.shape)

# 创建一个输入矩阵(批量样本)
input_matrix = torch.randn(3, input_dim)
print("Input matrix shape:", input_matrix.shape)

# 通过全连接层计算输出
output_matrix = fc_layer(input_matrix)
print("Output matrix shape:", output_matrix.shape)
权重矩阵和偏置向量

首先,让我们查看初始化的权重矩阵 W \mathbf{W} W 和偏置向量 b \mathbf{b} b

Initial weights: Parameter containing:
tensor([[-0.4161,  0.2601, -0.1442,  0.3651],
        [-0.0647, -0.0513, -0.2093,  0.4139]], requires_grad=True)
Initial bias: Parameter containing:
tensor([-0.2859,  0.0982], requires_grad=True)
  • 权重矩阵 W \mathbf{W} W 的形状是 2 × 4 2 \times 4 2×4,表示有两个输出特征(每个输出特征对应一行),四个输入特征(每个输入特征对应一列)。
  • 偏置向量 b \mathbf{b} b 的形状是 2 2 2,表示每个输出特征有一个偏置。
输入向量和输出向量
单个样本输入

输入向量 x \mathbf{x} x 的形状为 4 4 4

Input vector shape: torch.Size([4])

输出向量 y \mathbf{y} y 的形状为 2 2 2

Output vector shape: torch.Size([2])
输入矩阵和输出矩阵
批量样本输入

输入矩阵 X \mathbf{X} X 的形状为 3 × 4 3 \times 4 3×4

Input matrix shape: torch.Size([3, 4])

输出矩阵 Y \mathbf{Y} Y 的形状为 3 × 2 3 \times 2 3×2

Output matrix shape: torch.Size([3, 2])
计算过程解析

全连接层的计算过程可以表示为:

y = W x + b \mathbf{y} = \mathbf{W} \mathbf{x} + \mathbf{b} y=Wx+b

让我们逐步计算:

  1. 矩阵乘法 W x \mathbf{W} \mathbf{x} Wx
    • 首先将权重矩阵 W \mathbf{W} W 与输入向量 x \mathbf{x} x 相乘。

W = [ W 11 W 12 W 13 W 14 W 21 W 22 W 23 W 24 ] \mathbf{W} = \begin{bmatrix} W_{11} & W_{12} & W_{13} & W_{14} \\ W_{21} & W_{22} & W_{23} & W_{24} \end{bmatrix} W=[W11W21W12W22W13W23W14W24]

假设输入向量 x \mathbf{x} x 是:

x = [ x 1 x 2 x 3 x 4 ] \mathbf{x} = \begin{bmatrix} x_1 \\ x_2 \\ x_3 \\ x_4 \end{bmatrix} x= x1x2x3x4

计算:

W x = [ W 11 × x 1 + W 12 × x 2 + W 13 × x 3 + W 14 × x 4 W 21 × x 1 + W 22 × x 2 + W 23 × x 3 + W 24 × x 4 ] \mathbf{W} \mathbf{x} = \begin{bmatrix} W_{11} \times x_1 + W_{12} \times x_2 + W_{13} \times x_3 + W_{14} \times x_4 \\ W_{21} \times x_1 + W_{22} \times x_2 + W_{23} \times x_3 + W_{24} \times x_4 \end{bmatrix} Wx=[W11×x1+W12×x2+W13×x3+W14×x4W21×x1+W22×x2+W23×x3+W24×x4]

  1. 加上偏置向量 b \mathbf{b} b

b = [ b 1 b 2 ] \mathbf{b} = \begin{bmatrix} b_1 \\ b_2 \end{bmatrix} b=[b1b2]

加上偏置项:

y = W x + b = [ W 11 × x 1 + W 12 × x 2 + W 13 × x 3 + W 14 × x 4 + b 1 W 21 × x 1 + W 22 × x 2 + W 23 × x 3 + W 24 × x 4 + b 2 ] \mathbf{y} = \mathbf{W} \mathbf{x} + \mathbf{b} = \begin{bmatrix} W_{11} \times x_1 + W_{12} \times x_2 + W_{13} \times x_3 + W_{14} \times x_4 + b_1 \\ W_{21} \times x_1 + W_{22} \times x_2 + W_{23} \times x_3 + W_{24} \times x_4 + b_2 \end{bmatrix} y=Wx+b=[W11×x1+W12×x2+W13×x3+W14×x4+b1W21×x1+W22×x2+W23×x3+W24×x4+b2]

批量输入的计算过程

对于批量输入,输入矩阵 X \mathbf{X} X 3 × 4 3 \times 4 3×4,对应的输出矩阵 Y \mathbf{Y} Y 3 × 2 3 \times 2 3×2。计算过程与单个样本类似,只是需要对每个样本进行计算。

假设输入矩阵 X \mathbf{X} X 是:

X = [ x 11 x 12 x 13 x 14 x 21 x 22 x 23 x 24 x 31 x 32 x 33 x 34 ] \mathbf{X} = \begin{bmatrix} x_{11} & x_{12} & x_{13} & x_{14} \\ x_{21} & x_{22} & x_{23} & x_{24} \\ x_{31} & x_{32} & x_{33} & x_{34} \end{bmatrix} X= x11x21x31x12x22x32x13x23x33x14x24x34

权重矩阵 W \mathbf{W} W 和偏置向量 b \mathbf{b} b 如前所述。

计算:

Y = X W T + b = [ x 11 x 12 x 13 x 14 x 21 x 22 x 23 x 24 x 31 x 32 x 33 x 34 ] [ W 11 W 21 W 12 W 22 W 13 W 23 W 14 W 24 ] + [ b 1 b 2 ] \mathbf{Y} = \mathbf{X} \mathbf{W}^T + \mathbf{b} = \begin{bmatrix} x_{11} & x_{12} & x_{13} & x_{14} \\ x_{21} & x_{22} & x_{23} & x_{24} \\ x_{31} & x_{32} & x_{33} & x_{34} \end{bmatrix} \begin{bmatrix} W_{11} & W_{21} \\ W_{12} & W_{22} \\ W_{13} & W_{23} \\ W_{14} & W_{24} \end{bmatrix} +\begin{bmatrix} b_1 \\ b_2 \end{bmatrix} Y=XWT+b= x11x21x31x12x22x32x13x23x33x14x24x34 W11W12W13W14W21W22W23W24 +[b1b2]

逐行计算,可以得到输出矩阵 Y \mathbf{Y} Y

训练过程中的权重和偏置的优化

在训练过程中,权重矩阵 W \mathbf{W} W 和偏置向量 b \mathbf{b} b 是通过反向传播算法进行更新的。反向传播算法通过以下步骤优化这些参数:

  1. 前向传播:计算模型的预测输出。
  2. 计算损失:使用损失函数衡量模型预测值与真实值之间的差异。
  3. 反向传播:计算损失函数相对于每个参数的梯度。
  4. 参数更新:根据梯度信息,使用优化器(如SGD、Adam等)更新权重矩阵 W \mathbf{W} W 和偏置向量 b \mathbf{b} b

通过多次迭代和参数更新,模型的预测性能会逐步提高,最终收敛到一个使损失函数最小化的状态。

多层全连接网络与通用近似定理

多层全连接网络(Multi-layer Fully Connected Network),尤其是深度神经网络(Deep Neural Network,DNN),因其强大的表达能力和灵活性,被广泛应用于各种复杂的任务中。一个特别重要的理论是通用近似定理(Universal Approximation Theorem),它表明多层全连接网络可以逼近任意复杂的函数。以下是详细介绍这一理论及其背后的原理和意义。

通用近似定理
定理概述

通用近似定理指出,一个包含至少一个隐藏层且具有足够数量神经元的前馈神经网络(Feedforward Neural Network),在给定适当的激活函数(如Sigmoid函数或ReLU函数)的情况下,可以逼近任意的连续函数。具体来说:

  • 单隐层神经网络:一个单隐层的前馈神经网络(即输入层、一个隐藏层和输出层)已经足够逼近任意的连续函数,但可能需要非常多的神经元。
  • 多层神经网络:通过增加隐藏层的数量,可以用较少的神经元逼近同样的函数,从而提高网络的效率和表达能力。
数学表述

f f f 是一个定义在 R n \mathbb{R}^n Rn 上的连续函数,对于任意的误差 ϵ > 0 \epsilon > 0 ϵ>0,存在一个包含至少一个隐藏层的前馈神经网络 g g g,使得对于所有的 x ∈ R n x \in \mathbb{R}^n xRn,有:

∣ f ( x ) − g ( x ) ∣ < ϵ |f(x) - g(x)| < \epsilon f(x)g(x)<ϵ

理论背后的直觉
线性组合

单层全连接网络通过线性组合输入特征,然后通过激活函数引入非线性。虽然单层网络本身的表达能力有限,但通过层层叠加,网络可以捕捉到输入数据的复杂非线性关系。

分段线性逼近

激活函数如ReLU(Rectified Linear Unit)将输入分成不同的线性区域,多个ReLU层可以组合成复杂的分段线性函数,从而逼近任意的非线性函数。

增加复杂性

增加网络层数和神经元数量,使得网络可以表示更复杂的函数。每一层的输出作为下一层的输入,逐层提取和组合特征,从而实现对复杂函数的逼近。

实际应用与实现
网络结构

一个典型的多层全连接网络结构如下:

  • 输入层:接受输入数据。
  • 隐藏层:包括多个全连接层,每个层后接一个非线性激活函数。
  • 输出层:输出最终的预测结果。

例如,一个简单的三层全连接网络可以表示为:

h 1 = σ ( W 1 x + b 1 ) h_1 = \sigma(W_1 x + b_1) h1=σ(W1x+b1)
h 2 = σ ( W 2 h 1 + b 2 ) h_2 = \sigma(W_2 h_1 + b_2) h2=σ(W2h1+b2)
y = W 3 h 2 + b 3 y = W_3 h_2 + b_3 y=W3h2+b3

其中 σ \sigma σ 是激活函数,如ReLU。

示意图

为了更好地理解一个典型的多层全连接网络结构,我们可以使用Python的Matplotlib库来绘制一个示意图,展示一个三层全连接网络的结构
在这里插入图片描述
要在PyTorch中实现一个类似于我们在图形中展示的三层全连接神经网络,我们可以创建一个自定义的神经网络类。以下是一个示例代码,展示如何使用PyTorch构建一个具有3个输入节点、两个隐藏层(分别有5个和4个节点)以及2个输出节点的神经网络。

import torch
import torch.nn as nn
import torch.optim as optim

# 定义一个多层全连接神经网络
class SimpleNeuralNet(nn.Module):
    def __init__(self, input_size, hidden_sizes, output_size):
        super(SimpleNeuralNet, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_sizes[0])
        self.fc2 = nn.Linear(hidden_sizes[0], hidden_sizes[1])
        self.fc3 = nn.Linear(hidden_sizes[1], output_size)
        self.relu = nn.ReLU()

    def forward(self, x):
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        x = self.fc3(x)
        return x

# 定义网络结构参数
input_size = 3
hidden_sizes = [5, 4]
output_size = 2

# 创建网络实例
model = SimpleNeuralNet(input_size, hidden_sizes, output_size)

# 打印网络结构
print(model)

# 创建一些示例输入数据
x = torch.randn((1, input_size))

# 前向传播
output = model(x)
print("Input: ", x)
print("Output: ", output)

# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 示例训练过程
# 生成一些示例目标数据
target = torch.randn((1, output_size))

# 前向传播
output = model(x)

# 计算损失
loss = criterion(output, target)
print("Loss: ", loss.item())

# 反向传播和优化
optimizer.zero_grad()
loss.backward()
optimizer.step()

print("Updated Output: ", model(x))
代码解析
  1. 定义神经网络类

    • SimpleNeuralNet类继承自nn.Module
    • __init__方法中,我们定义了三个全连接层(fc1, fc2, fc3)和一个ReLU激活函数。
    • forward方法中,我们定义了前向传播的过程,依次通过全连接层和激活函数。
  2. 创建网络实例

    • 我们根据定义的网络结构参数(输入大小、隐藏层大小、输出大小)创建一个网络实例model
  3. 打印网络结构

    • 使用print(model)可以查看网络的结构。
  4. 前向传播

    • 创建一些示例输入数据x,并通过网络进行前向传播,得到输出output
  5. 定义损失函数和优化器

    • 使用均方误差损失函数MSELoss和随机梯度下降优化器SGD
  6. 示例训练过程

    • 生成一些示例目标数据target
    • 进行前向传播,计算损失,进行反向传播和优化。
    • 打印更新后的输出。

这段代码展示了如何使用PyTorch实现一个简单的多层全连接神经网络,并进行了一个基本的前向传播和训练过程。你可以根据自己的需求调整网络结构、损失函数和优化器。

全连接层最典型的应用

全连接层是神经网络中最基本和广泛使用的一种层类型,主要用于以下几个方面:

  1. 图像分类
    • 在卷积神经网络(CNN)中,全连接层通常用于网络的最后几层,将卷积层提取到的特征映射到各个类别上。例如,在经典的LeNet、AlexNet、VGG、ResNet等模型中,全连接层都是不可或缺的一部分。
import torch
import torch.nn as nn
import torch.nn.functional as F

class SimpleCNN(nn.Module):
    def __init__(self, num_classes=10):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(16, 32, kernel_size=3, padding=1)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)
        self.fc1 = nn.Linear(32 * 8 * 8, 128)
        self.fc2 = nn.Linear(128, num_classes)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 32 * 8 * 8)  # Flatten the tensor
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

model = SimpleCNN(num_classes=10)
  1. 文本分类
    • 在自然语言处理(NLP)任务中,全连接层常用于将文本表示(如RNN或Transformer输出的特征)映射到类别标签上。例如,情感分析、主题分类等任务。
import torch
import torch.nn as nn
import torch.nn.functional as F

class SimpleRNN(nn.Module):
    def __init__(self, input_size, hidden_size, num_classes):
        super(SimpleRNN, self).__init__()
        self.rnn = nn.RNN(input_size, hidden_size, batch_first=True)
        self.fc = nn.Linear(hidden_size, num_classes)

    def forward(self, x):
        h0 = torch.zeros(1, x.size(0), hidden_size).to(x.device)
        out, _ = self.rnn(x, h0)
        out = out[:, -1, :]  # Take the last hidden state
        out = self.fc(out)
        return out

model = SimpleRNN(input_size=300, hidden_size=128, num_classes=2)
  1. 回归任务
    • 在预测连续值的任务中,如房价预测、股票价格预测等,全连接层能够将输入特征映射到目标值。
import torch
import torch.nn as nn
import torch.nn.functional as F

class SimpleRegression(nn.Module):
    def __init__(self, input_size, output_size):
        super(SimpleRegression, self).__init__()
        self.fc1 = nn.Linear(input_size, 64)
        self.fc2 = nn.Linear(64, output_size)

    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

model = SimpleRegression(input_size=10, output_size=1)
  1. 多层感知器(MLP)
    • 多层感知器是最基础的神经网络结构之一,主要由多个全连接层组成。它适用于各种任务,包括分类、回归等。
import torch
import torch.nn as nn
import torch.nn.functional as F

class MLP(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(MLP, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.fc2 = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

model = MLP(input_size=20, hidden_size=64, output_size=3)
总结

全连接层是神经网络中非常重要的组成部分,广泛应用于各种任务中。它主要用于特征变换、模式识别、分类和回归问题。理解全连接层的工作原理和应用场景,对于构建和优化神经网络模型至关重要。

在训练神经网络模型时,权重矩阵 W \mathbf{W} W 和偏置向量 b \mathbf{b} b 是通过反向传播算法进行更新的。反向传播算法通过计算损失函数相对于每个参数的梯度,指导参数的更新方向和步长,从而逐步优化模型的性能。具体来说,损失函数衡量了模型预测值与真实值之间的差异,优化的目标是最小化这个差异。

权重矩阵和偏置向量的优化过程是神经网络训练的核心。通过多次迭代和调整,这些参数会逐渐收敛到一个使模型性能最优的状态。因此,理解和掌握全连接层的权重和偏置更新机制,对于构建高效、准确的神经网络模型至关重要。

参考链接

PyTorch概述
Pytorch :张量(Tensor)详解
PyTorch 卷积层详解


http://www.kler.cn/news/294039.html

相关文章:

  • 【开源免费】基于SpringBoot+Vue.JS高校校园招聘服务系统(JAVA毕业设计)
  • JAVA开源项目 图书个性化推荐系统 计算机毕业设计
  • 2024年全国大学生数学建模A题借鉴论文
  • java设计模式(行为型模式:状态模式、观察者模式、中介者模式、迭代器模式、访问者模式、备忘录模式、解释器模式)
  • Azure和Transformers的详细解释
  • uni-app填坑指南——解决处理处理静态资源的问题
  • CentOS 7 升级 OpenSSH 9.8p1
  • 苹果手机升级iOS 18时一直显示“正在检测更新”怎么办?
  • UWB定位室外基站
  • 使用openhtmltopdf 工具进行转PDF
  • RPC框架-protobuf-rpc-pro
  • 【图文实操教程】如何备份Docker容器中的PostgreSQL数据
  • Web3社交新经济,与 SOEX 实现无缝交易的高级安全性
  • 力扣第124题 二叉树中的最大路径和
  • HQL || SQL :连续签到领金币
  • 爆改YOLOv8|利用yolov10的SCDown改进yolov8-下采样
  • Harmony OS DevEco Studio 如何导入第三方库(以lottie为例)?-- HarmonyOS自学2
  • 【全网最新最全】Docker面试题
  • 浅析网页不安装插件播放RTSP/FLV视频的方法
  • chrome 插件开发入门
  • HTML <input> accept 属性
  • MQTT broker搭建并用SSL加密
  • 免费SSL证书怎么申请?
  • C#索引器(Indexer)
  • 排序算法(冒泡排序,选择排序,插入排序,快速排序)
  • 图片隐写方法
  • 使用c++创建WMI应用程序
  • Llama 3.1大模型的预训练和后训练范式解析
  • 【如何有效率地阅读源码】
  • 搜维尔科技:蹦床、跳绳或骑马,OptiTrack可以捕捉难以想象的物体