收藏！小白也能懂的大语言模型核心：从Next Token Prediction到nanoGPT实现全解析-优快云博客

大语言模型（LLM）如今已是AI领域的核心热点，但很多小白刚接触时会被一堆专业术语劝退。其实拆解下来你会发现，LLM的核心逻辑特别清晰——本质就是“预测下一个token”（Next Token Prediction），全程通过自回归方式逐字逐句生成文本。

简单来说，文本会先被拆分成一个个token（英文多为单词/子词，中文多为汉字/词语），经过分词（tokenization）后转换为模型能理解的嵌入向量（embedding）；再通过Transformer架构的位置编码保留文本顺序，最终围绕“预测下一个token”完成训练与推理。而热门的nanoGPT，核心就是多层Block的堆叠，每个Block又包含多头自注意力机制和前馈网络。此外，还有个关键参数“温度（Temperature）”，专门用来控制生成文本的随机性。

下面我们从基础概念到代码实现，一步步把LLM的核心逻辑讲透，小白也能轻松跟上！

一、先搞懂基础：什么是Token？

要理解LLM，首先得明白“Token”这个核心单位——它就是文本被拆分后的最小离散单元。不管是训练还是推理，原始文本都必须先经过“分词（Tokenize）”处理，变成一串token序列才能送入模型。

这里要注意：分词器（Tokenizer）是在无标签语料上预先训练好的，其包含的所有token集合就是我们常说的“词表（Vocab）”，每个词表的token数量都是固定且唯一的。

1. 英文中的Token

通常是单词、子词或标点符号；一个单词可能对应一个token，也可能被拆分成多个子词token。比如“unhappiness”会拆成“un”“happi”“ness”三个子词token，这样能有效处理未登录词（没出现在词表中的词）。
有个实用小规律：1个英文Token大约对应3-4个字母，或0.75个完整单词（比如4个Token大概能组成3个英文单词），后续估算文本长度时可以参考。

2. 中文中的Token

多为单个汉字或分词后的词语，比如“人工智能”可能拆成“人工”和“智能”两个token，“机器学习”可能直接作为一个token。
不同大模型平台对Token的换算标准略有差异（小白必记）：通义千问、千帆大模型中1 Token = 1个汉字；腾讯混元大模型中1 Token约等于1.8个汉字；OpenAI系列模型中1个汉字通常对应1-2个Token。

分词完成后，每个token都会对应一个固定维度的向量，这就是“嵌入向量（Embedding）”——获取这个向量的过程很简单，就像查字典一样：通过token在词表中的索引，从嵌入层（Embedding Layer）里直接取出对应的向量即可。

二、关键补充：位置编码——让模型“记住”文本顺序

文本是有先后顺序的（比如“我吃苹果”和“苹果吃我”完全是两个意思），但LLM的核心架构——Transformer的注意力机制，本身是“无序”的，无法自动识别token的位置信息。这时候就需要“位置编码（Positional Encoding）”来救场！

具体做法很简单：给每个位置分配一个专属的“位置嵌入向量（Position Embedding）”，然后把它和对应位置的token嵌入向量直接相加，这样得到的混合向量就同时包含了“token本身的语义信息”和“它在文本中的位置信息”。

小白重点提醒：这里会涉及一个高频概念“上下文长度（Context Length）”——就是模型训练时能接收的最大token序列长度。如果训练时只学了短文本的位置嵌入，推理时就没法处理比训练长度更长的文本（相当于没见过这么长的位置编码），这也是为什么有些模型会限制输入文本长度的原因。

三、LLM的核心逻辑：Next Token Prediction如何工作？

当我们拿到融合了语义和位置信息的嵌入向量后，就会把它送入一个“仅解码器（Decoder-Only）”的Transformer模型（比如GPT系列、nanoGPT都是这种结构）。模型会对每个token的向量进行特征加工，最终输出一个新的特征向量。

而LLM的核心任务——Next Token Prediction，本质就是把这个输出向量当成“分类问题”来解决，全程围绕“预测下一个token是谁”展开。

具体步骤（小白可直接对号入座）：

