别被 ChatGPT 的打字机效果骗了:一字一字蹦,才是 LLM 自回归的命门(附大厂 Java 流式落地)

0 阅读23分钟

ChatGPT 像打字机一样逐字输出,不是为了表演效果,而是 LLM 自回归生成的必然表现。这也是大厂 Java AI 岗的高频面试题,很多人只会说"就是一个字一个字生成",再往深就问不住了。这篇从原理讲到落地:下一个词预测、KV Cache、采样策略、Java 流式实现,一次讲透。

一、先说结论:LLM 本质是个"文字接龙大师"

一句话版本先给你:

LLM 本质是一个超大规模的"下一个 token 预测器"——给它前文,它算出词表上每个候选词的概率,挑一个出来,拼回输入,再算下一个,循环往复。

不神秘,数学上就是一个条件概率:P(下一个 token | 前面所有 token)。模型并不"理解"世界,它是在预训练阶段把海量语料压缩进参数,做最大似然估计——让真实语料的下一个词概率尽量高。

比如输入"今天天气真",模型输出的是这样一组概率分布:

好:   0.62
不错: 0.18
热:   0.09
冷:   0.05

采样出"好",再把"今天天气真好"整体喂回去,预测下一个 token,就像成语接龙:你出上句,它猜下一个字,猜完加进去,再猜下一个。

这里有两个容易误解的点,先掰扯清楚:

  • LLM 不是实时搜互联网,也不是查某个固定数据库,它靠概率推理生成,所以才会"一本正经地胡说八道";
  • LLM 是生成式模型,不是检索式模型,它输出的是词表上的概率分布,而不是查到的标准答案。

那这条接龙具体是怎么跑起来的?先看一遍完整的推理流水线。

二、一次推理的全流程:从一句话到概率分布

先看图,LLM 的一次前向计算会经过这么几步:

image.png

逐个拆开说。

1. Tokenizer:把文本切成词元

模型只认数字不认文字,所以第一步是把文本切成 token,转成 id 序列。主流用的是 BPE / WordPiece / SentencePiece 这类子词切分——不是按字切,而是按子词。比如 unhappiness 会被拆成 un + happi + ness,中文则常常一字一词一个 id。词表大小一般在 3 万到 15 万之间。

2. Embedding + 位置编码:让 token 变成"有序"的向量

Embedding 把 token 映射成高维向量。但注意力机制本身是不分顺序的,"猫抓老鼠"和"老鼠抓猫"在它眼里没区别,所以必须注入位置信息。主流做法是 RoPE 旋转位置编码,把"谁在前谁在后"旋进向量里。

3. Self-Attention:让每个字去"开会",决定该听谁的

一句话解释:每个 token 都去看其他所有 token,算相关性,再加权求和。具体靠 Q/K/V 三个矩阵:

  • Q(Query):我想查什么;
  • K(Key):每个词的"名片";
  • V(Value):每个词的"实际内容"。

举个经典例子:

句子: "小明把苹果给了小红,因为她饿了"

Q: "她"想知道该关注谁
K: 每个词的名片
V: 每个词的内容

Attention(Q,K,V) = Softmax(Q·Kᵀ/√d) · V

结果: "她" → "小红" 的注意力权重最高 (0.87)
      "她" → "苹果" 的权重很低   (0.02)

模型就是这样"理解"了指代关系。

4. Causal Mask:只看左边,不许偷看答案

生成第 t 个 token 时,模型只能看到 0..t-1 的位置,未来位置全部挡住。这个因果掩码是自回归成立的地基——不挡住的话,模型就"作弊"了。

5. FFN + 多层堆叠 + LM Head

Attention 之后接 FFN 前馈网络做特征变换,配合残差连接和 LayerNorm 稳定训练,这样堆叠几十层,形成强表达能力。最后 LM Head 把最后一层隐状态投影到词表大小(几万到十几万维),输出 logits,再经 Softmax 变成概率分布。

