作为一名在代码丛林里摸爬滚打多年的“老”程序员，我时常感到一种深深的无力感。前脚刚把 React 的 hooks 用熟，后脚 Next.js 就出了新版本；上周还在嘲笑苹果的 VR 头显是个玩具，这周可Neng就Yi经下单了 Mac Studio 准备开发 Vision Pro 应用。这种感觉，就像是被时代洪流裹挟着向前，每天dou是“新的一天”，每天也dou意味着“昨天的技术Yi死”。

特别是 AI 领域，简直是按周来刷新认知的。Manus 还没玩明白，OpenCode 就火了；Coworker 还没捂热，新的自动化工具又冒了出来。虽然我也算是体验过不少 AI 产品，甚至自己在本地源码跑过 Dify 和 LlamaIndex 这些“大杀器”，但说实话，AI 大模型在我心里一直是个神秘的黑盒子。出于一种程序员的本Neng——或者说是一种对确定性的渴望，我觉得与其每天焦虑地追逐新名词，不如静下心来研究一些底层不变的东西。于是我决定亲手写一遍 Transformer，这个大语言模型的鼻祖和核心架构。

要搞懂 Transformer，咱们得先回到 NLP的起点。计算机是不认识“中文”或者“英文”的，它只认识数字。所以所有的高级魔法，第一步dou是把文本变成向量。

这听起来hen高大上，其实道理hen简单。假设我们有一句话“我是张涛”。在向量模型眼里这四个字会被切分成四个 Token。每个 Token 会被转化成一个数组，代表它在高维空间里的坐标。比如在二维平面我们用 确定一个点；在三维空间，用 。现在的模型动不动就是几千维，咱们假设这是个 6 维的模型，那这四个字就变成了四个长度为 6 的数组。

为什么要这么Zuo？因为变成了坐标，我们就Neng算距离。就像高中数学里算空间两点距离一样， 和 之间是有距离的。通过这种方式，计算机就Neng知道“我”和“是”离得近，还是“我”和“苹果”离得近。这为后续理解语义打下了基础。

但是光有坐标还不够。这里有两个大坑：一是语序问题，“我喜欢你”和“你喜欢我”，字一样，意思天差地别；二是长距离依赖问题，比如一段几百字的长文，开头的“它”到底指代什么？在 Transformer 出现之前，处理这些问题简直是噩梦，就像早期 Android 开发里的 Handler 机制，必须按顺序处理消息，前面的任务一堵，后面的全得等着，而且随着序列变长，前面的信息hen容易“梯度消失”，导致模型理解力断崖式下跌。

为了解决这些痛点，大佬们参考计算机视觉里的注意力概念，搞出了 Transformer。它的核心思想非常人性化：当我们kan一张图时不会盯着每个像素kan，而是把注意力集中在重点区域。处理文本也是一样，模型不需要死记硬背整个句子，而是通过“注意力”去关注当前处理的部分与其他部分的关系。

这里不得不提三个核心角色：Query、Key和 Value。你Ke以把它想象成一个图书馆检索系统：你想找本书，去翻目录索引，找到了之后拿书的内容。

在 Transformer 里Zui关键的就是自注意力机制。简单来说就是让句子里的每个词dou去“查询”其他词，kankan谁跟自己关系Zui铁。比如“我是张涛”这句话，当“我”作为 Query 时它会发现“是”和“张涛”跟它的相关性Zui高。当 Q=K=V 时就是自注意力，这让模型Neng深刻理解句子内部的勾稽关系。

当然单头注意力就像是一个人kan问题，难免片面。为了geng全面我们引入了多头注意力。这就好比请了不同领域的专家来分析同一份文档：语言学家kan语法，历史学家kan背景，逻辑学家kan结构。Zui后把大家的意见汇总起来理解自然就深刻多了。它Neng捕捉序列中不同位置之间不同类型的依赖关系，极大地提升了模型的表达Neng力。

光说不练假把式，咱们直接上代码。 是Zui核心的多头注意力模块。这里我们用 PyTorch 来实现。

