标签TokenClassification

spaCy的NER标签转换成RoBERTa能用的格式

最近在做命名实体识别的项目，遇到了一个挺头疼的问题：spaCy标注出来的数据格式和RoBERTa需要的格式不一样。折腾了好久才搞明白，这里记录一下转换的过程。

先看看我们的数据长什么样：

text = "女 大专 xfwang@dayee.com 身份证 杨洋 无经验 学士"
entities = [
    (27, 29, 'NAME'),
    (1, 2, 'GENDER'),
    (6, 22, 'EMAIL_ADDRESS'),
    (30, 33, 'YEARS_OF_WORK_EXPERIENCE'),
    (34, 36, 'DEGREE')
]

这种格式是字符级别的起止位置 + 标签（spaCy的doc.ents就是这样的）。但是RoBERTa/Longformer做NER的时候，需要的是token级别的BIO/BILOU标签。所以我们得想办法把它们对应起来。

第一步：用RoBERTa的tokenizer分词

这一步很关键，因为RoBERTa用的是BPE分词，跟spaCy的分词方式完全不一样。字符位置和token位置肯定对不上，所以必须重新分词。

from transformers import RobertaTokenizerFast

tokenizer = RobertaTokenizerFast.from_pretrained("roberta-base")

tokens = tokenizer.tokenize(text)
print(tokens)

输出大概是这样的：

['女', 'Ġ大', '专', 'Ġxf', 'wang', '@', 'day', 'ee', '.', 'com', 'Ġ身份证', 'Ġ杨', '洋', 'Ġ无', '经验', 'Ġ学士']

这里的Ġ表示空格，BPE会把空格当成特殊的前缀处理。

第二步：建立字符和token的对应关系

这一步用tokenizer的char_to_token方法，把字符位置映射到token位置。

encoding = tokenizer(text, return_offsets_mapping=True)
offsets = encoding["offset_mapping"]

print(offsets)

输出：

[(0,1), (1,3), (3,4), (4,6), (6,10), (10,11), (11,14), (14,16), (16,17), (17,20), (20,24), (24,26), (26,27), (27,29), (29,31), (31,33)]

每个元组表示(start_char, end_char)，这样就能知道每个token对应原文的哪个字符区间了。

第三步：初始化BIO标签

先给所有token都打上"O"标签（Outside，表示不属于任何实体）。

labels = ["O"] * len(offsets)

第四步：把实体的字符位置转换成token位置

对每个(start_char, end_char, label)，找到对应的token下标。

for start_char, end_char, ent_label in entities:
    token_start = None
    token_end = None
    for i, (start, end) in enumerate(offsets):
        if start_char >= start and start_char < end:
            token_start = i
        if end_char > start and end_char <= end:
            token_end = i
    # BIO标注
    if token_start is not None and token_end is not None:
        labels[token_start] = "B-" + ent_label
        for j in range(token_start + 1, token_end + 1):
            labels[j] = "I-" + ent_label

第五步：看看最终结果

for tok, lab in zip(tokens, labels):
    print(f"{tok:15} {lab}")

输出大概是这样：

女              B-GENDER
Ġ大             B-DEGREE
专              I-DEGREE
Ġxf             B-EMAIL_ADDRESS
wang            I-EMAIL_ADDRESS
@               I-EMAIL_ADDRESS
day             I-EMAIL_ADDRESS
ee              I-EMAIL_ADDRESS
.               I-EMAIL_ADDRESS
com             I-EMAIL_ADDRESS
Ġ身份证          O
Ġ杨             B-NAME
洋              I-NAME
Ġ无             B-YEARS_OF_WORK_EXPERIENCE
经验            I-YEARS_OF_WORK_EXPERIENCE
Ġ学士           B-DEGREE

总结一下整个流程

经过这么一番折腾，我们成功把：

• spaCy的字符级span标签
• 转换成了RoBERTa需要的token级BIO标签

关键就是用offset_mapping来对齐字符位置和token位置。这样就能把spaCy的(start, end, label)格式转成RoBERTa能直接用的**input_ids + labels**对了。

