在自然语言处理（NLP）的璀璨星河中，Google于2018年发布的BERT（Bidirectional Encoder Representations from Transformers），无疑是一颗划时代的巨星。它以其"双向Transformer编码器"的架构，彻底改变了我们理解和处理文本的方式，为后续的语言模型发展奠定了坚实基础。

然而，AI的进步从未止步。在BERT的基础上，研究人员们不断探索，通过巧妙的改进，涌现出了RoBERTa、ALBERT等一系列更强大、更高效的续作。而近年来，以LLaMA（Large Language Model Meta AI）为代表的"大模型"更是将语言模型的能力推向了新的高度。

今天，我们就来一起回顾这场"BERT家族"的进化史，探究从BERT到LLaMA，每一次迭代的核心改进在哪里，并通过代码示例感受这些技术进步的脉络。

一、 BERT：开启双向预训练的革命

在BERT诞生之前，主流的NLP模型（如ELMo、GPT-1）在预训练时，大多采用单向或"填充式"的语言模型任务，这限制了它们对上下文信息的深度理解。BERT的革命性在于：

双向Transformer编码器： BERT使用多层的Transformer编码器，其注意力机制（Self-Attention）能够让模型同时关注一个词的左侧和右侧上下文，从而获得更丰富的双向语义表示。

Masked Language Model (MLM)： BERT引入了MLM任务，随机遮盖输入序列中的一些Token（例如，用[MASK]代替），然后训练模型预测这些被遮盖掉的Token。这种方式迫使模型学习Token之间的依赖关系，并通过"填空"的方式全面理解上下文。

Next Sentence Prediction (NSP)： BERT还有一个预训练任务是NSP，即判断两个句子之间是否存在逻辑上的承接关系。这有助于模型理解句子间的关系，对问答、自然语言推理等任务有益。

核心贡献：

彻底的双向上下文理解。

高质量的预训练表示，可迁移到下游任务，显著提升性能。

简化的BERT模型概念（使用Hugging Face transformers库）：

from transformers import BertTokenizer, TFBertModel

import tensorflow as tf

加载预训练模型和分词器

tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

model = TFBertModel.from_pretrained('bert-base-uncased')

准备输入文本

text = "Hello, I am a language model from Google."

encoded_input = tokenizer(text, return_tensors='tf', padding=True, truncation=True, max_length=512)

获取模型的输出 (last_hidden_state, pooler_output)

last_hidden_state: 每个Token的最终隐藏状态

pooler_output: 通常是第一个Token ([CLS]) 的隐藏状态，代表整个句子的语义（经过一个额外的线性层和tanh激活）

output = model(encoded_input)

last_hidden_states = output.last_hidden_state

pooler_output = output.pooler_output

print("Input IDs:", encoded_input['input_ids'])

print("Last Hidden States Shape:", last_hidden_states.shape) # (batch_size, sequence_length, hidden_size)

print("Pooler Output Shape:", pooler_output.shape) # (batch_size, hidden_size)

我们可以用 pooler_output 作为输入，接一个分类器来做下游任务，例如情感分析

classifier = tf.keras.Sequential([

tf.keras.layers.Dense(768, activation='relu'),

tf.keras.layers.Dropout(0.1),

tf.keras.layers.Dense(1, activation='sigmoid') # 二分类

])

prediction = classifier(pooler_output)

print("Prediction:", prediction.numpy())

二、 RoBERTa：BERT的"优化版"

Facebook AI在BERT成功后，对其训练策略进行了系统性的梳理和改进，提出了RoBERTa（A Robustly Optimized BERT Pretraining Approach）。RoBERTa并没有改变BERT的Transformer架构，而是在"recipe"上做了大量优化：

更大的数据集和更长的训练： RoBERTa在比BERT更大规模的数据集（160GB vs 16GB）上进行了更长时间的训练，参数更新次数也更多。