把模型输出的特征向量送入一个线性层，将向量维度转换为“词表大小”——这样就能得到每个token对应“词表中所有token”的得分（称为Logits）；
通过Softmax函数把这些得分转换成概率分布（所有token的概率加起来等于1）；
训练阶段：目标是让“预测真实下一个token的概率”最大化，通过计算概率与真实标签的误差（Loss）来更新模型参数；
推理阶段：从这个概率分布中“采样”出一个token作为下一个token，再把这个新token拼接到原始序列中，重复上述过程，就能实现文本的连续生成。

关键细节：因果自注意力（Causal Self-Attention）

不管是训练还是推理，LLM都只能“基于前面的token预测后面的token”，不能提前看到后面的信息——这就靠“因果自注意力”实现，核心是一个“掩码（Mask）”机制：

训练时：计算注意力权重时，会把“当前token之后的所有位置”的权重设为0，相当于“屏蔽”了未来信息，模型只能看到前面的token；
优势：可以一次性对整个句子的所有token进行“下一个token预测”，批量计算误差，提升训练效率。

推理阶段的自回归生成过程：

和训练不同，推理是“逐token生成”的，流程就像“滚雪球”：先输入初始序列→预测第一个新token→把新token加入序列→再预测下一个……循环直到生成指定长度的文本。

在这里插入图片描述

这里补充一个实用知识点：采样策略。从概率分布中选下一个token时，不是只有“选概率最高的token”（贪婪策略）一种方式，还有核采样、Top-k采样等；而“温度参数（Temperature）”就是用来调整采样随机性的核心超参数，后面会详细讲。

四、动手实践：nanoGPT的核心代码实现解析

理解了理论，再看代码就很简单了。nanoGPT是OpenAI前员工Karpathy写的极简GPT实现，核心就是“多层Block堆叠”，每个Block包含两大核心模块：多头因果自注意力（Multi-headed Causal Self-Attention）和前馈神经网络（Feed-forward Neural Network）。

nanoGPT官方仓库：https://github.com/karpathy/nanoGPT/tree/master（小白可直接克隆学习，代码量极少，适合入门）

1. 单个Block的结构（看图搭框架）

每个Block的核心逻辑：先做层归一化（LayerNorm）→ 经过多头因果自注意力→ 残差连接（Residual Connection）；再做一次层归一化→ 经过前馈网络→ 再做一次残差连接。残差连接的作用是解决深层模型的梯度消失问题，小白记住“先归一化再计算，最后加原始输入”即可。

import torch
import torch.nn as nn
from torch.nn import functional as F

class Block(nn.Module):
    def __init__(self, config):
        super().__init__()
        self.ln_1 = LayerNorm(config.n_embd, bias=config.bias)  # 第一层归一化
        self.attn = CausalSelfAttention(config)  # 多头因果自注意力模块
        self.ln_2 = LayerNorm(config.n_embd, bias=config.bias)  # 第二层归一化
        self.mlp = MLP(config)  # 前馈神经网络模块

    def forward(self, x):
        # 残差连接：x（原始输入） + 注意力模块输出
        x = x + self.attn(self.ln_1(x))
        # 残差连接：上一步结果 + 前馈网络输出
        x = x + self.mlp(self.ln_2(x))
        return x

2. 整个nanoGPT的完整结构

整个模型的流程：生成token嵌入→ 生成位置嵌入→ 两者相加后过Dropout→ 送入多层Block堆叠→ 最后一层归一化→ 线性层映射到词表大小（用于预测下一个token）。