关键点汇总成一张表:

关键点一句话解释加分表述
Token 化文本切成 token,词表 3w~15wBPE 子词切分,unhappiness → un+happi+ness
Self-Attention每个 token 与其他所有 token 算加权相关性Q/K/V 三个矩阵,算相关性再加权求和
概率预测输出是词表上的概率分布,不是"答案"所以 LLM 是生成式,不是检索式

流水线讲完了,但还有个问题:模型这一身本事是训练出来的,怎么训的?

三、接龙大师是怎么练成的:两阶段训练流水线

image.png

预训练是拿海量无监督文本(动辄万亿 token)喂模型,让它学人类语言的语法、知识和逻辑规律。训练目标简单粗暴:预测下一个 token。

但只会接龙的模型可能接出危险或不符合人类习惯的内容,所以要有第二步对齐微调:先用 SFT 监督微调,拿高质量问答对教模型按指令回答问题;再用 RLHF / DPO 拿人类偏好数据做校准,让输出符合人类价值观。

整个生命周期拉通看:

阶段核心目标关键技术
预训练学习通用语言能力与世界知识Transformer Decoder、自注意力、位置编码、大规模语料
对齐微调让输出符合人类指令与价值观SFT 监督微调、RLHF / DPO 人类偏好对齐
推理生成根据输入输出对应文本自回归生成、KV 缓存、采样策略

注意,自回归是推理生成阶段的核心逻辑,也是本文的主角,下面正式请它登场。

四、自回归生成:一场一个字往外蹦的"文字接龙"

一句话定义:每次只生成一个 token,把生成的 token 拼回输入,再预测下一个……循环往复,直到生成终止符 EOS。

"自回归"这个翻译其实挺传神,拆词最好记:

  • 自(Auto):上一步的输出,当作下一步的输入,自己吃自己;
  • 回归(Regressive):反复套用同一个模型、同一套参数。

数学上就是联合概率的条件概率链式分解:

P(x1,x2,...,xT)=∏t=1TP(xt∣x1,x2,...,xt−1)P(x_1, x_2, ..., x_T) = \prod_{t=1}^{T} P(x_t \mid x_1, x_2, ..., x_{t-1})

翻译成人话:第 1 个词由上文决定,第 2 个词由"上文 + 第 1 个词"决定,第 3 个词由"上文 + 第 1、2 个词"决定……一步一步往后推。每个词的概率只依赖它之前的所有词——因果方向,不可逆。

来一遍完整的接龙示范:

Round 1: 输入 "今天"                → 预测 "天气"
Round 2: 输入 "今天天气"             → 预测 "真"
Round 3: 输入 "今天天气真"            → 预测 "好"
Round 4: 输入 "今天天气真好"           → 预测 "!"
Round 5: 输入 "今天天气真好!"         → 预测 <EOS>,停止

像多米诺骨牌,一次只能倒下一张。整个过程画成时序图:

image.png

你在 ChatGPT 网页上看到的打字机效果,就是自回归生成 + 流式输出,一个字一个字蹦是真的,不是前端动画。

训练和推理:同一个模型,两种"吃法"

这里有个高频被追问的点:训练和推理用的是同一个模型,但执行方式完全不同。

对比项训练推理(自回归)
输入来源真实上文(Teacher Forcing)模型自己生成的上文(Free Running)
掩码Causal Mask 挡未来Causal Mask 挡未来
执行方式整句并行,一次算完所有位置的 loss真·串行,一个个 token 往外吐
吞吐特点一次算完,效率最高token 级延迟,随长度线性增长
Java 侧该盯啥数据管道、语料清洗TTFT 首字延迟、TPOT 每字延迟、SSE 流式

有人会问:既然推理是串行,训练为什么不也串行?因为训练时答案是已知的(真实语料),用 Causal Mask 可以一次性并行算出所有位置的 loss,效率最高。那训练时为什么也要加 Causal Mask? 为了保证训练和推理的分布一致,防止模型"作弊"看到未来——不然推理时见到的场景和训练时对不上,效果直接崩。

