很多人把大语言模型想象成"会思考的黑箱"，但它的运行方式其实非常朴素：**给定一串词，预测下一个最可能出现的词；把预测出的词接在末尾，再预测下一个，如此循环。** 这种"自回归"机制是大模型生成的本质。本文沿着一条真实的推理流水线，把从文本到输出之间的每一步拆开给你看。
## 一、整体流水线：五个必经阶段

无论模型大小，一次推理（生成）都要经过下面这条固定链路。示例程序 `llmrun1_pipeline.py` 正是按这条链路精简实现的：
![image](https://developer.qcloudimg.com/http-save/yehe-7617106/5d4282322f4960b148cd0391f8462e44.png)

## 二、分词（Tokenization）

模型看不到"字"或"词"本身，它先把文本切成一串 **token（令牌）**——可能是字、子词或词。英文常用 BPE（字节对编码），中文常落到字或词片段。分词后的序列会映射成整数编号（token id），才进入模型。
![image.png](https://developer.qcloudimg.com/http-save/yehe-7617106/64ce9b68d590da7c74ea3da0b50e5a1a.png)

>为什么重要？词表大小直接决定模型"词汇量"，而子词切分让模型能拼出从未见过的词，是处理开放域的关键。

## 三、词嵌入 + 位置编码

每个 token id 会查到一个高维向量（词嵌入），比如真实模型常用 4096 维。向量里编码了词汇的"语义位置"——意义相近的词，向量也接近。但嵌入本身没有顺序感：模型看到的是一堆并排的向量，不知道谁在前谁在后。于是要再叠加 **位置编码**，给每个位置注入独特的"坐标信号"，Transformer 才知道这是第几个词。
## 四、Transformer 块：模型的"思考单元"

真正的智能来自堆叠的多层 Transformer 块。每个块大致做两件事：先让每个词"看一眼上下文"（自注意力，下一篇详拆），再做一次非线性变换（前馈网络 FFN），中间用残差连接和归一化稳住训练。几十到上百层叠起来，浅层学语法、深层学语义与推理。
![image](https://developer.qcloudimg.com/http-save/yehe-7617106/9f17055548b03827a2d0f8eaf5ed6387.png)
残差连接让梯度能跨层回流，是训练深层网络的关键。
## 五、自回归生成：一个词一个词地"续写"

最后一层输出一个向量，经输出层映射成"词表上每个词作为下一词的概率"。取概率最高（或按策略采样）的词，接到序列末尾，再喂回模型——这就是 Demo1 打印出 `['the','cat','sat','mat','mat',...]` 的原因：模型在它"见过的数据分布"里继续续写。

>注意：模型每次只预测"下一个"词，并不提前规划整句。所谓"连贯"，来自长文本训练压进参数的统计规律，而非真正的心智。

运行 `llmrun1_pipeline.py`，你会看到输入 `["the","cat","sat"]` 后，模型给出的下一词 Top3 是 `mat / to / cat`，随后贪心生成续写出 `mat, mat, cat...`。这正好印证：生成质量完全取决于"训练时见过什么分布"。
```
# -*- coding: utf-8 -*-
"""
演示一条文本从「分词 → 词嵌入 → 位置编码 → 自注意力 → 输出 logits → 采样」
的完整前向过程，全部用标准库实现，零外部依赖。

目的不是训练真实模型，而是让你"看见"大模型在生成每个词时内部发生了什么。
"""
import random
import math

random.seed(42)

# ---- 1) 微型词表（真实模型词表是 3 万~20 万，这里压缩到可打印规模）----
CORPUS = "the cat sat on the mat the dog ran to the mat".split()
VOCAB = sorted(set(CORPUS))
V2I = {w: i for i, w in enumerate(VOCAB)}
I2W = {i: w for i, w in enumerate(VOCAB)}
V = len(VOCAB)
D = 8  # 嵌入维度（真实模型常用 4096/8192）

# 固定初始化的嵌入矩阵，保证每次运行结果可复现
emb = [[random.uniform(-0.5, 0.5) for _ in range(D)] for _ in range(V)]


# ---- 线性代数小工具 ----
def dot(a, b):
    return sum(x * y for x, y in zip(a, b))


def mat_vec(M, v):
    return [dot(row, v) for row in M]


def vec_add(a, b):
    return [x + y for x, y in zip(a, b)]


def scale(v, s):
    return [x * s for x in v]


def softmax(xs):
    m = max(xs)
    e = [math.exp(x - m) for x in xs]
    s = sum(e)
    return [x / s for x in e]


# ---- 2) 位置编码（Transformer 没有"位置感"，必须人工注入）----
def pos_enc(vec, pos):
    # 真实模型用不同频率的 sin/cos，这里用简化的正弦偏置示意
    return [v + 0.1 * math.sin(pos * 0.5 + i) for i, v in enumerate(vec)]


# ---- 3) 简化自注意力（单头，权重随机固定）----
Wq = [[random.uniform(-0.5, 0.5) for _ in range(D)] for _ in range(D)]
Wk = [[random.uniform(-0.5, 0.5) for _ in range(D)] for _ in range(D)]
Wv = [[random.uniform(-0.5, 0.5) for _ in range(D)] for _ in range(D)]


def attend(toks_emb):
    Q = [mat_vec(Wq, e) for e in toks_emb]
    K = [mat_vec(Wk, e) for e in toks_emb]
    Vs = [mat_vec(Wv, e) for e in toks_emb]
    L = len(toks_emb)
    out = []
    for i in range(L):
        scores = [dot(Q[i], K[j]) / math.sqrt(D) for j in range(L)]
        a = softmax(scores)                      # 注意力权重：当前词"看"每个词的强度
        o = [0.0] * D
        for j in range(L):
            o = vec_add(o, scale(Vs[j], a[j]))   # 按权重把 Value 聚合
        out.append(o)
    return out


# ---- 4) 输出层：把最后位置的隐藏向量映射到词表概率 ----
Wout = [[random.uniform(-0.5, 0.5) for _ in range(V)] for _ in range(D)]


def forward(tokens):
    te = [pos_enc(emb[V2I[t]], p) for p, t in enumerate(tokens)]
    h = attend(te)
    # 取序列最后一个位置的表示，预测"下一个词"
    logits = [dot(h[-1], col) for col in zip(*Wout)]
    return softmax(logits)


if __name__ == "__main__":
    print("词汇表(%d):" % V, VOCAB)
    inp = ["the", "cat", "sat"]
    print("\n输入序列:", inp)
    probs = forward(inp)
    ranked = sorted(zip(VOCAB, probs), key=lambda x: -x[1])
    print("→ 下一词概率 Top3:")
    for w, p in ranked[:3]:
        print("    %-6s %.3f" % (w, p))

    # 自回归生成（贪心：每步取概率最高的词续写）
    gen = list(inp)
    for _ in range(4):
        p = forward(gen)
        nxt = max(range(V), key=lambda i: p[i])
        gen.append(I2W[nxt])
    print("\n贪心自回归生成序列:", gen)
    print("（模型在'它见过的数据分布'里续写——这就是大模型'生成'的本质）")
```
![image](https://developer.qcloudimg.com/http-save/yehe-7617106/6122e42eeb8fd1a5d25ecb6e7cf57120.png)

## 六、常见疑问（FAQ）

**Q1：模型是一次算整句吗？** 不是。它一次预测一个 token，再把结果拼回去循环，所以生成长度越长、耗时越久。

**Q2：为什么有时答非所问？** 因为它按统计接续续写，若训练数据里有类似"误导模式"，就可能被带偏。

**Q3：位置编码有什么替代？** 除正弦编码外，还有可学习位置嵌入、旋转位置编码（RoPE）等，本质都是"告诉模型顺序"。

**Q4：层数越多越好吗？** 更多层能学到更抽象的模式，但也更贵、更易过拟合，需要数据和算力撑住。

**Q5：demo 里的随机权重代表真实模型吗？** 不代表。demo 只为演示"计算流程"，真实权重由海量数据训练得到，才有实际语言能力。

很多人把大语言模型想象成"会思考的黑箱"，但它的运行方式其实非常朴素：给定一串词，预测下一个最可能出现的词；把预测出的词接在末尾，再预测下一个，如此循环。 这种"自回归"机制是大模型生成的本质。本文沿着一条真实的推理流水线，把从文本到输出之间的每一步拆开给你看。

大模型是怎么跑起来的：架构与推理流水线

人工智能

算法

架构设计

大语言模型通过"自回归"机制逐词预测生成文本，本质是统计续写而非真正思考。本文沿真实推理流水线拆解五个关键阶段：分词、词嵌入、位置编码、Transformer块和自回归采样，并用零依赖的Python示例程序可视化每个计算步骤。从token到概率输出，揭示模型如何利用训练数据中的统计规律实现连贯表达，适合想理解生成原理的AI学习者。

代码解释

Transformer

对象存储COS新用户低至1元！


文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

大语言模型通过"自回归"机制逐词预测生成文本，本质是统计续写而非真正思考。本文沿真实推理流水线拆解五个关键阶段：分词、词嵌入、位置编码、Transformer块和自回归采样，并用零依赖的Python示例程序可视化每个计算步骤。从token到概率输出，揭示模型如何利用训练数据中的统计规律实现连贯表达，适合想理解生成原理的...

大模型是怎么跑起来的：架构与推理流水线-腾讯云开发者社区-腾讯云

大模型是怎么跑起来的：架构与推理流水线

大模型是怎么跑起来的：架构与推理流水线

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