fastNLP

fastNLP是一款轻量级的自然语言处理（NLP）工具包，目标是减少用户项目中的工程型代码，例如数据处理循环、训练循环、多卡运行等。

fastNLP具有如下的特性：

• 便捷。在数据处理中可以通过apply函数避免循环、使用多进程提速等；在训练循环阶段可以很方便定制操作。
• 高效。无需改动代码，实现fp16切换、多卡、ZeRO优化等。
• 兼容。fastNLP支持多种深度学习框架作为后端。

:warning: 为了实现对不同深度学习架构的兼容，fastNLP 1.0.0之后的版本重新设计了架构，因此与过去的fastNLP版本不完全兼容， 基于更早的fastNLP代码需要做一定的调整:

fastNLP文档

中文文档

安装指南

fastNLP可以通过以下的命令进行安装

pip install fastNLP>=1.0.0alpha

如果需要安装更早版本的fastNLP请指定版本号，例如

pip install fastNLP==0.7.1

另外，请根据使用的深度学习框架，安装相应的深度学习框架。

from fastNLP.io import ChnSentiCorpLoader
from functools import partial
from fastNLP import cache_results
from fastNLP.transformers.torch import BertTokenizer

# 使用cache_results装饰器装饰函数，将prepare_data的返回结果缓存到caches/cache.pkl，再次运行时，如果
#  该文件还存在，将自动读取缓存文件，而不再次运行预处理代码。
@cache_results('caches/cache.pkl')
def prepare_data():
    # 会自动下载数据，并且可以通过文档看到返回的 dataset 应该是包含"raw_words"和"target"两个field的
    data_bundle = ChnSentiCorpLoader().load()
    # 使用tokenizer对数据进行tokenize
    tokenizer = BertTokenizer.from_pretrained('hfl/chinese-bert-wwm')
    tokenize = partial(tokenizer, max_length=256)  # 限制数据的最大长度
    data_bundle.apply_field_more(tokenize， field_name='raw_chars', num_proc=4)  # 会新增"input_ids", "attention_mask"等field进入dataset中
    data_bundle.apply_field(int， field_name='target', new_field_name='labels')  # 将int函数应用到每个target上，并且放入新的labels field中
    return data_bundle
data_bundle = prepare_data()
print(data_bundle.get_dataset('train')[:4])

# 初始化model, optimizer
from fastNLP.transformers.torch import BertForSequenceClassification
from torch import optim
model = BertForSequenceClassification.from_pretrained('hfl/chinese-bert-wwm')
optimizer = optim.AdamW(model.parameters(), lr=2e-5)

# 准备dataloader
from fastNLP import prepare_dataloader
dls = prepare_dataloader(data_bundle， batch_size=32)