最终的效果大概是这样：

原文：  女 大专 xfwang@dayee.com 身份证 杨洋 无经验 学士
tokens： ['女', '大', '专', 'x', '##fw', '##ang', '@', 'day', '##ee', '.', 'com', '身', '份', '证', '杨', '洋', '无', '经', '验', '学', '士']
labels： ['B-GENDER', 'O', 'O', 'B-EMAIL_ADDRESS', 'I-EMAIL_ADDRESS', 'I-EMAIL_ADDRESS', 'I-EMAIL_ADDRESS', 'I-EMAIL_ADDRESS', 'I-EMAIL_ADDRESS', 'I-EMAIL_ADDRESS', 'I-EMAIL_ADDRESS', 'O', 'O', 'O', 'B-NAME', 'I-NAME', 'B-YEARS_OF_WORK_EXPERIENCE', 'I-YEARS_OF_WORK_EXPERIENCE', 'I-YEARS_OF_WORK_EXPERIENCE', 'B-DEGREE', 'I-DEGREE']

spacy config.cfg

配置文件分成 六大块：

1. 路径 & 系统全局
2. nlp 基础设置（语言、pipeline、tokenizer、vectors）
3. 语料库 (corpora)
4. 训练通用超参数（seed、dropout、early‑stop、epoch/step 等）
5. 训练子模块（logger、batcher、optimizer）
6. 初始化 (initialize) 阶段的资源

阅读提示

• null 在配置里表示 “不指定 / 使用默认值”。
• ${...} 是 变量引用，把前面定义的值插入当前位置。
• @xxx = "module.v1" 表示 使用 spaCy 的注册工厂（factory）来实例化对应的对象。

下面逐节、逐项解释每个变量的 含义、默认行为、以及在训练/推理时的作用。

1️⃣ [paths] – 文件路径占位符

为什么要把路径放在单独的 [paths] 节？
这样在 命令行（spacy train config.cfg -c paths.train=./mytrain.spacy）或 Python 脚本 中可以统一覆盖，避免在多个位置硬编码。

2️⃣ [system] – 系统层面的全局设置

3️⃣ [nlp] – 核心 Language 对象的配置

3.1 [nlp.tokenizer] – 分词器工厂

3.2 [nlp.vectors] – 词向量表工厂

4️⃣ [components] – 流水线组件的具体配置

当前文件里 没有任何子节（如 [components.tagger]），因为 pipeline = []。
当你向 pipeline 中加入组件时，需要在这里添加对应的块，例如：

[components.tagger]
factory = "tagger"
...

5️⃣ [corpora] – 语料库读取器的配置

5.1 [corpora.train] – 训练语料

5.2 [corpora.dev] – 验证语料

同训练块，只是 path 指向 paths.dev，其它字段意义完全相同。

为什么两块几乎相同？
因为 训练 与 评估 常常使用相同的读取逻辑，只是数据来源不同。把它们分开可以让你在 training.dev_corpus 中指向 corpora.dev，而不必在每个块里重复写 dev_corpus = "corpora.dev"。

6️⃣ [training] – 训练过程的全局超参数

7️⃣ [training.logger] – 训练日志记录器

8️⃣ [training.batcher] – 批次划分器（batch generator）

8.1 [training.batcher.size] – batch size 的调度（schedule）

实际 batch 大小 = schedule(step) → 受 tolerance、discard_oversize 进一步调节。

9️⃣ [training.optimizer] – 优化器（Adam）及其超参数

关联解释：

• learn_rate 与 [training.optimizer.learn_rate]（如果你另建该块）配合使用，schedule 会在每 step 调整 learn_rate 的实际数值。
• L2_is_weight_decay 与 L2 共同决定 权重衰减，而 权重衰减 会 乘以当前学习率，所以它们间接受 schedule 的影响。

🔟 [initialize] – nlp.initialize() 时的资源加载

何时会调用 initialize？

• 训练前（spacy train 自动调用）
• 预训练模型（spacy pretrain）
• 手动脚本中使用 nlp.initialize() 来 预加载词表、标签、向量，确保后续 nlp.update() 不会因缺失信息报错。

