AI 之 LLM（大语言模型）是如何生成文本的！

你是不是也曾在朋友面前自信满满地说："AI我可太熟了！"然后随便丢一句"写篇短文"给大模型，坐等它秒出结果？但你有没有想过，那几秒钟里，AI到底干了什么？从你敲下的几个字，到屏幕上蹦出的流畅句子，这背后可不是什么"魔法"。如果你连LLM（大语言模型）如何生成文本都不清楚，还好意思说自己懂AI？别急，今天我就带你拆开这台"写作机器"，用最直白的方式讲清楚每个步骤，看完你再吹牛，至少底气足点！

一、LLM文本生成的核心步骤

1. 输入阶段（Input）：一切从你开始

一切的开始，来自用户的输入。你可以输入一个提示、一个问题，或者是一段未完成的句子，模型会基于这个"起点"继续生成内容。

2. 分词（Tokenization）：把句子拆成小块

为了让模型理解文本，首先需要将文字拆解成更小的单元------Token。Token 可能是一个词、一个子词，甚至是一个字符，具体取决于使用的分词器（如 BPE、WordPiece 等）。比如"Hello, I'm an AI assistant."可能会被拆成['Hello', ',', 'I', "'m", 'an', 'AI', 'assistant', '.']。

3. 嵌入（Embedding）：给每个小块赋予"含义"

接下来，分词后的每个Token会被转换为向量，也就是我们常说的"嵌入表示"。这个过程帮助模型理解每个Token的语义信息。比如，"Hello"和"Hi"在嵌入空间里会很接近。

4. 位置编码（Positional Encoding）：记住谁在前谁在后

由于 Transformer 本身不具备处理"顺序"的能力，因此需要为每个Token添加位置信息，以便模型知道哪个词在前，哪个在后。位置编码给每个Token加上顺序信息，确保模型理解词序，比如"猫追狗"和"狗追猫"的区别。

5. Transformer处理阶段：大脑开始运转

这一步是 LLM 的"核心大脑"部分。嵌入和位置编码后的向量会被送入多层Transformer结构中，每层都包含自注意力机制和前馈神经网络。自注意力（Self-Attention）允许模型在处理某个词时，同时"关注"其他词，从而捕捉长距离的上下文依赖。它通常有多层（比如Llama3有32层），逐步完善文本。

6. 输出转换（Output Transformation）：准备"选词"

经过多层 Transformer 后，输出结果还不能直接变成文字。我们需要通过一个线性变换，将它映射回词表中的每个词可能性。处理后的结果变成一个巨大的向量，每个维度对应词汇表中的一个词。

7. Softmax函数：把潜力变成概率

接下来应用 Softmax，把这些值转化为概率分布，表示下一个Token是词表中每个词的可能性有多大。

8. 采样（Sampling）：决定下一个词

有了概率分布，模型就可以选择下一个Token了。不同的策略会影响生成结果，比如：

• 贪心采样（Greedy）：每次选最高概率的词。

• 随机采样（Random）：按概率随机选择一个词。

• 核采样（Top-p）：在累计概率前p%的词中随机选一个。

• 温度采样（Temperature）：控制生成的多样性。

9. 生成文本：一步步拼凑

Token 一个个被采样出来，拼接在一起，直到模型遇到结束标记，或达到设定长度，完成整个文本生成过程。模型通过重复预测和采样的过程，直到生成完整的句子。

10. 后处理（Post-processing）：给文本"化妆"

最后，对生成的文本进行一些清理，比如去掉特殊符号、调整格式，甚至可以进行语法检查，使得文本更自然可读。

二、用代码案例深入理解生成流程（程序员最兴奋的章节

）

我们以 OpenAI 的 GPT-2 模型为例，配合 tikToken 分词器和 PyTorch 框架，来展示如何分词、嵌入，并查看每个Token的语义向量。

import torch
import tikToken
from transformers import GPT2Model

# 初始化编码器
encoder = tikToken.get_encoding("gpt2")
model = GPT2Model.from_pretrained("gpt2")

