Transformers 4.37 中文文档（四）（4）-阿里云开发者社区

Transformers 4.37 中文文档（四）（3）https://developer.aliyun.com/article/1564978

评估

在训练过程中包含一个度量标准通常有助于评估模型的性能。您可以使用🤗 Evaluate库快速加载一个评估方法。对于这个任务，加载mean Intersection over Union (IoU)度量标准（查看🤗 Evaluate quick tour以了解如何加载和计算度量标准）：

>>> import evaluate
>>> metric = evaluate.load("mean_iou")

然后创建一个函数来compute度量标准。您的预测需要首先转换为 logits，然后重新调整形状以匹配标签的大小，然后才能调用compute：

PytorchHide Pytorch 内容

>>> import numpy as np
>>> import torch
>>> from torch import nn
>>> def compute_metrics(eval_pred):
...     with torch.no_grad():
...         logits, labels = eval_pred
...         logits_tensor = torch.from_numpy(logits)
...         logits_tensor = nn.functional.interpolate(
...             logits_tensor,
...             size=labels.shape[-2:],
...             mode="bilinear",
...             align_corners=False,
...         ).argmax(dim=1)
...         pred_labels = logits_tensor.detach().cpu().numpy()
...         metrics = metric.compute(
...             predictions=pred_labels,
...             references=labels,
...             num_labels=num_labels,
...             ignore_index=255,
...             reduce_labels=False,
...         )
...         for key, value in metrics.items():
...             if isinstance(value, np.ndarray):
...                 metrics[key] = value.tolist()
...         return metrics

TensorFlowHide TensorFlow 内容

>>> def compute_metrics(eval_pred):
...     logits, labels = eval_pred
...     logits = tf.transpose(logits, perm=[0, 2, 3, 1])
...     logits_resized = tf.image.resize(
...         logits,
...         size=tf.shape(labels)[1:],
...         method="bilinear",
...     )
...     pred_labels = tf.argmax(logits_resized, axis=-1)
...     metrics = metric.compute(
...         predictions=pred_labels,
...         references=labels,
...         num_labels=num_labels,
...         ignore_index=-1,
...         reduce_labels=image_processor.do_reduce_labels,
...     )
...     per_category_accuracy = metrics.pop("per_category_accuracy").tolist()
...     per_category_iou = metrics.pop("per_category_iou").tolist()
...     metrics.update({f"accuracy_{id2label[i]}": v for i, v in enumerate(per_category_accuracy)})
...     metrics.update({f"iou_{id2label[i]}": v for i, v in enumerate(per_category_iou)})
...     return {"val_" + k: v for k, v in metrics.items()}

您的compute_metrics函数现在已经准备就绪，当您设置训练时会再次用到它。

训练

PytorchHide Pytorch 内容

如果您不熟悉如何使用 Trainer 对模型进行微调，请查看这里的基本教程[…/training#finetune-with-trainer]！

您现在已经准备好开始训练您的模型了！使用 AutoModelForSemanticSegmentation 加载 SegFormer，并将模型传递给标签 id 和标签类之间的映射：

>>> from transformers import AutoModelForSemanticSegmentation, TrainingArguments, Trainer
>>> model = AutoModelForSemanticSegmentation.from_pretrained(checkpoint, id2label=id2label, label2id=label2id)

目前只剩下三个步骤：

在 TrainingArguments 中定义您的训练超参数。重要的是不要删除未使用的列，因为这会删除image列。没有image列，您就无法创建pixel_values。设置remove_unused_columns=False以防止这种行为！另一个必需的参数是output_dir，指定保存模型的位置。通过设置push_to_hub=True将此模型推送到 Hub（您需要登录 Hugging Face 才能上传您的模型）。在每个 epoch 结束时，Trainer 将评估 IoU 度量标准并保存训练检查点。
将训练参数传递给 Trainer，同时还需要传递模型、数据集、分词器、数据整理器和compute_metrics函数。
调用 train()来微调您的模型。

>>> training_args = TrainingArguments(
...     output_dir="segformer-b0-scene-parse-150",
...     learning_rate=6e-5,
...     num_train_epochs=50,
...     per_device_train_batch_size=2,
...     per_device_eval_batch_size=2,
...     save_total_limit=3,
...     evaluation_strategy="steps",
...     save_strategy="steps",
...     save_steps=20,
...     eval_steps=20,
...     logging_steps=1,
...     eval_accumulation_steps=5,
...     remove_unused_columns=False,
...     push_to_hub=True,
... )
>>> trainer = Trainer(
...     model=model,
...     args=training_args,
...     train_dataset=train_ds,
...     eval_dataset=test_ds,
...     compute_metrics=compute_metrics,
... )
>>> trainer.train()

训练完成后，使用 push_to_hub()方法将您的模型共享到 Hub，这样每个人都可以使用您的模型：

>>> trainer.push_to_hub()

TensorFlowHide TensorFlow 内容

如果您不熟悉使用 Keras 进行模型微调，请先查看基本教程！

要在 TensorFlow 中微调模型，请按照以下步骤进行：

定义训练超参数，并设置优化器和学习率调度。
实例化一个预训练模型。
将一个🤗数据集转换为tf.data.Dataset。
编译您的模型。
添加回调以计算指标并将您的模型上传到🤗 Hub
使用fit()方法运行训练。

首先定义超参数、优化器和学习率调度：

>>> from transformers import create_optimizer
>>> batch_size = 2
>>> num_epochs = 50
>>> num_train_steps = len(train_ds) * num_epochs
>>> learning_rate = 6e-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,
... )