# 准备训练
from fastNLP import Trainer， Accuracy， LoadBestModelCallback， TorchWarmupCallback， Event
callbacks = [
    TorchWarmupCallback(warmup=0.1， schedule='linear），   # 训练过程中调整学习率。
    LoadBestModelCallback()  # 将在训练结束之后，加载性能最优的model
]
# 在训练特定时机加入一些操作， 不同时机能够获取到的参数不一样，可以通过Trainer.on函数的文档查看每个时机的参数
@Trainer.on(Event.on_before_backward())
def print_loss(trainer， outputs):
    if trainer.global_forward_batches % 10 == 0：  # 每10个batch打印一次loss。
        print(outputs.loss.item())

trainer = Trainer(model=model， train_dataloader=dls['train']， optimizers=optimizer，
                  device=0， evaluate_dataloaders=dls['dev']， metrics={'acc': Accuracy()}，
                  callbacks=callbacks， monitor='acc#acc'，n_epochs=5，
                  # Accuracy的update()函数需要pred，target两个参数，它们实际对应的就是以下的field。
                  evaluate_input_mapping={'labels': 'target'}，  # 在评测时，将dataloader中会输入到模型的labels重新命名为target
                  evaluate_output_mapping={'logits': 'pred'}  # 在评测时，将model输出中的logits重新命名为pred
                  )
trainer.run()

# 在测试集合上进行评测
from fastNLP import Evaluator
evaluator = Evaluator(model=model， dataloaders=dls['test']， metrics={'acc': Accuracy()}，
                      # Accuracy的update()函数需要pred，target两个参数，它们实际对应的就是以下的field。
                      output_mapping={'logits': 'pred'}，
                      input_mapping={'labels': 'target'})
evaluator.run()

from fastNLP.io import ChnSentiCorpLoader
from functools import partial

# 会自动下载数据，并且可以通过文档看到返回的 dataset 应该是包含"raw_words"和"target"两个field的
data_bundle = ChnSentiCorpLoader().load()

# 使用tokenizer对数据进行tokenize
from paddlenlp.transformers import BertTokenizer
tokenizer = BertTokenizer.from_pretrained('hfl/chinese-bert-wwm')
tokenize = partial(tokenizer， max_length=256)  # 限制一下最大长度
data_bundle.apply_field_more(tokenize， field_name='raw_chars'， num_proc=4)  # 会新增"input_ids"， "attention_mask"等field进入dataset中
data_bundle.apply_field(int， field_name='target'， new_field_name='labels')  # 将int函数应用到每个target上，并且放入新的labels field中
print(data_bundle.get_dataset('train')[:4])

# 初始化模型
from paddlenlp.transformers import BertForSequenceClassification, LinearDecayWithWarmup
from paddle import optimizer, nn
class SeqClsModel(nn.Layer):
    def __init__(self, model_checkpoint, num_labels):
        super(SeqClsModel, self).__init__()
        self.num_labels = num_labels
        self.bert = BertForSequenceClassification.from_pretrained(model_checkpoint)

    def forward(self, input_ids, token_type_ids=None, position_ids=None, attention_mask=None):
        logits = self.bert(input_ids, token_type_ids, position_ids, attention_mask)
        return logits

    def train_step(self, input_ids, labels, token_type_ids=None, position_ids=None, attention_mask=None):
        logits = self(input_ids, token_type_ids, position_ids, attention_mask)
        loss_fct = nn.CrossEntropyLoss()
        loss = loss_fct(logits.reshape((-1, self.num_labels)), labels.reshape((-1, )))
        return {
            "logits": logits,
            "loss": loss,
        }
    
    def evaluate_step(self, input_ids, token_type_ids=None, position_ids=None, attention_mask=None):
        logits = self(input_ids, token_type_ids, position_ids, attention_mask)
        return {
            "logits": logits,
        }

model = SeqClsModel('hfl/chinese-bert-wwm', num_labels=2)

# 准备数据加载器
from fastNLP import prepare_dataloader
dls = prepare_dataloader(data_bundle, batch_size=16)

# 训练过程中调整学习率。
scheduler = LinearDecayWithWarmup(2e-5, total_steps=20 * len(dls['train']), warmup=0.1)
optimizer = optimizer.AdamW(parameters=model.parameters(), learning_rate=scheduler)

# 准备训练
from fastNLP import Trainer, Accuracy, LoadBestModelCallback, Event
callbacks = [
    LoadBestModelCallback()  # 将在训练结束之后，加载性能最优的模型
]
# 在训练特定时机加入一些操作， 不同时机能够获取到的参数不一样，可以通过Trainer.on函数的文档查看每个时机的参数
@Trainer.on(Event.on_before_backward())
def print_loss(trainer, outputs):
    if trainer.global_forward_batches % 10 == 0:  # 每10个batch打印一次loss。
        print(outputs["loss"].item())

trainer = Trainer(model=model, train_dataloader=dls['train'], optimizers=optimizer,
                  device=0, evaluate_dataloaders=dls['dev'], metrics={'acc': Accuracy()},
                  callbacks=callbacks, monitor='acc#acc',
                  # Accuracy的update()函数需要pred，target两个参数，它们实际对应的就是以下的field。
                  evaluate_output_mapping={'logits': 'pred'},
                  evaluate_input_mapping={'labels': 'target'}
                  )
trainer.run()

# 在测试集合上进行评测
from fastNLP import Evaluator
evaluator = Evaluator(model=model, dataloaders=dls['test'], metrics={'acc': Accuracy()},
                      # Accuracy的update()函数需要pred，target两个参数，它们实际对应的就是以下的field。
                      output_mapping={'logits': 'pred'},
                      input_mapping={'labels': 'target'})
evaluator.run()

项目结构

fastNLP的项目结构如下：

fastNLP 快速上手指南

fastNLP 是一款轻量级的自然语言处理（NLP）工具包，旨在减少数据处理、训练循环及多卡运行等工程型代码。它支持 PyTorch、PaddlePaddle 等多种深度学习框架后端，具备便捷、高效和兼容的特性。

环境准备

• 系统要求：支持 Linux、macOS 和 Windows。
• Python 版本：建议 Python 3.7 及以上。
• 前置依赖：
  • 需先安装对应的深度学习框架（如 torch>=1.6.0 或 paddle>=2.2.0 + paddlenlp>=2.3.3）。
  • fastNLP 1.0.0+ 版本重构了架构，与旧版本（0.x）不完全兼容，请根据项目需求选择版本。

安装步骤

1. 安装 fastNLP

推荐使用 pip 安装最新稳定版（1.0.0+）：

pip install fastNLP>=1.0.0alpha

若需使用旧版本（如 0.7.1），请指定版本号：

pip install fastNLP==0.7.1

提示：国内用户可使用清华源加速安装： pip install fastNLP>=1.0.0alpha -i https://pypi.tuna.tsinghua.edu.cn/simple

2. 安装深度学习后端

根据你选择的框架安装相应依赖（以 PyTorch 为例）：

pip install torch>=1.6.0

基本使用

以下是一个基于 PyTorch 的中文文本分类最小示例，展示了从数据加载、预处理到训练评估的全流程。

示例：中文情感分析 (ChnSentiCorp)

from fastNLP.io import ChnSentiCorpLoader
from functools import partial
from fastNLP import cache_results
from fastNLP.transformers.torch import BertTokenizer

# 1. 数据准备与缓存
# 使用 cache_results 装饰器自动缓存处理后的数据，避免重复预处理
@cache_results('caches/cache.pkl')
def prepare_data():
    # 自动下载数据集，包含 "raw_words" 和 "target" 字段
    data_bundle = ChnSentiCorpLoader().load()
    
    # 加载分词器并进行 Tokenize
    tokenizer = BertTokenizer.from_pretrained('hfl/chinese-bert-wwm')
    tokenize = partial(tokenizer, max_length=256)
    
    # 多进程加速数据处理，新增 "input_ids", "attention_mask" 等字段
    data_bundle.apply_field_more(tokenize, field_name='raw_chars', num_proc=4)
    
    # 转换标签格式
    data_bundle.apply_field(int, field_name='target', new_field_name='labels')
    return data_bundle

data_bundle = prepare_data()

# 2. 模型与优化器初始化
from fastNLP.transformers.torch import BertForSequenceClassification
from torch import optim

model = BertForSequenceClassification.from_pretrained('hfl/chinese-bert-wwm')
optimizer = optim.AdamW(model.parameters(), lr=2e-5)

# 3. 构建 DataLoader
from fastNLP import prepare_dataloader
dls = prepare_dataloader(data_bundle, batch_size=32)

# 4. 配置训练器
from fastNLP import Trainer, Accuracy, LoadBestModelCallback, TorchWarmupCallback, Event

callbacks = [
    TorchWarmupCallback(warmup=0.1, schedule='linear'),  # 学习率预热
    LoadBestModelCallback()  # 保存最佳模型
]

# 自定义回调：每 10 个 batch 打印一次 loss
@Trainer.on(Event.on_before_backward())
def print_loss(trainer, outputs):
    if trainer.global_forward_batches % 10 == 0:
        print(outputs.loss.item())

trainer = Trainer(
    model=model, 
    train_dataloader=dls['train'], 
    optimizers=optimizer,
    device=0,  # 指定 GPU 设备
    evaluate_dataloaders=dls['dev'], 
    metrics={'acc': Accuracy()},
    callbacks=callbacks, 
    monitor='acc#acc',
    n_epochs=5,
    # 字段映射：将 dataloader 的 labels 映射为 metric 需要的 target，logits 映射为 pred
    evaluate_input_mapping={'labels': 'target'},
    evaluate_output_mapping={'logits': 'pred'}
)

# 5. 开始训练
trainer.run()

# 6. 测试集评估
from fastNLP import Evaluator
evaluator = Evaluator(
    model=model, 
    dataloaders=dls['test'], 
    metrics={'acc': Accuracy()},
    output_mapping={'logits': 'pred'},
    input_mapping={'labels': 'target'}
)
evaluator.run()

核心特性说明

• 便捷数据处理：通过 apply_field 和 apply_field_more 避免手动循环，支持多进程加速。
• 灵活训练控制：Trainer 支持通过 Event 在训练的不同阶段（如反向传播前）插入自定义逻辑。
• 自动字段映射：通过 input_mapping 和 output_mapping 解耦模型输出与评估指标所需的字段名称。

更多详细教程请参考 fastNLP 官方文档。