PyTorch 全连接层（Fully Connected Layer）详解

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

基本概念

在全连接层中，每一个输入节点与输出节点之间都存在连接。假设有一个输入行向量 $\mathbf{x}$ 和一个输出行向量 $\mathbf{y}$，为了匹配深度学习框架（如PyTorch）中常用的数据格式（输入为行向量或批次），全连接层的计算过程可以表示为：
$$\mathbf{y}=\mathbf{x}{\mathbf{W}}^T+\mathbf{b}$$
其中：

• $\mathbf{x}$ 是输入向量，在PyTorch中通常是一个行向量，维度为 $1\times D_{in}$。
• $\mathbf{W}$ 是权重矩阵，包含了所有连接的权重。
• $\mathbf{b}$ 是偏置向量，通常用于调整输出的线性变换。

权重矩阵 $\mathbf{W}$：

• 在PyTorch的 nn.Linear 模块中，权重矩阵 $\mathbf{W}$ 的维度被定义为 $D_{out}\times D_{in}$，其中 $D_{in}$ 是输入特征的数量，$D_{out}$ 是输出特征的数量。
• 每个元素 $W_{ij}$ 表示输入特征 $x_j$ 对输出特征 $y_i$ 的影响程度。
• 在计算时，我们需要将其转置为 ${\mathbf{W}}^T$（维度为 $D_{in}\times D_{out}$）来与行向量 $\mathbf{x}$ 相乘。
• 在训练过程中，权重矩阵 $\mathbf{W}$ 是通过反向传播算法进行更新的，目标是最小化损失函数，使得模型的预测结果尽可能接近真实值。

偏置向量 $\mathbf{b}$：

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

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

PyTorch 中的 nn.Linear

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

class torch.nn.Linear(in_features, out_features, bias=True)

参数说明

• in_features: 输入特征的数量，即输入向量的维度。
• out_features: 输出特征的数量，即输出向量的维度。
• bias（可选，默认为True）：是否包含偏置项 $\mathbf{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)
# 创建一个输入向量 (批大小为1)
input_vector = torch.randn(1, input_dim)
# 通过全连接层计算输出
output_vector = fc_layer(input_vector)
print("Input vector:", input_vector)
print("Output vector:", output_vector)

输出结果

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

权重矩阵和偏置向量

首先，让我们查看初始化的权重矩阵 $\mathbf{W}$ 和偏置向量 $\mathbf{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)

• 权重矩阵 $\mathbf{W}$ 的形状是 $2\times 4$，表示有两个输出特征（每个输出特征对应一行），四个输入特征（每个输入特征对应一列）。
• 偏置向量 $\mathbf{b}$ 的形状是 $2$，表示每个输出特征有一个偏置。

输入向量

输入向量 $\mathbf{x}$ 如下：

Input vector: tensor([[ 0.6784, -0.5674, -0.5408, -0.0243]])

• 输入向量 $\mathbf{x}$ 的形状是 $1\times 4$，表示一个样本（批大小为1），包含四个特征。这是一个行向量。

输出向量

输出向量 $\mathbf{y}$ 如下：

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

• 输出向量 $\mathbf{y}$ 的形状是 $1\times 2$，表示一个样本（批大小为1），包含两个输出特征。

计算过程解析

PyTorch中 nn.Linear 层的实际计算过程遵循 $\mathbf{y}=\mathbf{x}{\mathbf{W}}^T+\mathbf{b}$ 的形式，以适配批处理（batch processing）的输入格式。让我们用单个样本的例子来逐步计算：

1. 准备输入和参数：

   • 输入向量 $\mathbf{x}$ (行向量, 维度 $1\times 4$):
     $$\mathbf{x}=\left[\begin{array}{cccc}0.6784& -0.5674& -0.5408& -0.0243\end{array}\right]$$
   • 权重矩阵 $\mathbf{W}$ (维度 $2\times 4$):
     $$\mathbf{W}=\left[\begin{array}{cccc}0.1385& -0.3149& -0.2930& -0.1360\\ -0.4598& 0.4449& 0.2633& 0.2245\end{array}\right]$$
   • 偏置向量 $\mathbf{b}$ (维度 $1\times 2$):
     $$\mathbf{b}=\left[\begin{array}{cc}-0.0132& -0.4703\end{array}\right]$$