顺带澄清一个架构误区:

  • BERT 是双向的去噪自编码,擅长理解,不适合直接做生成;
  • GPT / LLaMA 是 Decoder-only + 自回归,天然适合续写和对话,所以现在生成式大模型清一色走这条路。

自回归 vs 非自回归:不是只有一条路

也有非自回归的做法,一次并行全部生成出来,对比一下:

自回归(GPT / LLaMA)非自回归(BERT 填空 / MaskGIT)
生成顺序串行,一个接一个并行,一次出全部
长处上下文连贯、质量高速度快
短处延迟随长度线性增长连贯性差
适用对话 / 写作 / 推理图像生成、文本填空

自回归的好处是逻辑简单、生成可控、上下文连贯;缺点也很明显——串行。第 N 个 token 依赖第 N-1 个,天生没法并行,这就是 LLM 推理慢的根源。

那工程上怎么办?先认清推理的两个阶段。

五、推理的两阶段:Prefill 和 Decode,性格完全不同

image.png

  • Prefill(预填充):把所有输入 token 一次性并行处理掉,吃满算力,是算力密集型,顺手把 KV Cache 建好;
  • Decode(解码):逐个串行生成,每步计算量不大,但要反复搬运大量参数和缓存,是访存密集型(memory-bound)。

这个差异直接决定了线上两个常聊的指标:

  • TTFT(Time To First Token):首字延迟,主要受 Prefill 影响;
  • TPOT(Time Per Output Token):每字延迟,由 Decode 决定。

用户盯着空白屏等,等的是 TTFT;读起来的流畅感,看的是 TPOT。而 Decode 阶段最大的优化空间,就是下一节的主角——KV Cache。

六、KV Cache:自回归的性能命脉

先算笔账:不做任何优化的话,生成第 1000 个词时,要把前 999 个词的 Attention 全部重算一遍。每步都全量重算,计算量随长度平方级膨胀,纯浪费。

KV Cache 的思路很直白:把历史 token 的 Key/Value 缓存在显存里,新 token 来了只算它自己的 Q,然后和缓存做 Attention。

方式每步计算量说明
无 KV Cache重算全序列慢,浪费
有 KV Cache只算新增 token主流推理引擎必备

一句话:用显存换时间,把复杂度从 O(n²) 干到 O(n),长文本场景下推理速度能提升数倍。

这里有个高频追问:为什么只缓存 K/V,不缓存 Q?

因为 Q 是"我要查什么",每一步的 Q 只属于当前这个新 token,用完一次就没有复用价值了;而 K/V 是"被查询的名片和内容",后面每一个新 token 都要来查它们,才值得缓存。这也解释了为什么 KV Cache 会随上下文线性膨胀——显存爆炸的伏笔就在这,后面会讲怎么治。

用 Java 伪代码表示一下:

/**
 * KV Cache: 推理加速的关键
 * 不用每次重新计算所有历史 token 的 Key / Value
 * 真实形态: keyCache[layer][head][seq][dim], 生产上是 Tensor
 */
public class KVCache {
    private final Map<Integer, Tensor> keyCache = new HashMap<>();
    private final Map<Integer, Tensor> valueCache = new HashMap<>();

    public void append(Token newToken, int position) {
        // 只计算新 token 的 K、V 并追加进缓存,历史的不碰
        keyCache.put(position, computeKey(newToken));
        valueCache.put(position, computeValue(newToken));
    }

    public Tensor attentionWithCache(int currentPos) {
        Tensor query = computeQuery(currentToken);   // Q 只算当前位置的
        // 复用历史 K/V, 避免 O(n²) 重复计算
        return attention(query, keyCache, valueCache, currentPos);
    }
}