移除NSP任务：研究发现，NSP任务对模型的下游性能提升有限，甚至可能有害。RoBERTa取消了NSP，采用文档级别的MLM，即模型可以一次性处理整个文档，而不是只处理固定长度的句子对。

动态Masking： BERT在预训练时对句子进行一次"Masking"，然后训练。RoBERTa则在每次训练epoch时动态地生成Masking模式，这意味着同一文本在不同epoch中会被以不同的方式Masked，增加了模型的鲁棒性。

更大的Batch Size： RoBERTa采用了更大的Batch Size，这在一定程度上能够提升模型性能。

核心改进：

更精细的训练策略，优化了预训练效果。

移除了NSP任务，专注于MLM，效果更佳。

使用动态Masking增加数据多样性。

RoBERTa模型使用示例（与BERT类似）：

from transformers import RobertaTokenizer, TFRobertaModel

加载RoBERTa预训练模型和分词器

tokenizer = RobertaTokenizer.from_pretrained('roberta-base')

model = TFRobertaModel.from_pretrained('roberta-base')

text = "RoBERTa is an optimization of BERT."

encoded_input = tokenizer(text, return_tensors='tf', padding=True, truncation=True, max_length=512)

RoBERTa的输出与BERT类似

output = model(encoded_input)

last_hidden_states = output.last_hidden_state

pooler_output = output.pooler_output # RoBERTa有个叫做 'pooler_output' 的属性，但它和BERT的pooler_output含义可能略有不同（RoBERTa默认不执行pooler操作，而是直接从`last_hidden_state`的第一个token获取表示）

print("RoBERTa Last Hidden States Shape:", last_hidden_states.shape)

print("RoBERTa Pooler Output Shape:", pooler_output.shape)

三、 ALBERT：轻巧而高效的"近亲"

在追求模型性能的同时，模型的计算效率和参数量也是重要考量。ALBERT（A Lite BERT）提出了多项创新，旨在大幅减小BERT的参数量，同时保持甚至提升性能：

参数共享（Parameter Sharing）： ALBERT在Transformer的多个层之间共享参数，例如，所有Encoder层都使用同一组参数。这使得模型的总参数量急剧减少，但同时保留了深度结构带来的信息处理能力。

Factorized Embedding Parameterization：将原本与隐藏层维度（H）相同的Vocabulary Embedding矩阵（E x H，其中E为Vocabulary大小）分解成两个较小的矩阵（E x h 和 h x H，其中h << H）。这显著减小了Embedding层的参数量，同时允许H进一步增大，理论上可以提升模型性能。

Sentence Order Prediction (SOP)： ALBERT借鉴了BERT的NSP任务，但发现NSP可能容易被"Masking"和"Token Type"等信息所干扰，导致模型学习到的是"文档的连贯性"而非"句子间的连贯性"。ALBERT提出SOP任务，它不是随机选择两个句子，而是选择一个文档中的两个连续的句子，然后随机交换它们的顺序，训练模型区分原始顺序和交换顺序。这被证明是一个更精细、更能捕捉句子间连贯性的任务。

核心改进：

参数共享，大幅降低参数量，模型更轻更高效。

Embeddings分解，减小Embedding层参数，允许更大隐藏尺寸。

SOP任务，提升了模型对句子间关系的理解。

ALBERT模型使用示例：

from transformers import AlbertTokenizer, TFBertModel # ALBERT的模型类在`transformers`库中通常沿用BertModel的命名

import tensorflow as tf

ALBERT模型名称通常是 'albert-base-v2' 或 'albert-large-v2' 等

tokenizer = AlbertTokenizer.from_pretrained('albert-base-v2')

注意：ALBERT的模型类名虽然叫BertModel，但实际加载的是ALBERT的权重和结构

model = TFBertModel.from_pretrained('albert-base-v2')

text = "ALBERT is a parameter-efficient model that significantly reduces parameters."

encoded_input = tokenizer(text, return_tensors='tf', padding=True, truncation=True, max_length=512)

