Transformers 4.37 中文文档（一）

            <div id="content_views" class="markdown_views prism-tomorrow-night" deep="6">
                <svg xmlns="http://www.w3.org/2000/svg" style="display: none;">
                    <path stroke-linecap="round" d="M5,0 0,2.5 5,5z" id="raphael-marker-block" style="-webkit-tap-highlight-color: rgba(0, 0, 0, 0);"></path>
                </svg>
                <blockquote> 

原文：huggingface.co/docs/transformers

开始吧

🤗 Transformers

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

PyTorch、TensorFlow和JAX的最先进机器学习。

🤗 Transformers 提供 API 和工具，可以轻松下载和训练最先进的预训练模型。使用预训练模型可以减少计算成本、碳足迹，并节省训练模型所需的时间和资源。这些模型支持不同模态中的常见任务，例如：

📝 自然语言处理：文本分类、命名实体识别、问答、语言建模、摘要、翻译、多项选择和文本生成。

🖼️ 计算机视觉：图像分类、目标检测和分割。

🗣️ 音频：自动语音识别和音频分类。

🐙 多模态：表格问答、光学字符识别、从扫描文档中提取信息、视频分类和视觉问答。

🤗 Transformers 支持 PyTorch、TensorFlow 和 JAX 之间的框架互操作性。这提供了在模型生命周期的每个阶段使用不同框架的灵活性；在一个框架中用三行代码训练模型，然后在另一个框架中加载进行推断。模型还可以导出到类似 ONNX 和 TorchScript 的格式，以在生产环境中部署。

立即加入Hub、论坛或Discord上不断增长的社区！

如果您正在寻找 Hugging Face 团队的定制支持

目录

文档分为五个部分：

• 开始提供了一个快速浏览库和安装说明，让您快速上手。

• 教程是初学者入门的好地方。本节将帮助您获得开始使用库所需的基本技能。

• 操作指南向您展示如何实现特定目标，例如对预训练模型进行微调以进行语言建模，或者如何编写和共享自定义模型。

• 概念指南提供了更多关于模型、任务和🤗 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

 
 

 
 
1

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

Pytorch 隐藏 Pytorch 内容

pip install torch

 
 

 
 
1

TensorFlow 隐藏 TensorFlow 内容

pip install tensorflow

 
 

 
 
1

管道

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”)

• 1
• 2
• 3

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

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

 
 

 
 
1
2

如果您有多个输入，请将输入作为列表传递给 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

 
 

 
 
1
2
3
4
5

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

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

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

• 1
• 2
• 3
• 4

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

>>> from datasets import load_dataset, Audio

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

• 1
• 2
• 3

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

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

 
 

 
 
1

在调用"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']

 
 

 
 
1
2
3

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

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

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

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

 
 

 
 
1

Pytorch 隐藏 Pytorch 内容

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

>>> from transformers import AutoTokenizer, AutoModelForSequenceClassification

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

• 1
• 2
• 3
• 4

TensorFlow 隐藏 TensorFlow 内容

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

>>> from transformers import AutoTokenizer, TFAutoModelForSequenceClassification

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

• 1
• 2
• 3
• 4

在 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}]

 
 

 
 
1
2
3

如果找不到适合您用例的模型，您需要在您的数据上对预训练模型进行微调。查看我们的微调教程以了解如何操作。最后，在微调预训练模型后，请考虑在 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)

• 1
• 2
• 3
• 4

将文本传递给分词器：

>>> 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]}

 
 

 
 
1
2
3
4
5

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

• 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",
... )

 
 

 
 
1
2
3
4
5
6
7

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",
... )

 
 

 
 
1
2
3
4
5
6
7

查看预处理教程，了解有关分词以及如何使用 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)

• 1
• 2
• 3
• 4

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

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

>>> pt_outputs = pt_model(**pt_batch)

 
 

 
 
1

模型在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>)

• 1
• 2
• 3
• 4
• 5
• 6

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)

• 1
• 2
• 3
• 4

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

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

>>> tf_outputs = tf_model(tf_batch)

 
 

 
 
1

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

>>> import tensorflow as tf

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

• 1
• 2
• 3
• 4

所有🤗 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)

 
 

 
 
1
2
3

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

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

 
 

 
 
