大语言模型 | LLM文本生成的核心步骤详细解析！_大语言模型生成token的过程-优快云博客

本文链接：https://blog.youkuaiyun.com/Code1994/article/details/147149444

一、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 torch
import 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)