import torch
import torch.nn as nn
import torch.nn.functional as F
import math
class MultiHeadAttention:
    def __init__:
        super.__init__
        # 确保隐藏层维度Neng被头数整除，不然没法切分
        assert args.dim % args.n_heads == 0
        self.n_heads = args.n_heads
        # 每个头的维度
        self.head_dim = args.dim // args.n_heads
        # 定义 Q, K, V 的权重矩阵
        # 这里用一个大矩阵代替多个小矩阵，原理是矩阵内积再拼接 = 拼接矩阵再内积
        self.wq = nn.Linear
        self.wk = nn.Linear
        self.wv = nn.Linear
        # 输出投影层
        self.wo = nn.Linear
        # Dropout 防止过拟合
        self.attn_dropout = nn.Dropout
        self.resid_dropout = nn.Dropout
        self.is_causal = is_causal
        # Ru果是因果注意力，需要 Mask 掉未来信息
        if is_causal:
            # 创建一个上三角矩阵，未来位置填负无穷
            mask = torch.full, float)
            mask = torch.triu
            self.register_buffer
    def forward:
        bsz, seqlen, _ = q.shape
        # 1. 线性变换得到 Q, K, V
        xq, xk, xv = self.wq, self.wk, self.wv
        # 2. 拆分成多头，并调整维度顺序以便矩阵运算
        # 变成 
        xq = xq.view.transpose
        xk = xk.view.transpose
        xv = xv.view.transpose
        # 3. 计算注意力分数
        # Q * K^T / sqrt
        scores = torch.matmul) / math.sqrt
        # 4. Ru果需要，加上 Mask
        if self.is_causal:
            scores = scores + self.mask
        # 5. Softmax 归一化
        scores = F.softmax, dim=-1).type_as
        scores = self.attn_dropout
        # 6. 加权求和
        output = torch.matmul
        # 7. 拼接多头结果，并恢复维度
        output = output.transpose.contiguous.view
        # 8. Zui终投影
        output = self.wo
        output = self.resid_dropout
        return output

这段代码的逻辑其实非常清晰：先把输入切成多头，分别算注意力，Zui后再拼回来。那个 `is_causal` 参数hen重要，它决定了我们在Zuo预测时是不是只Nengkan过去，不Neng偷kan未来。

Transformer 采用了经典的 Encoder-Decoder 架构。Encoder 负责把输入序列“读懂”，压缩成特征；Decoder 则负责根据这些特征，一个字一个字地把结果“吐”出来。

Encoder 由多个相同的层堆叠而成。每一层里面dou有两个核心组件：多头自注意力层和前馈神经网络。为了防止训练时的梯度消失和加速收敛，我们在每个子层后面dou加了残差连接和层归一化。

class EncoderLayer:
    '''Encoder 单层结构'''
    def __init__:
        super.__init__
        # 注意力前的归一化
        self.attention_norm = nn.LayerNorm
        # Encoder 不需要 Mask，所以 is_causal=False
        self.attention = MultiHeadAttention
        # MLP 前的归一化
        self.fnn_norm = nn.LayerNorm
        self.feed_forward = MLP
    def forward:
        # 残差连接 + 注意力
        h = x + self.attention.forward, self.attention_norm, self.attention_norm)
        # 残差连接 + 前馈网络
        out = h + self.feed_forward.forward)
        return out
class Encoder:
    '''Encoder 整体块'''
    def __init__:
        super.__init__
        # 堆叠 N 层
        self.layers = nn.ModuleList for _ in range])
        self.norm = nn.LayerNorm
    def forward:
        # 逐层通过
        for layer in self.layers:
            x = layer
        return self.norm

Decoder 的结构稍微复杂一点。它每一层有三个子层：掩码多头自注意力、多头注意力和前馈神经网络。

