Transformers 4.37 中文文档（一）

ApacheCN_飞龙

发布于 2024-06-26 14:21:05

1120

发布于 2024-06-26 14:21:05

文章被收录于专栏：信数据得永生信数据得永生

文档分为五个部分：

开始提供了一个快速浏览库和安装说明，让您快速上手。
教程是初学者入门的好地方。本节将帮助您获得开始使用库所需的基本技能。
操作指南向您展示如何实现特定目标，例如对预训练模型进行微调以进行语言建模，或者如何编写和共享自定义模型。
概念指南提供了更多关于模型、任务和🤗 Transformers 设计理念背后的概念和思想的讨论和解释。
API描述了所有类和函数：
- 主要类详细介绍了配置、模型、分词器和管道等最重要的类。
- 模型详细介绍了库中实现的每个模型相关的类和函数。
- 内部助手详细介绍了内部使用的实用类和函数。

支持的模型和框架

下表表示库中对这些模型的当前支持，它们是否有 Python 分词器（称为“slow”）。由🤗 Tokenizers 库支持的“fast”分词器，它们是否在 Jax（通过 Flax）、PyTorch 和/或 TensorFlow 中有支持。

模型	PyTorch 支持	TensorFlow 支持	Flax 支持
ALBERT	✅	✅	✅
ALIGN	✅	❌	❌
AltCLIP	✅	❌	❌
Audio Spectrogram Transformer	✅	❌	❌
Autoformer	✅	❌	❌
Bark	✅	❌	❌
BART	✅	✅	✅
BARThez	✅	✅	✅
BARTpho	✅	✅	✅
BEiT	✅	❌	✅
BERT	✅	✅	✅
Bert Generation	✅	❌	❌
BertJapanese	✅	✅	✅
BERTweet	✅	✅	✅
BigBird	✅	❌	✅
BigBird-Pegasus	✅	❌	❌
BioGpt	✅	❌	❌
BiT	✅	❌	❌
Blenderbot	✅	✅	✅
BlenderbotSmall	✅	✅	✅
BLIP	✅	✅	❌
BLIP-2	✅	❌	❌
BLOOM	✅	❌	✅
BORT	✅	✅	✅
BridgeTower	✅	❌	❌
BROS	✅	❌	❌
ByT5	✅	✅	✅
CamemBERT	✅	✅	❌
CANINE	✅	❌	❌
Chinese-CLIP	✅	❌	❌
CLAP	✅	❌	❌
CLIP	✅	✅	✅
CLIPSeg	✅	❌	❌
CLVP	✅	❌	❌
CodeGen	✅	❌	❌
CodeLlama	✅	❌	✅
Conditional DETR	✅	❌	❌
ConvBERT	✅	✅	❌
ConvNeXT	✅	✅	❌
ConvNeXTV2	✅	✅	❌
CPM	✅	✅	✅
CPM-Ant	✅	❌	❌
CTRL	✅	✅	❌
CvT	✅	✅	❌
Data2VecAudio	✅	❌	❌
Data2VecText	✅	❌	❌
Data2VecVision	✅	✅	❌
DeBERTa	✅	✅	❌
DeBERTa-v2	✅	✅	❌
Decision Transformer	✅	❌	❌
Deformable DETR	✅	❌	❌
DeiT	✅	✅	❌
DePlot	✅	❌	❌
DETA	✅	❌	❌
DETR	✅	❌	❌
DialoGPT	✅	✅	✅
DiNAT	✅	❌	❌
DINOv2	✅	❌	❌
DistilBERT	✅	✅	✅
DiT	✅	❌	✅
DonutSwin	✅	❌	❌
DPR	✅	✅	❌
DPT	✅	❌	❌
EfficientFormer	✅	✅	❌
EfficientNet	✅	❌	❌
ELECTRA	✅	✅	✅
EnCodec	✅	❌	❌
Encoder decoder	✅	✅	✅
ERNIE	✅	❌	❌
ErnieM	✅	❌	❌
ESM	✅	✅	❌
FairSeq Machine-Translation	✅	❌	❌
Falcon	✅	❌	❌
FastSpeech2Conformer	✅	❌	❌
FLAN-T5	✅	✅	✅
FLAN-UL2	✅	✅	✅
FlauBERT	✅	✅	❌
FLAVA	✅	❌	❌
FNet	✅	❌	❌
FocalNet	✅	❌	❌
Funnel Transformer	✅	✅	❌
Fuyu	✅	❌	❌
GIT	✅	❌	❌
GLPN	✅	❌	❌
GPT Neo	✅	❌	✅
GPT NeoX	✅	❌	❌
GPT NeoX Japanese	✅	❌	❌
GPT-J	✅	✅	✅
GPT-Sw3	✅	✅	✅
GPTBigCode	✅	❌	❌
GPTSAN-japanese	✅	❌	❌
Graphormer	✅	❌	❌
GroupViT	✅	✅	❌
HerBERT	✅	✅	✅
Hubert	✅	✅	❌
I-BERT	✅	❌	❌
IDEFICS	✅	❌	❌
ImageGPT	✅	❌	❌
Informer	✅	❌	❌
InstructBLIP	✅	❌	❌
Jukebox	✅	❌	❌
KOSMOS-2	✅	❌	❌
LayoutLM	✅	✅	❌
LayoutLMv2	✅	❌	❌
LayoutLMv3	✅	✅	❌
LayoutXLM	✅	❌	❌
LED	✅	✅	❌
LeViT	✅	❌	❌
LiLT	✅	❌	❌
LLaMA	✅	❌	✅
Llama2	✅	❌	✅
LLaVa	✅	❌	❌
Longformer	✅	✅	❌
LongT5	✅	❌	✅
LUKE	✅	❌	❌
LXMERT	✅	✅	❌
M-CTC-T	✅	❌	❌
M2M100	✅	❌	❌
MADLAD-400	✅	✅	✅
Marian	✅	✅	✅
MarkupLM	✅	❌	❌
Mask2Former	✅	❌	❌
MaskFormer	✅	❌	❌
MatCha	✅	❌	❌
mBART	✅	✅	✅
mBART-50	✅	✅	✅
MEGA	✅	❌	❌
Megatron-BERT	✅	❌	❌
Megatron-GPT2	✅	✅	✅
MGP-STR	✅	❌	❌
Mistral	✅	❌	❌
Mixtral	✅	❌	❌
mLUKE	✅	❌	❌
MMS	✅	✅	✅
MobileBERT	✅	✅	❌
MobileNetV1	✅	❌	❌
MobileNetV2	✅	❌	❌
MobileViT	✅	✅	❌
MobileViTV2	✅	❌	❌
MPNet	✅	✅	❌
MPT	✅	❌	❌
MRA	✅	❌	❌
MT5	✅	✅	✅
MusicGen	✅	❌	❌
MVP	✅	❌	❌
NAT	✅	❌	❌
Nezha	✅	❌	❌
NLLB	✅	❌	❌
NLLB-MOE	✅	❌	❌
Nougat	✅	✅	✅
Nyströmformer	✅	❌	❌
OneFormer	✅	❌	❌
OpenAI GPT	✅	✅	❌
OpenAI GPT-2	✅	✅	✅
OpenLlama	✅	❌	❌
OPT	✅	✅	✅
OWL-ViT	✅	❌	❌
OWLv2	✅	❌	❌
PatchTSMixer	✅	❌	❌
PatchTST	✅	❌	❌
Pegasus	✅	✅	✅
PEGASUS-X	✅	❌	❌
Perceiver	✅	❌	❌
Persimmon	✅	❌	❌
Phi	✅	❌	❌
PhoBERT	✅	✅	✅
Pix2Struct	✅	❌	❌
PLBart	✅	❌	❌
PoolFormer	✅	❌	❌
Pop2Piano	✅	❌	❌
ProphetNet	✅	❌	❌
PVT	✅	❌	❌
QDQBert	✅	❌	❌
Qwen2	✅	❌	❌
RAG	✅	✅	❌
REALM	✅	❌	❌
Reformer	✅	❌	❌
RegNet	✅	✅	✅
RemBERT	✅	✅	❌
ResNet	✅	✅	✅
RetriBERT	✅	❌	❌
RoBERTa	✅	✅	✅
RoBERTa-PreLayerNorm	✅	✅	✅
RoCBert	✅	❌	❌
RoFormer	✅	✅	✅
RWKV	✅	❌	❌
SAM	✅	✅	❌
SeamlessM4T	✅	❌	❌
SeamlessM4Tv2	✅	❌	❌
SegFormer	✅	✅	❌
SEW	✅	❌	❌
SEW-D	✅	❌	❌
SigLIP	✅	❌	❌
Speech Encoder decoder	✅	❌	✅
Speech2Text	✅	✅	❌
SpeechT5	✅	❌	❌
Splinter	✅	❌	❌
SqueezeBERT	✅	❌	❌
SwiftFormer	✅	❌	❌
Swin Transformer	✅	✅	❌
Swin Transformer V2	✅	❌	❌
Swin2SR	✅	❌	❌
SwitchTransformers	✅	❌	❌
T5	✅	✅	✅
T5v1.1	✅	✅	✅
Table Transformer	✅	❌	❌
TAPAS	✅	✅	❌
TAPEX	✅	✅	✅
Time Series Transformer	✅	❌	❌
TimeSformer	✅	❌	❌
Trajectory Transformer	✅	❌	❌
Transformer-XL	✅	✅	❌
TrOCR	✅	❌	❌
TVLT	✅	❌	❌
TVP	✅	❌	❌
UL2	✅	✅	✅
UMT5	✅	❌	❌
UniSpeech	✅	❌	❌
UniSpeechSat	✅	❌	❌
UnivNet	✅	❌	❌
UPerNet	✅	❌	❌
VAN	✅	❌	❌
VideoMAE	✅	❌	❌
ViLT	✅	❌	❌
VipLlava	✅	❌	❌
Vision Encoder decoder	✅	✅	✅
VisionTextDualEncoder	✅	✅	✅
VisualBERT	✅	❌	❌
ViT	✅	✅	✅
ViT Hybrid	✅	❌	❌
VitDet	✅	❌	❌
ViTMAE	✅	✅	❌
ViTMatte	✅	❌	❌
ViTMSN	✅	❌	❌
VITS	✅	❌	❌
ViViT	✅	❌	❌
Wav2Vec2	✅	✅	✅
Wav2Vec2-BERT	✅	❌	❌
Wav2Vec2-Conformer	✅	❌	❌
Wav2Vec2Phoneme	✅	✅	✅
WavLM	✅	❌	❌
Whisper	✅	✅	✅
X-CLIP	✅	❌	❌
X-MOD	✅	❌	❌
XGLM	✅	✅	✅
XLM	✅	✅	❌
XLM-ProphetNet	✅	❌	❌
XLM-RoBERTa	✅	✅	✅
XLM-RoBERTa-XL	✅	❌	❌
XLM-V	✅	✅	✅
XLNet	✅	✅	❌
XLS-R	✅	✅	✅
XLSR-Wav2Vec2	✅	✅	✅
YOLOS	✅	❌	❌
YOSO	✅	❌	❌

快速导览

原文链接：huggingface.co/docs/transformers/v4.37.2/en/quicktour