但 KV Cache 是有代价的:缓存随上下文线性增长,并发一高显存就爆。工业界的解法:

  • PagedAttention(vLLM 的核心):像操作系统管理虚拟内存一样,把 KV Cache 按"页"管理,按需分配、随时回收,还支持多请求前缀共享,显存利用率大幅提升;
  • K/V 量化:用 FP8 等低精度压缩缓存体积;
  • 工程侧淘汰策略:会话级 LRU、maxContext 限流、请求取消时主动释放缓存。

划重点:PagedAttention 的分页思想,跟操作系统虚拟内存几乎一个套路——分页、按需分配、碎片治理。这就是后端工程师学 AI 的知识迁移优势,面试聊到这个,档次直接上一级。

缓存的问题解决了,每一步都输出了 logits 概率分布,新问题来了:怎么从里面挑一个词?

七、采样策略:不是取最大概率那么简单

有同学会说,每次取概率最大的不就完了?这叫 Greedy 贪心解码,稳定但死板,容易复读,输出千篇一律。真实系统都是采样:

参数作用效果
temperature调概率分布的平滑度<1 分布变尖,保守稳定;>1 分布变平,发散有创意
top_k只在前 K 个候选里采样控制发散程度
top_p按累积概率截断(核采样 nucleus)更动态,0.9 时兼顾多样性又不跑偏
repetition_penalty抑制重复内容常用 1.1~1.3
stop_words遇到指定词停止生成业务侧停止控制

采样流程有固定顺序,顺序不能乱:

image.png

两个实战经验:

① Softmax 一定要先减 max。 直接对 logits 做 exp,数值稍大 float 就溢出,当场 NaN。先减去最大值,数学上等价,数值上稳定——这个细节大厂面试爱问,线上真踩过。

② temperature=0 也不完全确定。 理论上它退化成 greedy decode,结果应该可复现,但 GPU 浮点运算存在非确定性,严格场景别指望完全一致,得固定种子 + 低温组合着用。

复读机问题:三层兜底

重复是自回归的常见病:输出不断喂回输入,错误会累积放大,模型卡在"很好很好很好"里出不来。本质是暴露偏差(Exposure Bias)+ 采样空间塌缩,工程上一般三层兜底:

  1. 采样层:Top-P 0.8~0.9 + Temperature 0.7,砍掉尾部低质 token;
  2. 惩罚层:对最近 N 个 token 的 logits 施加 repetition_penalty 惩罚;
  3. 产品层:检测到连续重复的 n-gram,触发重生成或直接打断。

如果还能碰训练侧,可以加 unlikelihood training,专门惩罚重复。

记住一句话:LLM 生成不是"查答案",而是**"按概率采样"**——这是所有输出不确定性的根源。

如果你也在学大模型工程,可以先点个关注,下一篇拆"Attention 为什么要除以 √d",这道追问一半人答不上来。

八、Java 实战:把流式生成链路串起来

先说清楚定位:真实推理跑在 GPU 上,活在 vLLM / Triton 里,Java 不用重造推理引擎。但模型不归我们训,这条串行链路的低延迟和可治理,归我们管。真实链路长这样:

image.png

Java 侧该干的活,列个清单:

  • 流式输出:SSE / WebSocket;
  • 超时与取消、资源释放;
  • Token 级限流、租户配额;
  • 会话上下文管理;
  • 模型服务网关与降级(兜底小模型)。

而 AI 方向 Java 研发的核心阵地就在这:RAG 编排、Agent 调度、流式输出、服务治理。下面用代码把整条链路串起来。

1. 生成配置:采样参数全部配置化

public record GenerateConfig(
        int maxNewTokens,
        float temperature,
        int topK,
        float topP,
        int eosTokenId
) {
    public static GenerateConfig ofDefault() {
        // 常用组合: temperature 0.7 + top-p 0.9, 兼顾稳定与多样
        return new GenerateConfig(256, 0.7f, 50, 0.9f, 2);
    }
}

2. 自回归主循环:一段代码看懂本质

