Transformers 4.37 中文文档（四）（1）https://developer.aliyun.com/article/1564976
推理
很好，现在您已经微调了一个模型，可以用它进行推理！
加载要运行推理的音频文件。记得重新采样音频文件的采样率以匹配模型的采样率（如果需要的话）！
>>> from datasets import load_dataset, Audio >>> dataset = load_dataset("PolyAI/minds14", "en-US", split="train") >>> dataset = dataset.cast_column("audio", Audio(sampling_rate=16000)) >>> sampling_rate = dataset.features["audio"].sampling_rate >>> audio_file = dataset[0]["audio"]["path"]
尝试使用 pipeline()来进行推理是尝试您微调模型的最简单方法。使用您的模型实例化一个用于自动语音识别的pipeline，并将音频文件传递给它：
>>> from transformers import pipeline >>> transcriber = pipeline("automatic-speech-recognition", model="stevhliu/my_awesome_asr_minds_model") >>> transcriber(audio_file) {'text': 'I WOUD LIKE O SET UP JOINT ACOUNT WTH Y PARTNER'}
转录结果还不错，但可以更好！尝试在更多示例上微调您的模型，以获得更好的结果！
如果您愿意，也可以手动复制pipeline的结果：
Pytorch 隐藏 Pytorch 内容
加载处理器以预处理音频文件和转录，并将input返回为 PyTorch 张量：
>>> from transformers import AutoProcessor >>> processor = AutoProcessor.from_pretrained("stevhliu/my_awesome_asr_mind_model") >>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
将您的输入传递给模型并返回 logits：
>>> from transformers import AutoModelForCTC >>> model = AutoModelForCTC.from_pretrained("stevhliu/my_awesome_asr_mind_model") >>> with torch.no_grad(): ... logits = model(**inputs).logits
获取具有最高概率的预测input_ids，并使用处理器将预测的input_ids解码回文本：
>>> import torch >>> predicted_ids = torch.argmax(logits, dim=-1) >>> transcription = processor.batch_decode(predicted_ids) >>> transcription ['I WOUL LIKE O SET UP JOINT ACOUNT WTH Y PARTNER']
计算机视觉
图像分类
原始文本：
huggingface.co/docs/transformers/v4.37.2/en/tasks/image_classification
www.youtube-nocookie.com/embed/tjAIM7BOYhw
图像分类为图像分配一个标签或类别。与文本或音频分类不同，输入是组成图像的像素值。图像分类有许多应用，例如在自然灾害后检测损坏、监测作物健康或帮助筛查医学图像中的疾病迹象。
本指南说明了如何：
- 在Food-101数据集上对 ViT 进行微调，以对图像中的食物项目进行分类。
- 使用您微调的模型进行推断。
本教程中所示的任务由以下模型架构支持：
BEiT、BiT、ConvNeXT、ConvNeXTV2、CvT、Data2VecVision、DeiT、DiNAT、DINOv2、EfficientFormer、EfficientNet、FocalNet、ImageGPT、LeViT、MobileNetV1、MobileNetV2、MobileViT、MobileViTV2、NAT、Perceiver、PoolFormer、PVT、RegNet、ResNet、SegFormer、SwiftFormer、Swin Transformer、Swin Transformer V2、VAN、ViT、ViT Hybrid、ViTMSN
在开始之前，请确保您已安装所有必要的库：
pip install transformers datasets evaluate
我们鼓励您登录您的 Hugging Face 帐户，以便上传和与社区分享您的模型。在提示时，输入您的令牌以登录：
>>> from huggingface_hub import notebook_login >>> notebook_login()
加载 Food-101 数据集
首先从🤗数据集库中加载 Food-101 数据集的一个较小子集。这将让您有机会进行实验，并确保一切正常，然后再花更多时间在完整数据集上进行训练。
>>> from datasets import load_dataset >>> food = load_dataset("food101", split="train[:5000]")
使用train_test_split方法将数据集的train拆分为训练集和测试集：
>>> food = food.train_test_split(test_size=0.2)
然后看一个示例：
>>> food["train"][0] {'image': <PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=512x512 at 0x7F52AFC8AC50>, 'label': 79}
数据集中的每个示例都有两个字段：
image：食物项目的 PIL 图像label：食物项目的标签类别
为了使模型更容易从标签 ID 获取标签名称，创建一个将标签名称映射到整数及反之的字典：
>>> labels = food["train"].features["label"].names >>> label2id, id2label = dict(), dict() >>> for i, label in enumerate(labels): ... label2id[label] = str(i) ... id2label[str(i)] = label
现在您可以将标签 ID 转换为标签名称：
>>> id2label[str(79)] 'prime_rib'
预处理
下一步是加载一个 ViT 图像处理器，将图像处理为张量：
>>> from transformers import AutoImageProcessor >>> checkpoint = "google/vit-base-patch16-224-in21k" >>> image_processor = AutoImageProcessor.from_pretrained(checkpoint)
PytorchHide Pytorch content
对图像应用一些图像转换，使模型更具抗过拟合能力。在这里，您将使用 torchvision 的transforms模块，但您也可以使用您喜欢的任何图像库。
裁剪图像的随机部分，调整大小，并使用图像的均值和标准差进行归一化：
>>> from torchvision.transforms import RandomResizedCrop, Compose, Normalize, ToTensor >>> normalize = Normalize(mean=image_processor.image_mean, std=image_processor.image_std) >>> 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), ToTensor(), normalize])
然后创建一个预处理函数来应用转换并返回pixel_values - 图像的模型输入：
>>> def transforms(examples): ... examples["pixel_values"] = [_transforms(img.convert("RGB")) for img in examples["image"]] ... del examples["image"] ... return examples
要在整个数据集上应用预处理函数，请使用🤗数据集的with_transform方法。当加载数据集的元素时，转换会即时应用：
>>> food = food.with_transform(transforms)
现在使用 DefaultDataCollator 创建一批示例。与🤗 Transformers 中的其他数据整理器不同，DefaultDataCollator不会应用额外的预处理，如填充。
>>> from transformers import DefaultDataCollator >>> data_collator = DefaultDataCollator()
TensorFlow 隐藏 TensorFlow 内容
为了避免过拟合并使模型更加健壮，在数据集的训练部分添加一些数据增强。在这里，我们使用 Keras 预处理层来定义训练数据（包括数据增强）的转换，以及验证数据（仅中心裁剪、调整大小和归一化）的转换。您可以使用tf.image或您喜欢的任何其他库。
>>> from tensorflow import keras >>> from tensorflow.keras import layers >>> size = (image_processor.size["height"], image_processor.size["width"]) >>> train_data_augmentation = keras.Sequential( ... [ ... layers.RandomCrop(size[0], size[1]), ... layers.Rescaling(scale=1.0 / 127.5, offset=-1), ... layers.RandomFlip("horizontal"), ... layers.RandomRotation(factor=0.02), ... layers.RandomZoom(height_factor=0.2, width_factor=0.2), ... ], ... name="train_data_augmentation", ... ) >>> val_data_augmentation = keras.Sequential( ... [ ... layers.CenterCrop(size[0], size[1]), ... layers.Rescaling(scale=1.0 / 127.5, offset=-1), ... ], ... name="val_data_augmentation", ... )
接下来，创建函数将适当的转换应用于一批图像，而不是一次一个图像。
>>> import numpy as np >>> import tensorflow as tf >>> from PIL import Image >>> def convert_to_tf_tensor(image: Image): ... np_image = np.array(image) ... tf_image = tf.convert_to_tensor(np_image) ... # `expand_dims()` is used to add a batch dimension since ... # the TF augmentation layers operates on batched inputs. ... return tf.expand_dims(tf_image, 0) >>> def preprocess_train(example_batch): ... """Apply train_transforms across a batch.""" ... images = [ ... train_data_augmentation(convert_to_tf_tensor(image.convert("RGB"))) for image in example_batch["image"] ... ] ... example_batch["pixel_values"] = [tf.transpose(tf.squeeze(image)) for image in images] ... return example_batch ... def preprocess_val(example_batch): ... """Apply val_transforms across a batch.""" ... images = [ ... val_data_augmentation(convert_to_tf_tensor(image.convert("RGB"))) for image in example_batch["image"] ... ] ... example_batch["pixel_values"] = [tf.transpose(tf.squeeze(image)) for image in images] ... return example_batch
使用🤗 Datasets set_transform在运行时应用转换：
food["train"].set_transform(preprocess_train) food["test"].set_transform(preprocess_val)
作为最后的预处理步骤，使用DefaultDataCollator创建一批示例。与🤗 Transformers 中的其他数据整理器不同，DefaultDataCollator不会应用额外的预处理，如填充。
>>> from transformers import DefaultDataCollator >>> data_collator = DefaultDataCollator(return_tensors="tf")
评估
在训练过程中包含一个度量通常有助于评估模型的性能。您可以使用🤗 Evaluate库快速加载评估方法。对于此任务，加载accuracy度量（查看🤗 Evaluate 快速导览以了解如何加载和计算度量）：
>>> import evaluate >>> accuracy = evaluate.load("accuracy")
然后创建一个函数，将您的预测和标签传递给compute以计算准确性：
>>> import numpy as np >>> def compute_metrics(eval_pred): ... predictions, labels = eval_pred ... predictions = np.argmax(predictions, axis=1) ... return accuracy.compute(predictions=predictions, references=labels)
您的compute_metrics函数现在已经准备就绪，当您设置训练时会返回到它。
训练
Pytorch 隐藏 Pytorch 内容
如果您不熟悉使用 Trainer 对模型进行微调，请查看基本教程这里！
现在您可以开始训练您的模型了！使用 AutoModelForImageClassification 加载 ViT。指定标签数量以及预期标签数量和标签映射：
>>> from transformers import AutoModelForImageClassification, TrainingArguments, Trainer >>> model = AutoModelForImageClassification.from_pretrained( ... checkpoint, ... num_labels=len(labels), ... id2label=id2label, ... label2id=label2id, ... )
在这一点上，只剩下三个步骤：
- 在 TrainingArguments 中定义您的训练超参数。重要的是不要删除未使用的列，因为那会删除
image列。没有image列，您就无法创建pixel_values。设置remove_unused_columns=False以防止这种行为！唯一的其他必需参数是output_dir，指定保存模型的位置。通过设置push_to_hub=True将此模型推送到 Hub（您需要登录 Hugging Face 才能上传您的模型）。在每个 epoch 结束时，Trainer 将评估准确性并保存训练检查点。 - 将训练参数传递给 Trainer，以及模型、数据集、分词器、数据整理器和
compute_metrics函数。 - 调用 train()来微调您的模型。
>>> training_args = TrainingArguments( ... output_dir="my_awesome_food_model", ... remove_unused_columns=False, ... evaluation_strategy="epoch", ... save_strategy="epoch", ... learning_rate=5e-5, ... per_device_train_batch_size=16, ... gradient_accumulation_steps=4, ... per_device_eval_batch_size=16, ... num_train_epochs=3, ... warmup_ratio=0.1, ... logging_steps=10, ... load_best_model_at_end=True, ... metric_for_best_model="accuracy", ... push_to_hub=True, ... ) >>> trainer = Trainer( ... model=model, ... args=training_args, ... data_collator=data_collator, ... train_dataset=food["train"], ... eval_dataset=food["test"], ... tokenizer=image_processor, ... compute_metrics=compute_metrics, ... ) >>> trainer.train()
训练完成后，使用 push_to_hub()方法将您的模型共享到 Hub，这样每个人都可以使用您的模型：
>>> trainer.push_to_hub()
TensorFlow 隐藏 TensorFlow 内容
如果您不熟悉使用 Keras 微调模型，请先查看基本教程！
要在 TensorFlow 中微调模型，请按照以下步骤进行：
- 定义训练超参数，并设置优化器和学习率调度。
- 实例化一个预训练模型。
- 将🤗数据集转换为
tf.data.Dataset。 - 编译您的模型。
- 添加回调并使用
fit()方法运行训练。 - 将您的模型上传到🤗 Hub 以与社区共享。
首先定义超参数、优化器和学习率调度：
>>> from transformers import create_optimizer >>> batch_size = 16 >>> num_epochs = 5 >>> num_train_steps = len(food["train"]) * num_epochs >>> learning_rate = 3e-5 >>> weight_decay_rate = 0.01 >>> optimizer, lr_schedule = create_optimizer( ... init_lr=learning_rate, ... num_train_steps=num_train_steps, ... weight_decay_rate=weight_decay_rate, ... num_warmup_steps=0, ... )
然后，使用 TFAutoModelForImageClassification 加载 ViT 以及标签映射：
>>> from transformers import TFAutoModelForImageClassification >>> model = TFAutoModelForImageClassification.from_pretrained( ... checkpoint, ... id2label=id2label, ... label2id=label2id, ... )
使用to_tf_dataset和您的data_collator将数据集转换为tf.data.Dataset格式：
>>> # converting our train dataset to tf.data.Dataset >>> tf_train_dataset = food["train"].to_tf_dataset( ... columns="pixel_values", label_cols="label", shuffle=True, batch_size=batch_size, collate_fn=data_collator ... ) >>> # converting our test dataset to tf.data.Dataset >>> tf_eval_dataset = food["test"].to_tf_dataset( ... columns="pixel_values", label_cols="label", shuffle=True, batch_size=batch_size, collate_fn=data_collator ... )
使用compile()配置模型进行训练：
>>> from tensorflow.keras.losses import SparseCategoricalCrossentropy >>> loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) >>> model.compile(optimizer=optimizer, loss=loss)
要从预测中计算准确性并将模型推送到🤗 Hub，请使用 Keras 回调。将您的compute_metrics函数传递给 KerasMetricCallback，并使用 PushToHubCallback 上传模型：
>>> from transformers.keras_callbacks import KerasMetricCallback, PushToHubCallback >>> metric_callback = KerasMetricCallback(metric_fn=compute_metrics, eval_dataset=tf_eval_dataset) >>> push_to_hub_callback = PushToHubCallback( ... output_dir="food_classifier", ... tokenizer=image_processor, ... save_strategy="no", ... ) >>> callbacks = [metric_callback, push_to_hub_callback]
最后，您已经准备好训练您的模型了！使用您的训练和验证数据集、时代数和回调来微调模型调用fit()：
>>> model.fit(tf_train_dataset, validation_data=tf_eval_dataset, epochs=num_epochs, callbacks=callbacks) Epoch 1/5 250/250 [==============================] - 313s 1s/step - loss: 2.5623 - val_loss: 1.4161 - accuracy: 0.9290 Epoch 2/5 250/250 [==============================] - 265s 1s/step - loss: 0.9181 - val_loss: 0.6808 - accuracy: 0.9690 Epoch 3/5 250/250 [==============================] - 252s 1s/step - loss: 0.3910 - val_loss: 0.4303 - accuracy: 0.9820 Epoch 4/5 250/250 [==============================] - 251s 1s/step - loss: 0.2028 - val_loss: 0.3191 - accuracy: 0.9900 Epoch 5/5 250/250 [==============================] - 238s 949ms/step - loss: 0.1232 - val_loss: 0.3259 - accuracy: 0.9890
恭喜！您已经对模型进行了微调，并在🤗 Hub 上共享。现在您可以用它进行推理！
要了解如何为图像分类微调模型的更深入示例，请查看相应的PyTorch 笔记本。
推理
太棒了，现在您已经对模型进行了微调，可以用于推理！
加载要运行推理的图像：
>>> ds = load_dataset("food101", split="validation[:10]") >>> image = ds["image"][0]
尝试使用您微调的模型进行推理的最简单方法是在 pipeline()中使用它。使用您的模型实例化一个用于图像分类的pipeline，并将图像传递给它：
>>> from transformers import pipeline >>> classifier = pipeline("image-classification", model="my_awesome_food_model") >>> classifier(image) [{'score': 0.31856709718704224, 'label': 'beignets'}, {'score': 0.015232225880026817, 'label': 'bruschetta'}, {'score': 0.01519392803311348, 'label': 'chicken_wings'}, {'score': 0.013022331520915031, 'label': 'pork_chop'}, {'score': 0.012728818692266941, 'label': 'prime_rib'}]
如果愿意，您也可以手动复制pipeline的结果：
PytorchHide Pytorch 内容
加载图像处理器以预处理图像并将input返回为 PyTorch 张量：
>>> from transformers import AutoImageProcessor >>> import torch >>> image_processor = AutoImageProcessor.from_pretrained("my_awesome_food_model") >>> inputs = image_processor(image, return_tensors="pt")
将输入传递给模型并返回 logits：
>>> from transformers import AutoModelForImageClassification >>> model = AutoModelForImageClassification.from_pretrained("my_awesome_food_model") >>> with torch.no_grad(): ... logits = model(**inputs).logits
获取具有最高概率的预测标签，并使用模型的id2label映射将其转换为标签：
>>> predicted_label = logits.argmax(-1).item() >>> model.config.id2label[predicted_label] 'beignets'
TensorFlowHide TensorFlow 内容
加载图像处理器以预处理图像并将input返回为 TensorFlow 张量：
>>> from transformers import AutoImageProcessor >>> image_processor = AutoImageProcessor.from_pretrained("MariaK/food_classifier") >>> inputs = image_processor(image, return_tensors="tf")
将输入传递给模型并返回 logits：
>>> from transformers import TFAutoModelForImageClassification >>> model = TFAutoModelForImageClassification.from_pretrained("MariaK/food_classifier") >>> logits = model(**inputs).logits
获取具有最高概率的预测标签，并使用模型的id2label映射将其转换为标签：
>>> predicted_class_id = int(tf.math.argmax(logits, axis=-1)[0]) >>> model.config.id2label[predicted_class_id] 'beignets'
Transformers 4.37 中文文档（四）（3）https://developer.aliyun.com/article/1564978