# 输入文本
text = "Hello, I'm an AI assistant."
Token_ids = encoder.encode(text)
Tokens = [encoder.decode([tid]) for tid in Token_ids]

# 转换为张量
inputs = torch.tensor([Token_ids])

# 获取模型嵌入输出
with torch.no_grad():
    outputs = model(inputs)

last_hidden_states = outputs.last_hidden_state
for Token, emb in zip(Tokens, last_hidden_states[0]):
    print(f"Token: {Token}\nEmbedding: {emb}\n")

每一个Token对应的向量（Embedding），都承载着它在语义空间中的"位置"。

三、继续深入：从位置编码到输出生成

示例1：位置编码 Positional Encoding

Transformer需要位置信息才能理解顺序。以下代码实现了位置编码的生成：

import torchimport math
def positional_encoding(seq_length, d_model):    pe = torch.zeros(seq_length, d_model)    position = torch.arange(0, seq_length, dtype=torch.float).unsqueeze(1)    div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))    pe[:, 0::2] = torch.sin(position * div_term)    pe[:, 1::2] = torch.cos(position * div_term)    return pe
pos_encoding = positional_encoding(10, 16)print(pos_encoding)

示例2：构建一个简化的 Transformer 模型

import torch.nn as nn
class SimpleTransformer(nn.Module):    def __init__(self, input_dim, model_dim, num_heads, num_layers):        super(SimpleTransformer, self).__init__()        self.embedding = nn.Embedding(input_dim, model_dim)        self.position_encoding = positional_encoding(5000, model_dim)        self.transformer_layers = nn.TransformerEncoder(            nn.TransformerEncoderLayer(model_dim, num_heads, model_dim * 4), num_layers        )        self.fc_out = nn.Linear(model_dim, input_dim)
    def forward(self, x):        x = self.embedding(x) + self.position_encoding[:x.size(1), :]        x = self.transformer_layers(x)        return self.fc_out(x)
# 示例运行model = SimpleTransformer(input_dim=10000, model_dim=512, num_heads=8, num_layers=6)input_seq = torch.randint(0, 10000, (10, 20))output_seq = model(input_seq)
# Softmax 转换为概率output_layer = nn.Linear(512, 10000)output_seq_transformed = output_layer(output_seq)softmax = nn.Softmax(dim=-1)probabilities = softmax(output_seq_transformed)

可以看到，最终得到的是一个维度为 (batch_size, seq_length, vocab_size) 的概率分布，用于采样生成下一个词。

示例3：采样策略与预测

# 贪心预测predicted_tokens = torch.argmax(probabilities, dim=-1)print(predicted_tokens)
# 随机采样predicted_tokens_random = torch.multinomial(    probabilities.view(-1, probabilities.size(-1)), 1).view(probabilities.size()[:-1])print(predicted_tokens_random)

示例4：文本生成主流程

以 LLaMA3 为例，下面是一个典型的生成循环：def generate_text(model, tokenizer, start_text, max_length):

    tokens = tokenizer.encode(start_text)    generated = tokens.copy()    for _ in range(max_length - len(tokens)):        input_tensor = torch.tensor([generated])        with torch.no_grad():            output = model(input_tensor)        next_token_logits = output[:, -1, :]        next_token_probs = torch.softmax(next_token_logits, dim=-1)        next_token = torch.multinomial(next_token_probs, num_samples=1).item()        generated.append(next_token)    return tokenizer.decode(generated)

四、总结

看完这篇，LLM从输入到输出的"魔法"流程你总算搞清楚了吧？别再只是当个"AI用家"了，懂点门道，下次跟人聊AI也能硬气地说："生成文本？小意思，我连Transformer怎么跑都知道！"当然，这只是AI世界的入门课，想真正在这个领域站稳脚跟，还有更多硬核知识等着你去啃。怎么样，敢不敢给LLM丢个复杂问题，测试一下你刚学的"理论"？