2. 转置权重矩阵：
   首先，我们将权重矩阵 $\mathbf{W}$ 进行转置，得到 ${\mathbf{W}}^T$ (维度 $4\times 2$):
   $${\mathbf{W}}^T=\left[\begin{array}{cc}0.1385& -0.4598\\ -0.3149& 0.4449\\ -0.2930& 0.2633\\ -0.1360& 0.2245\end{array}\right]$$

3. 矩阵乘法 $\mathbf{x}{\mathbf{W}}^T$：
   现在，我们将输入行向量 $\mathbf{x}$ 与转置后的权重矩阵 ${\mathbf{W}}^T$ 相乘。

   • 维度检查： $(1\times 4)\times (4\times 2)\to (1\times 2)$。维度匹配。
     $$\begin{array}{rl}\mathbf{x}{\mathbf{W}}^T& =\left[\begin{array}{cccc}0.6784& -0.5674& -0.5408& -0.0243\end{array}\right]\left[\begin{array}{cc}0.1385& -0.4598\\ -0.3149& 0.4449\\ -0.2930& 0.2633\\ -0.1360& 0.2245\end{array}\right]\\ & =\left[\begin{array}{cc}0.4344& -0.7121\end{array}\right]\end{array}$$
     (注：这里仅展示计算结果以保持简洁)

4. 加上偏置向量 $\mathbf{b}$：
   最后，将上一步的结果与偏置向量 $\mathbf{b}$ 相加。PyTorch会使用广播（broadcasting）机制。
   $$\mathbf{y}=\mathbf{x}{\mathbf{W}}^T+\mathbf{b}=\left[\begin{array}{cc}0.4344& -0.7121\end{array}\right]+\left[\begin{array}{cc}-0.0132& -0.4703\end{array}\right]=\left[\begin{array}{cc}0.4212& -1.1824\end{array}\right]$$
   这与PyTorch的输出结果完全一致：

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

   通过这种方式解释，数学公式与PyTorch的代码实现和维度变化完全统一。

维度变化

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

1. 输入维度：
   • 输入可以是一个二维张量（矩阵），其形状为 (N, D_in)，其中 N 是批量大小（batch size），D_in 是输入特征的数量。
   • 输入也可以是一个一维张量（向量），其形状为 (D_in,)，即单个样本的输入。PyTorch会自动将其视为 (1, D_in)。