然后，使用 TFAutoModelForSemanticSegmentation 加载 SegFormer 以及标签映射，并使用优化器对其进行编译。请注意，Transformers 模型都有一个默认的与任务相关的损失函数，因此除非您想要指定一个，否则不需要指定：

>>> from transformers import TFAutoModelForSemanticSegmentation
>>> model = TFAutoModelForSemanticSegmentation.from_pretrained(
...     checkpoint,
...     id2label=id2label,
...     label2id=label2id,
... )
>>> model.compile(optimizer=optimizer)  # No loss argument!

使用to_tf_dataset和 DefaultDataCollator 将您的数据集转换为tf.data.Dataset格式：

>>> from transformers import DefaultDataCollator
>>> data_collator = DefaultDataCollator(return_tensors="tf")
>>> tf_train_dataset = train_ds.to_tf_dataset(
...     columns=["pixel_values", "label"],
...     shuffle=True,
...     batch_size=batch_size,
...     collate_fn=data_collator,
... )
>>> tf_eval_dataset = test_ds.to_tf_dataset(
...     columns=["pixel_values", "label"],
...     shuffle=True,
...     batch_size=batch_size,
...     collate_fn=data_collator,
... )

要从预测中计算准确率并将您的模型推送到🤗 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, batch_size=batch_size, label_cols=["labels"]
... )
>>> push_to_hub_callback = PushToHubCallback(output_dir="scene_segmentation", tokenizer=image_processor)
>>> callbacks = [metric_callback, push_to_hub_callback]

最后，您已经准备好训练您的模型了！使用您的训练和验证数据集、时代数量和回调来调用fit()来微调模型：

>>> model.fit(
...     tf_train_dataset,
...     validation_data=tf_eval_dataset,
...     callbacks=callbacks,
...     epochs=num_epochs,
... )

恭喜！您已经对模型进行了微调并在🤗 Hub 上分享了它。现在您可以用它进行推理！

推理

很好，现在您已经对模型进行了微调，可以用它进行推理！

加载一张图片进行推理：

>>> image = ds[0]["image"]
>>> image

Pytorch 隐藏 Pytorch 内容

现在我们将看到如何在没有管道的情况下进行推理。使用图像处理器处理图像，并将pixel_values放在 GPU 上：

>>> device = torch.device("cuda" if torch.cuda.is_available() else "cpu")  # use GPU if available, otherwise use a CPU
>>> encoding = image_processor(image, return_tensors="pt")
>>> pixel_values = encoding.pixel_values.to(device)

将输入传递给模型并返回logits：

>>> outputs = model(pixel_values=pixel_values)
>>> logits = outputs.logits.cpu()

接下来，将 logits 重新缩放到原始图像大小：

>>> upsampled_logits = nn.functional.interpolate(
...     logits,
...     size=image.size[::-1],
...     mode="bilinear",
...     align_corners=False,
... )
>>> pred_seg = upsampled_logits.argmax(dim=1)[0]

TensorFlow 隐藏 TensorFlow 内容

加载一个图像处理器来预处理图像并将输入返回为 TensorFlow 张量：

>>> from transformers import AutoImageProcessor
>>> image_processor = AutoImageProcessor.from_pretrained("MariaK/scene_segmentation")
>>> inputs = image_processor(image, return_tensors="tf")

将输入传递给模型并返回logits：

>>> from transformers import TFAutoModelForSemanticSegmentation
>>> model = TFAutoModelForSemanticSegmentation.from_pretrained("MariaK/scene_segmentation")
>>> logits = model(**inputs).logits

接下来，将 logits 重新缩放到原始图像大小，并在类维度上应用 argmax：

>>> logits = tf.transpose(logits, [0, 2, 3, 1])
>>> upsampled_logits = tf.image.resize(
...     logits,
...     # We reverse the shape of `image` because `image.size` returns width and height.
...     image.size[::-1],
... )
>>> pred_seg = tf.math.argmax(upsampled_logits, axis=-1)[0]

要可视化结果，加载数据集颜色调色板作为ade_palette()，将每个类映射到它们的 RGB 值。然后您可以组合并绘制您的图像和预测的分割地图：