快速上手 🤗 Transformers！无论您是开发人员还是日常用户，这个快速导览将帮助您入门，展示如何使用 pipeline()进行推理，加载一个预训练模型和预处理器与 AutoClass，并快速使用 PyTorch 或 TensorFlow 训练模型。如果您是初学者，我们建议您查看我们的教程或课程以获取更深入的解释。

在开始之前，请确保您已安装所有必要的库：

!pip install transformers datasets

您还需要安装您喜欢的机器学习框架：

Pytorch 隐藏 Pytorch 内容

pip install torch

TensorFlow 隐藏 TensorFlow 内容

pip install tensorflow

管道

www.youtube-nocookie.com/embed/tiZFewofSLM

pipeline()是使用预训练模型进行推理的最简单和最快速的方法。您可以直接使用 pipeline()来处理许多不同模态的任务，其中一些显示在下表中：

要查看所有可用任务的完整列表，请查看 pipeline API 参考。

任务	描述	模态	管道标识符
文本分类	为给定的文本序列分配一个标签	NLP	pipeline(task=“sentiment-analysis”)
文本生成	根据提示生成文本	NLP	pipeline(task=“text-generation”)
摘要	生成文本或文档序列的摘要	NLP	pipeline(task=“summarization”)
图像分类	为图像分配一个标签	计算机视觉	pipeline(task=“image-classification”)
图像分割	为图像的每个像素分配一个标签（支持语义、全景和实例分割）	计算机视觉	pipeline(task=“image-segmentation”)
物体检测	预测图像中物体的边界框和类别	计算机视觉	pipeline(task=“object-detection”)
音频分类	为一些音频数据分配一个标签	音频	pipeline(task=“audio-classification”)
自动语音识别	将语音转录为文本	音频	pipeline(task=“automatic-speech-recognition”)
视觉问答	回答关于图像的问题，给定一个图像和一个问题	多模态	pipeline(task=“vqa”)
文档问答	回答关于文档的问题，给定一个文档和一个问题	多模态	pipeline(task=“document-question-answering”)
图像字幕	为给定图像生成字幕	多模态	pipeline(task=“image-to-text”)

首先创建一个 pipeline()实例，并指定要用它进行的任务。在本指南中，您将使用 pipeline()进行情感分析作为示例：

>>> from transformers import pipeline

>>> classifier = pipeline("sentiment-analysis")

pipeline()会下载并缓存一个默认的预训练模型和情感分析的分词器。现在您可以在目标文本上使用classifier：

>>> classifier("We are very happy to show you the 🤗 Transformers library.")
[{'label': 'POSITIVE', 'score': 0.9998}]

如果您有多个输入，请将输入作为列表传递给 pipeline()以返回一个字典列表：

>>> results = classifier(["We are very happy to show you the 🤗 Transformers library.", "We hope you don't hate it."])
>>> for result in results:
...     print(f"label: {result['label']}, with score: {round(result['score'], 4)}")
label: POSITIVE, with score: 0.9998
label: NEGATIVE, with score: 0.5309

pipeline()还可以迭代处理任何您喜欢的任务的整个数据集。在此示例中，让我们选择自动语音识别作为我们的任务：

>>> import torch
>>> from transformers import pipeline

>>> speech_recognizer = pipeline("automatic-speech-recognition", model="facebook/wav2vec2-base-960h")

加载音频数据集（有关更多详细信息，请参阅🤗数据集快速入门）。例如，加载MInDS-14数据集：

>>> from datasets import load_dataset, Audio

>>> dataset = load_dataset("PolyAI/minds14", name="en-US", split="train")

您需要确保数据集的采样率与facebook/wav2vec2-base-960h训练时的采样率匹配：

>>> dataset = dataset.cast_column("audio", Audio(sampling_rate=speech_recognizer.feature_extractor.sampling_rate))

在调用"audio"列时，音频文件将自动加载并重新采样。从前 4 个样本中提取原始波形数组，并将其作为列表传递给管道：

>>> result = speech_recognizer(dataset[:4]["audio"])
>>> print([d["text"] for d in result])
['I WOULD LIKE TO SET UP A JOINT ACCOUNT WITH MY PARTNER HOW DO I PROCEED WITH DOING THAT', "FONDERING HOW I'D SET UP A JOIN TO HELL T WITH MY WIFE AND WHERE THE AP MIGHT BE", "I I'D LIKE TOY SET UP A JOINT ACCOUNT WITH MY PARTNER I'M NOT SEEING THE OPTION TO DO IT ON THE APSO I CALLED IN TO GET SOME HELP CAN I JUST DO IT OVER THE PHONE WITH YOU AND GIVE YOU THE INFORMATION OR SHOULD I DO IT IN THE AP AN I'M MISSING SOMETHING UQUETTE HAD PREFERRED TO JUST DO IT OVER THE PHONE OF POSSIBLE THINGS", 'HOW DO I FURN A JOINA COUT']

对于输入数据量较大的情况（比如语音或视觉），您将希望传递一个生成器而不是列表，以将所有输入加载到内存中。查看 pipeline API 参考以获取更多信息。

在管道中使用另一个模型和分词器

pipeline()可以适应Hub中的任何模型，从而可以轻松地调整 pipeline()以适应其他用例。例如，如果您需要一个能够处理法语文本的模型，请使用 Hub 上的标签来过滤适当的模型。顶部过滤结果返回一个针对情感分析进行微调的多语言BERT 模型，您可以用于法语文本：

>>> model_name = "nlptown/bert-base-multilingual-uncased-sentiment"

Pytorch 隐藏 Pytorch 内容

使用 AutoModelForSequenceClassification 和 AutoTokenizer 来加载预训练模型及其关联的分词器（关于AutoClass的更多信息请参见下一节）：

>>> from transformers import AutoTokenizer, AutoModelForSequenceClassification

>>> model = AutoModelForSequenceClassification.from_pretrained(model_name)
>>> tokenizer = AutoTokenizer.from_pretrained(model_name)

TensorFlow 隐藏 TensorFlow 内容

使用 TFAutoModelForSequenceClassification 和 AutoTokenizer 来加载预训练模型及其关联的分词器（关于TFAutoClass的更多信息请参见下一节）：

>>> from transformers import AutoTokenizer, TFAutoModelForSequenceClassification

>>> model = TFAutoModelForSequenceClassification.from_pretrained(model_name)
>>> tokenizer = AutoTokenizer.from_pretrained(model_name)

在 pipeline()中指定模型和分词器，现在您可以在法语文本上应用classifier：

>>> classifier = pipeline("sentiment-analysis", model=model, tokenizer=tokenizer)
>>> classifier("Nous sommes très heureux de vous présenter la bibliothèque 🤗 Transformers.")
[{'label': '5 stars', 'score': 0.7273}]

如果找不到适合您用例的模型，您需要在您的数据上对预训练模型进行微调。查看我们的微调教程以了解如何操作。最后，在微调预训练模型后，请考虑在 Hub 上共享该模型，以使机器学习民主化！🤗

AutoClass

www.youtube-nocookie.com/embed/AhChOFRegn4

在幕后，AutoModelForSequenceClassification 和 AutoTokenizer 类共同驱动您上面使用的 pipeline()。AutoClass 是一个快捷方式，可以根据预训练模型的名称或路径自动检索架构。您只需要为您的任务选择适当的AutoClass及其关联的预处理类。

让我们回到前一节的示例，看看如何使用AutoClass来复制 pipeline()的结果。

AutoTokenizer

分词器负责将文本预处理为输入模型的数字数组。有多个规则管理标记化过程，包括如何拆分单词以及单词应该在什么级别拆分（在分词器摘要中了解更多关于分词的信息）。最重要的是要记住，您需要使用相同模型名称实例化分词器，以确保您使用与模型预训练时相同的标记化规则。

使用 AutoTokenizer 加载分词器：

>>> from transformers import AutoTokenizer

>>> model_name = "nlptown/bert-base-multilingual-uncased-sentiment"
>>> tokenizer = AutoTokenizer.from_pretrained(model_name)

将文本传递给分词器：