📌 小结（关键关联）

调参技巧（快速参考）

1. 学习率：先把 initial_rate（在 schedule）和 optimizer.learn_rate 设为相同值（如 1e‑3），再观察 loss 曲线；若收敛慢可把 initial_rate 降到 5e‑4。
2. 批次大小：compounding 的 start 与 stop 影响显存占用；对显存紧张的 GPU 把 stop 降到 500，或把 tolerance 调小。
3. 正则：L2 = 0.01 对大模型通常足够；如果出现 过拟合（dev 分数下降），可以把 L2 加大到 0.02 或 0.05。
4. 梯度裁剪：对 序列标注、NER 这类梯度可能爆炸的任务，保持 grad_clip = 1.0；若出现 nan，尝试调小到 0.5。
5. 早停：patience 与 eval_frequency 配合使用；如果每 200 步评估一次，patience=1600 相当于 最多 8 次（1600/200）没有提升才停止。

token词表固定吗

1️⃣ 词表（Vocabulary）到底是「固定」还是「可改」？

2️⃣ 词表改变会产生哪些直接影响？

3️⃣ 具体案例：改动词表会怎样「看得见」？

3.1 只 增加 新 token（最安全的改动）

from transformers import BertTokenizerFast, BertModel

tokenizer = BertTokenizerFast.from_pretrained("bert-base-uncased")
model     = BertModel.from_pretrained("bert-base-uncased")

# 假设我们要加入三个行业专有词
new_tokens = ["[MED]", "[FIN]", "[GEO]"]          # 这里用方括号只是举例
num_added = tokenizer.add_tokens(new_tokens)     # <-- 自动在词表末尾追加

print("新增 token 数量:", num_added)            # 3
print("新词表大小:", len(tokenizer))            # 30523 (原来 30522)

# 对模型的 embedding 进行对应扩展
model.resize_token_embeddings(len(tokenizer))

# 现在可以直接 fine‑tune，新增 token 的 embedding 会是随机初始化

• 影响：[MED]、[FIN]、[GEO] 的 ID 会是原词表最后的三个（如 30522、30523、30524）。
• 好处：原有 token‑ID 保持不变，所有预训练权重仍然对应原来的向量，只有 新增行 需要在微调阶段学习。

3.2 删除 现有 token（不推荐）

# 假设你想把词表里 "the" 这个 token 删除
old_id = tokenizer.convert_tokens_to_ids("the")
# 直接删除会导致 ID 错位，模型会把原来 "the" 的 embedding 用在别的 token 上

• 后果：所有 ID > old_id 的 token 会向前平移 1 位，embedding 行全部错位，模型在每一步都会使用错误的向量，导致 几乎所有下游任务的性能崩溃。
• 唯一可行的做法：重新训练一个完整的 tokenizer（重新生成 vocab.txt），从头训练或 从头微调（使用随机初始化的 embedding），这等价于 换模型。

3.3 更改 特殊 token 的 ID（极度危险）

# 把 <pad> 的 ID 从 0 改成 5
tokenizer.pad_token = "[PAD]"          # 确保 token 本身仍在词表中
tokenizer.pad_token_id = 5
model.config.pad_token_id = 5

• 如果不同步：attention_mask 仍会把原来的 0 当作 padding，导致模型把实际 token 当作 padding，注意力会 忽略 这些位置，输出全是 0。
• 如果同步：模型仍然可以工作，但 所有已有的 checkpoint（在 pad_token_id=0 时训练得到的）在 梯度计算 时会把错误的 mask 传进来，微调效果会变差。
• 推荐：保持默认 ID（0、101、102、103、100）不动，若必须改动请 重新训练 或 在微调前彻底重新生成 attention_mask。

4️⃣ 为什么词表的 ID 映射 会影响模型表现？

5️⃣ 如何安全地 扩展 或 微调 词表？

常见的「扩展」技巧

6️⃣ 何时必须 重新训练 整个模型？

7️⃣ 小结（要点回顾）

