神经网络学习-神经网络简介【Transformer、pytorch、Attention介绍与区别】

神经网络学习笔记

本笔记总结了神经网络基础理论、常见模型结构、优化方法以及 PyTorch 实践，适用于初学者和进阶者查阅学习。

一、神经网络基础

1. 神经元模型

神经元通过输入加权求和后激活：

$$y=f\left(\sum _{i=1}^n{w}_i{x}_i+b\right)$$

• $x_i$：输入
• $w_i$：权重
• $b$：偏置
• $f$：激活函数，如 ReLU、Sigmoid 等

2. Hebbian 学习规则

• 原则：共同激活 → 增强连接
• 表达式（无监督）：
  $$\Delta w_{ij}=\eta \cdot x_i\cdot y_j$$

二、常见网络结构

1. 多层感知机（MLP）

• 构成：输入层 → 多个隐藏层 → 输出层
• 特点：适用于结构化数据，学习能力强但对图像序列效果有限

2. 卷积神经网络（CNN）

• 核心模块：
  • 卷积层：提取局部特征
  • 池化层：降维、去噪
  • 激活层：非线性（ReLU）
  • 全连接层：输出分类/回归结果
• 适用场景：图像分类、目标检测、图像分割等

三、激活函数比较

四、优化器对比

五、注意力机制与 Transformer

1. 注意力机制（Attention）

核心思想：给不同位置分配不同权重，捕捉长距离依赖。

$$\text{Attention}(Q,K,V)=\text{softmax}\left(\frac{Q{K}^T}{\sqrt{d_k}}\right)V$$

• $Q$（Query）、$K$（Key）、$V$（Value）来自输入
• 权重通过 $Q{K}^T$ 的相似性计算获得

2. Transformer 架构

• 自注意力机制（Self-Attention）支持并行计算
• 组成模块：
  • 多头注意力（Multi-head Attention）
  • 残差连接 + 层归一化（Residual + LayerNorm）
  • 前馈神经网络（FFN）

结构图：

左图Encoder和右图Decoder

六、PyTorch 实践模板

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

# 简单 MLP 示例
class MLP(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(MLP, self).__init__()
        self.net = nn.Sequential(
            nn.Linear(input_size, hidden_size),
            nn.ReLU(),
            nn.Linear(hidden_size, output_size)
        )
    def forward(self, x):
        return self.net(x)

# 初始化模型、损失、优化器
model = MLP(100, 64, 10)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练过程示例
for epoch in range(10):
    outputs = model(inputs)
    loss = criterion(outputs, labels)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

Transformer vs PyTorch：你分得清吗？｜代码+解析

💡 简要区分

Transformer 是什么？

Transformer 是 2017 年 Google 提出的神经网络架构，摒弃了 RNN/CNN，完全基于「注意力机制」，用于建模序列之间的关系。

架构结构：

• 多头注意力机制（Multi-Head Attention）
• 残差连接 + LayerNorm
• 前馈网络（FFN）
• 编码器（Encoder）和解码器（Decoder）

PyTorch 是什么？

PyTorch 是 Facebook 开发的深度学习框架，支持：

• 自动微分（autograd）
• 自定义网络结构（通过 nn.Module）
• GPU 加速
• 动态计算图

代码对比：PyTorch 实现 MLP vs Transformer Block

示例 1：用 PyTorch 写个简单的 MLP

import torch
import torch.nn as nn

class SimpleMLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(100, 64),
            nn.ReLU(),
            nn.Linear(64, 10)
        )

    def forward(self, x):
        return self.net(x)

x = torch.randn(16, 100)
model = SimpleMLP()
out = model(x)
print(out.shape)  # torch.Size([16, 10])


import torch
import torch.nn as nn

class TransformerBlock(nn.Module):
    def __init__(self, embed_dim, heads, ff_hidden):
        super().__init__()
        self.attn = nn.MultiheadAttention(embed_dim, heads, batch_first=True)
        self.ln1 = nn.LayerNorm(embed_dim)
        self.ff = nn.Sequential(
            nn.Linear(embed_dim, ff_hidden),
            nn.ReLU(),
            nn.Linear(ff_hidden, embed_dim)
        )
        self.ln2 = nn.LayerNorm(embed_dim)

    def forward(self, x):
        # Multi-Head Attention
        attn_out, _ = self.attn(x, x, x)
        x = self.ln1(x + attn_out)
        # Feedforward
        ff_out = self.ff(x)
        x = self.ln2(x + ff_out)
        return x

# 示例输入
x = torch.randn(16, 50, 128)  # batch_size=16, seq_len=50, embedding_dim=128
block = TransformerBlock(embed_dim=128, heads=4, ff_hidden=256)
out = block(x)
print(out.shape)  # torch.Size([16, 50, 128])

示例 2：用 PyTorch 写一个简化版 Transformer Block

import torch
import torch.nn as nn

class TransformerBlock(nn.Module):
    def __init__(self, embed_dim, heads, ff_hidden):
        super().__init__()
        self.attn = nn.MultiheadAttention(embed_dim, heads, batch_first=True)
        self.ln1 = nn.LayerNorm(embed_dim)
        self.ff = nn.Sequential(
            nn.Linear(embed_dim, ff_hidden),
            nn.ReLU(),
            nn.Linear(ff_hidden, embed_dim)
        )
        self.ln2 = nn.LayerNorm(embed_dim)

    def forward(self, x):
        # Multi-Head Attention
        attn_out, _ = self.attn(x, x, x)
        x = self.ln1(x + attn_out)
        # Feedforward
        ff_out = self.ff(x)
        x = self.ln2(x + ff_out)
        return x

# 示例输入
x = torch.randn(16, 50, 128)  # batch_size=16, seq_len=50, embedding_dim=128
block = TransformerBlock(embed_dim=128, heads=4, ff_hidden=256)
out = block(x)
print(out.shape)  # torch.Size([16, 50, 128])