class GPT(nn.Module):
    def __init__(self, config):
        super().__init__()
        # 校验必要的配置参数（词表大小、上下文长度）
        assert config.vocab_size is not None
        assert config.block_size is not None
        self.config = config

        # Transformer核心组件：token嵌入、位置嵌入、Dropout、多层Block、输出归一化
        self.transformer = nn.ModuleDict(dict(
            wte = nn.Embedding(config.vocab_size, config.n_embd),  # token嵌入层（wte: word token embedding）
            wpe = nn.Embedding(config.block_size, config.n_embd),  # 位置嵌入层（wpe: word position embedding）
            drop = nn.Dropout(config.dropout),  # Dropout层（防止过拟合）
            h = nn.ModuleList([Block(config) for _ in range(config.n_layer)]),  # 多层Block堆叠
            ln_f = LayerNorm(config.n_embd, bias=config.bias),  # 输出层归一化
        ))
        # 输出层：将嵌入向量映射到词表大小（用于分类预测）
        self.lm_head = nn.Linear(config.n_embd, config.vocab_size, bias=False)

        # 权重共享（重要优化！减少参数数量，提升训练效率）
        self.transformer.wte.weight = self.lm_head.weight

        # 初始化模型参数
        self.apply(self._init_weights)
        # 对残差连接的投影层做特殊初始化（参考GPT-2论文）
        for pn, p in self.named_parameters():
            if pn.endswith('c_proj.weight'):
                torch.nn.init.normal_(p, mean=0.0, std=0.02/math.sqrt(2 * config.n_layer))

    # 参数初始化函数（默认实现，小白可不用深究）
    def _init_weights(self, module):
        if isinstance(module, nn.Linear):
            torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)
            if module.bias is not None:
                torch.nn.init.zeros_(module.bias)
        elif isinstance(module, nn.Embedding):
            torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)

核心优化点：权重共享。上面代码中，token嵌入层（wte）和输出层（lm_head）的权重是共享的——这样做能大幅减少模型的参数数量，同时提升训练效率，这也是GPT系列模型的经典优化手段。

3. 训练与推理的前向传播逻辑

（1）训练阶段的前向传播

核心步骤：生成token嵌入和位置嵌入→ 叠加后过Dropout→ 送入多层Block→ 最后做层归一化，得到用于预测的特征向量。

def forward(self, idx, targets=None):
    device = idx.device
    b, t = idx.size()  # b: 批量大小，t: 序列长度
    assert t <= self.config.block_size, f"序列长度{t}超过模型最大上下文长度{self.config.block_size}"

    # 生成位置索引（0到t-1）
    pos = torch.arange(0, t, dtype=torch.long, device=device)  # shape (t)
    
    # 1. 获取token嵌入和位置嵌入
    tok_emb = self.transformer.wte(idx)  # token嵌入：shape (b, t, n_embd)
    pos_emb = self.transformer.wpe(pos)  # 位置嵌入：shape (t, n_embd)
    
    # 2. 嵌入向量叠加 + Dropout
    x = self.transformer.drop(tok_emb + pos_emb)
    
    # 3. 送入多层Block处理
    for block in self.transformer.h:
        x = block(x)
    
    # 4. 输出层归一化
    x = self.transformer.ln_f(x)  # shape (b, t, n_embd)

    # 计算损失（训练时需要，推理时不需要）
    if targets is not None:
        logits = self.lm_head(x)  # 映射到词表大小：shape (b, t, vocab_size)
        # 调整形状以适配交叉熵损失（input: (b*t, vocab_size), target: (b*t,)）
        loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1))
    else:
        logits = self.lm_head(x[:, [-1], :])  # 推理时只取最后一个token的输出：shape (b, 1, vocab_size)
        loss = None

    return logits, loss

（2）推理阶段的生成逻辑

推理时核心是“循环生成”：每次取当前序列的最后一个token的输出，调整概率分布后采样新token，拼接到序列中再循环，直到生成指定数量的新token。这里会用到前面提到的温度参数（Temperature）和Top-k采样。

@torch.no_grad()  # 推理时不需要计算梯度，提升速度
def generate(self, idx, max_new_tokens, temperature=1.0, top_k=None):
    """
    idx: 初始输入序列（shape: (b, t)）
    max_new_tokens: 要生成的新token数量
    temperature: 温度参数，控制随机性
    top_k: 可选，只从概率最高的k个token中采样
    """
    for _ in range(max_new_tokens):
        # 裁剪序列长度（防止超过模型的最大上下文长度）
        idx_cond = idx if idx.size(1) <= self.config.block_size else idx[:, -self.config.block_size:]
        
        # 前向传播，获取最后一个token的logits
        logits, _ = self(idx_cond)
        logits = logits[:, -1, :] / temperature  # 调整温度，改变logits分布
        
        # 可选：Top-k采样（只保留概率最高的k个token，减少噪声）
        if top_k is not None:
            v, _ = torch.topk(logits, min(top_k, logits.size(-1)))
            logits[logits < v[:, [-1]]] = -float('Inf')  # 把k以外的token概率设为负无穷
        
        # 转换为概率分布
        probs = F.softmax(logits, dim=-1)
        
        # 从概率分布中采样下一个token
        idx_next = torch.multinomial(probs, num_samples=1)
        
        # 把新token拼接到序列中，进入下一轮循环
        idx = torch.cat((idx, idx_next), dim=1)
    
    return idx