/**
 * LLM 自回归生成服务(Java 编排层)
 * 亮点: Prefill/Decode 分离、KV Cache 增量推理、
 *      多重停止条件、可直接对接流式输出
 */
public class AutoregressiveGenerator {

    private final LlmModel model;      // 真实场景对接 vLLM / ONNX Runtime / 推理网关
    private final Tokenizer tokenizer;
    private final TokenSampler sampler;

    public String generate(String prompt, GenerateConfig config) {
        // 1. 编码: 文本 → token id 序列
        List<Integer> tokenIds = new ArrayList<>(tokenizer.encode(prompt));

        // 2. Prefill: 一次性并行处理全部 prompt, 建立 KV 缓存
        KVCache kvCache = model.prefill(tokenIds);

        StringBuilder result = new StringBuilder();
        for (int step = 0; step < config.maxNewTokens(); step++) {
            // 3. Decode: 只喂上一步的新 token, 复用 KV Cache
            //    性能关键: 避免每步重算整段前缀
            int lastToken = tokenIds.get(tokenIds.size() - 1);
            float[] logits = model.forwardOneStep(lastToken, kvCache);

            // 4. 采样: temperature → top-k → top-p
            int nextToken = sampler.sample(logits, config);

            // 5. 停止条件: EOS / 最大长度(生产再加超时与取消信号)
            if (nextToken == config.eosTokenId()) {
                break;
            }

            // 6. 自回归的精髓: 把刚生成的 token 拼回序列
            tokenIds.add(nextToken);
            result.append(tokenizer.decode(nextToken));
        }
        return result.toString();
    }
}

3. 流式版本:打字机效果就是这么实现的

/**
 * 流式生成: 每个 token 实时推给前端
 * doOnCancel 是踩坑点: 前端关页面必须释放 KV 缓存,
 * 否则显存慢慢漏, 服务跑几天就得重启
 */
public Flux<String> generateStream(String prompt, GenerateConfig config) {
    List<Integer> ids = tokenizer.encode(prompt);
    KVCache cache = model.prefill(ids);

    return Flux.generate(
        () -> new StepState(ids.size(), cache, 0, lastOf(ids), false),
        (state, sink) -> {
            // 三重停止: 最大长度 / EOS / 外层再加 timeout + cancel
            if (state.step() >= config.maxNewTokens() || state.done()) {
                sink.complete();
                return state;
            }
            // 只喂「上一个 token」+ cache, 不重算整段前缀
            float[] logits = model.forwardOneStep(state.lastToken(), state.cache());

            int next = sampler.sample(logits, config);
            if (next == config.eosTokenId()) {
                sink.complete();
                return state.markDone();
            }
            sink.next(tokenizer.decode(next));   // SSE 推前端, 首字不等全篇
            return state.advance(next);
        }
    ).doOnCancel(cache::release);   // 关键: 断连时回收缓存
}

4. 采样器:顺序和数值稳定性

/**
 * 采样: 顺序很重要 —— Temperature → Top-K → Top-P → 随机采样
 */
public class TokenSampler {

    public int sample(float[] logits, GenerateConfig config) {
        // 1. 温度缩放 + Softmax: T<1 锐化更稳, T>1 平滑更发散
        float[] probs = softmax(logits, config.temperature());
        // 2. Top-K: 只保留概率最大的 K 个候选
        List<Integer> candidates = topKFilter(probs, config.topK());
        // 3. Top-P(核采样): 累积概率达到 p 就截断
        candidates = nucleusFilter(candidates, probs, config.topP());
        // 4. 轮盘赌: 候选集内按归一化概率随机抽一个
        return rouletteWheelSelect(candidates, probs);
    }

