AI Datawhale NLP

Hugging Face 生态与核心库

本文介绍 Hugging Face 生态与核心库。

Hugging Face 生态与核心库

我们在前面的学习中简单尝试了 BERT、GPT 和 T5 三大模型的应用。可以发现，无论使用哪种架构，都离不开一个核心工具库——Hugging Face Transformers。

如今，Hugging Face 已经从一家 NLP 初创公司演变为 AI 时代的基础设施。它构建了一个涵盖模型开发全生命周期的完整生态系统——从数据获取、模型开发、训练微调到最终的评估与部署。本节将深入剖析 Hugging Face 的生态构成，并以 Transformers 库为核心，结合 Datasets 和 Tokenizers，展示现代化模型开发链路。

本节完整代码

一、Hugging Face 生态全景

Hugging Face 的生态系统可以看作是由核心软件库、协作平台和辅助工具 共同构成的有机整体。

Hugging Face 官网

图 5-7 Hugging Face 官网

1.1 Hugging Face Hub

如果说 GitHub 是代码的托管中心，那么 Hugging Face Hub 就是 AI 领域的 GitHub。它是一个集成了模型、数据集和应用演示的中央枢纽，支持 Git 版本控制：

  • Models（模型库）：托管了数十万个预训练模型，涵盖 NLP、CV、Audio 等多模态领域。用户可以下载、使用甚至在线体验模型效果。
  • Datasets（数据集）：托管各类公开数据集。支持数据预览和高效的流式传输。
  • Spaces（演示空间）：允许开发者使用 Gradio、Streamlit 或 Docker 快速构建 Web 应用，在线展示模型效果。

1.2 核心软件库的“三驾马车”

在开发层面，以下三个开源库构成了生态系统的技术基石：

  1. Transformers: 生态系统的引擎。提供统一的 API 来下载、加载和使用预训练模型 1。
  2. Tokenizers: 连接文本与模型的桥梁。底层由 Rust 编写，提供极致的文本处理速度（Fast Tokenizers），并与 Transformers 无缝集成 2。
  3. Datasets: 数据处理的加速器。提供标准化的接口来加载、处理和管理大型数据集，内置高效的内存映射机制 3。

1.3 辅助工具

为了应对更复杂的开发需求，生态中还包含了一系列强大的辅助库：

  • Accelerate: 简化分布式训练。让同一套代码可以无缝运行在 CPU、单卡 GPU、多卡 GPU 甚至 TPU 上，无需手动处理复杂的分布式逻辑。
  • Evaluate: 标准化的模型评估框架。提供数十种常用的评估指标（如 Accuracy, F1, BLEU, ROUGE） 4。
  • Diffusers: 专注于生成式 AI（如 Stable Diffusion）的库。
  • PEFT: 参数高效微调库（Parameter-Efficient Fine-Tuning），支持 LoRA 等前沿微调技术。

二、Transformers 核心库详解

2.1 开箱即用的 Pipeline

对于刚接触 AI 的开发者，或者只想快速验证某个想法，Pipeline 是最高效的工具。它将预处理 -> 模型推理 -> 后处理这一复杂的全流程封装成了一个黑盒。

  • NLP 任务： 在前面的 GPT 实战中，我们曾显式指定模型（model="gpt2"）来完成文本生成。同时，Pipeline 还拥有强大的“自动导航”能力——无需指定模型，只需指定任务。

    当指定一个任务类型（如 sentiment-analysis）时，Pipeline 会自动从 Hub 上下载并加载该任务对应的默认预训练模型。

    1
2
3
4
5
6

    from transformers import pipeline

# 情感分析（默认下载英文模型）
classifier = pipeline("sentiment-analysis")
result = classifier("I love Hugging Face!")
result

    默认模型通常为英文，中文任务建议显式指定中文模型（如 model="bert-base-chinese"）。*

  • 跨模态能力： Transformers 早已突破 NLP 边界，支持 CV 和 Audio 等多个领域。

    1
2
3
4
5

    # 图像分类示例（显式指定小模型 apple/mobilevit-small）