1. 词表在预训练时是固定的，因为它与模型的 embedding 行一一对应。
2. 下游任务可以安全地
   • 增加 新 token（add_tokens → resize_token_embeddings），
   • 保持 所有已有 token 的 ID 不变。
3. 删除或改动已有 token 的 ID 会导致 embedding 行错位，从而 破坏模型的所有层——只能重新训练。
4. 特殊 token（[PAD]、[CLS]、[SEP]、[MASK]、[UNK]）的 ID 在 模型代码、Tokenizer、config 中都有硬编码，改动时必须 同步更新，否则会出现 mask 错误、attention 错位等问题。
5. 词表扩展的影响：新增 token 的向量是随机（或均值）初始化，需要 微调 让它们学到有意义的表示；但原有权重保持不变，模型的整体能力基本不受影响。
6. 实战建议：
   • 先 检查 len(tokenizer) 与 model.config.vocab_size 是否一致。
   • 用 model.resize_token_embeddings(new_vocab_size) 自动扩展/裁剪。
   • 对 特殊 token 使用 tokenizer.pad_token_id, tokenizer.cls_token_id 等属性，而不是硬写数字。
   • 若需要 大量新词（>5% 词表），考虑 重新训练 tokenizer（SentencePiece/WordPiece）并 从头或继续预训练（model.train()）以获得更好的子词分布。

一句话概括：
词表的 ID ↔ embedding 行 是模型的核心映射，只要保持这一映射不变（即不改动已有 token 的 ID），你就可以安全地 增添新 token，并通过 resize_token_embeddings 让模型接受这些新词；若破坏了映射，就必须 重新训练（或重新生成 tokenizer），否则模型的所有表示都会错位，性能会瞬间崩溃。

bert和任务头

1️⃣ 「BERT 本身」和「任务头」的边界

结论：

• 原始的 bert-base-uncased、bert-large‑cased 等 checkpoint 只提供 通用隐藏向量，没有任何 NER、分类或其他任务的专用头。
• 任何 “跑分” （GLUE、CoNLL‑2003、SQuAD 等）都是 在这些通用向量之上 再 训练（或 微调）一个 任务头（有时连同全部参数一起微调，有时只微调头部）。

2️⃣ 怎样判断一个 checkpoint 已经 包含了任务头？

2.1 看模型类（AutoModel…）

快速检查Python）：

from transformers import AutoConfig, AutoModel, AutoModelForTokenClassification

model_name = "bert-base-uncased"                     # 只含 BERT
cfg = AutoConfig.from_pretrained(model_name)
print("architectures:", cfg.architectures)           # ['BertModel']
print("num_labels:", getattr(cfg, "num_labels", None))  # None → 没有任务头

# 如果是已经微调好的 NER checkpoint
ner_name = "dslim/bert-base-NER"
cfg2 = AutoConfig.from_pretrained(ner_name)
print(cfg2.architectures)   # ['BertForTokenClassification']
print("num_labels =", cfg2.num_labels)  # e.g. 9 (B‑ORG, I‑ORG, …)

2.2 看模型的 权重文件（pytorch_model.bin）

import torch, os
state = torch.load("pytorch_model.bin", map_location="cpu")
print([k for k in state.keys() "classifier" in k])   # → ['classifier.weight', 'classifier.bias']

如果 只看到 embeddings.*, encoder.*，没有 classifier、qa_outputs、lm_head，说明 没有任务头。

2.3 看 config.json 中的 special fields

{
  "architectures": ["BertForTokenClassification"],
  "id2label": {"0":"O","1":"B-PER","2":"I-PER", ...},
  "label2id": {"O":0,"B-PER":1, ...},
  "num_labels": 9
}

• architectures 指明模型类。
• id2label/label2id / num_labels 只在 下游微调 时出现。
• 如果这些字段缺失，则模型是 纯 BERT。

3️⃣ “跑分” 是怎么来的？