2. 输出维度：
   • 对于 (N, D_in) 的输入，输出将是一个二维张量，其形状为 (N, D_out)，其中 D_out 是输出特征的数量。
   • 对于 (D_in,) 的输入，输出将是一个一维张量，其形状为 (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 shape:", fc_layer.weight.shape)
print("Initial bias shape:", fc_layer.bias.shape)
# 创建一个输入向量（单个样本）
input_vector = torch.randn(input_dim)
print("\nInput 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("\nInput matrix shape:", input_matrix.shape)
# 通过全连接层计算输出
output_matrix = fc_layer(input_matrix)
print("Output matrix shape:", output_matrix.shape)

输出结果示例

Initial weights shape: torch.Size([2, 4])
Initial bias shape: torch.Size([2])

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

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

批量输入的计算过程

对于批量输入，计算公式保持一致，只是输入 $\mathbf{X}$ 变成了一个矩阵，其中每一行代表一个样本。
$$\mathbf{Y}=\mathbf{X}{\mathbf{W}}^T+\mathbf{B}$$
假设输入矩阵 $\mathbf{X}$ 是 $3\times 4$（3个样本，每个样本4个特征），对应的输出矩阵 $\mathbf{Y}$ 是 $3\times 2$。

• $\mathbf{X}$ 维度: $3\times 4$
• ${\mathbf{W}}^T$ 维度: $4\times 2$ (由 $2\times 4$ 的 $\mathbf{W}$ 转置而来)
• $\mathbf{Y}$ 维度: $(3\times 4)\times (4\times 2)\to 3\times 2$

计算过程如下：
$$\mathbf{Y}=\left[\begin{array}{cccc}{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{array}\right]\left[\begin{array}{cc}{W}_{11}& W_{21}\\ W_{12}& W_{22}\\ W_{13}& W_{23}\\ W_{14}& W_{24}\end{array}\right]+\left[\begin{array}{cc}{b}_1& b_2\\ b_1& b_2\\ b_1& b_2\end{array}\right]$$
其中，偏置向量 $\mathbf{b}$ (维度 $1\times 2$) 会被广播到每一行上进行相加。这个公式与前面单个样本的计算方式完全一致，也解释了为什么PyTorch等框架偏好将输入处理为行向量或批次。

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

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

1. 前向传播：计算模型的预测输出。
2. 计算损失：使用损失函数衡量模型预测值与真实值之间的差异。
3. 反向传播：计算损失函数相对于每个参数的梯度。
4. 参数更新：根据梯度信息，使用优化器（如SGD、Adam等）更新权重矩阵 $\mathbf{W}$ 和偏置向量 $\mathbf{b}$。
   通过多次迭代和参数更新，模型的预测性能会逐步提高，最终收敛到一个使损失函数最小化的状态。

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

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

通用近似定理

定理概述

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

数学表述

设 $f$ 是一个定义在 ${\mathbb{R}}^n$ 上的连续函数，对于任意的误差 $ϵ>0$，存在一个包含至少一个隐藏层的前馈神经网络 $g$，使得对于所有的 $x\in {\mathbb{R}}^n$，有：
$$|f(x)-g(x)|<ϵ$$

实际应用与实现

网络结构

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

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

例如，一个简单的三层全连接网络，若遵循PyTorch的计算方式，可以表示为：
$h_1=\sigma (\mathbf{x}{\mathbf{W}}_1^T+{\mathbf{b}}_1)$
$h_2=\sigma ({\mathbf{h}}_1{\mathbf{W}}_2^T+{\mathbf{b}}_2)$
$\mathbf{y}={\mathbf{h}}_2{\mathbf{W}}_3^T+{\mathbf{b}}_3$
其中 $\sigma$ 是激活函数，如ReLU。

示意图

下图展示了一个包含输入层、两个隐藏层和输出层的多层全连接网络结构。

要在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("\nInput: ", 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("\nLoss: ", loss.item())
# 反向传播和优化
optimizer.zero_grad()
loss.backward()
optimizer.step()
print("Updated Output: ", model(x))

代码解析

1. 定义神经网络类：SimpleNeuralNet类继承自nn.Module，在__init__中定义网络层，在forward中定义数据流。
2. 创建网络实例：根据定义的网络结构参数创建一个网络实例model。
3. 前向传播：创建示例输入数据x，通过网络进行前向传播，得到输出output。
4. 定义损失函数和优化器：使用均方误差损失函数MSELoss和随机梯度下降优化器SGD。
5. 示例训练过程：进行一次完整的前向传播、损失计算、反向传播和参数优化。

全连接层最典型的应用

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

1. 图像分类：
   • 在卷积神经网络（CNN）中，全连接层通常用于网络的最后几层，将卷积层提取到的特征图（feature map）展平（flatten）后，映射到各个类别上。

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)
        # 假设输入是 32x32 图像, 经过两次 2x2 池化后, 尺寸变为 8x8
        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)  # 展平张量
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

2. 文本分类：
   • 在自然语言处理（NLP）任务中，全连接层常用于将文本表示（如RNN或Transformer输出的特征）映射到类别标签上。

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, :]  # 取最后一个时间步的隐藏状态
        out = self.fc(out)
        return out

3. 回归任务：
   • 在预测连续值的任务中，如房价预测、股票价格预测等，全连接层能够将输入特征映射到目标值。

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

4. 多层感知器（MLP）：
   • 多层感知器是最基础的神经网络结构之一，完全由多个全连接层组成。它适用于各种表格数据任务。

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

总结

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

参考链接

PyTorch概述
Pytorch ：张量（Tensor）详解
PyTorch 卷积层详解
PyTorch 全连接层（Fully Connected Layer）详解
PyTorch 池化层详解