# pip install pillow
vision_classifier = pipeline(model="apple/mobilevit-small")
result = vision_classifier("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/coco_sample.png")
result

2.2 AutoClass：智能加载机制

当深入定制模型时，我们需要手动加载模型。AutoClass（如 AutoTokenizer, AutoModel, AutoConfig）是库设计的精髓。

它的作用是根据 Checkpoint 名称，自动推断并加载正确的模型架构。例如，调用 AutoModel.from_pretrained("bert-base-chinese") 时，库会自动识别这是 BERT 架构，并实例化 BertModel 类。

  • from_pretrained: 加载接口。既支持从 Hub 在线下载，也支持从本地目录加载。
  • save_pretrained: 保存接口。将模型权重、配置和词表保存到本地。

2.3 核心组件拆解

Transformers 的处理流程主要包含三个核心阶段。我们将结合代码演示，分析每个阶段的职责与实现：

  1. Tokenizer（分词）
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

import torch
from transformers import AutoTokenizer, AutoModelForSequenceClassification

# 准备模型与分词器
checkpoint = "bert-base-chinese"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
model = AutoModelForSequenceClassification.from_pretrained(checkpoint)
# 1. Tokenizer: 文本 -> Tensor
text = "Hugging Face 让 NLP 变得简单"
inputs = tokenizer(text, return_tensors="pt")
inputs['input_ids']

Tokenizer 充当数据的“翻译官”，负责将原始文本转换为模型可理解的数字序列（如 Input IDs 和 Attention Mask）。它利用 Rust 实现的 Fast Tokenizer 技术，在处理海量语料时比纯 Python 实现快几个数量级。

输出：

1

tensor([[ 101,  100,  100, 6375,  100, 1359, 2533, 5042, 1296,  102]])

输出的 Tensor 就是分词后的 Token IDs。其中 101 是 BERT 特有的起始标记 [CLS]，102 是结束标记 [SEP]。 中间的数字对应文本 “Hugging Face 让 NLP 变得简单” 的词表索引：

  • 100：对应特殊标记 [UNK]（未知词）。
  • 6375: “让”
  • 1359: “变”
  • 2533: “得”
  • 5042: “简”
  • 1296: “单”

由于 bert-base-chinese 词表未包含英文单词 Hugging、Face、NLP，它们都会被映射为 [UNK]。

  1. Model（模型）
1
2
3

# 2. Model: Tensor -> Logits
outputs = model(**inputs)
logits = outputs.logits

模型是计算的“引擎”，由 Config（架构定义）和 Weights（参数权重）组成。它接收 Token IDs，执行前向传播，最终输出隐藏状态（Hidden States）或 Logits。

输出：

1

tensor([[0.2436, 0.1208]], grad_fn=<AddmmBackward0>)

模型输出的 logits 是未归一化的数值。可以看到输出是一个 [1, 2] 的张量，在一个二分类任务中通常可以理解为两个类别（例如“负面/正面”）的原始得分。这里我们主要演示前向推理流程；在实际应用中，需要在标注数据上对模型进行微调（或直接加载已经在下游任务上微调好的权重），这两个维度才会对应具体语义的类别标签。

  1. Post-processing（后处理）
1
2
3

# 3. Post-processing: Logits -> 概率
predictions = torch.nn.functional.softmax(logits, dim=-1)
predictions

后处理阶段的职责是将模型输出的 Logits 转换为人类可读的概率或标签。

输出：

1

tensor([[0.5306, 0.4694]], grad_fn=<SoftmaxBackward0>)

经过 Softmax 层后，logits 被转换为概率分布（和为 1）。此例中，第一个类别的概率约为 53%，第二个类别约为 47%。

三、使用 Datasets 构建数据流水线

在深度学习中，数据的准备工作往往繁琐。虽然清洗逻辑仍需开发者根据业务定制，但 datasets 库提供了一套高效的框架，解决了数据加载、内存管理和并行处理等底层工程问题，让开发者能专注于预处理逻辑本身。

3.1 内存映射与流式处理