output = model(encoded_input)

ALBERT 的输出结构通常与BERT/RoBERTa一致

last_hidden_states = output.last_hidden_state

pooler_output = output.pooler_output

print("ALBERT Last Hidden States Shape:", last_hidden_states.shape)

print("ALBERT Pooler Output Shape:", pooler_output.shape)

四、 LLaMA：向"大模型"时代的进军

虽然BERT及其改进模型在许多NLP任务上表现出色，但研究人员并未停止探索更大的模型和更优的训练方法。Meta AI发布的LLaMA（Large Language Model Meta AI）系列模型，标志着语言模型正向着"巨型"化和"通用化"迈进。LLaMA并不是在前人基础上进行细微调整，而是提出了更重要的理念和结构上的优化，为后续的大模型（如GPT-3/4, Bard/Gemini）铺平了道路。

LLaMA系列（LLaMA, LLaMA 2, ...) 并非只是简单地增加参数量，而是综合运用了多种技术：

改进的Transformer架构：

RMSNorm（Root Mean Square Layer Normalization）： ALBERT已经开始使用RMSNorm，LLaMA也沿用了这种规范化方式，相较于LayerNorm，可能更高效且性能相当。

SwiGLU激活函数：很多大模型采用了SwiGLU（Shi-GLU）作为激活函数，它是一种GEGLU（Gated Linear Unit with GELU）的变体，通常能提供更好的性能。

RoPE（Rotary Positional Embeddings）： LLaMA使用旋转位置嵌入（Rotary Positional Embeddings），它将位置信息编码到Query和Key的旋转角度中，不同于BERT中的绝对位置编码或RoBERTa/ALBERT中的相对位置编码，RoPE在处理长序列时表现更优，也更容易外推到更长的文本。

大量数据和计算资源： LLaMA是在海量的、高质量的公开数据集上进行预训练的，其数据量和训练计算量远超BERT时代。

更精细的训练优化： LLaMA的训练过程也经过了大量的工程优化和超参数调整，例如使用AdamW优化器、学习率调度器等。

核心改进（LLaMA的理念和技术）：

先进的Transformer变体： RMSNorm, SwiGLU, RoPE等，提升了模型效率和长序列处理能力。

超大规模的预训练：强调了数据量、模型规模和计算资源在提升语言模型能力上的重要性。

模型通用化： LLM的目标是成为一个"元语言模型"，能够应对日益广泛的下游任务，而不仅仅是特定任务的微调。

LLaMA模型使用示例（通过transformers库，如llama-2-7b-hf）：

注意：LLaMA模型通常需要通过Hugging Face的 `accelerate` 和 `transformers` 库来加载

并且常常需要登录Hugging Face Hub，同意使用条款

确保已安装：pip install transformers accelerate sentencepiece

import torch # LLaMA通常用PyTorch实现

from transformers import LlamaTokenizer, LlamaForCausalLM # LLaMA是生成模型，用ForCausalLM

import torch

假设你已经下载了LLaMA模型权重，或者有权限访问Hugging Face Hub上的 LLaMA-2-7b-hf

model_name = 'meta-llama/Llama-2-7b-hf' # 需要Hugging Face认证

tokenizer = LlamaTokenizer.from_pretrained(model_name)

model = LlamaForCausalLM.from_pretrained(model_name)

为了示例，我们使用一个较小的、可能公开可用的llama-like模型，或者就用同等规模的GPT-2来模拟其接口

（请理解LLaMA的真正强大之处在于其规模和训练数据，这里仅演示代码接口）

假设我们已经加载了一个类似LLaMA的 tokenizer 和 model

实际中，你需要替换为实际的LLaMA模型名称和加载方式

并且可能需要指定设备 (device='cuda' if torch.cuda.is_available() else 'cpu')

class MockLLaMAModel:

def init(self):

print("Mock LLaMA Model Initialized. (Actual LLaMA requires specific loading)")