所以：如果你在某篇论文或模型库里看到 “BERT‑base achieves 92.3 % on SST‑2”，那 一定 是在 SST‑2 上微调（或在 冻结 BERT + 训练一个小 linear classifier）后得到的 微调 checkpoint，不是原始 bert-base-uncased。

4️⃣ 如何确认 最后几层 是否已经被 任务头 “吃掉” 了？

1. 检查 requires_grad

   for name, param in model.named_parameters():
       if param.requires_grad:
           print(name)   # 只会列出被训练的层
   

   • 若只看到 classifier.*（或 qa_outputs.*）被 requires_grad=True，说明 BERT 本体被冻结，只有头在训练。
   • 若所有 encoder.layer.* 也在列表中，说明 全模型微调。

2. 输出张量的形状

   outputs = model(**batch)          # batch 为 tokenized inputs
   if hasattr(outputs, "logits"):
       print("logits shape:", outputs.logits.shape)   # (batch, seq_len, num_labels) for token classification
   print("hidden shape:", outputs.hidden_states[-1].shape)  # (batch, seq_len, hidden_size)
   

   • logits 的最后一维是 任务标签数，不等于 hidden_size → 说明有 线性映射层。
   • hidden_states[-1] 仍然保留 原始 BERT 隐藏向量，未被 “吞掉”。

3. 查看 model.config

   print(model.config.hidden_size)   # e.g. 768
   print(getattr(model.config, "num_labels", None))   # e.g. 9 (NER)  → 任务头存在
   

5️⃣ 如何在 spaCy 里把 BERT 接入 NER（如果你只看到 BERT 没有任务头）

spaCy 的 spacy‑transformers 会 自动在 BERT 之上加一个 NER 头（Transition‑Based Parser）：

[components.transformer]
factory = "transformer"
model.name = "bert-base-uncased"   # 只加载 BERT 本体

[components.ner]
factory = "ner"
model.hidden_width = 512          # MLP 宽度（不影响 BERT 输出维度）
extra_state_tokens = false
nO = null                         # 自动取 transformer.hidden_size (768)

• transformer 只提供 hidden vectors（shape = (batch, subword_len, 768)）。
• ner 会在内部 Linear(hidden, num_labels) 上做 token‑classification（如果你在 config 中写 nO = null，spaCy 会把 hidden_size 自动写进去）。
• 训练时，spaCy 会 微调整个 BERT（默认）或者只微调 NER 头（通过 trainer.optimizer 的 freeze 参数控制）。

如果你想自己手动加 NER 头（不走 spaCy），可以直接使用 HuggingFace：

from transformers import AutoModelForTokenClassification, AutoTokenizer

model = AutoModelForTokenClassification.from_pretrained(
    "bert-base-uncased",
    num_labels=9,                     # 你的实体类别数
    id2label={0:"O",1:"B-PER",2:"I-PER",...},
    label2id={v:k for k,v in id2label.items()}
)
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")

• 这里 AutoModelForTokenClassification 会 在ERT 最后一层 上自动添加 nn.Linear(hidden_size, num_labels)（以及可选的 CRF、dropout）。
• 只要把 num_labels、id2label、label2id 填好，模型在 forward 时返回 logits（shape = (batch, seq_len, num_labels))。

6️⃣ 小结：一步步判断与使用

核心概念：

• 原始 BERT 只提供 通用的上下文向量，没有任何任务的输出层。
• 所有跑分（GLUE、CoNLL‑2003、SQuAD 等）都是 在这些向量之上 训练（或微调）任务头（线性层、CRF、QA 输出层等）得到的。
• 只要检查 config.json、权重名称、requires_grad，就能快速判断 是否已经做了任务适配，以及 是否只训练了头部。

Ernie‑4.5‑Causal‑LM 是什么模型？

2️⃣ 配置文件里各字段的含义（简要）

3️⃣ 与 “预训练” /  “NSP” 的关系

因此，它是一个“预训练的自回归语言模型”，而不是针对 MLM 或 NSP 的预训练模型。如果你看到 Ernie4_5ForCausalLM，就可以把它当作 GPT‑style 的 生成模型 来使用。

4️⃣ 如何把它用于 中文 NER（两种常用思路）