datasets 库底层基于 Apache Arrow 格式，支持内存映射。这意味着它可以在不将整个数据集加载到 RAM 的情况下进行读取和处理。即使是 TB 级别的数据集，也能在普通笔记本上高效运行。

1
2
3
4
5

from datasets import load_dataset

# 加载烂番茄影评数据集
dataset = load_dataset("rotten_tomatoes")
dataset

输出：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

DatasetDict({
    train: Dataset({
        features: ['text', 'label'],
        num_rows: 8530
    })
    validation: Dataset({
        features: ['text', 'label'],
        num_rows: 1066
    })
    test: Dataset({
        features: ['text', 'label'],
        num_rows: 1066
    })
})

加载后的 DatasetDict 类似于一个字典，包含了 train（训练集）、validation（验证集）和 test（测试集）三个子集。每个子集都明确列出了特征列（features）和数据量（num_rows）。

此外，对于超大规模数据集，datasets 库还支持流式模式，按需迭代数据而无需下载完整文件。

3.2 并行的预处理

map 是 datasets 最强大的功能。它允许你将预处理函数（如 Tokenizer）应用到数据集的每一个样本上。

  • 批处理 (batched=True)：一次处理一批数据，充分利用 Tokenizer 的多线程优势。
  • 多进程 (num_proc=N)：并行处理，显著加快大数据集的预处理速度。
1
2
3
4
5

def tokenize_function(examples):
    return tokenizer(examples["text"], padding="max_length", truncation=True)

# 高效并行处理
# tokenized_datasets = dataset.map(tokenize_function, batched=True, num_proc=4)

四、Trainer 与 Evaluate

4.1 Trainer 训练框架

数据准备就绪后，transformers 提供了 Trainer API，这是一个高度封装的训练框架。虽然可以手写 PyTorch 循环，但 Trainer 集成了大量工程化特性（如混合精度、梯度累积、分布式训练支持），且底层自动调用 Accelerate 库。使用 Trainer 通常遵循“三步走”：

  1. 准备组件
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

from transformers import TrainingArguments, Trainer, AutoModelForSequenceClassification, AutoTokenizer

# 使用英文模型 distilbert-base-uncased
tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")

def tokenize_function(examples):
    return tokenizer(examples["text"], padding="max_length", truncation=True)

tokenized_datasets = dataset.map(tokenize_function, batched=True)

# 为了快速演示，我们只取一小部分数据
small_train_dataset = tokenized_datasets["train"].shuffle(seed=42).select(range(100)) 
small_eval_dataset = tokenized_datasets["validation"].shuffle(seed=42).select(range(100))

# 1. 准备模型
model = AutoModelForSequenceClassification.from_pretrained("distilbert-base-uncased", num_labels=2)

model

可以看到第一步我们实例化了 Model、Dataset 和 Tokenizer 等核心组件。

输出：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