1

TensorFlow 隐藏 TensorFlow 内容

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

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

 
 

 
 
1
2
3

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

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

 
 

 
 
1

🤗 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)

• 1
• 2
• 3
• 4

TensorFlow 隐藏 TensorFlow 内容

>>> from transformers import TFAutoModel

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

• 1
• 2
• 3
• 4

自定义模型构建

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

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

>>> from transformers import AutoConfig

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

• 1
• 2
• 3

Pytorch 隐藏 Pytorch 内容

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

>>> from transformers import AutoModel

>>> my_model = AutoModel.from_config(my_config)

• 1
• 2
• 3

TensorFlow 隐藏 TensorFlow 内容

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

>>> from transformers import TFAutoModel

>>> my_model = TFAutoModel.from_config(my_config)

• 1
• 2
• 3

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

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

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

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

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

   >>> from transformers import AutoModelForSequenceClassification
   

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

• 1
• 2
• 3

• 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,
  ... )

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

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

  >>> from transformers import AutoTokenizer
  

• >>> tokenizer = AutoTokenizer.from_pretrained(“distilbert-base-uncased”)

  • 1
  • 2
  • 3

• 加载数据集：

  >>> from datasets import load_dataset
  

• >>> dataset = load_dataset(“rotten_tomatoes”) # doctest: +IGNORE_RESULT

  • 1
  • 2
  • 3

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

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

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

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

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

  >>> from transformers import DataCollatorWithPadding
  

• >>> data_collator = DataCollatorWithPadding(tokenizer=tokenizer)

  • 1
  • 2
  • 3

  现在将所有这些类聚集在 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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

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

  >>> trainer.train()
  
   
   
  
   
   
  1

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

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

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

  使用 TensorFlow 进行训练

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

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

     >>> from transformers import TFAutoModelForSequenceClassification
     

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

  • 1
  • 2
  • 3

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

  >>> from transformers import AutoTokenizer
  

• >>> tokenizer = AutoTokenizer.from_pretrained(“distilbert-base-uncased”)

  • 1
  • 2
  • 3

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

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