    private float[] softmax(float[] logits, float temperature) {
        // 亮点: 先减 max 防 exp 溢出, 数值稳定
        float max = Float.NEGATIVE_INFINITY;
        for (float v : logits) max = Math.max(max, v);

        float temp = Math.max(temperature, 1e-5f);
        float sum = 0f;
        float[] probs = new float[logits.length];
        for (int i = 0; i < logits.length; i++) {
            probs[i] = (float) Math.exp((logits[i] - max) / temp);
            sum += probs[i];
        }
        for (int i = 0; i < probs.length; i++) probs[i] /= sum;
        return probs;
    }

    private List<Integer> nucleusFilter(List<Integer> cand, float[] probs, float topP) {
        cand.sort((a, b) -> Float.compare(probs[b], probs[a]));
        float cum = 0f;
        List<Integer> nucleus = new ArrayList<>();
        for (int id : cand) {
            nucleus.add(id);
            cum += probs[id];
            if (cum >= topP) break;   // 累积概率达到核阈值即截断
        }
        return nucleus;
    }
    // topKFilter / rouletteWheelSelect 略, 逻辑同名字所示
}

5. Spring AI 快速接入

不想自己写循环,Spring AI 已经封装好了:

@RestController
public class ChatController {

    private final ChatModel chatModel; // Spring AI 统一抽象

    public ChatController(ChatModel chatModel) {
        this.chatModel = chatModel;
    }

    @GetMapping("/stream")
    public Flux<String> stream(@RequestParam String prompt) {
        return chatModel.stream(new Prompt(prompt))
                .map(resp -> resp.getResult().getOutput().getText())
                .filter(Objects::nonNull); // 流式吐字
    }
}

流式输出(SSE / WebFlux)的本质,就是把自回归的每个 token 实时推给前端——原理和工程在这一下就串起来了。

6. WebClient 调 OpenAI 兼容协议

真实业务里更多是远程调模型服务:

@Service
public class ChatStreamService {

    private final WebClient webClient = WebClient.builder()
            .baseUrl("https://open.bigmodel.cn/api/paas/v4")
            .build();

    public Flux<String> streamChat(String userMessage) {
        return webClient.post()
                .uri("/chat/completions")
                .header(HttpHeaders.AUTHORIZATION, "Bearer " + apiKey)
                .bodyValue(Map.of(
                        "model", "glm-4",
                        "messages", List.of(Map.of("role", "user", "content", userMessage)),
                        "stream", true   // 流式开关, 逐 token 增量推送
                ))
                .retrieve()
                .bodyToFlux(String.class)
                .filter(line -> !"[DONE]".equals(line))
                .map(this::extractDeltaContent)   // 解析每帧的增量 token
                .timeout(Duration.ofSeconds(60))
                .retryWhen(Retry.backoff(2, Duration.ofMillis(500)));  // 指数退避重试
    }
}

注意重试一定要指数退避,LLM 超时后无脑重试,会把 GPU 瞬间打满——重试风暴打挂推理服务这种事,真不少见。

7. Java 21 虚拟线程:低成本扛高并发流式

流式调用是典型的长连接 IO 密集任务,平台线程一个请求占一个,扛不住,虚拟线程正好对口:

// Java 21+: 用虚拟线程低成本支撑高并发 LLM 流式调用
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    IntStream.range(0, 10_000).forEach(i -> executor.submit(() -> {
        var req = HttpRequest.newBuilder(URI.create(llmUrl))
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(json))
                .build();
        var resp = httpClient.send(req, HttpResponse.BodyHandlers.ofLines());
        resp.body()
            .filter(line -> line.startsWith("data:"))   // OpenAI / vLLM SSE 格式
            .forEach(this::pushToClient);               // 逐 token 推给前端
        return null;
    }));
}

一个容易忽视的坑:Tokenizer 一致性

推理服务多在 Python 侧,如果 Java 侧另搞一套分词,两边 Tokenizer 不一致,同一句话编码结果不同,输出直接错乱。解法:统一 Tokenizer(比如用 HuggingFace Tokenizers 的 Java binding),并把 encode 结果缓存,避免重复计算。