正常情况这里会加载真正的模型和tokenizer

self.tokenizer = LlamaTokenizer.from_pretrained(...)

self.model = LlamaForCausalLM.from_pretrained(...)

def call(self, inputs):

这是一个模拟的call方法，返回类似HiddenState的结构

实际LLaMA模型是生成文本的，输出结构不同

这里为了演示，我们假设它返回一个字典，其中包含一个 'last_hidden_state'

print("Mock Model generating output...")

模拟一个shape

mock_hidden_state = torch.randn(inputs['input_ids'].shape[0], inputs['input_ids'].shape[1], 4096) # LLaMA-7B hidden size is 4096

return {'last_hidden_state': mock_hidden_state}

class MockLLaMATokenizer:

def call(self, text, return_tensors='tf', padding=True, truncation=True, max_length=512):

print("Mock Tokenizer processing text...")

模拟token outputs

num_tokens = len(text.split()) + 2 # 假设加入CLS和SEP token

return {'input_ids': torch.randint(0, 30000, (1, num_tokens))} # 模拟token IDs

由于直接加载LLaMA需要特定权限和环境，这里使用Mock对象来展示接口行为

mock_tokenizer = MockLLaMATokenizer()

mock_model = MockLLaMAModel()

text = "LLaMA is a foundation model from Meta AI, aiming for broad capabilities."

encoded_input = mock_tokenizer(text, return_tensors='tf', padding=True, truncation=True, max_length=512)

LLaMA作为生成模型，其主要的输出是生成的文本

如果我们只是想看它的隐藏层表示，通常也需要通过类似accessing `hidden_states` in `output`

For a CausalLM, the 'output' object is usually a dataclass with attributes like 'logits', 'past_key_values', 'hidden_states' etc.

Here, our mock returns a dictionary mimicking a BaseModelOutput

output = mock_model(encoded_input)

实际LLaMA模型会返回一个包含logits, past_key_values, hidden_states等的Outputs object

我们可以从hidden_states[0] (或最后一个)获取类似MLM模型的last_hidden_state

这里的 mock_model 仅返回一个简单的字典，以展示通用接口

print("LLaMA Last Hidden States Shape:", output['last_hidden_state'].shape)

print(f"Mock LLaMA processing complete for '{text}'.")

实际LLaMA的输出是用于生成的，例如：

generated_ids = model.generate(encoded_input['input_ids'], max_length=100)

generated_text = tokenizer.decode(generated_ids[0], skip_special_tokens=True)

print("LLaMA Generated Text:", generated_text)

注意：运行LLaMA的代码需要专门的环境和模型权重。上面的示例使用了Mock对象来模拟调用接口，以展示其概念。实际使用时（例如通过Hugging Face transformers库加载 Meta 的 LLaMA-2 模型），您会发现LLaMA作为一个CausalLM（因果语言模型），其主要功能是生成文本，通常有一个 model.generate() 方法，而不是直接像BERT那样返回last_hidden_state来做一个分类任务。但其内部的 Transformer 结构仍然是通过多层编码器（或者更准确地说，解码器，因为CausalLM通常是Decoder-only架构）来处理输入的。

五、总结：一次次突破的背后

BERT家族的进化史，是一部关于如何更深层次地理解模型"学习"过程的历史：

BERT 确立了双向性和MLM的强大能力。

RoBERTa 通过优化训练策略，揭示了数据、计算和训练方法的关键作用。

ALBERT 则在效率与性能之间找到了新的平衡点，证明了参数共享和精细的任务设计能带来巨大效益。

LLaMA 代表了向大规模、通用、高效基础模型的迈进，强调了架构创新、数据质量和算力的协同作用。

每一次的进步，都建立在对前代模型不足的深刻洞察之上，并融入了新的理论和工程实践。从BERT到LLaMA，我们看到了NLP模型在理解语言、生成内容方面能力的飞跃，也预示着AI将在更多领域发挥更加核心的作用。理解这些演进的脉络，不仅是对技术进步的回顾，更是对未来的探索和展望。