方案 A：直接在上层加 NER 头（推荐）

1. 加载模型

   from transformers import AutoModelForCausalLM, AutoTokenizer
   tokenizer = AutoTokenizer.from_pretrained("your/ernie4_5_causal", use_fast=True)
   model = AutoModelForCausalLM.from_pretrained("your/ernie4_5_causal")
   

2. **在其上添加 TokenClassificationHead（官方提供 ErnieForTokenClassification）

   from transformers import AutoModelForTokenClassification, AutoConfig
   cfg = AutoConfig.from_pretrained("your/ernie4_5_causal", num_labels=NUM_LABELS)
   model = AutoModelForTokenClassification.from_pretrained(
           "your/ernie4_5_causal",
           config=cfg
   )
   

   • 这里 NUM_LABELS 对应你的实体类别数（如 5：["O","B-PER","I-PER","B-LOC","I-LOC"] 等）。
3. 使用 Trainer 或 accelerate 进行 token‑classification 微调（输入是 input_ids，标签是 token‑level 标签）。

优点：直接利用已有的 Causal LM 权重，迁移学习效果好。
缺点：模型本身是 decoder‑only，在训练时会把每个 token 的 全部隐藏层 作为特征输出，计算量略大于 encoder‑only（如 BERT、RoBERTa）但仍可接受（显存≈ 8‑10 GB）。

方案 B：只保留 Encoder，配合 spaCy‑transformers（推荐用于 spaCy）

1. 在 spaCy‑transformers 中只加载 Encoder（去掉语言模型头）

   [components.transformer.model]
   @architectures = "spacy-transformers.TransformerModel.v3"
   name = "your/ernie4_5_causal"
   tokenizer_config = {"use_fast": true}
   # 只保留 Encoder，省显存
   extra_layers = []   # <-- 关键
   

2. 在 spaCy pipeline 中加入 ner 组件（如 ner、entity_ruler）

   python -m spacy init config ernie_ner.cfg \
        --lang zh \
        --pipeline transformer,ner \
        --optimize efficiency
   

3. 微调 NER（和前面示例的 Longformer、BigBird 等一样）

   python -m spacy train ernie_ner.cfg \
        --paths.train train.spacy \
        --paths.dev dev.spacy \
        --output ./output_ner \
        --gpu-id 0
   

好处：只保留 Encoder，显存占用约 30‑40% 更低；适合 spaCy 的 token‑level 任务（NER、POS、依存）且不需要额外的 MLM 头。

如何选择？

5️⃣ 关键代码示例（完整流程）

5.1 下载并加载模型（PyTorch）

from transformers import AutoModelForCausalLM, AutoTokenizer, AutoConfig
import torch

model_name = "your_org/ernie4_5_causal"   # 如 "bert-base-zh" 等
tokenizer = AutoTokenizer.from_pretrained(model_name, use_fast=True)
model = AutoModelForCausalLM.from_pretrained(
        model_name,
        torch_dtype=torch.bfloat16,     # 取决于硬件，CPU 可用 float32
        device_map="auto"
)

5.2 添加 Token‑Classification 头（用于 NER）

num_labels = 5   # 示例：O, B-PER, I-PER, B-LOC, I-LOC
config = AutoConfig.from_pretrained(
        model_name,
        num_labels=num_labels,
        is_encoder_decoder=False,
        # 以下参数保持原模型结构
        hidden_size=1024,
        num_hidden_layers=18,
        num_attention_heads=16,
        # ...
)

# 用同一权重初始化 token‑classification 模型
from transformers import AutoModelForTokenClassification
ner_model = AutoModelForTokenClassification.from_pretrained(
        model_name,
        config=config,
)

5.3 使用 Trainer 进行微调（示例）

from datasets import load_dataset
from transformers import DataCollatorForTokenClassification, Trainer, TrainingArguments

# 假设已有 CoNLL‑style 数据集
dataset = load_dataset("conll2003", split="train")
def tokenize_and_align_labels(example):
    tokenized = tokenizer(example["tokens"], is_split_into_words=True, truncation=True, max_length=4096)
    # 这里需要把 word‑level 标签映射到 sub‑word
    # ...
    return tokenized