DistilBertForSequenceClassification(
  (distilbert): DistilBertModel(
    (embeddings): Embeddings(
      (word_embeddings): Embedding(30522, 768, padding_idx=0)
      (position_embeddings): Embedding(512, 768)
      (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
      (dropout): Dropout(p=0.1, inplace=False)
    )
    (transformer): Transformer(
      (layer): ModuleList(
        (0-5): 6 x TransformerBlock(
          (attention): DistilBertSdpaAttention(
            (dropout): Dropout(p=0.1, inplace=False)
            (q_lin): Linear(in_features=768, out_features=768, bias=True)
            (k_lin): Linear(in_features=768, out_features=768, bias=True)
            (v_lin): Linear(in_features=768, out_features=768, bias=True)
            (out_lin): Linear(in_features=768, out_features=768, bias=True)
          )
          (sa_layer_norm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
          (ffn): FFN(
            (dropout): Dropout(p=0.1, inplace=False)
            (lin1): Linear(in_features=768, out_features=3072, bias=True)
            (lin2): Linear(in_features=3072, out_features=768, bias=True)
            (activation): GELUActivation()
          )
...
  )
  (pre_classifier): Linear(in_features=768, out_features=768, bias=True)
  (classifier): Linear(in_features=768, out_features=2, bias=True)
  (dropout): Dropout(p=0.2, inplace=False)
)

打印模型对象可以看到其完整的网络结构。注意最后的 classifier 层，其 out_features=2 对应我们在加载时设置的 num_labels=2，这表明模型已经被正确初始化为二分类任务。

  1. 配置参数
1
2
3
4
5
6

# 2. 配置参数
training_args = TrainingArguments(
    output_dir="test_trainer",
    eval_strategy="epoch", # 每个 epoch 结束进行评估
    num_train_epochs=1,
)

使用 TrainingArguments 定义超参数（Batch Size, LR, Epoch, 保存策略等）。

  1. 启动训练
1
2
3
4
5
6
7
8

# 3. 实例化 Trainer 并启动训练
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=small_train_dataset,
    eval_dataset=small_eval_dataset,
)
trainer.train()

实例化 Trainer 并调用 train() 即可开启训练流程。

4.2 Evaluate 性能评估

evaluate 库用于计算 Metrics（指标），如 Accuracy、F1-score。它与 Trainer 无缝集成：

  • 定义一个 compute_metrics 函数。
  • 将其传入 Trainer。
  • 在训练过程中，Trainer 会自动调用该函数评估模型在验证集上的表现。
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import numpy as np
import evaluate

# 加载评估指标
metric = evaluate.load("accuracy")

# 定义计算函数：将 Logits 转换为 Predictions 并计算 Accuracy
def compute_metrics(eval_pred):
    logits, labels = eval_pred
    predictions = np.argmax(logits, axis=-1)
    return metric.compute(predictions=predictions, references=labels)

# 重新实例化 Trainer，注入 compute_metrics
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=small_train_dataset,
    eval_dataset=small_eval_dataset,
    compute_metrics=compute_metrics, # 关键步骤
)

# 训练并评估
trainer.train()

本章小结

本章我们探索了预训练语言模型的三大主流技术路线及其工程实践：

  • BERT（理解）：基于 Transformer Encoder 结构，主要通过 MLM（掩码语言建模）（以及 NSP 等）任务学习双向上下文表示。BERT 及其变体（RoBERTa、ALBERT）在文本分类、序列标注等自然语言理解任务上表现出色，是解决此类问题的经典方案。
  • GPT（生成）：基于 Transformer Decoder 结构，通过 自回归 预测下一个词。GPT 系列模型不仅在自然语言生成（NLG） 上表现优异，更通过 GPT-3 系统性展示了提示工程和上下文学习的潜力，在实践层面推动了现代大语言模型的发展。
  • T5（统一）：回归 Encoder-Decoder 经典架构，提出了 “Text-to-Text”（万物皆文本） 的统一框架。T5 证明通过将不同任务（翻译、分类、回归）统一为文本生成的形式，可以用一个模型解决多种 NLP 问题。
  • Hugging Face 实战：本章还详细介绍了 NLP 领域的标准工具——Hugging Face。通过 Transformers（模型）、Tokenizers（分词）、Datasets（数据） 和 Evaluate（评估）这四大核心库，开发者能够以极低的代码量，高效地复现和应用现代 NLP 模型。

从理论原理到工具实践，本章构建了使用预训练模型的完整知识体系。在下一章中，将进一步深入底层，探索如何从零开始构建一个类 LLaMA 的大模型结构。

练习

  • 尝试将之前实现的文本分类模型，从基于 Word2Vec 和 LSTM 的结构，迁移为使用 BERT 模型进行微调。对比分析两者在模型构建、训练流程以及最终性能上的异同。（可以参考微调 BERT 模型进行文本分类）

参考文献

  1. Hugging Face. Transformers Documentation. ↩︎

  2. Hugging Face. Tokenizers Documentation. ↩︎

  3. Hugging Face. Datasets Documentation. ↩︎

  4. Hugging Face. Evaluate Documentation. ↩︎

comments powered by Disqus
© 2020 - 2026 hanguangwu
使用 Hugo 构建
主题 Stack 由 Jimmy 设计