>>> encoding = tokenizer("We are very happy to show you the 🤗 Transformers library.")
>>> print(encoding)
{'input_ids': [101, 11312, 10320, 12495, 19308, 10114, 11391, 10855, 10103, 100, 58263, 13299, 119, 102],
 'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}

分词器返回一个包含的字典：

input_ids：您的标记的数值表示。
attention_mask：指示应该关注哪些标记。

分词器还可以接受输入列表，并填充和截断文本以返回具有统一长度的批处理：

Pytorch 隐藏 Pytorch 内容

>>> pt_batch = tokenizer(
...     ["We are very happy to show you the 🤗 Transformers library.", "We hope you don't hate it."],
...     padding=True,
...     truncation=True,
...     max_length=512,
...     return_tensors="pt",
... )

TensorFlow 隐藏 TensorFlow 内容

>>> tf_batch = tokenizer(
...     ["We are very happy to show you the 🤗 Transformers library.", "We hope you don't hate it."],
...     padding=True,
...     truncation=True,
...     max_length=512,
...     return_tensors="tf",
... )

查看预处理教程，了解有关分词以及如何使用 AutoImageProcessor、AutoFeatureExtractor 和 AutoProcessor 预处理图像、音频和多模态输入的更多详细信息。

AutoModel

Pytorch 隐藏 Pytorch 内容

🤗 Transformers 提供了一种简单而统一的方式来加载预训练实例。这意味着您可以加载一个 AutoModel，就像加载 AutoTokenizer 一样。唯一的区别是选择正确的 AutoModel 用于任务。对于文本（或序列）分类，您应该加载 AutoModelForSequenceClassification：

>>> from transformers import AutoModelForSequenceClassification

>>> model_name = "nlptown/bert-base-multilingual-uncased-sentiment"
>>> pt_model = AutoModelForSequenceClassification.from_pretrained(model_name)

查看任务摘要以了解 AutoModel 类支持的任务。

现在直接将预处理的输入批次传递给模型。您只需通过添加**来解包字典：

>>> pt_outputs = pt_model(**pt_batch)

模型在logits属性中输出最终激活值。将 softmax 函数应用于logits以检索概率：

>>> from torch import nn

>>> pt_predictions = nn.functional.softmax(pt_outputs.logits, dim=-1)
>>> print(pt_predictions)
tensor([[0.0021, 0.0018, 0.0115, 0.2121, 0.7725],
        [0.2084, 0.1826, 0.1969, 0.1755, 0.2365]], grad_fn=<SoftmaxBackward0>)

TensorFlow 隐藏 TensorFlow 内容

🤗 Transformers 提供了一种简单而统一的方式来加载预训练实例。这意味着您可以加载一个 TFAutoModel，就像加载 AutoTokenizer 一样。唯一的区别是选择正确的 TFAutoModel 用于任务。对于文本（或序列）分类，您应该加载 TFAutoModelForSequenceClassification：

>>> from transformers import TFAutoModelForSequenceClassification

>>> model_name = "nlptown/bert-base-multilingual-uncased-sentiment"
>>> tf_model = TFAutoModelForSequenceClassification.from_pretrained(model_name)

查看任务摘要以了解 AutoModel 类支持的任务。

现在直接将预处理的输入批次传递给模型。您可以直接传递张量：

>>> tf_outputs = tf_model(tf_batch)

模型在logits属性中输出最终激活值。将 softmax 函数应用于logits以检索概率：

>>> import tensorflow as tf

>>> tf_predictions = tf.nn.softmax(tf_outputs.logits, axis=-1)
>>> tf_predictions

所有🤗 Transformers 模型（PyTorch 或 TensorFlow）在最终激活函数（如 softmax）之前输出张量，因为最终激活函数通常与损失融合在一起。模型输出是特殊的数据类，因此在 IDE 中可以自动完成其属性。模型输出的行为类似于元组或字典（可以使用整数、切片或字符串进行索引），在这种情况下，空属性将被忽略。

保存模型

Pytorch 隐藏 Pytorch 内容

一旦您的模型微调完成，您可以使用 PreTrainedModel.save_pretrained()保存模型及其分词器：

>>> pt_save_directory = "./pt_save_pretrained"
>>> tokenizer.save_pretrained(pt_save_directory)
>>> pt_model.save_pretrained(pt_save_directory)

当您准备再次使用模型时，请使用 PreTrainedModel.from_pretrained()重新加载它：

>>> pt_model = AutoModelForSequenceClassification.from_pretrained("./pt_save_pretrained")

TensorFlow 隐藏 TensorFlow 内容

一旦您的模型微调完成，您可以使用 TFPreTrainedModel.save_pretrained()保存模型及其分词器：

>>> tf_save_directory = "./tf_save_pretrained"
>>> tokenizer.save_pretrained(tf_save_directory)
>>> tf_model.save_pretrained(tf_save_directory)

当您准备再次使用模型时，请使用 TFPreTrainedModel.from_pretrained()重新加载它：

>>> tf_model = TFAutoModelForSequenceClassification.from_pretrained("./tf_save_pretrained")

🤗 Transformers 的一个特别酷的功能是能够将模型保存并重新加载为 PyTorch 或 TensorFlow 模型。from_pt 或 from_tf 参数可以将模型从一个框架转换为另一个框架：

Pytorch 隐藏 Pytorch 内容

>>> from transformers import AutoModel

>>> tokenizer = AutoTokenizer.from_pretrained(tf_save_directory)
>>> pt_model = AutoModelForSequenceClassification.from_pretrained(tf_save_directory, from_tf=True)

TensorFlow 隐藏 TensorFlow 内容

>>> from transformers import TFAutoModel

>>> tokenizer = AutoTokenizer.from_pretrained(pt_save_directory)
>>> tf_model = TFAutoModelForSequenceClassification.from_pretrained(pt_save_directory, from_pt=True)

自定义模型构建

您可以修改模型的配置类以更改模型的构建方式。配置指定模型的属性，例如隐藏层或注意力头的数量。当您从自定义配置类初始化模型时，您将从头开始。模型属性是随机初始化的，您需要在使用它以获得有意义的结果之前对模型进行训练。

首先导入 AutoConfig，然后加载您想要修改的预训练模型。在 AutoConfig.from_pretrained()中，您可以指定要更改的属性，比如注意力头的数量：

>>> from transformers import AutoConfig

>>> my_config = AutoConfig.from_pretrained("distilbert-base-uncased", n_heads=12)

Pytorch 隐藏 Pytorch 内容

使用 AutoModel.from_config()从您的自定义配置创建模型：

>>> from transformers import AutoModel

>>> my_model = AutoModel.from_config(my_config)

TensorFlow 隐藏 TensorFlow 内容

使用 TFAutoModel.from_config()从您的自定义配置创建模型：

>>> from transformers import TFAutoModel

>>> my_model = TFAutoModel.from_config(my_config)

查看创建自定义架构指南，了解有关构建自定义配置的更多信息。

Trainer - 一个 PyTorch 优化的训练循环

所有模型都是标准的torch.nn.Module，因此您可以在任何典型的训练循环中使用它们。虽然您可以编写自己的训练循环，🤗 Transformers 提供了一个用于 PyTorch 的 Trainer 类，其中包含基本的训练循环，并添加了额外的功能，如分布式训练、混合精度等。

根据您的任务，通常会将以下参数传递给 Trainer：

您将从 PreTrainedModel 或torch.nn.Module开始：

>>> from transformers import AutoModelForSequenceClassification

>>> model = AutoModelForSequenceClassification.from_pretrained("distilbert-base-uncased")

TrainingArguments 包含您可以更改的模型超参数，如学习率、批量大小和训练的时代数。如果您不指定任何训练参数，将使用默认值：

>>> from transformers import TrainingArguments

>>> training_args = TrainingArguments(
...     output_dir="path/to/save/folder/",
...     learning_rate=2e-5,
...     per_device_train_batch_size=8,
...     per_device_eval_batch_size=8,
...     num_train_epochs=2,
... )

加载一个预处理类，比如分词器、图像处理器、特征提取器或处理器：

>>> from transformers import AutoTokenizer

>>> tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")

加载数据集：

>>> from datasets import load_dataset

>>> dataset = load_dataset("rotten_tomatoes")  # doctest: +IGNORE_RESULT

创建一个函数来对数据集进行分词：

>>> def tokenize_dataset(dataset):
...     return tokenizer(dataset["text"])

然后在整个数据集上应用它，使用map：

>>> dataset = dataset.map(tokenize_dataset, batched=True)

一个 DataCollatorWithPadding 来从您的数据集中创建一批示例：

>>> from transformers import DataCollatorWithPadding

>>> data_collator = DataCollatorWithPadding(tokenizer=tokenizer)

现在将所有这些类聚集在 Trainer 中：

>>> from transformers import Trainer

>>> trainer = Trainer(
...     model=model,
...     args=training_args,
...     train_dataset=dataset["train"],
...     eval_dataset=dataset["test"],
...     tokenizer=tokenizer,
...     data_collator=data_collator,
... )  # doctest: +SKIP

当你准备好时，调用 train()开始训练：

>>> trainer.train()

对于使用序列到序列模型的任务，比如翻译或摘要，使用 Seq2SeqTrainer 和 Seq2SeqTrainingArguments 类。

您可以通过对 Trainer 中的方法进行子类化来自定义训练循环行为。这样可以自定义特性，如损失函数、优化器和调度器。查看 Trainer 参考，了解哪些方法可以被子类化。

另一种自定义训练循环的方法是使用 Callbacks。您可以使用回调函数与其他库集成，并检查训练循环以报告进度或提前停止训练。回调函数不会修改训练循环本身。要自定义像损失函数这样的东西，您需要对 Trainer 进行子类化。

使用 TensorFlow 进行训练

所有模型都是标准的tf.keras.Model，因此它们可以在 TensorFlow 中使用Keras API 进行训练。🤗 Transformers 提供了 prepare_tf_dataset()方法，可以轻松将数据集加载为tf.data.Dataset，这样您就可以立即开始使用 Keras 的compile和fit方法进行训练。

您将从 TFPreTrainedModel 或tf.keras.Model开始：

>>> from transformers import TFAutoModelForSequenceClassification

>>> model = TFAutoModelForSequenceClassification.from_pretrained("distilbert-base-uncased")

加载一个预处理类，比如分词器、图像处理器、特征提取器或处理器：

>>> from transformers import AutoTokenizer

>>> tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")

创建一个函数来对数据集进行分词：

>>> def tokenize_dataset(dataset):
...     return tokenizer(dataset["text"])  # doctest: +SKIP

使用map在整个数据集上应用分词器，然后将数据集和分词器传递给 prepare_tf_dataset()。如果需要，您还可以在这里更改批量大小和对数据集进行洗牌：

>>> dataset = dataset.map(tokenize_dataset)  # doctest: +SKIP
>>> tf_dataset = model.prepare_tf_dataset(
...     dataset["train"], batch_size=16, shuffle=True, tokenizer=tokenizer
... )  # doctest: +SKIP

当您准备好时，您可以调用compile和fit开始训练。请注意，Transformers 模型都有一个默认的与任务相关的损失函数，所以除非您想要，否则不需要指定一个：

>>> from tensorflow.keras.optimizers import Adam

>>> model.compile(optimizer=Adam(3e-5))  # No loss argument!
>>> model.fit(tf_dataset)  # doctest: +SKIP

接下来是什么？

现在您已经完成了🤗 Transformers 的快速导览，请查看我们的指南，学习如何做更具体的事情，比如编写自定义模型，为任务微调模型，以及如何使用脚本训练模型。如果您对学习更多关于🤗 Transformers 核心概念感兴趣，请拿杯咖啡，看看我们的概念指南！

安装

原文：huggingface.co/docs/transformers/v4.37.2/en/installation

为您正在使用的任何深度学习库安装🤗 Transformers，设置您的缓存，并可选择配置🤗 Transformers 以离线运行。

🤗 Transformers 在 Python 3.6+、PyTorch 1.1.0+、TensorFlow 2.0+和 Flax 上进行了测试。按照下面的安装说明为您正在使用的深度学习库安装：

PyTorch安装说明。
TensorFlow 2.0安装说明。
Flax安装说明。

使用 pip 安装

您应该在virtual environment中安装🤗 Transformers。如果您不熟悉 Python 虚拟环境，请查看这个guide。虚拟环境使得管理不同项目更容易，并避免依赖项之间的兼容性问题。

首先在项目目录中创建一个虚拟环境：

python -m venv .env

激活虚拟环境。在 Linux 和 MacOs 上：

source .env/bin/activate

在 Windows 上激活虚拟环境

.env/Scripts/activate

现在您可以使用以下命令安装🤗 Transformers：

pip install transformers

仅支持 CPU 的情况下，您可以方便地在一行中安装🤗 Transformers 和一个深度学习库。例如，使用以下命令安装🤗 Transformers 和 PyTorch：

pip install 'transformers[torch]'

🤗 Transformers 和 TensorFlow 2.0：

pip install 'transformers[tf-cpu]'

M1 / ARM 用户

在安装 TensorFLow 2.0 之前，您需要安装以下内容

brew install cmake
brew install pkg-config

🤗 Transformers 和 Flax：

pip install 'transformers[flax]'

最后，通过运行以下命令检查🤗 Transformers 是否已正确安装。它将下载一个预训练模型：

python -c "from transformers import pipeline; print(pipeline('sentiment-analysis')('we love you'))"

然后打印标签和分数：

[{'label': 'POSITIVE', 'score': 0.9998704791069031}]

从源代码安装

使用以下命令从源代码安装🤗 Transformers：

pip install git+https://github.com/huggingface/transformers

此命令安装最新的stable版本而不是最新的main版本。main版本对于保持与最新发展保持最新是有用的。例如，如果自上次官方发布以来修复了错误但尚未推出新版本。但是，这意味着main版本可能不总是稳定的。我们努力保持main版本的运行，并且大多数问题通常在几个小时或一天内解决。如果遇到问题，请打开一个Issue，以便我们更快地解决！

通过运行以下命令检查🤗 Transformers 是否已正确安装：

python -c "from transformers import pipeline; print(pipeline('sentiment-analysis')('I love you'))"

可编辑安装

如果您想要，您将需要一个可编辑的安装：

使用源代码的main版本。
为🤗 Transformers 做出贡献并需要测试代码更改。

克隆存储库并使用以下命令安装🤗 Transformers：

git clone https://github.com/huggingface/transformers.git
cd transformers
pip install -e .

这些命令将链接您克隆存储库的文件夹和您的 Python 库路径。现在 Python 将在您克隆到的文件夹中查找，除了正常的库路径。例如，如果您的 Python 包通常安装在~/anaconda3/envs/main/lib/python3.7/site-packages/中，Python 还将搜索您克隆到的文件夹：~/transformers/。

如果要继续使用该库，必须保留transformers文件夹。

现在您可以使用以下命令轻松将克隆更新到最新版本的🤗 Transformers：

cd ~/transformers/
git pull

您的 Python 环境将在下一次运行时找到🤗 Transformers 的main版本。

使用 conda 安装

从 conda 频道conda-forge安装：

conda install conda-forge::transformers

缓存设置

预训练模型将被下载并在~/.cache/huggingface/hub中本地缓存。这是由 shell 环境变量TRANSFORMERS_CACHE给出的默认目录。在 Windows 上，默认目录由C:\Users\username\.cache\huggingface\hub给出。您可以更改下面显示的 shell 环境变量 - 以优先顺序列出 - 以指定不同的缓存目录：

Shell 环境变量（默认）：HUGGINGFACE_HUB_CACHE或TRANSFORMERS_CACHE。
Shell 环境变量：HF_HOME。
Shell 环境变量：XDG_CACHE_HOME + /huggingface。

🤗 Transformers 将使用 shell 环境变量PYTORCH_TRANSFORMERS_CACHE或PYTORCH_PRETRAINED_BERT_CACHE，如果您来自此库的早期版本并设置了这些环境变量，除非您指定 shell 环境变量TRANSFORMERS_CACHE。

离线模式

通过设置环境变量TRANSFORMERS_OFFLINE=1在防火墙或离线环境中运行🤗 Transformers，并使用本地缓存文件。

通过环境变量HF_DATASETS_OFFLINE=1将🤗 Datasets添加到您的离线训练工作流程。

HF_DATASETS_OFFLINE=1 TRANSFORMERS_OFFLINE=1 \
python examples/pytorch/translation/run_translation.py --model_name_or_path t5-small --dataset_name wmt16 --dataset_config ro-en ...

此脚本应该可以在不挂起或等待超时的情况下运行，因为它不会尝试从 Hub 下载模型。

您还可以通过local_files_only参数在每个 from_pretrained()调用中绕过从 Hub 加载模型。当设置为True时，只加载本地文件：

from transformers import T5Model

model = T5Model.from_pretrained("./path/to/local/directory", local_files_only=True)

获取模型和分词器以离线使用

另一种离线使用🤗 Transformers 的选项是提前下载文件，然后在需要离线使用时指向它们的本地路径。有三种方法可以做到这一点：

通过点击↓图标在Model Hub上的用户界面下载文件。

使用 PreTrainedModel.from_pretrained()和 PreTrainedModel.save_pretrained()工作流程：

使用 PreTrainedModel.from_pretrained()提前下载您的文件：

>>> from transformers import AutoTokenizer, AutoModelForSeq2SeqLM

>>> tokenizer = AutoTokenizer.from_pretrained("bigscience/T0_3B")
>>> model = AutoModelForSeq2SeqLM.from_pretrained("bigscience/T0_3B")

使用 PreTrainedModel.save_pretrained()将文件保存到指定目录：

>>> tokenizer.save_pretrained("./your/path/bigscience_t0")
>>> model.save_pretrained("./your/path/bigscience_t0")

现在当您离线时，通过从指定目录重新加载您的文件使用 PreTrainedModel.from_pretrained()：

>>> tokenizer = AutoTokenizer.from_pretrained("./your/path/bigscience_t0")
>>> model = AutoModel.from_pretrained("./your/path/bigscience_t0")

使用huggingface_hub库以编程方式下载文件：

在您的虚拟环境中安装huggingface_hub库：

python -m pip install huggingface_hub

使用hf_hub_download函数将文件下载到特定路径。例如，以下命令将从T0模型下载config.json文件到您想要的路径：

>>> from huggingface_hub import hf_hub_download

>>> hf_hub_download(repo_id="bigscience/T0_3B", filename="config.json", cache_dir="./your/path/bigscience_t0")

一旦您的文件被下载并本地缓存，指定它的本地路径以加载和使用它：

>>> from transformers import AutoConfig

>>> config = AutoConfig.from_pretrained("./your/path/bigscience_t0/config.json")

查看如何从 Hub 下载文件部分，了解有关下载存储在 Hub 上的文件的更多详细信息。

教程

用于推断的管道

原始文本：huggingface.co/docs/transformers/v4.37.2/en/pipeline_tutorial

pipeline()使得在任何语言、计算机视觉、语音和多模态任务上使用 Hub 中的任何模型进行推断变得简单。即使您没有使用特定模态的经验或不熟悉模型背后的代码，您仍然可以使用 pipeline()进行推断！本教程将教您：

用于推断的 pipeline()。
使用特定的分词器或模型。
为音频、视觉和多模态任务使用 pipeline()。

查看 pipeline()文档，了解支持的任务和可用参数的完整列表。

管道用法

虽然每个任务都有一个相关的 pipeline()，但使用包含所有特定任务管道的通用 pipeline()抽象更简单。pipeline()会自动加载默认模型和适用于您任务的推断预处理类。让我们以使用 pipeline()进行自动语音识别（ASR）或语音转文本为例。

首先创建一个 pipeline()，并指定推断任务：

>>> from transformers import pipeline

>>> transcriber = pipeline(task="automatic-speech-recognition")

将您的输入传递给 pipeline()。在语音识别的情况下，这是一个音频输入文件：

>>> transcriber("https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/mlk.flac")
{'text': 'I HAVE A DREAM BUT ONE DAY THIS NATION WILL RISE UP LIVE UP THE TRUE MEANING OF ITS TREES'}

不是您想要的结果？查看 Hub 上一些最受欢迎的自动语音识别模型，看看是否可以获得更好的转录。

让我们尝试来自 OpenAI 的Whisper large-v2模型。Whisper 比 Wav2Vec2 晚发布了 2 年，训练数据接近 10 倍。因此，它在大多数下游基准测试中击败了 Wav2Vec2。它还具有预测标点和大小写的附加好处，而这两者在 Wav2Vec2 中都不可能。

Wav2Vec2。

让我们在这里尝试一下，看看它的表现如何：

>>> transcriber = pipeline(model="openai/whisper-large-v2")
>>> transcriber("https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/mlk.flac")
{'text': ' I have a dream that one day this nation will rise up and live out the true meaning of its creed.'}

现在这个结果看起来更准确了！要深入比较 Wav2Vec2 和 Whisper，请参考音频变换器课程。我们真的鼓励您查看 Hub 中不同语言的模型、专门针对您领域的模型等。您可以直接从 Hub 在浏览器上查看和比较模型结果，看看它是否比其他模型更适合或更好地处理边缘情况。如果您找不到适用于您用例的模型，您始终可以开始训练您自己的模型！

如果您有多个输入，可以将输入作为列表传递：

transcriber(
    [
        "https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/mlk.flac",
        "https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/1.flac",
    ]
)

管道对于实验很有用，因为从一个模型切换到另一个模型很简单；然而，有一些方法可以优化它们以处理比实验更大的工作量。查看以下指南，深入探讨如何迭代整个数据集或在 web 服务器中使用管道：文档中的：

在数据集上使用管道
在 web 服务器上使用管道

参数

pipeline()支持许多参数；一些是任务特定的，一些是所有管道通用的。一般来说，您可以在任何地方指定参数：

transcriber = pipeline(model="openai/whisper-large-v2", my_parameter=1)

out = transcriber(...)  # This will use `my_parameter=1`.
out = transcriber(..., my_parameter=2)  # This will override and use `my_parameter=2`.
out = transcriber(...)  # This will go back to using `my_parameter=1`.

让我们看看 3 个重要的参数：

设备

如果您使用device=n，管道会自动将模型放在指定的设备上。无论您使用 PyTorch 还是 Tensorflow，这都可以工作。

transcriber = pipeline(model="openai/whisper-large-v2", device=0)

如果模型对单个 GPU 来说太大，并且您使用的是 PyTorch，您可以设置device_map="auto"来自动确定如何加载和存储模型权重。使用device_map参数需要 🤗 Accelerate 软件包：

pip install --upgrade accelerate

以下代码会自动在设备之间加载和存储模型权重：

transcriber = pipeline(model="openai/whisper-large-v2", device_map="auto")

请注意，如果传递了device_map="auto"，在实例化您的pipeline时无需添加参数device=device，否则可能会遇到一些意外行为！

批处理大小

默认情况下，管道不会批量推理，原因在这里有详细解释。原因是批处理不一定更快，在某些情况下实际上可能会更慢。

但如果在您的使用案例中有效，您可以使用：

transcriber = pipeline(model="openai/whisper-large-v2", device=0, batch_size=2)
audio_filenames = [f"https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/{i}.flac" for i in range(1, 5)]
texts = transcriber(audio_filenames)

这会在提供的 4 个音频文件上运行管道，但会将它们分批传递给模型（模型在 GPU 上，批处理更有可能有所帮助），而无需您进一步编写任何代码。输出应始终与没有批处理时收到的结果相匹配。这只是一种帮助您从管道中获得更快速度的方法。

管道还可以减轻一些批处理的复杂性，因为对于某些管道，单个项目（如长音频文件）需要被分成多个部分才能被模型处理。管道会为您执行这种块批处理。

任务特定参数

所有任务都提供任务特定参数，这些参数允许额外的灵活性和选项，帮助您完成工作。例如，transformers.AutomaticSpeechRecognitionPipeline.call()方法有一个return_timestamps参数，对于为视频添加字幕听起来很有希望：

>>> transcriber = pipeline(model="openai/whisper-large-v2", return_timestamps=True)
>>> transcriber("https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/mlk.flac")
{'text': ' I have a dream that one day this nation will rise up and live out the true meaning of its creed.', 'chunks': [{'timestamp': (0.0, 11.88), 'text': ' I have a dream that one day this nation will rise up and live out the true meaning of its'}, {'timestamp': (11.88, 12.38), 'text': ' creed.'}]}

正如您所看到的，模型推断了文本，并且还输出了各个句子的发音时间。

每个任务都有许多可用的参数，因此请查看每个任务的 API 参考，看看您可以调整哪些参数！例如，AutomaticSpeechRecognitionPipeline 有一个chunk_length_s参数，对于处理非常长的音频文件（例如，为整部电影或长达一小时的视频添加字幕）非常有帮助，这是模型通常无法独立处理的：

>>> transcriber = pipeline(model="openai/whisper-large-v2", chunk_length_s=30, return_timestamps=True)
>>> transcriber("https://huggingface.co/datasets/sanchit-gandhi/librispeech_long/resolve/main/audio.wav")
{'text': " Chapter 16\. I might have told you of the beginning of this liaison in a few lines, but I wanted you to see every step by which we came.  I, too, agree to whatever Marguerite wished, Marguerite to be unable to live apart from me. It was the day after the evening...

如果找不到一个真正有帮助的参数，请随时请求！

在数据集上使用管道

管道还可以在大型数据集上运行推理。我们建议的最简单方法是使用迭代器：

def data():
    for i in range(1000):
        yield f"My example {i}"

pipe = pipeline(model="gpt2", device=0)
generated_characters = 0
for out in pipe(data()):
    generated_characters += len(out[0]["generated_text"])

迭代器data()会产生每个结果，管道会自动识别输入是可迭代的，并在继续在 GPU 上处理数据的同时开始获取数据（这在底层使用DataLoader）。这很重要，因为您不必为整个数据集分配内存，可以尽可能快地将数据馈送到 GPU。

由于批处理可能加快速度，尝试调整这里的batch_size参数可能会有用。

迭代数据集的最简单方法就是从 🤗 Datasets 加载一个：

# KeyDataset is a util that will just output the item we're interested in.
from transformers.pipelines.pt_utils import KeyDataset
from datasets import load_dataset

pipe = pipeline(model="hf-internal-testing/tiny-random-wav2vec2", device=0)
dataset = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation[:10]")

for out in pipe(KeyDataset(dataset, "audio")):
    print(out)

在 web 服务器上使用管道

创建推理引擎是一个复杂的主题，值得有自己的页面。

链接

视觉管道

对于视觉任务使用 pipeline()几乎是相同的。

指定您的任务并将图像传递给分类器。图像可以是链接，本地路径或 base64 编码的图像。例如，下面显示了什么品种的猫？

>>> from transformers import pipeline

>>> vision_classifier = pipeline(model="google/vit-base-patch16-224")
>>> preds = vision_classifier(
...     images="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"
... )
>>> preds = [{"score": round(pred["score"], 4), "label": pred["label"]} for pred in preds]
>>> preds
[{'score': 0.4335, 'label': 'lynx, catamount'}, {'score': 0.0348, 'label': 'cougar, puma, catamount, mountain lion, painter, panther, Felis concolor'}, {'score': 0.0324, 'label': 'snow leopard, ounce, Panthera uncia'}, {'score': 0.0239, 'label': 'Egyptian cat'}, {'score': 0.0229, 'label': 'tiger cat'}]

文本管道

对于 NLP 任务使用 pipeline()几乎是相同的。

>>> from transformers import pipeline

>>> # This model is a `zero-shot-classification` model.
>>> # It will classify text, except you are free to choose any label you might imagine
>>> classifier = pipeline(model="facebook/bart-large-mnli")
>>> classifier(
...     "I have a problem with my iphone that needs to be resolved asap!!",
...     candidate_labels=["urgent", "not urgent", "phone", "tablet", "computer"],
... )
{'sequence': 'I have a problem with my iphone that needs to be resolved asap!!', 'labels': ['urgent', 'phone', 'computer', 'not urgent', 'tablet'], 'scores': [0.504, 0.479, 0.013, 0.003, 0.002]}

多模态管道

pipeline()支持多种模态。例如，视觉问答（VQA）任务结合了文本和图像。随意使用您喜欢的任何图像链接和您想要询问有关图像的问题。图像可以是 URL 或图像的本地路径。

例如，如果您使用这个发票图像：

>>> from transformers import pipeline

>>> vqa = pipeline(model="impira/layoutlm-document-qa")
>>> vqa(
...     image="https://huggingface.co/spaces/impira/docquery/resolve/2359223c1837a7587402bda0f2643382a6eefeab/invoice.png",
...     question="What is the invoice number?",
... )
[{'score': 0.42515, 'answer': 'us-001', 'start': 16, 'end': 16}]

要运行上面的示例，您需要安装pytesseract以及🤗 Transformers：

sudo apt install -y tesseract-ocr
pip install pytesseract

在大型模型上使用🤗加速器：

您可以轻松地在大型模型上使用🤗accelerate运行pipeline！首先确保您已经安装了accelerate和pip install accelerate。

首先使用device_map="auto"加载您的模型！我们将在示例中使用facebook/opt-1.3b。

# pip install accelerate
import torch
from transformers import pipeline

pipe = pipeline(model="facebook/opt-1.3b", torch_dtype=torch.bfloat16, device_map="auto")
output = pipe("This is a cool example!", do_sample=True, top_p=0.95)

如果安装了bitsandbytes并添加参数load_in_8bit=True，还可以传递 8 位加载的模型

# pip install accelerate bitsandbytes
import torch
from transformers import pipeline

pipe = pipeline(model="facebook/opt-1.3b", device_map="auto", model_kwargs={"load_in_8bit": True})
output = pipe("This is a cool example!", do_sample=True, top_p=0.95)

请注意，您可以用支持大型模型加载的任何 Hugging Face 模型替换检查点，例如 BLOOM！

使用 AutoClass 加载预训练实例

原文链接：huggingface.co/docs/transformers/v4.37.2/en/autoclass_tutorial

由于有这么多不同的 Transformer 架构，为您的检查点创建一个可能是具有挑战性的。作为🤗 Transformers 核心理念的一部分，使库易于使用、简单灵活，AutoClass会自动推断并从给定的检查点加载正确的架构。from_pretrained()方法让您快速加载任何架构的预训练模型，这样您就不必花时间和资源从头开始训练模型。生成这种与检查点无关的代码意味着，如果您的代码适用于一个检查点，它将适用于另一个检查点 - 只要它是为类似任务训练的 - 即使架构不同。

请记住，架构指的是模型的骨架，检查点是给定架构的权重。例如，BERT是一个架构，而bert-base-uncased是一个检查点。模型是一个通用术语，可以指代架构或检查点。

在本教程中，学习：

加载一个预训练分词器。
加载一个预训练图像处理器
加载一个预训练特征提取器。
加载一个预训练处理器。
加载一个预训练模型。
加载一个作为骨干的模型。

AutoTokenizer

几乎每个 NLP 任务都以分词器开始。分词器将您的输入转换为模型可以处理的格式。

使用 AutoTokenizer.from_pretrained()加载一个分词器：

>>> from transformers import AutoTokenizer

>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")

然后按照下面所示对您的输入进行标记化：

>>> sequence = "In a hole in the ground there lived a hobbit."
>>> print(tokenizer(sequence))
{'input_ids': [101, 1999, 1037, 4920, 1999, 1996, 2598, 2045, 2973, 1037, 7570, 10322, 4183, 1012, 102], 
 'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 
 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}

AutoImageProcessor

对于视觉任务，图像处理器将图像处理成正确的输入格式。

>>> from transformers import AutoImageProcessor

>>> image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224")

AutoFeatureExtractor

对于音频任务，特征提取器将音频信号处理成正确的输入格式。

使用 AutoFeatureExtractor.from_pretrained()加载一个特征提取器：

>>> from transformers import AutoFeatureExtractor

>>> feature_extractor = AutoFeatureExtractor.from_pretrained(
...     "ehcalabres/wav2vec2-lg-xlsr-en-speech-emotion-recognition"
... )

AutoProcessor

多模态任务需要一个结合两种预处理工具的处理器。例如，LayoutLMV2 模型需要一个图像处理器来处理图像，一个分词器来处理文本；处理器将两者结合起来。

使用 AutoProcessor.from_pretrained()加载一个处理器：

>>> from transformers import AutoProcessor

>>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv2-base-uncased")

AutoModel

PytorchHide Pytorch content

AutoModelFor类让您加载给定任务的预训练模型（请参阅此处以获取可用任务的完整列表）。例如，使用 AutoModelForSequenceClassification.from_pretrained()加载一个用于序列分类的模型：

>>> from transformers import AutoModelForSequenceClassification

>>> model = AutoModelForSequenceClassification.from_pretrained("distilbert-base-uncased")

轻松重用相同的检查点来加载不同任务的架构：

>>> from transformers import AutoModelForTokenClassification

>>> model = AutoModelForTokenClassification.from_pretrained("distilbert-base-uncased")

对于 PyTorch 模型，from_pretrained()方法使用torch.load()，内部使用pickle，已知存在安全风险。一般来说，永远不要加载可能来自不受信任来源或可能被篡改的模型。对于在 Hugging Face Hub 上托管的公共模型，这种安全风险部分得到缓解，这些模型在每次提交时都会进行恶意软件扫描。查看Hub 文档以获取最佳实践，如使用 GPG 进行签名提交验证。

TensorFlow 和 Flax 检查点不受影响，可以在 PyTorch 架构中使用from_tf和from_flax参数加载，以绕过此问题。

通常，我们建议使用AutoTokenizer类和AutoModelFor类来加载模型的预训练实例。这将确保您每次加载正确的架构。在下一个教程中，学习如何使用新加载的分词器、图像处理器、特征提取器和处理器来预处理数据集进行微调。

TensorFlow 隐藏 TensorFlow 内容

最后，TFAutoModelFor类让您加载给定任务的预训练模型（请参阅此处以获取可用任务的完整列表）。例如，使用 TFAutoModelForSequenceClassification.from_pretrained()加载用于序列分类的模型：

>>> from transformers import TFAutoModelForSequenceClassification

>>> model = TFAutoModelForSequenceClassification.from_pretrained("distilbert-base-uncased")

轻松地重复使用相同的检查点来加载不同任务的架构：

>>> from transformers import TFAutoModelForTokenClassification

>>> model = TFAutoModelForTokenClassification.from_pretrained("distilbert-base-uncased")

通常，我们建议使用AutoTokenizer类和TFAutoModelFor类来加载模型的预训练实例。这将确保您每次加载正确的架构。在下一个教程中，学习如何使用新加载的分词器、图像处理器、特征提取器和处理器来预处理数据集进行微调。

AutoBackbone

AutoBackbone允许您将预训练模型用作骨干，并从模型的不同阶段获得特征图作为输出。下面您可以看到如何从 Swin 检查点获取特征图。

>>> from transformers import AutoImageProcessor, AutoBackbone
>>> import torch
>>> from PIL import Image
>>> import requests
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> processor = AutoImageProcessor.from_pretrained("microsoft/swin-tiny-patch4-window7-224")
>>> model = AutoBackbone.from_pretrained("microsoft/swin-tiny-patch4-window7-224", out_indices=(0,))

>>> inputs = processor(image, return_tensors="pt")
>>> outputs = model(**inputs)
>>> feature_maps = outputs.feature_maps
>>> list(feature_maps[-1].shape)
[1, 96, 56, 56]

预处理

原始文本：huggingface.co/docs/transformers/v4.37.2/en/preprocessing

在您可以在数据集上训练模型之前，需要将其预处理为预期的模型输入格式。无论您的数据是文本、图像还是音频，都需要将其转换并组装成张量批次。🤗 Transformers 提供了一组预处理类来帮助准备数据供模型使用。在本教程中，您将了解到：

文本，使用 Tokenizer 将文本转换为一系列标记，创建标记的数值表示，并将它们组装成张量。
语音和音频，使用 Feature extractor 从音频波形中提取序列特征并将其转换为张量。
图像输入使用 ImageProcessor 将图像转换为张量。
多模态输入，使用 Processor 来结合一个分词器和一个特征提取器或图像处理器。

AutoProcessor 总是有效，并自动选择您正在使用的模型的正确类别，无论您是使用分词器、图像处理器、特征提取器还是处理器。

在开始之前，请安装🤗数据集，以便加载一些数据集进行实验：

pip install datasets

自然语言处理

www.youtube-nocookie.com/embed/Yffk5aydLzg

预处理文本数据的主要工具是 tokenizer。分词器根据一组规则将文本分割为标记。这些标记被转换为数字，然后成为模型输入的张量。分词器会添加模型所需的任何额外输入。

如果您打算使用预训练模型，重要的是使用相关的预训练分词器。这确保文本被分割的方式与预训练语料库相同，并且在预训练期间使用相同的对应标记索引（通常称为词汇表）。

通过 AutoTokenizer.from_pretrained()方法加载预训练的分词器来开始。这会下载模型预训练时使用的词汇表：

>>> from transformers import AutoTokenizer

>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")

然后将您的文本传递给分词器：

>>> encoded_input = tokenizer("Do not meddle in the affairs of wizards, for they are subtle and quick to anger.")
>>> print(encoded_input)
{'input_ids': [101, 2079, 2025, 19960, 10362, 1999, 1996, 3821, 1997, 16657, 1010, 2005, 2027, 2024, 11259, 1998, 4248, 2000, 4963, 1012, 102],
 'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}

分词器返回一个包含三个重要项目的字典：

input_ids 是句子中每个标记对应的索引。
attention_mask 指示一个标记是否应该被关注。
token_type_ids 标识一个标记属于哪个序列，当有多个序列时。

通过解码input_ids返回您的输入：

>>> tokenizer.decode(encoded_input["input_ids"])
'[CLS] Do not meddle in the affairs of wizards, for they are subtle and quick to anger. [SEP]'

正如您所看到的，分词器添加了两个特殊标记 - CLS和SEP（分类器和分隔符）- 到句子中。并非所有模型都需要特殊标记，但如果需要，分词器会自动为您添加它们。

如果有几个句子需要预处理，将它们作为列表传递给分词器：

>>> batch_sentences = [
...     "But what about second breakfast?",
...     "Don't think he knows about second breakfast, Pip.",
...     "What about elevensies?",
... ]
>>> encoded_inputs = tokenizer(batch_sentences)
>>> print(encoded_inputs)
{'input_ids': [[101, 1252, 1184, 1164, 1248, 6462, 136, 102],
               [101, 1790, 112, 189, 1341, 1119, 3520, 1164, 1248, 6462, 117, 21902, 1643, 119, 102],
               [101, 1327, 1164, 5450, 23434, 136, 102]],
 'token_type_ids': [[0, 0, 0, 0, 0, 0, 0, 0],
                    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                    [0, 0, 0, 0, 0, 0, 0]],
 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1],
                    [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
                    [1, 1, 1, 1, 1, 1, 1]]}

填充

句子长度不总是相同，这可能是一个问题，因为张量，即模型输入，需要具有统一的形状。填充是一种确保张量是矩形的策略，通过向较短的句子添加一个特殊的填充标记。

将padding参数设置为True，以将批次中较短的序列填充到与最长序列相匹配的长度：

>>> batch_sentences = [
...     "But what about second breakfast?",
...     "Don't think he knows about second breakfast, Pip.",
...     "What about elevensies?",
... ]
>>> encoded_input = tokenizer(batch_sentences, padding=True)
>>> print(encoded_input)
{'input_ids': [[101, 1252, 1184, 1164, 1248, 6462, 136, 102, 0, 0, 0, 0, 0, 0, 0],
               [101, 1790, 112, 189, 1341, 1119, 3520, 1164, 1248, 6462, 117, 21902, 1643, 119, 102],
               [101, 1327, 1164, 5450, 23434, 136, 102, 0, 0, 0, 0, 0, 0, 0, 0]],
 'token_type_ids': [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],
 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
                    [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
                    [1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0]]}

第一句和第三句现在用0填充，因为它们较短。

截断

另一方面，有时一个序列可能太长，模型无法处理。在这种情况下，您需要将序列截断为较短的长度。

将truncation参数设置为True，将序列截断为模型接受的最大长度：

>>> batch_sentences = [
...     "But what about second breakfast?",
...     "Don't think he knows about second breakfast, Pip.",
...     "What about elevensies?",
... ]
>>> encoded_input = tokenizer(batch_sentences, padding=True, truncation=True)
>>> print(encoded_input)
{'input_ids': [[101, 1252, 1184, 1164, 1248, 6462, 136, 102, 0, 0, 0, 0, 0, 0, 0],
               [101, 1790, 112, 189, 1341, 1119, 3520, 1164, 1248, 6462, 117, 21902, 1643, 119, 102],
               [101, 1327, 1164, 5450, 23434, 136, 102, 0, 0, 0, 0, 0, 0, 0, 0]],
 'token_type_ids': [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],
 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
                    [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
                    [1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0]]}

查看填充和截断概念指南，了解更多不同的填充和截断参数。

构建张量

最后，您希望分词器返回实际馈送到模型的张量。

将return_tensors参数设置为pt以供 PyTorch 使用，或设置为tf以供 TensorFlow 使用：

Pytorch 隐藏 Pytorch 内容

>>> batch_sentences = [
...     "But what about second breakfast?",
...     "Don't think he knows about second breakfast, Pip.",
...     "What about elevensies?",
... ]
>>> encoded_input = tokenizer(batch_sentences, padding=True, truncation=True, return_tensors="pt")
>>> print(encoded_input)
{'input_ids': tensor([[101, 1252, 1184, 1164, 1248, 6462, 136, 102, 0, 0, 0, 0, 0, 0, 0],
                      [101, 1790, 112, 189, 1341, 1119, 3520, 1164, 1248, 6462, 117, 21902, 1643, 119, 102],
                      [101, 1327, 1164, 5450, 23434, 136, 102, 0, 0, 0, 0, 0, 0, 0, 0]]),
 'token_type_ids': tensor([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]),
 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
                           [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
                           [1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0]])}

TensorFlow 隐藏 TensorFlow 内容

>>> batch_sentences = [
...     "But what about second breakfast?",
...     "Don't think he knows about second breakfast, Pip.",
...     "What about elevensies?",
... ]
>>> encoded_input = tokenizer(batch_sentences, padding=True, truncation=True, return_tensors="tf")
>>> print(encoded_input)
{'input_ids': <tf.Tensor: shape=(2, 9), dtype=int32, numpy=
array([[101, 1252, 1184, 1164, 1248, 6462, 136, 102, 0, 0, 0, 0, 0, 0, 0],
       [101, 1790, 112, 189, 1341, 1119, 3520, 1164, 1248, 6462, 117, 21902, 1643, 119, 102],
       [101, 1327, 1164, 5450, 23434, 136, 102, 0, 0, 0, 0, 0, 0, 0, 0]],
      dtype=int32)>,
 'token_type_ids': <tf.Tensor: shape=(2, 9), dtype=int32, numpy=
array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=int32)>,
 'attention_mask': <tf.Tensor: shape=(2, 9), dtype=int32, numpy=
array([[1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
       [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=int32)>}

不同的管道以不同的方式在其__call__()中支持分词器参数。text-2-text-generation管道仅支持（即传递）truncation。text-generation管道支持max_length、truncation、padding和add_special_tokens。在fill-mask管道中，分词器参数可以在tokenizer_kwargs参数（字典）中传递。

音频

对于音频任务，您将需要一个特征提取器来准备您的数据集以供模型使用。特征提取器旨在从原始音频数据中提取特征，并将其转换为张量。

加载MInDS-14数据集（查看🤗Datasets 教程以获取有关如何加载数据集的更多详细信息）以查看如何在音频数据集中使用特征提取器：

>>> from datasets import load_dataset, Audio

>>> dataset = load_dataset("PolyAI/minds14", name="en-US", split="train")

访问audio列的第一个元素以查看输入。调用audio列会自动加载和重新采样音频文件：

>>> dataset[0]["audio"]
{'array': array([ 0.        ,  0.00024414, -0.00024414, ..., -0.00024414,
         0.        ,  0.        ], dtype=float32),
 'path': '/root/.cache/huggingface/datasets/downloads/extracted/f14948e0e84be638dd7943ac36518a4cf3324e8b7aa331c5ab11541518e9368c/en-US~JOINT_ACCOUNT/602ba55abb1e6d0fbce92065.wav',
 'sampling_rate': 8000}

这将返回三个项目：

array是加载的语音信号 - 可能已重新采样 - 作为 1D 数组。
path指向音频文件的位置。
sampling_rate指的是每秒测量的语音信号中有多少数据点。

在本教程中，您将使用Wav2Vec2模型。查看模型卡片，您将了解到 Wav2Vec2 是在 16kHz 采样的语音音频上进行预训练的。重要的是，您的音频数据的采样率要与用于预训练模型的数据集的采样率匹配。如果您的数据采样率不同，则需要对数据进行重新采样。

使用🤗 Datasets 的cast_column方法将采样率上采样至 16kHz：

>>> dataset = dataset.cast_column("audio", Audio(sampling_rate=16_000))

再次调用audio列以重新采样音频文件：

>>> dataset[0]["audio"]
{'array': array([ 2.3443763e-05,  2.1729663e-04,  2.2145823e-04, ...,
         3.8356509e-05, -7.3497440e-06, -2.1754686e-05], dtype=float32),
 'path': '/root/.cache/huggingface/datasets/downloads/extracted/f14948e0e84be638dd7943ac36518a4cf3324e8b7aa331c5ab11541518e9368c/en-US~JOINT_ACCOUNT/602ba55abb1e6d0fbce92065.wav',
 'sampling_rate': 16000}

接下来，加载一个特征提取器来对输入进行归一化和填充。在填充文本数据时，会为较短的序列添加0。相同的思想也适用于音频数据。特征提取器会向array中添加一个0 - 被解释为静音。

使用 AutoFeatureExtractor.from_pretrained()加载特征提取器：

>>> from transformers import AutoFeatureExtractor

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base")

将音频array传递给特征提取器。我们还建议在特征提取器中添加sampling_rate参数，以更好地调试可能发生的任何静默错误。

>>> audio_input = [dataset[0]["audio"]["array"]]
>>> feature_extractor(audio_input, sampling_rate=16000)
{'input_values': [array([ 3.8106556e-04,  2.7506407e-03,  2.8015103e-03, ...,
        5.6335266e-04,  4.6588284e-06, -1.7142107e-04], dtype=float32)]}

与分词器一样，您可以应用填充或截断来处理批处理中的可变序列。查看这两个音频样本的序列长度：

>>> dataset[0]["audio"]["array"].shape
(173398,)

>>> dataset[1]["audio"]["array"].shape
(106496,)

创建一个函数来预处理数据集，使音频样本具有相同的长度。指定最大样本长度，特征提取器将填充或截断序列以匹配它：

>>> def preprocess_function(examples):
...     audio_arrays = [x["array"] for x in examples["audio"]]
...     inputs = feature_extractor(
...         audio_arrays,
...         sampling_rate=16000,
...         padding=True,
...         max_length=100000,
...         truncation=True,
...     )
...     return inputs

对数据集中的前几个示例应用preprocess_function：

>>> processed_dataset = preprocess_function(dataset[:5])

现在样本长度相同并与指定的最大长度匹配。现在可以将处理过的数据集传递给模型了！

>>> processed_dataset["input_values"][0].shape
(100000,)

>>> processed_dataset["input_values"][1].shape
(100000,)

计算机视觉

对于计算机视觉任务，您将需要一个图像处理器来准备您的数据集以供模型使用。图像预处理包括几个步骤，将图像转换为模型期望的输入。这些步骤包括但不限于调整大小、归一化、颜色通道校正以及将图像转换为张量。

图像预处理通常遵循某种形式的图像增强。图像预处理和图像增强都会转换图像数据，但它们有不同的目的：

图像增强以一种可以帮助防止过拟合并增加模型鲁棒性的方式改变图像。您可以在数据增强中发挥创造力 - 调整亮度和颜色，裁剪，旋转，调整大小，缩放等。但是，请注意不要通过增强改变图像的含义。
图像预处理确保图像与模型期望的输入格式匹配。在微调计算机视觉模型时，图像必须与模型最初训练时的预处理方式完全相同。

您可以使用任何您喜欢的库进行图像增强。对于图像预处理，请使用与模型关联的ImageProcessor。

加载food101数据集（请参阅🤗数据集教程以获取有关如何加载数据集的更多详细信息），以查看如何在计算机视觉数据集中使用图像处理器：

使用🤗数据集split参数仅加载训练集中的一小部分样本，因为数据集非常大！

>>> from datasets import load_dataset

>>> dataset = load_dataset("food101", split="train[:100]")

接下来，看一下带有🤗数据集Image特征的图像：

>>> dataset[0]["image"]

使用 AutoImageProcessor.from_pretrained()加载图像处理器：

>>> from transformers import AutoImageProcessor

>>> image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224")

首先，让我们添加一些图像增强。您可以使用任何您喜欢的库，但在本教程中，我们将使用 torchvision 的transforms模块。如果您有兴趣使用其他数据增强库，请在Albumentations或Kornia notebooks中学习如何使用。

在这里，我们使用Compose来链接一些转换 - RandomResizedCrop和ColorJitter。请注意，对于调整大小，我们可以从image_processor获取图像大小要求。对于某些模型，期望精确的高度和宽度，对于其他模型只定义了shortest_edge。

>>> from torchvision.transforms import RandomResizedCrop, ColorJitter, Compose

>>> size = (
...     image_processor.size["shortest_edge"]
...     if "shortest_edge" in image_processor.size
...     else (image_processor.size["height"], image_processor.size["width"])
... )

>>> _transforms = Compose([RandomResizedCrop(size), ColorJitter(brightness=0.5, hue=0.5)])

模型接受pixel_values作为其输入。ImageProcessor可以负责归一化图像，并生成适当的张量。创建一个函数，将图像增强和图像预处理组合为一批图像，并生成pixel_values：

>>> def transforms(examples):
...     images = [_transforms(img.convert("RGB")) for img in examples["image"]]
...     examples["pixel_values"] = image_processor(images, do_resize=False, return_tensors="pt")["pixel_values"]
...     return examples

在上面的示例中，我们设置了do_resize=False，因为我们已经在图像增强转换中调整了图像的大小，并利用了适当的image_processor的size属性。如果您在图像增强期间不调整图像大小，请省略此参数。默认情况下，ImageProcessor将处理调整大小。

如果希望将图像归一化作为增强转换的一部分，请使用image_processor.image_mean和image_processor.image_std值。

然后使用🤗数据集set_transform来动态应用转换：

>>> dataset.set_transform(transforms)

现在当您访问图像时，您会注意到图像处理器已添加了pixel_values。现在您可以将处理过的数据集传递给模型了！

>>> dataset[0].keys()

这是应用转换后的图像样子。图像已被随机裁剪，其颜色属性不同。

>>> import numpy as np
>>> import matplotlib.pyplot as plt

>>> img = dataset[0]["pixel_values"]
>>> plt.imshow(img.permute(1, 2, 0))

对于目标检测、语义分割、实例分割和全景分割等任务，ImageProcessor提供后处理方法。这些方法将模型的原始输出转换为有意义的预测，如边界框或分割地图。

填充

在某些情况下，例如在微调 DETR 时，模型会在训练时应用尺度增强。这可能导致批处理中的图像大小不同。您可以使用来自 DetrImageProcessor 的DetrImageProcessor.pad()，并定义一个自定义的collate_fn来将图像批处理在一起。

>>> def collate_fn(batch):
...     pixel_values = [item["pixel_values"] for item in batch]
...     encoding = image_processor.pad(pixel_values, return_tensors="pt")
...     labels = [item["labels"] for item in batch]
...     batch = {}
...     batch["pixel_values"] = encoding["pixel_values"]
...     batch["pixel_mask"] = encoding["pixel_mask"]
...     batch["labels"] = labels
...     return batch

多模态

对于涉及多模态输入的任务，您将需要一个处理器来为模型准备您的数据集。处理器将两个处理对象（如标记器和特征提取器）耦合在一起。

加载LJ Speech数据集（查看🤗数据集教程以获取有关如何加载数据集的更多详细信息），以查看如何使用处理器进行自动语音识别（ASR）：

>>> from datasets import load_dataset

>>> lj_speech = load_dataset("lj_speech", split="train")

对于 ASR，您主要关注音频和文本，因此可以删除其他列：

>>> lj_speech = lj_speech.map(remove_columns=["file", "id", "normalized_text"])

现在看一下音频和文本列：

>>> lj_speech[0]["audio"]
{'array': array([-7.3242188e-04, -7.6293945e-04, -6.4086914e-04, ...,
         7.3242188e-04,  2.1362305e-04,  6.1035156e-05], dtype=float32),
 'path': '/root/.cache/huggingface/datasets/downloads/extracted/917ece08c95cf0c4115e45294e3cd0dee724a1165b7fc11798369308a465bd26/LJSpeech-1.1/wavs/LJ001-0001.wav',
 'sampling_rate': 22050}

>>> lj_speech[0]["text"]
'Printing, in the only sense with which we are at present concerned, differs from most if not from all the arts and crafts represented in the Exhibition'

记住，你应该始终重新采样你的音频数据集的采样率，以匹配用于预训练模型的数据集的采样率！

>>> lj_speech = lj_speech.cast_column("audio", Audio(sampling_rate=16_000))

使用 AutoProcessor.from_pretrained()加载一个处理器：

>>> from transformers import AutoProcessor

>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-base-960h")

创建一个函数来处理array中包含的音频数据为input_values，并将文本标记化为标签。这些是模型的输入：

>>> def prepare_dataset(example):
...     audio = example["audio"]

...     example.update(processor(audio=audio["array"], text=example["text"], sampling_rate=16000))

...     return example

将prepare_dataset函数应用到一个样本中：

>>> prepare_dataset(lj_speech[0])

处理器现在已经添加了input_values和labels，采样率也已经正确降采样到 16kHz。现在您可以将处理过的数据集传递给模型了！

对预训练模型进行微调

原始文本：huggingface.co/docs/transformers/v4.37.2/en/training

使用预训练模型有很多好处。它可以减少计算成本、减少碳足迹，并且可以让您使用最先进的模型，而无需从头开始训练。🤗 Transformers 提供了数千个预训练模型，适用于各种任务。当您使用预训练模型时，您需要在特定于您任务的数据集上对其进行训练。这被称为微调，是一种非常强大的训练技术。在本教程中，您将使用您选择的深度学习框架对预训练模型进行微调：

使用 🤗 Transformers Trainer 对预训练模型进行微调。
使用 Keras 在 TensorFlow 中对预训练模型进行微调。
在原生 PyTorch 中对预训练模型进行微调。

准备数据集

www.youtube-nocookie.com/embed/_BZearw7f0w

在对预训练模型进行微调之前，下载一个数据集并为训练做好准备。之前的教程向您展示了如何处理训练数据，现在您有机会将这些技能付诸实践！

首先加载 Yelp 评论数据集：

>>> from datasets import load_dataset

>>> dataset = load_dataset("yelp_review_full")
>>> dataset["train"][100]
{'label': 0,
 'text': 'My expectations for McDonalds are t rarely high. But for one to still fail so spectacularly...that takes something special!\\nThe cashier took my friends\'s order, then promptly ignored me. I had to force myself in front of a cashier who opened his register to wait on the person BEHIND me. I waited over five minutes for a gigantic order that included precisely one kid\'s meal. After watching two people who ordered after me be handed their food, I asked where mine was. The manager started yelling at the cashiers for \\"serving off their orders\\" when they didn\'t have their food. But neither cashier was anywhere near those controls, and the manager was the one serving food to customers and clearing the boards.\\nThe manager was rude when giving me my order. She didn\'t make sure that I had everything ON MY RECEIPT, and never even had the decency to apologize that I felt I was getting poor service.\\nI\'ve eaten at various McDonalds restaurants for over 30 years. I\'ve worked at more than one location. I expect bad days, bad moods, and the occasional mistake. But I have yet to have a decent experience at this store. It will remain a place I avoid unless someone in my party needs to avoid illness from low blood sugar. Perhaps I should go back to the racially biased service of Steak n Shake instead!'}

现在您知道，您需要一个分词器来处理文本，并包含填充和截断策略以处理任何可变序列长度。为了一次处理您的数据集，使用 🤗 Datasets map 方法在整个数据集上应用预处理函数：

>>> from transformers import AutoTokenizer

>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")

>>> 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(1000))
>>> small_eval_dataset = tokenized_datasets["test"].shuffle(seed=42).select(range(1000))

训练

在这一点上，您应该按照您想要使用的框架对应的部分进行操作。您可以使用右侧边栏中的链接跳转到您想要的部分 - 如果您想隐藏给定框架的所有内容，只需使用该框架块右上角的按钮！

PytorchHide Pytorch 内容

www.youtube-nocookie.com/embed/nvBXf7s7vTI

使用 PyTorch Trainer 进行训练

🤗 Transformers 提供了一个专为训练 🤗 Transformers 模型优化的 Trainer 类，使得开始训练变得更加容易，而无需手动编写自己的训练循环。Trainer API 支持各种训练选项和功能，如日志记录、梯度累积和混合精度。

首先加载您的模型并指定预期标签的数量。从 Yelp 评论数据集卡片中，您知道有五个标签：

>>> from transformers import AutoModelForSequenceClassification

>>> model = AutoModelForSequenceClassification.from_pretrained("bert-base-cased", num_labels=5)

您将看到一个警告，指出一些预训练权重未被使用，一些权重被随机初始化。不用担心，这是完全正常的！BERT 模型的预训练头被丢弃，并用随机初始化的分类头替换。您将对这个新模型头进行微调，将预训练模型的知识转移到它上面进行序列分类任务。

训练超参数

接下来，创建一个包含所有可以调整的超参数以及激活不同训练选项的标志的 TrainingArguments 类。对于本教程，您可以从默认的训练超参数开始，但请随时尝试这些参数以找到您的最佳设置。

指定保存训练检查点的位置：

>>> from transformers import TrainingArguments

>>> training_args = TrainingArguments(output_dir="test_trainer")

评估

Trainer 在训练期间不会自动评估模型性能。您需要传递 Trainer 一个函数来计算和报告指标。🤗 Evaluate库提供了一个简单的accuracy函数，您可以使用evaluate.load加载（有关更多信息，请参阅此快速导览）：

>>> import numpy as np
>>> import evaluate

>>> metric = evaluate.load("accuracy")

在metric上调用compute以计算您预测的准确性。在将预测传递给compute之前，您需要将 logits 转换为预测（请记住，所有🤗 Transformers 模型都返回 logits）：

>>> def compute_metrics(eval_pred):
...     logits, labels = eval_pred
...     predictions = np.argmax(logits, axis=-1)
...     return metric.compute(predictions=predictions, references=labels)

如果您想在微调期间监视评估指标，请在训练参数中指定evaluation_strategy参数，以在每个时期结束时报告评估指标：

>>> from transformers import TrainingArguments, Trainer

>>> training_args = TrainingArguments(output_dir="test_trainer", evaluation_strategy="epoch")

Trainer

使用您的模型、训练参数、训练和测试数据集以及评估函数创建一个 Trainer 对象：

>>> trainer = Trainer(
...     model=model,
...     args=training_args,
...     train_dataset=small_train_dataset,
...     eval_dataset=small_eval_dataset,
...     compute_metrics=compute_metrics,
... )

然后通过调用 train()微调您的模型：

>>> trainer.train()

TensorFlow 隐藏 TensorFlow 内容

www.youtube-nocookie.com/embed/rnTGBy2ax1c

使用 Keras 训练 TensorFlow 模型

您还可以使用 Keras API 在 TensorFlow 中训练🤗 Transformers 模型！

为 Keras 加载数据

当您想要使用 Keras API 训练🤗 Transformers 模型时，您需要将数据集转换为 Keras 理解的格式。如果您的数据集很小，您可以将整个数据集转换为 NumPy 数组并将其传递给 Keras。在我们做更复杂的事情之前，让我们先尝试这个。

首先，加载一个数据集。我们将使用来自GLUE 基准的 CoLA 数据集，因为它是一个简单的二进制文本分类任务，现在只取训练拆分。

from datasets import load_dataset

dataset = load_dataset("glue", "cola")
dataset = dataset["train"]  # Just take the training split for now

接下来，加载一个分词器并将数据标记为 NumPy 数组。请注意，标签已经是 0 和 1 的列表，因此我们可以直接将其转换为 NumPy 数组而无需进行标记化！

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
tokenized_data = tokenizer(dataset["sentence"], return_tensors="np", padding=True)
# Tokenizer returns a BatchEncoding, but we convert that to a dict for Keras
tokenized_data = dict(tokenized_data)

labels = np.array(dataset["label"])  # Label is already an array of 0 and 1

最后，加载，compile，和fit模型。请注意，Transformers 模型都有一个默认的与任务相关的损失函数，因此除非您想要，否则不需要指定一个：

from transformers import TFAutoModelForSequenceClassification
from tensorflow.keras.optimizers import Adam

# Load and compile our model
model = TFAutoModelForSequenceClassification.from_pretrained("bert-base-cased")
# Lower learning rates are often better for fine-tuning transformers
model.compile(optimizer=Adam(3e-5))  # No loss argument!

model.fit(tokenized_data, labels)

当您compile()模型时，您不必向模型传递损失参数！如果将此参数留空，Hugging Face 模型会自动选择适合其任务和模型架构的损失。如果您想要，您始终可以通过指定自己的损失来覆盖这一点！

这种方法对于较小的数据集效果很好，但对于较大的数据集，您可能会发现它开始成为一个问题。为什么？因为标记化的数组和标签必须完全加载到内存中，而且因为 NumPy 不处理“不规则”数组，所以每个标记化的样本都必须填充到整个数据集中最长样本的长度。这将使您的数组变得更大，所有这些填充标记也会减慢训练速度！

将数据加载为 tf.data.Dataset

如果您想避免减慢训练速度，可以将数据加载为tf.data.Dataset。虽然如果您愿意，您可以编写自己的tf.data流水线，但我们有两种方便的方法来做到这一点：

prepare_tf_dataset()：这是我们在大多数情况下推荐的方法。因为它是在您的模型上的一个方法，它可以检查模型以自动找出哪些列可用作模型输入，并丢弃其他列以使数据集更简单、更高效。
to_tf_dataset：此方法更低级，当您想要精确控制数据集创建方式时很有用，通过指定要包含的确切columns和label_cols。

在您可以使用 prepare_tf_dataset()之前，您需要将分词器的输出添加到数据集中作为列，如下面的代码示例所示：

def tokenize_dataset(data):
    # Keys of the returned dictionary will be added to the dataset as columns
    return tokenizer(data["text"])

dataset = dataset.map(tokenize_dataset)

请记住，Hugging Face 数据集默认存储在磁盘上，因此这不会增加您的内存使用！一旦添加了列，您可以从数据集中流式传输批次并对每个批次进行填充，这将大大减少与填充整个数据集相比的填充标记数量。

>>> tf_dataset = model.prepare_tf_dataset(dataset["train"], batch_size=16, shuffle=True, tokenizer=tokenizer)

请注意，在上面的代码示例中，您需要将分词器传递给prepare_tf_dataset，以便它可以正确地填充批次。如果数据集中的所有样本长度相同且不需要填充，则可以跳过此参数。如果您需要执行比填充样本更复杂的操作（例如，为了进行掩码语言建模而破坏标记），则可以使用collate_fn参数，而不是传递一个函数，该函数将被调用以将样本列表转换为批次并应用任何您想要的预处理。查看我们的示例或notebooks以查看此方法的实际操作。

一旦创建了tf.data.Dataset，您可以像以前一样编译和拟合模型：

model.compile(optimizer=Adam(3e-5))  # No loss argument!

model.fit(tf_dataset)

在本机 PyTorch 中训练

PytorchHide Pytorch content

www.youtube-nocookie.com/embed/Dh9CL8fyG80

Trainer 负责训练循环，并允许您在一行代码中微调模型。对于喜欢编写自己训练循环的用户，您也可以在本机 PyTorch 中微调🤗 Transformers 模型。

此时，您可能需要重新启动笔记本或执行以下代码以释放一些内存：

del model
del trainer
torch.cuda.empty_cache()

接下来，手动后处理tokenized_dataset以准备训练。

删除text列，因为模型不接受原始文本作为输入：

>>> tokenized_datasets = tokenized_datasets.remove_columns(["text"])

将label列重命名为labels，因为模型期望参数命名为labels：

>>> tokenized_datasets = tokenized_datasets.rename_column("label", "labels")

将数据集的格式设置为返回 PyTorch 张量而不是列表：

>>> tokenized_datasets.set_format("torch")

然后创建数据集的较小子集，以加快微调速度：

>>> small_train_dataset = tokenized_datasets["train"].shuffle(seed=42).select(range(1000))
>>> small_eval_dataset = tokenized_datasets["test"].shuffle(seed=42).select(range(1000))

DataLoader

为您的训练和测试数据集创建一个DataLoader，这样您就可以迭代处理数据批次：

>>> from torch.utils.data import DataLoader

>>> train_dataloader = DataLoader(small_train_dataset, shuffle=True, batch_size=8)
>>> eval_dataloader = DataLoader(small_eval_dataset, batch_size=8)

加载您的模型并指定预期标签的数量：

>>> from transformers import AutoModelForSequenceClassification

>>> model = AutoModelForSequenceClassification.from_pretrained("bert-base-cased", num_labels=5)

优化器和学习率调度程序

创建一个优化器和学习率调度程序来微调模型。让我们使用 PyTorch 中的AdamW优化器：

>>> from torch.optim import AdamW

>>> optimizer = AdamW(model.parameters(), lr=5e-5)

从 Trainer 创建默认学习率调度程序：

>>> from transformers import get_scheduler

>>> num_epochs = 3
>>> num_training_steps = num_epochs * len(train_dataloader)
>>> lr_scheduler = get_scheduler(
...     name="linear", optimizer=optimizer, num_warmup_steps=0, num_training_steps=num_training_steps
... )

最后，如果您可以使用 GPU，请指定device来使用 GPU。否则，使用 CPU 进行训练可能需要几个小时，而不是几分钟。

>>> import torch

>>> device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
>>> model.to(device)

如果您没有云 GPU，可以通过像Colaboratory或SageMaker StudioLab这样的托管笔记本获得免费访问。

很好，现在您已经准备好开始训练了！🥳

训练循环

为了跟踪您的训练进度，使用tqdm库在训练步骤数量上添加进度条：

>>> from tqdm.auto import tqdm

>>> progress_bar = tqdm(range(num_training_steps))

>>> model.train()
>>> for epoch in range(num_epochs):
...     for batch in train_dataloader:
...         batch = {k: v.to(device) for k, v in batch.items()}
...         outputs = model(**batch)
...         loss = outputs.loss
...         loss.backward()

...         optimizer.step()
...         lr_scheduler.step()
...         optimizer.zero_grad()
...         progress_bar.update(1)

评估

就像您在 Trainer 中添加了一个评估函数一样，当您编写自己的训练循环时，您需要做同样的事情。但是，这次您将累积所有批次并在最后计算指标，而不是在每个 epoch 结束时计算和报告指标。

>>> import evaluate

>>> metric = evaluate.load("accuracy")
>>> model.eval()
>>> for batch in eval_dataloader:
...     batch = {k: v.to(device) for k, v in batch.items()}
...     with torch.no_grad():
...         outputs = model(**batch)

...     logits = outputs.logits
...     predictions = torch.argmax(logits, dim=-1)
...     metric.add_batch(predictions=predictions, references=batch["labels"])

>>> metric.compute()

额外资源

有关更多微调示例，请参考:

🤗 Transformers Examples 包括了用于在 PyTorch 和 TensorFlow 中训练常见 NLP 任务的脚本。
🤗 Transformers Notebooks 包含了关于如何在 PyTorch 和 TensorFlow 中为特定任务微调模型的各种笔记本。学习率调度程序

创建一个优化器和学习率调度程序来微调模型。让我们使用 PyTorch 中的AdamW优化器：

>>> from torch.optim import AdamW

>>> optimizer = AdamW(model.parameters(), lr=5e-5)

从 Trainer 创建默认学习率调度程序：

>>> from transformers import get_scheduler

>>> num_epochs = 3
>>> num_training_steps = num_epochs * len(train_dataloader)
>>> lr_scheduler = get_scheduler(
...     name="linear", optimizer=optimizer, num_warmup_steps=0, num_training_steps=num_training_steps
... )

最后，如果您可以使用 GPU，请指定device来使用 GPU。否则，使用 CPU 进行训练可能需要几个小时，而不是几分钟。

>>> import torch

>>> device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
>>> model.to(device)

如果您没有云 GPU，可以通过像Colaboratory或SageMaker StudioLab这样的托管笔记本获得免费访问。

很好，现在您已经准备好开始训练了！🥳

训练循环

为了跟踪您的训练进度，使用tqdm库在训练步骤数量上添加进度条：

>>> from tqdm.auto import tqdm

>>> progress_bar = tqdm(range(num_training_steps))

>>> model.train()
>>> for epoch in range(num_epochs):
...     for batch in train_dataloader:
...         batch = {k: v.to(device) for k, v in batch.items()}
...         outputs = model(**batch)
...         loss = outputs.loss
...         loss.backward()

...         optimizer.step()
...         lr_scheduler.step()
...         optimizer.zero_grad()
...         progress_bar.update(1)

评估

>>> import evaluate

>>> metric = evaluate.load("accuracy")
>>> model.eval()
>>> for batch in eval_dataloader:
...     batch = {k: v.to(device) for k, v in batch.items()}
...     with torch.no_grad():
...         outputs = model(**batch)

...     logits = outputs.logits
...     predictions = torch.argmax(logits, dim=-1)
...     metric.add_batch(predictions=predictions, references=batch["labels"])

>>> metric.compute()

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2024-06-26，如有侵权请联系 cloudcommunity@tencent.com 删除

音频

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！