BERT家族进化史：从BERT到LLaMA，每一次飞跃都源于对“学习”的更深理解

加载预训练模型和分词器

准备输入文本

获取模型的输出 (last_hidden_state, pooler_output)

last_hidden_state: 每个Token的最终隐藏状态

pooler_output: 通常是第一个Token ([CLS]) 的隐藏状态，代表整个句子的语义（经过一个额外的线性层和tanh激活）

我们可以用 pooler_output 作为输入，接一个分类器来做下游任务，例如情感分析

classifier = tf.keras.Sequential([

tf.keras.layers.Dense(768, activation='relu'),

tf.keras.layers.Dropout(0.1),

tf.keras.layers.Dense(1, activation='sigmoid') # 二分类

])

prediction = classifier(pooler_output)

print("Prediction:", prediction.numpy())

加载RoBERTa预训练模型和分词器

RoBERTa的输出与BERT类似

ALBERT模型名称通常是 'albert-base-v2' 或 'albert-large-v2' 等

注意：ALBERT的模型类名虽然叫BertModel，但实际加载的是ALBERT的权重和结构

ALBERT 的输出结构通常与BERT/RoBERTa一致

注意：LLaMA模型通常需要通过Hugging Face的 `accelerate` 和 `transformers` 库来加载

并且常常需要登录Hugging Face Hub，同意使用条款

确保已安装：pip install transformers accelerate sentencepiece

import torch # LLaMA通常用PyTorch实现

假设你已经下载了LLaMA模型权重，或者有权限访问Hugging Face Hub上的 LLaMA-2-7b-hf

model_name = 'meta-llama/Llama-2-7b-hf' # 需要Hugging Face认证

tokenizer = LlamaTokenizer.from_pretrained(model_name)

model = LlamaForCausalLM.from_pretrained(model_name)

为了示例，我们使用一个较小的、可能公开可用的llama-like模型，或者就用同等规模的GPT-2来模拟其接口

（请理解LLaMA的真正强大之处在于其规模和训练数据，这里仅演示代码接口）

假设我们已经加载了一个类似LLaMA的 tokenizer 和 model

实际中，你需要替换为实际的LLaMA模型名称和加载方式

并且可能需要指定设备 (device='cuda' if torch.cuda.is_available() else 'cpu')

正常情况这里会加载真正的模型和tokenizer

self.tokenizer = LlamaTokenizer.from_pretrained(...)

self.model = LlamaForCausalLM.from_pretrained(...)

这是一个模拟的call方法，返回类似HiddenState的结构

实际LLaMA模型是生成文本的，输出结构不同

这里为了演示，我们假设它返回一个字典，其中包含一个 'last_hidden_state'

模拟一个shape

模拟token outputs

由于直接加载LLaMA需要特定权限和环境，这里使用Mock对象来展示接口行为

LLaMA作为生成模型，其主要的输出是生成的文本

如果我们只是想看它的隐藏层表示，通常也需要通过类似accessing `hidden_states` in `output`

For a CausalLM, the 'output' object is usually a dataclass with attributes like 'logits', 'past_key_values', 'hidden_states' etc.

Here, our mock returns a dictionary mimicking a BaseModelOutput

实际LLaMA模型会返回一个包含logits, past_key_values, hidden_states等的Outputs object

我们可以从hidden_states[0] (或最后一个)获取类似MLM模型的last_hidden_state

这里的 mock_model 仅返回一个简单的字典，以展示通用接口

print("LLaMA Last Hidden States Shape:", output['last_hidden_state'].shape)

实际LLaMA的输出是用于生成的，例如：

generated_ids = model.generate(encoded_input['input_ids'], max_length=100)

generated_text = tokenizer.decode(generated_ids[0], skip_special_tokens=True)

print("LLaMA Generated Text:", generated_text)