KV Cache 降计算、Top-p 控多样性、SSE 做流式、虚拟线程 / WebFlux 抗高并发——这四板斧下去,Java 侧就能把 LLM 接得明明白白。但真上了线,还有更棘手的问题等着你。

九、八大难点与解决方案

把 LLM 工程化的常见难点归成三类:性能成本、生成质量、Java 工程。先看表,再展开重点。

性能与成本类

难点本质原因解决方案
串行生成慢每个 token 都要一次前向,天生无法并行KV Cache 复用、Continuous Batching、投机解码、INT4/INT8 量化
Attention 计算/显存爆炸Attention 是 O(n²) 复杂度FlashAttention、滑动窗口注意力(Mistral)、PagedAttention
KV Cache 显存膨胀缓存随上下文线性增长,并发一高就 OOMPagedAttention 分页 + 前缀共享、K/V 量化(FP8)、会话级 LRU、maxContext 限流、cancel 时释放
吞吐低单条请求打不满 GPUContinuous / Dynamic Batching、Prefix Caching、请求队列
部署成本高模型太大,普通服务器部署不了量化(4bit/8bit)、剪枝、知识蒸馏、LoRA 轻量化微调、张量/流水线并行分布式部署
延迟-吞吐-成本不可能三角三者难以兼得PD 分离架构:Prefill / Decode 分离部署,各自配最优硬件

两个值得展开的亮点:

投机解码(Speculative Decoding):让小模型先"猜" N 个 token,大模型再一次性并行验证,猜对就直接采纳,提速 2~3 倍。本质是用廉价计算去赌昂贵的串行,非常聪明的设计。还有 Medusa,给大模型加多个预测头并行预测,思路类似。

Continuous Batching(连续批处理):传统静态批处理要等一批里最慢的请求,快的只能干等,GPU 空转;连续批处理按迭代粒度动态组批,谁完成谁出队,新请求随时插入,GPU 始终满载,吞吐翻几倍。这是 vLLM / SGLang 高吞吐的标配。

生成质量类

难点本质原因解决方案
幻觉只建模"像不像",不理解"对不对"RAG 检索增强、CoT 思维链、引用溯源、生成后事实校验、低温、Function Call 工具调用、SFT+DPO 高质量对齐、认知稳态治理(让模型知道自己不知道)
重复退化暴露偏差 + 采样空间塌缩Repetition Penalty(1.1~1.3)、Top-P / Temperature 调参、产品层 n-gram 检测重生成、unlikelihood training
输出不可控自由文本容易跑偏System Prompt 约束、Function Calling、JSON Schema 校验、Grammar / JSON 约束解码
长上下文退化超出训练长度 RoPE 掉点、注意力失焦RoPE scaling / NTK 外推、滑动窗口注意力、RAG 检索切块而非整篇塞 prompt、摘要压缩、向量检索记忆,支撑 128K 级长上下文
训练-推理不一致训练喂真值,推理喂自己的输出Scheduled Sampling、RLHF 偏好对齐
输出不稳定采样本身有随机性降低 temperature、固定种子、Top-P / Top-K 约束

关于幻觉,一句话最实在:别让模型裸答。事实类业务要么上 RAG 外挂知识库,要么让它走 Function Call 调工具,再配上引用溯源——概率模型不保证事实,这不是 bug,是机制。

Java 工程类

难点本质原因解决方案
用户盯着空白屏首字延迟高SSE 流式首字优先、首包优化、断线重连
背压与断连模型生成慢、前端关页面、线程池被打满Flux 背压、信号量限流、异步 gRPC 不阻塞 Tomcat 线程、doOnCancel 回收缓存、SSE 心跳
高并发 GPU 压力大GPU 昂贵,容易被打满Token 级限流、请求队列、租户配额、降级小模型、Resilience4j 熔断
会话上下文膨胀多轮对话历史越滚越大滑动窗口截断、摘要压缩、向量检索记忆
Java 与推理栈集成推理在 Python / GPU 服务里gRPC / HTTP / SSE 调用;DJL / ONNX Runtime;统一 Tokenizer 避免跨语言偏差