train_dataset = dataset.map(tokenize_and_align_examples, batched=True)

training_args = TrainingArguments(
    output_dir="./ner_ernie",
    per_device_train_batch_size=8,
    gradient_accumulation_steps=2,
    learning_rate=5e-5,
    num_train_epochs=3,
    fp16=True,        # 若支持 bfloat16，可改为 bf16
    eval_strategy="steps",
    eval_steps=500,
    logging_steps=100,
)

trainer = Trainer(
    model=ner_model,
    args=training_args,
    train_dataset=train_dataset,
    data_collator=DataCollatorForTokenClassification(tokenizer),
)

trainer.train()

5.4 在 spaCy 中使用（仅 Encoder）

# big_ernie.cfg
[components.transformer]
factory = "transformer"
max_batch_items = 8192

[components.transformer.model]
@architectures = "spacy-transformers.TransformerModel.v3"
name = "your_org/ernie4_5_causal"
tokenizer_config = {"use_fast": true}
extra_layers = []   # 只保留 encoder

[components.ner]
factory = "ner"

然后：

python -m spacy train big_ernie.cfg \
   --paths.train ./train.spacy \
   --paths.dev ./dev.spacy \
   --output ./output_ernie

6️⃣ 小结

BigBird和Longformer推理速度

参数量：

Longformer基于BERT架构，参数量与BERT-base相当，约1.1亿参数，具体取决于变体大小。

BigBird参数量稍大，类似于BERT-large级别，约3亿多参数，因其引入稀疏注意力机制稍有增加。

DeBERTa-v3-Long版本参数量取决于具体的模型大小，比如base型约8600万主干参数，另有较大词表嵌入参数，总体略大于BERT-base。

RoBERTa-Long则是RoBERTa模型的长文本版本，参数量接近RoBERTa-base或large，分别约1.25亿或3.55亿参数。

推理速度：

Longformer采用局部+全局稀疏注意力，推理速度相对提升，适合长文本但仍高于普通BERT。

BigBird使用块稀疏注意力结合随机和全局注意力，推理复杂度近似线性，推理速度优于Longformer，特别适合超长序列。

DeBERTa-v3-Long采用增强解码器结构，聚焦于改进表示能力，推理速度相较于普通BERT略慢，具体取决于实现。

RoBERTa-Long基于RoBERTa进化，实现在Longformer、BigBird等框架下，速度表现介于Longformer和BigBird之间，根据具体优化不同有所差异。

最大上下文长度：

Longformer支持最大输入长度可达4096 tokens及以上。

BigBird支持最长输入长度在4096到8192 tokens，具体实现可调。

DeBERTa-v3-Long支持较长上下文，通常为2048到4096 tokens。

RoBERTa-Long支持最多4096 tokens左右。

• Longformer使用了局部窗口注意力结合少量全局注意力，降低了Transformer原有的O(n²)复杂度，推理速度显著比标准Transformer快，但其复杂度仍大约是O(n√n)（局部+全局注意力混合），推理速度随序列长度增长有一定上升。
• BigBird采用块稀疏注意力机制，包括全局token、局部滑动窗口token和随机token三部分。该机制使模型的复杂度接近线性O(n)，理论上在长序列推理时比Longformer更快，特别是超长序列（如4000+ tokens）情况下。
• 论文和实测结果中，BigBird在长文本任务的效果和推理速度整体优于Longformer，尤其在处理非常长的序列时，BigBird能更高效完成计算，同时保持较好性能。Longformer推理速度虽快于标准BERT，但实际速度比BigBird稍慢。
• 具体论文中提到，BigBird的推理速度几乎能保持与普通Transformer相当的性能优势（线性复杂度），而Longformer则在部分场景速度稍逊，但资源使用较少，适合中等长度长文本。

总结：

因此，BigBird在理论复杂度和实测推理速度上均优于Longformer，尤其适合非常长的文本处理任务。