五、深入理解：温度参数（Temperature）的核心作用

前面的代码中多次出现“temperature”参数，它是控制生成文本随机性的“关键开关”，本质是通过调整logits的分布，来改变最终token的采样概率。很多小白在调参时会忽略它，导致生成结果要么太死板，要么太混乱——掌握它的用法，能让你的生成效果提升一个档次！

1. 不同温度值的效果

Temperature > 1（增加随机性）：会放大logits的值，让概率分布变得更“平坦”——也就是说，各个token的概率更接近，模型更容易采样到低概率的token，生成的文本更多样、更有创造性，但也可能出现逻辑混乱。比如温度设为1.5时，适合生成诗歌、故事等需要创意的内容。
Temperature < 1（减少随机性）：会缩小logits的值，让概率分布变得更“尖锐”——高概率token的优势更明显，低概率token的概率几乎被忽略，生成的文本更稳定、更符合逻辑，但可能会显得死板、重复。比如温度设为0.7时，适合生成技术文档、问答答案等需要准确性的内容。
Temperature = 1（默认值）：不改变logits的分布，完全按照模型预测的原始概率采样，平衡了随机性和稳定性。

2. 直观例子（帮你快速理解）

假设模型预测下一个token的原始logits是[10, 20, 30]（对应三个token A、B、C）：

Temperature=2时：logits变为[5, 10, 15]，经过Softmax后，A、B、C的概率差距变小，C的优势没那么明显，A和B也有机会被采样到；
Temperature=0.5时：logits变为[20, 40, 60]，经过Softmax后，C的概率会接近100%，几乎一定会采样到C，生成结果很确定；
Temperature=1时：logits保持[10,20,30]，C的概率最高，但A和B也有少量概率被采样到。

3. 不同场景的温度参数推荐（小白直接抄）

应用场景	推荐温度值	核心原因
技术文档、问答系统	0.5-0.8	需要高准确性，避免逻辑错误
诗歌、故事创作	1.2-1.8	需要多样性和创造性，打破常规表达
日常对话、摘要生成	0.9-1.1	平衡自然度和逻辑性

六、总结：LLM核心逻辑一句话打通

LLM的本质就是“基于前面的token，用自回归方式预测下一个token”——从文本拆分token，到生成嵌入向量+位置编码，再通过Transformer Block加工特征，最后通过温度参数调整采样随机性，全程都围绕这个核心逻辑展开。而nanoGPT的代码，就是把这个逻辑用极简的方式实现了出来，非常适合小白入门学习。

如何学习大模型 AI ？

由于新岗位的生产效率，要优于被取代岗位的生产效率，所以实际上整个社会的生产效率是提升的。

但是具体到个人，只能说是：

“最先掌握AI的人，将会比较晚掌握AI的人有竞争优势”。

这句话，放在计算机、互联网、移动互联网的开局时期，都是一样的道理。

我在一线互联网企业工作十余年里，指导过不少同行后辈。帮助很多人得到了学习和成长。

我意识到有很多经验和知识值得分享给大家，也可以通过我们的能力和经验解答大家在人工智能学习中的很多困惑，所以在工作繁忙的情况下还是坚持各种整理和分享。但苦于知识传播途径有限，很多互联网行业朋友无法获得正确的资料得到学习提升，故此将并将重要的AI大模型资料包括AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。

这份完整版的大模型 AI 学习资料已经上传优快云，朋友们如果需要可以微信扫描下方优快云官方认证二维码免费领取【保证100%免费】