class DecoderLayer:
    '''解码层单层结构'''
    def __init__:
        super.__init__
        # 第一个子层：Masked Self-Attention
        self.attention_norm_1 = nn.LayerNorm
        self.mask_attention = MultiHeadAttention
        # 第二个子层：Cross-Attention 
        self.attention_norm_2 = nn.LayerNorm
        self.attention = MultiHeadAttention
        # 第三个子层：MLP
        self.ffn_norm = nn.LayerNorm
        self.feed_forward = MLP
    def forward:
        # 1. 带掩码的自注意力
        x = x + self.mask_attention.forward, self.attention_norm_1, self.attention_norm_1)
        # 2. 跨注意力模块
        h = x + self.attention.forward, enc_out, enc_out)
        # 3. 前馈网络
        out = h + self.feed_forward.forward)
        return out
class Decoder:
    '''解码器整体块'''
    def __init__:
        super.__init__
        self.layers = nn.ModuleList for _ in range])
        self.norm = nn.LayerNorm
    def forward:
        for layer in self.layers:
            x = layer
        return self.norm

注意力机制负责处理词与词之间的关系，而 MLP 则负责对每个位置的向量进行geng深层次的特征提取和变换。它的结构hen简单，就是两层线性变换加一个激活函数。

class MLP:
    def __init__:
        super.__init__
        self.w1 = nn.Linear
        self.w2 = nn.Linear
        self.dropout = nn.Dropout
    def forward:
        # 先升维，ReLU 激活，再降维
        return self.dropout)))

有了零件，Zui后就是组装了。我们需要把 Embedding 层、Positional Encoding、Encoder 和 Decoder 串起来。

大模型的本质，其实就是概率计算。它根据前文算下一个字出现的概率。当“我”出来后它知道后面大概率是“是”或者“爱”。这就是为什么我们在写代码时要特别关注位置编码和掩码机制。

class Transformer:
    '''完整的 Transformer 模型'''
    def __init__:
        super.__init__
        assert args.vocab_size is not None
        assert args.block_size is not None
        self.args = args
        self.transformer = nn.ModuleDict(dict(
            wte = nn.Embedding, # 词嵌入
            wpe = PositionalEncoding,                  # 位置编码
            drop = nn.Dropout,
            encoder = Encoder,
            decoder = Decoder,
        ))
        # Zui后用于预测下一个 token 的层
        self.lm_head = nn.Linear
        self.apply
        print/1e6:.2f}M")
    def _init_weights:
        # 标准的权重初始化
        if isinstance:
            torch.nn.init.normal_
            if module.bias is not None:
                torch.nn.init.zeros_
        elif isinstance:
            torch.nn.init.normal_
    def forward:
        device = idx.device
        b, t = idx.size
        assert t <= self.args.block_size, f"序列长度超限: {t}> {self.args.block_size}"
        # 1. 获取 Token Embedding
        tok_emb = self.transformer.wte
        # 2. 加上位置编码
        pos_emb = self.transformer.wpe
        x = self.transformer.drop
        # 3. 通过 Encoder
        enc_out = self.transformer.encoder
        # 4. 通过 Decoder
        x = self.transformer.decoder
        if targets is not None:
            # 训练模式：计算 Loss
            logits = self.lm_head
            loss = F.cross_entropy), targets.view, ignore_index=-1)
        else:
            # 推理模式：只预测Zui后一个
            logits = self.lm_head
            loss = None
        return logits, loss

写完这些代码，再回kan那些让人眼花缭乱的 AI 新闻，心里踏实多了。无论外面的世界怎么变，无论是 GPT-4 还是 Claude 100，底层的数学原理和架构逻辑依然是有迹可循的。

AI 大模型确实是当前科技圈的顶流，它强大的理解和生成Neng力正在重塑我们的工作流。但作为技术人员，我们不应止步于调用 API。通过亲手复现这些架构，我们不仅Neng理解“它”是如何将“苹果”关联起来的，gengNeng明白在“梯度消失”的困境中，前人是如何用“残差连接”搭起桥梁的。

技术虽然日新月异，但探索未知的乐趣是永恒的。希望这篇文章Neng给你带来一点启发，让你找到属于自己的那份定力。毕竟只有理解了内核，才Neng真正掌握未来。