• 使用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
  
    
    
  
    
    
  1
  2
  3
  4

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

  >>> from tensorflow.keras.optimizers import Adam
  

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

  • 1
  • 2
  • 3
  • 4

  接下来是什么？

  现在您已经完成了🤗 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
  
   
   
  
   
   
  1

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

  source .env/bin/activate
  
   
   
  
   
   
  1

  在 Windows 上激活虚拟环境

  .env/Scripts/activate
  
   
   
  
   
   
  1

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

  pip install transformers
  
   
   
  
   
   
  1

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

  pip install 'transformers[torch]'
  
   
   
  
   
   
  1

  🤗 Transformers 和 TensorFlow 2.0：

  pip install 'transformers[tf-cpu]'
  
   
   
  
   
   
  1

  M1 / ARM 用户

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

  brew install cmake
  brew install pkg-config
  
   
   
  
   
   
  1
  2

  🤗 Transformers 和 Flax：

  pip install 'transformers[flax]'
  
   
   
  
   
   
  1

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

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

  然后打印标签和分数：

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

  从源代码安装

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

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

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

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

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

  可编辑安装

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

  • 使用源代码的main版本。

  • 为🤗 Transformers 做出贡献并需要测试代码更改。

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

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

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

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

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

  cd ~/transformers/
  git pull
  
   
   
  
   
   
  1
  2

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

  使用 conda 安装

  从 conda 频道conda-forge安装：

  conda install conda-forge::transformers
  
   
   
  
   
   
  1

  缓存设置

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

  1. Shell 环境变量（默认）：HUGGINGFACE_HUB_CACHE或TRANSFORMERS_CACHE。

  2. Shell 环境变量：HF_HOME。

  3. 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 ...
  
   
   
  
   
   
  1
  2

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

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

  from transformers import T5Model
  

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

  • 1
  • 2
  • 3

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

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

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

    

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

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

       >>> from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
       

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

  • 1
  • 2
  • 3
  • 4

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

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

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

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

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

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

     python -m pip install huggingface_hub
     
         
         
     
         
         
     1

  2. 使用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”)

  • 1
  • 2
  • 3

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

  >>> from transformers import AutoConfig
  

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

  • 1
  • 2
  • 3

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

  教程

  用于推断的管道

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

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

  • 用于推断的 pipeline()。

  • 使用特定的分词器或模型。

  • 为音频、视觉和多模态任务使用 pipeline()。

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

  管道用法

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

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

  >>> from transformers import pipeline
  

  >>> transcriber = pipeline(task=“automatic-speech-recognition”)

  • 1
  • 2
  • 3
  1. 将您的输入传递给 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'}
  
   
   
  
   
   
  1
  2

  不是您想要的结果？查看 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.'}
  
   
   
  
   
   
  1
  2
  3

  现在这个结果看起来更准确了！要深入比较 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",
      ]
  )
  
   
   
  
   
   
  1
  2
  3
  4
  5
  6

  管道对于实验很有用，因为从一个模型切换到另一个模型很简单；然而，有一些方法可以优化它们以处理比实验更大的工作量。查看以下指南，深入探讨如何迭代整个数据集或在 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.

  • 1
  • 2
  • 3
  • 4
  • 5

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

  设备

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

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

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

  pip install --upgrade accelerate
  
   
   
  
   
   
  1

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

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

  请注意，如果传递了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)
  
   
   
  
   
   
  1
  2
  3

  这会在提供的 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.'}]}
  
   
   
  
   
   
  1
  2
  3

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

  每个任务都有许多可用的参数，因此请查看每个任务的 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...
  
   
   
  
   
   
  1
  2
  3

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

  在数据集上使用管道

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

  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”])

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

  迭代器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)

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

  在 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’}]

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

  文本管道

  对于 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]}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

  多模态管道

  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}]

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

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

  sudo apt install -y tesseract-ocr
  pip install pytesseract
  
   
   
  
   
   
  1
  2

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

  您可以轻松地在大型模型上使用🤗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)

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

  如果安装了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)

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

  请注意，您可以用支持大型模型加载的任何 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”)

  • 1
  • 2
  • 3

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

  >>> 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]}
  
   
   
  
   
   
  1
  2
  3
  4
  5

  AutoImageProcessor

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

  >>> from transformers import AutoImageProcessor
  

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

  • 1
  • 2
  • 3

  AutoFeatureExtractor

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

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

  >>> from transformers import AutoFeatureExtractor
  

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

  • 1
  • 2
  • 3
  • 4
  • 5

  AutoProcessor

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

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

  >>> from transformers import AutoProcessor
  

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

  • 1
  • 2
  • 3

  AutoModel

  PytorchHide Pytorch content

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

  >>> from transformers import AutoModelForSequenceClassification
  

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

  • 1
  • 2
  • 3

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

  >>> from transformers import AutoModelForTokenClassification
  

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

  • 1
  • 2
  • 3

  对于 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”)

  • 1
  • 2
  • 3

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

  >>> from transformers import TFAutoModelForTokenClassification
  

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

  • 1
  • 2
  • 3

  通常，我们建议使用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]

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

  预处理

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

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

  • 文本，使用 Tokenizer 将文本转换为一系列标记，创建标记的数值表示，并将它们组装成张量。

  • 语音和音频，使用 Feature extractor 从音频波形中提取序列特征并将其转换为张量。

  • 图像输入使用 ImageProcessor 将图像转换为张量。

  • 多模态输入，使用 Processor 来结合一个分词器和一个特征提取器或图像处理器。

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

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

  pip install datasets
  
   
   
  
   
   
  1

  自然语言处理

  www.youtube-nocookie.com/embed/Yffk5aydLzg

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

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

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

  >>> from transformers import AutoTokenizer
  

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

  • 1
  • 2
  • 3

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

  >>> 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]}
  
   
   
  
   
   
  1
  2
  3
  4
  5

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

  • 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]'
  
   
   
  
   
   
  1
  2

  正如您所看到的，分词器添加了两个特殊标记 - 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]]}
  
   
   
  
   
   
  
    
    
   
   
   
   
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16

  填充

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

  将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]]}
  
   
   
  
   
   
  
    
    
   
   
   
   
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16

  第一句和第三句现在用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]]}
  
   
   
  
   
   
  
    
    
   
   
   
   
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16

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

  构建张量

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

  将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,