>>> import matplotlib.pyplot as plt
>>> import numpy as np
>>> color_seg = np.zeros((pred_seg.shape[0], pred_seg.shape[1], 3), dtype=np.uint8)
>>> palette = np.array(ade_palette())
>>> for label, color in enumerate(palette):
...     color_seg[pred_seg == label, :] = color
>>> color_seg = color_seg[..., ::-1]  # convert to BGR
>>> img = np.array(image) * 0.5 + color_seg * 0.5  # plot the image with the segmentation map
>>> img = img.astype(np.uint8)
>>> plt.figure(figsize=(15, 10))
>>> plt.imshow(img)
>>> plt.show()

视频分类

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

视频分类是将标签或类别分配给整个视频的任务。预期每个视频只有一个类别。视频分类模型将视频作为输入，并返回关于视频属于哪个类别的预测。这些模型可用于对视频内容进行分类。视频分类的现实应用是动作/活动识别，对于健身应用非常有用。对于视力受损的个体，尤其是在通勤时，这也是有帮助的。

本指南将向您展示如何：

在UCF101数据集的子集上对VideoMAE进行微调。
使用您微调的模型进行推断。

本教程中所示的任务由以下模型架构支持：

TimeSformer, VideoMAE, ViViT

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

pip install -q pytorchvideo transformers evaluate

您将使用PyTorchVideo（称为pytorchvideo）来处理和准备视频。

我们鼓励您登录您的 Hugging Face 帐户，这样您就可以上传和与社区分享您的模型。提示时，请输入您的令牌以登录：

>>> from huggingface_hub import notebook_login
>>> notebook_login()

加载 UCF101 数据集

首先加载UCF-101 数据集的子集。这将让您有机会进行实验，并确保一切正常，然后再花更多时间在完整数据集上进行训练。

>>> from huggingface_hub import hf_hub_download
>>> hf_dataset_identifier = "sayakpaul/ucf101-subset"
>>> filename = "UCF101_subset.tar.gz"
>>> file_path = hf_hub_download(repo_id=hf_dataset_identifier, filename=filename, repo_type="dataset")

在下载子集后，您需要提取压缩存档：

>>> import tarfile
>>> with tarfile.open(file_path) as t:
...      t.extractall(".")

在高层次上，数据集的组织方式如下：

UCF101_subset/
    train/
        BandMarching/
            video_1.mp4
            video_2.mp4
            ...
        Archery
            video_1.mp4
            video_2.mp4
            ...
        ...
    val/
        BandMarching/
            video_1.mp4
            video_2.mp4
            ...
        Archery
            video_1.mp4
            video_2.mp4
            ...
        ...
    test/
        BandMarching/
            video_1.mp4
            video_2.mp4
            ...
        Archery
            video_1.mp4
            video_2.mp4
            ...
        ...

（排序后的）视频路径看起来像这样：

...
'UCF101_subset/train/ApplyEyeMakeup/v_ApplyEyeMakeup_g07_c04.avi',
'UCF101_subset/train/ApplyEyeMakeup/v_ApplyEyeMakeup_g07_c06.avi',
'UCF101_subset/train/ApplyEyeMakeup/v_ApplyEyeMakeup_g08_c01.avi',
'UCF101_subset/train/ApplyEyeMakeup/v_ApplyEyeMakeup_g09_c02.avi',
'UCF101_subset/train/ApplyEyeMakeup/v_ApplyEyeMakeup_g09_c06.avi'
...

您会注意到有属于同一组/场景的视频片段，其中组在视频文件路径中用g表示。例如，v_ApplyEyeMakeup_g07_c04.avi和v_ApplyEyeMakeup_g07_c06.avi。

对于验证和评估拆分，您不希望从同一组/场景中获取视频片段，以防止数据泄漏。本教程中使用的子集考虑了这些信息。

接下来，您将推导数据集中存在的标签集。还要创建两个在初始化模型时有用的字典：

label2id：将类名映射到整数。
id2label：将整数映射到类名。

>>> class_labels = sorted({str(path).split("/")[2] for path in all_video_file_paths})
>>> label2id = {label: i for i, label in enumerate(class_labels)}
>>> id2label = {i: label for label, i in label2id.items()}
>>> print(f"Unique classes: {list(label2id.keys())}.")
# Unique classes: ['ApplyEyeMakeup', 'ApplyLipstick', 'Archery', 'BabyCrawling', 'BalanceBeam', 'BandMarching', 'BaseballPitch', 'Basketball', 'BasketballDunk', 'BenchPress'].

有 10 个独特的类别。每个类别在训练集中有 30 个视频。

Transformers 4.37 中文文档（四）（5）https://developer.aliyun.com/article/1564980

Transformers 4.37 中文文档（四）（4）

评估

训练

推理

视频分类

加载 UCF101 数据集

热门文章

最新文章

相关电子书

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

训练营

直播

乘风者计划

下载

镜像站

技术资料

Transformers 4.37 中文文档（四）（4）

评估

训练

推理

视频分类

加载 UCF101 数据集

热门文章

最新文章

相关电子书