作为一名前端开发者，AI应用开发逐步发展中，也想赶上时代的潮流，最近一直在研究主流大模型（GPT、LLaMA、文心一言、通义千问）底层是如何实现的，自己尝试编写了一个最简单的版本用于理解大模型的底层，个人认为大模型就像一张庞大的数据表格，不断地进行计算得到每个数据的近似向量位置，核心逻辑包括:
-
自注意力机制：让模型能 “关注” 输入序列中不同位置的关联信息（比如理解 “他” 指代谁），解决了传统 RNN 无法并行计算、长距离依赖的问题；
-
残差连接 + 层归一化：解决深度网络的梯度消失问题，让模型能堆叠上百层甚至上千层；
-
前馈神经网络：在注意力提取的关联特征基础上，进一步学习复杂的非线性特征。 大家可以参考学习，
# 导入PyTorch核心库，是构建深度学习模型的基础
import torch
# 导入PyTorch的神经网络模块，包含所有层和模型基类
import torch.nn as nn
# 导入PyTorch的函数式接口，包含激活函数、池化等常用函数
import torch.nn.functional as F
# 定义模型的核心参数：特征维度（d_model），Transformer的核心超参数
# 大模型中该值通常为512/768/1024，这里简化为16方便演示
d_model = 16
# ===================== 自注意力机制模块（Transformer核心） =====================
class Attention(nn.Module):
def __init__(self):
super(Attention, self).__init__()
# 定义Query（查询）线性变换层：将输入特征映射到d_model维度
self.Wq = nn.Linear(d_model, d_model)
# 定义Key（键）线性变换层：将输入特征映射到d_model维度
self.Wk = nn.Linear(d_model, d_model)
# 定义Value（值）线性变换层：将输入特征映射到d_model维度
self.Wv = nn.Linear(d_model, d_model)
def forward(self, x):
# 生成Query矩阵：输入x经过线性变换得到Q
Q = self.Wq(x)
# 生成Key矩阵：输入x经过线性变换得到K
K = self.Wk(x)
# 生成Value矩阵：输入x经过线性变换得到V
V = self.Wv(x)
# 计算注意力分数：Q与K的转置矩阵相乘，除以特征维度的平方根（防止数值过大）
# transpose(-2, -1)：交换最后两个维度，实现K矩阵的转置
attn = Q @ K.transpose(-2, -1) / torch.sqrt(torch.tensor(d_model))
# 对注意力分数做softmax归一化，得到0-1之间的注意力权重
attn = F.softmax(attn, dim=-1)
# 注意力加权求和：用注意力权重乘以V矩阵，得到最终的注意力输出
out = attn @ V
return out
# ===================== 前馈神经网络模块（FFN） =====================
class FFN(nn.Module):
def __init__(self):
super(FFN, self).__init__()
# 第一层线性变换：将d_model维度映射到2*d_model（扩维）
self.fc1 = nn.Linear(d_model, d_model*2)
# 第二层线性变换：将2*d_model维度映射回d_model（降维）
self.fc2 = nn.Linear(d_model*2, d_model)
def forward(self, x):
# 前馈网络执行逻辑：线性变换 → ReLU激活 → 线性变换
# ReLU激活函数引入非线性，让模型能学习复杂特征
return self.fc2(F.relu(self.fc1(x)))
# ===================== Transformer基础块（Encoder Block） =====================
class Block(nn.Module):
def __init__(self):
super(Block, self).__init__()
# 实例化自注意力模块
self.attn = Attention()
# 实例化前馈神经网络模块
self.ffn = FFN()
# 第一层层归一化：稳定训练过程，加速收敛
self.norm1 = nn.LayerNorm(d_model)
# 第二层层归一化
self.norm2 = nn.LayerNorm(d_model)
def forward(self, x):
# Transformer核心逻辑：残差连接 + 层归一化
# 第一步：注意力层 + 残差连接 → 层归一化
# x + self.attn(x)：残差连接，防止梯度消失
x = self.norm1(x + self.attn(x))
# 第二步：前馈网络 + 残差连接 → 层归一化
x = self.norm2(x + self.ffn(x))
return x
# ===================== 迷你Transformer完整模型 =====================
class MYminiTransformer(nn.Module):
def __init__(self):
super(miniTransformer, self).__init__()
# 词嵌入层：将离散的token ID（0-999）映射为d_model维的连续向量
# 1000：词汇表大小，d_model：嵌入维度
self.emb = nn.Embedding(1000, d_model)
# 堆叠第一个Transformer Block
self.block1 = Block()
# 堆叠第二个Transformer Block
self.block2 = Block()
def forward(self, x):
# 模型前向传播逻辑：
# 1. 输入token ID → 词嵌入 → 得到语义向量
x = self.emb(x)
# 2. 经过第一个Transformer Block提取特征
x = self.block1(x)
# 3. 经过第二个Transformer Block进一步抽象特征
x = self.block2(x)
return x
# ===================== 模型测试 =====================
# 实例化迷你Transformer模型
model = MYminiTransformer()
# 构造输入：长度为4的token序列（ID分别为1,2,3,4）
x = torch.tensor([1,2,3,4])
# 执行模型前向传播，得到输出特征
out = model(x)
# 打印输入和输出形状，验证模型正确性
print("输入形状", x.shape) # 输出：输入形状 torch.Size([4])
print("输出特征形状", out.shape) # 输出：输出特征形状 torch.Size([4, 16])
欢迎有兴趣学习和研究AI一起交流和学习！DevHyper
