文档分为五个部分:
下表表示库中对这些模型的当前支持,它们是否有 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 | ✅ | ❌ | ❌ |
快速上手 🤗 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 上共享该模型,以使机器学习民主化!🤗
www.youtube-nocookie.com/embed/AhChOFRegn4
在幕后,AutoModelForSequenceClassification 和 AutoTokenizer 类共同驱动您上面使用的 pipeline()。AutoClass 是一个快捷方式,可以根据预训练模型的名称或路径自动检索架构。您只需要为您的任务选择适当的AutoClass
及其关联的预处理类。
让我们回到前一节的示例,看看如何使用AutoClass
来复制 pipeline()的结果。
分词器负责将文本预处理为输入模型的数字数组。有多个规则管理标记化过程,包括如何拆分单词以及单词应该在什么级别拆分(在分词器摘要中了解更多关于分词的信息)。最重要的是要记住,您需要使用相同模型名称实例化分词器,以确保您使用与模型预训练时相同的标记化规则。
使用 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]}
分词器返回一个包含的字典:
分词器还可以接受输入列表,并填充和截断文本以返回具有统一长度的批处理:
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 预处理图像、音频和多模态输入的更多详细信息。
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)
查看创建自定义架构指南,了解有关构建自定义配置的更多信息。
所有模型都是标准的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 进行子类化。
所有模型都是标准的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 核心概念感兴趣,请拿杯咖啡,看看我们的概念指南!
为您正在使用的任何深度学习库安装🤗 Transformers,设置您的缓存,并可选择配置🤗 Transformers 以离线运行。
🤗 Transformers 在 Python 3.6+、PyTorch 1.1.0+、TensorFlow 2.0+和 Flax 上进行了测试。按照下面的安装说明为您正在使用的深度学习库安装:
您应该在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:
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-forge
安装:
conda install conda-forge::transformers
预训练模型将被下载并在~/.cache/huggingface/hub
中本地缓存。这是由 shell 环境变量TRANSFORMERS_CACHE
给出的默认目录。在 Windows 上,默认目录由C:\Users\username\.cache\huggingface\hub
给出。您可以更改下面显示的 shell 环境变量 - 以优先顺序列出 - 以指定不同的缓存目录:
HUGGINGFACE_HUB_CACHE
或TRANSFORMERS_CACHE
。
HF_HOME
。
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()进行自动语音识别(ASR)或语音转文本为例。
>>> from transformers import pipeline
>>> transcriber = pipeline(task="automatic-speech-recognition")
>>> 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 服务器中使用管道:文档中的:
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)
创建推理引擎是一个复杂的主题,值得有自己的页面。
链接
对于视觉任务使用 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!
原文链接:
huggingface.co/docs/transformers/v4.37.2/en/autoclass_tutorial
由于有这么多不同的 Transformer 架构,为您的检查点创建一个可能是具有挑战性的。作为🤗 Transformers 核心理念的一部分,使库易于使用、简单灵活,AutoClass
会自动推断并从给定的检查点加载正确的架构。from_pretrained()
方法让您快速加载任何架构的预训练模型,这样您就不必花时间和资源从头开始训练模型。生成这种与检查点无关的代码意味着,如果您的代码适用于一个检查点,它将适用于另一个检查点 - 只要它是为类似任务训练的 - 即使架构不同。
请记住,架构指的是模型的骨架,检查点是给定架构的权重。例如,BERT是一个架构,而bert-base-uncased
是一个检查点。模型是一个通用术语,可以指代架构或检查点。
在本教程中,学习:
几乎每个 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]}
对于视觉任务,图像处理器将图像处理成正确的输入格式。
>>> from transformers import AutoImageProcessor
>>> image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224")
对于音频任务,特征提取器将音频信号处理成正确的输入格式。
使用 AutoFeatureExtractor.from_pretrained()加载一个特征提取器:
>>> from transformers import AutoFeatureExtractor
>>> feature_extractor = AutoFeatureExtractor.from_pretrained(
... "ehcalabres/wav2vec2-lg-xlsr-en-speech-emotion-recognition"
... )
多模态任务需要一个结合两种预处理工具的处理器。例如,LayoutLMV2 模型需要一个图像处理器来处理图像,一个分词器来处理文本;处理器将两者结合起来。
使用 AutoProcessor.from_pretrained()加载一个处理器:
>>> from transformers import AutoProcessor
>>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv2-base-uncased")
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
允许您将预训练模型用作骨干,并从模型的不同阶段获得特征图作为输出。下面您可以看到如何从 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 提供了一组预处理类来帮助准备数据供模型使用。在本教程中,您将了解到:
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
返回您的输入:
>>> 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 采样的语音音频上进行预训练的。重要的是,您的音频数据的采样率要与用于预训练模型的数据集的采样率匹配。如果您的数据采样率不同,则需要对数据进行重新采样。
>>> 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
值。
>>> 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。现在您可以将处理过的数据集传递给模型了!
使用预训练模型有很多好处。它可以减少计算成本、减少碳足迹,并且可以让您使用最先进的模型,而无需从头开始训练。🤗 Transformers 提供了数千个预训练模型,适用于各种任务。当您使用预训练模型时,您需要在特定于您任务的数据集上对其进行训练。这被称为微调,是一种非常强大的训练技术。在本教程中,您将使用您选择的深度学习框架对预训练模型进行微调:
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
🤗 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(
... 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 API 在 TensorFlow 中训练🤗 Transformers 模型!
当您想要使用 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
流水线,但我们有两种方便的方法来做到这一点:
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)
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
,这样您就可以迭代处理数据批次:
>>> 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()
有关更多微调示例,请参考:
创建一个优化器和学习率调度程序来微调模型。让我们使用 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()