推理框架怎么选

最后看下主流推理框架,按场景选型:

框架核心亮点适用场景
vLLMPagedAttention,显存利用率高高吞吐在线服务
TensorRT-LLMNVIDIA 硬件深度优化NVIDIA GPU 上追求极致性能
SGLang结构化生成优化复杂多轮对话、结构化输出

Java 生态这边可以提 DJL、ONNX Runtime,或者直接调 vLLM 的 OpenAI 兼容接口 / Java SDK——模型服务黑盒化,治理能力握在自己手里。

十、面试追问小抄

这道题在面试里通常只是开胃菜,追问才是深水区。高频问题清单,提前备好:

Q1:为什么用 Self-Attention 不用 RNN? 训练可并行,长距离依赖直接建模——任意两个 token 之间的路径长度是 O(1),RNN 得一步步传。

Q2:temperature=0 就完全确定了吗? 理论上退化成 greedy decode,但 GPU 浮点运算存在非确定性,别指望严格复现。

Q3:自回归能不能加速? 投机解码:小模型先猜 N 个,大模型一次验证;还有 Medusa 多头并行预测。

Q4:Prefill 和 Decode 阶段的区别? Prefill 并行、算力密集;Decode 串行、访存密集(memory-bound)。所以推理优化大多在"怎么省访存"上做文章。

Q5:训练时为什么也要加 Causal Mask? 保证训练和推理的分布一致,防止模型"作弊"看到未来。

Q6:KV Cache 为什么只缓存 K/V,不缓存 Q? Q 只属于当前新 token,用完即弃;K/V 要被后面所有 token 查询,才值得缓存。

Q7:Continuous Batching 怎么提升吞吐? 按迭代粒度动态组批,完成的请求立刻出队、新请求随时插入,避免短请求等长请求,GPU 始终满载。

Q8:让你设计一个 Java LLM 网关,怎么分层? 路由 + 鉴权 + 流式 + Batching + 限流 + 缓存 + 可观测,模型推理交给 vLLM / Triton,网关只做治理。

面试官其实就看四个维度:概念准确度(Token / Attention / 概率分布)、深度(公式、KV Cache、O(n²)→O(n))、工程落地(采样参数、流式、能写代码)、问题意识(幻觉 / 延迟 / 复读,有解法清单)。能主动把话题往 TTFT、KV Cache、背压释放上引,基本就和"背过博客"的候选人拉开差距了。

最后送个记忆口诀:

分词向量进 Transformer, 因果掩码只看左; 预测下一个 token, 拼回去再预测——就是自回归。

十一、写在最后

三句话收束全文要点:

  • LLM 本质:基于 Transformer 把海量语料压成条件概率分布,给定上文,预测下一个 token;
  • 自回归生成:条件概率的链式分解,把输出回灌成输入,逐 token 生成,串行是它的命门,也是所有优化的起点;
  • 工程关键:Prefill 并行 + Decode 串行,靠 KV Cache、采样策略、流式输出、批处理这四板斧,撑起大模型的线上体验。

四条落地建议:

  1. 接 LLM 先上流式输出,首字延迟从秒级降到毫秒级,体验直接上一个档次;
  2. 采样参数配置化,代码生成用低温求严谨,创意文案用高温求发散,不同场景不同 profile;
  3. 把 LLM 当"不可靠下游"治理:超时、退避重试、限流、降级、断连释放缓存,一个都不能少;
  4. 别让模型裸答,事实类业务上 RAG 或工具调用,配上引用溯源。

如果这篇文章对你有帮助,点赞、在看、关注就是最大的支持,号里会持续更新 AI + Java 工程化的实战内容。

最后留个互动话题:你在项目里用的 temperature / top_p 组合是多少?踩过哪些复读或幻觉的坑? 评论区聊聊你的经历。