抱抱脸（hugging face）教程-中文翻译-预处理

2023-11-09

预处理

在您可以在模型中使用数据之前，需要将数据处理为模型可接受的格式。模型不理解原始文本、图像或音频。这些输入需要转换成数字并组装成张量。在本教程中，您将:

用tokenizer处理文本.
用特征提取器对图像或音频数据进行预处理。
使用处理器预处理多通道任务的数据。

自然语言处理

处理文本数据的主要工具是tokenizer。tokenizer首先根据一组规则将文本分割为tokens。令牌被转换成数字，用于构建张量作为模型的输入。模型所需的任何额外输入也由tokenizer添加。

如果您计划使用预先训练的模型，那么使用相关的预先训练的tokenizer是很重要的。这样可以确保文本按照与预训练语料库相同的方式进行分割，并在预训练期间使用相同的标记到索引(通常作为词汇表的参考)。

通过使用 AutoTokenizer 类加载一个预训练的 tokenizer 来快速启动。这将下载模型预先训练时使用的单词。

Tokenize

利用 AutoTokenizer.from_pretrained() 加载一个预训练的 tokenizer

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

Tokenizer 返回一个字典，其中包含三个重要信息:

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

正如您所看到的，tokenizer 向句子添加了两个特殊的令牌 – CLS 和 SEP (分类器和分隔符)。并非所有模型都需要特殊标记，但如果需要，tokenizer 将自动为您添加它们。

如果有几个句子你需要处理，把这些句子作为一个列表传递给tokenizer:

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

Pad

这就引出了一个重要的话题。当你处理一批句子时，它们的长度并不总是一样的。这是一个问题，因为模型的输入张量需要有一个统一的形状。填充是一种策略，可以通过向具有较少标记的句子添加特殊填充标记来确保张量为矩形。

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

注意 tokenizer 用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]]}

建立张量

最后，您希望 tokenizer 返回输入到模型的实际张量。

将 return_tensors 参数设置为 PyTorch 的 pt 或 TensorFlow 的 tf:

Pytorch

batch_sentences = [
    "But what about second breakfast?",
    "Don't think he knows about second breakfast, Pip.",
    "What about elevensies?",
]
encoded_input = tokenizer(batch, padding=True, truncation=True, return_tensors="pt")
print(encoded_input)
{'input_ids': tensor([[  101,   153,  7719, 21490,  1122,  1114,  9582,  1623,   102],
                      [  101,  5226,  1122,  9649,  1199,  2610,  1236,   102,     0]]), 
 'token_type_ids': tensor([[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, 1],
                           [1, 1, 1, 1, 1, 1, 1, 1, 0]])}

TensorFlow

batch_sentences = [
    "But what about second breakfast?",
    "Don't think he knows about second breakfast, Pip.",
    "What about elevensies?",
]
encoded_input = tokenizer(batch, padding=True, truncation=True, return_tensors="tf")
print(encoded_input)
{'input_ids': <tf.Tensor: shape=(2, 9), dtype=int32, numpy=
array([[  101,   153,  7719, 21490,  1122,  1114,  9582,  1623,   102],
       [  101,  5226,  1122,  9649,  1199,  2610,  1236,   102,     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]], dtype=int32)>, 
 'attention_mask': <tf.Tensor: shape=(2, 9), dtype=int32, numpy=
array([[1, 1, 1, 1, 1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1, 1, 1, 1, 0]], dtype=int32)>}

音频

音频输入的预处理方式与文本输入不同，但最终目标是相同的: 创建模型可以理解的数字序列。设计了一种特征提取器，用于从原始图像或音频数据中提取特征并将其转换为张量。在开始之前，请安装数据集以加载音频数据集进行实验:

pip install datasets

从 SUPERB 基准加载关键词发现任务(有关如何加载数据集的详细信息，请参阅数据集教程) :

from datasets import load_dataset, Audio

dataset = load_dataset("superb", "ks")

访问音频列的第一个元素，查看输入。调用音频列会自动加载并重采样音频文件:

dataset["train"][0]["audio"]
{'array': array([ 0.        ,  0.        ,  0.        , ..., -0.00592041,
        -0.00405884, -0.00253296], dtype=float32),
 'path': '/root/.cache/huggingface/datasets/downloads/extracted/05734a36d88019a09725c20cc024e1c4e7982e37d7d55c0c1ca1742ea1cdd47f/_background_noise_/doing_the_dishes.wav',
 'sampling_rate': 16000}

上述操作返回三个值:

数组是语音信号加载-和潜在的重叠-作为一个一维阵列。
路径指向音频文件的位置。
采样率是指语音信号中每秒测量的数据点数。

重采样

在本教程中，您将使用 wav2vec2模型。正如您可以从模型卡中看到的，wav2vec2模型是根据16khz 的语音采样预先训练的。音频数据的采样率与用于预训练模型的数据集的采样率匹配非常重要。如果数据的采样率不一样，那么您需要对音频数据进行重采样。

例如，加载采样率为22050khz 的 LJ 语音数据集。为了在这个数据集中使用 wav2vec2模型，将采样率下调到16khz:

lj_speech = load_dataset("lj_speech", split="train")
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}

使用 Datasets’cast_column 方法将采样率下调到16khz:

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

加载音频文件:

lj_speech[0]["audio"]
{'array': array([-0.00064146, -0.00074657, -0.00068768, ...,  0.00068341,
         0.00014045,  0.        ], dtype=float32),
 'path': '/root/.cache/huggingface/datasets/downloads/extracted/917ece08c95cf0c4115e45294e3cd0dee724a1165b7fc11798369308a465bd26/LJSpeech-1.1/wavs/LJ001-0001.wav',
 'sampling_rate': 16000}

正如你所看到的，采样率被下调到16khz。现在您已经了解了重取样的工作原理，接下来让我们用 SUPERB 数据集回到前面的例子！

特性提取器

下一步是加载一个特性提取器来规范化和填充输入。在填充文本数据时，会为较短的序列添加0。同样的想法也适用于音频数据，音频特性提取器将添加一个0-解释为沉默-到数组。

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

from transformers import AutoFeatureExtractor

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

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

audio_input = [dataset["train"][0]["audio"]["array"]]
feature_extractor(audio_input, sampling_rate=16000)
{'input_values': [array([ 0.00045439,  0.00045439,  0.00045439, ..., -0.1578519 , -0.10807519, -0.06727459], dtype=float32)]}

填充和截断

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

dataset["train"][0]["audio"]["array"].shape
(1522930,)

dataset["train"][1]["audio"]["array"].shape
(988891,)

如您所见，第一个样本的序列比第二个样本的序列更长。让我们创建一个函数来预处理数据集。指定一个最大的采样长度，特征提取器会将序列平移或截断以匹配它:

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=1000000,
        truncation=True,
    )
    return inputs

对数据集中的前几个例子应用该函数:

processed_dataset = preprocess_function(dataset["train"][:5])

现在再看一下处理过的样本长度:

processed_dataset["input_values"][0].shape
(1000000,)

processed_dataset["input_values"][1].shape
(1000000,)

前两个示例的长度现在匹配您指定的最大长度。

视觉

特征提取器也用于处理视觉任务的图像。同样，我们的目标是将原始图像转换为一批张量作为输入。

让我们加载本教程的 food101数据集。使用 Datasets split 参数只从训练分割中加载小样本，因为数据集非常大:

from datasets import load_dataset

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

接下来，我们来看看这张带有数据集功能的图片:

dataset[0]["image"]
vision-preprocess-tutorial.png

特性提取器特性提取器

使用 AutoFeatureExtractor.from_pretrained ()加载特性提取器:

from transformers import AutoFeatureExtractor

feature_extractor = AutoFeatureExtractor.from_pretrained("google/vit-base-patch16-224")

数据增加数据增加

对于视觉任务，通常添加一些类型的数据增强作为预处理的一部分图像。您可以添加任何您喜欢的库的扩展，但是在本教程中，您将使用 torchvision 的转换模块。

将图像正常化并使用 Compose 链接一些转换—— RandomResizedCrop 和 ColorJitter ——一起:

from torchvision.transforms import Compose, Normalize, RandomResizedCrop, ColorJitter, ToTensor

normalize = Normalize(mean=feature_extractor.image_mean, std=feature_extractor.image_std)
_transforms = Compose(
    [RandomResizedCrop(feature_extractor.size), ColorJitter(brightness=0.5, hue=0.5), ToTensor(), normalize]
)

该模型接受像素值作为输入。此值由特征提取器生成。创建一个函数，通过转换生成像素值:

def transforms(examples):
    examples["pixel_values"] = [_transforms(image.convert("RGB")) for image in examples["image"]]
    return examples

然后使用 Datasets set_transform 动态应用转换:

dataset.set_transform(transforms)
``

现在当你访问图像时，你会注意到特征提取器已经添加了模型输入 pixel_值:

```python
dataset[0]["image"]
{'image': <PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=384x512 at 0x7F1A7B0630D0>,
 'label': 6,
 'pixel_values': tensor([[[ 0.0353,  0.0745,  0.1216,  ..., -0.9922, -0.9922, -0.9922],
          [-0.0196,  0.0667,  0.1294,  ..., -0.9765, -0.9843, -0.9922],
          [ 0.0196,  0.0824,  0.1137,  ..., -0.9765, -0.9686, -0.8667],
          ...,
          [ 0.0275,  0.0745,  0.0510,  ..., -0.1137, -0.1216, -0.0824],
          [ 0.0667,  0.0824,  0.0667,  ..., -0.0588, -0.0745, -0.0980],
          [ 0.0353,  0.0353,  0.0431,  ..., -0.0039, -0.0039, -0.0588]],
 
         [[ 0.2078,  0.2471,  0.2863,  ..., -0.9451, -0.9373, -0.9451],
          [ 0.1608,  0.2471,  0.3098,  ..., -0.9373, -0.9451, -0.9373],
          [ 0.2078,  0.2706,  0.3020,  ..., -0.9608, -0.9373, -0.8275],
          ...,
          [-0.0353,  0.0118, -0.0039,  ..., -0.2392, -0.2471, -0.2078],
          [ 0.0196,  0.0353,  0.0196,  ..., -0.1843, -0.2000, -0.2235],
          [-0.0118, -0.0039, -0.0039,  ..., -0.0980, -0.0980, -0.1529]],
 
         [[ 0.3961,  0.4431,  0.4980,  ..., -0.9216, -0.9137, -0.9216],
          [ 0.3569,  0.4510,  0.5216,  ..., -0.9059, -0.9137, -0.9137],
          [ 0.4118,  0.4745,  0.5216,  ..., -0.9137, -0.8902, -0.7804],
          ...,
          [-0.2314, -0.1922, -0.2078,  ..., -0.4196, -0.4275, -0.3882],
          [-0.1843, -0.1686, -0.2000,  ..., -0.3647, -0.3804, -0.4039],
          [-0.1922, -0.1922, -0.1922,  ..., -0.2941, -0.2863, -0.3412]]])}

下面是对图像进行预处理后的效果。正如您所期望的从应用变换，图像已经随机裁剪，它的颜色属性是不同的。

import numpy as np
import matplotlib.pyplot as plt

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

多式联运多式联运

对于多通道任务。您将使用到目前为止所学的一切知识的组合，并将您的技能应用于自动语音识别(ASR)任务。这意味着你需要一个:

特征提取器来预处理音频数据。

用 Tokenizer 处理文本用 Tokenizer 处理文本

让我们回到 LJ 的演讲数据集:

from datasets import load_dataset

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

因为你主要对音频和文本栏感兴趣，删除其他栏:

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

处理器

处理器结合了功能提取器和tokenizer。用[‘ AutoProcessor.from_pretrained ]加载处理器:

from transformers import AutoProcessor

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

创建一个函数来处理音频数据以输入_值，并将文本标记为标签。这些是你对模型的投入:

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

    example["input_values"] = processor(audio["array"], sampling_rate=16000)

    with processor.as_target_processor():
        example["labels"] = processor(example["text"]).input_ids
    return example

将 prepare_dataset 函数应用于示例:

prepare_dataset(lj_speech[0])

注意处理器已经添加了 input_value 和标签，取样速率也被正确地下调到了16khz。

太棒了，你现在应该能够预处理任何模式的数据，甚至结合不同的模式！在下一个教程中，学习如何对新的预处理数据进行模型优化。

所有你一直想知道的关于填充和截断的东西所有你一直想知道的关于填充和截断的东西

我们已经看到了适用于大多数情况的命令(将您的批处理添加到最大句子的长度并截断到模型可以接受的最大长度)。但是，如果您需要的话，这个 API 支持更多的策略。您需要知道的三个参数是 padding、 trunation 和 max_length。

Padding 控制填充。它可以是一个布尔值或一个字符串，它应该是:
- True 或 “longest”来填充批处理中最长的序列(如果只提供单个序列，则不进行填充)。
- 如果没有提供最大长度，“ max_length”可以填充到 max_length 参数指定的长度，或者模型可以接受的最大长度(max_length = None)。如果您只提供一个序列，则仍将对其应用填充。
- 默认不进行填充。
截断控制截断。它可以是一个布尔值或一个应该是:
- 如果没有提供最大长度，则截断为 max_length 参数指定的最大长度或模型接受的最大长度(max_length = None)。这将逐个令牌截断令牌，从对中最长的序列中删除令牌，直到达到合适的长度。
- only_second 截断到 max_length 参数指定的最大长度，如果没有提供 max_length = None，则截断到模型可接受的最大长度。如果提供了一对序列(或一批序列对) ，则只会截断一对序列的第二句。
- only_first 截断到 max_length 参数指定的最大长度，或者在没有提供 max_length = None 的情况下模型接受的最大长度。如果提供了一对序列(或一批序列对) ，则只会截断一对序列的第一句。
- False 或者 do_not_truncate 来避免截断序列。
Max_length 来控制填充/截断的长度。它可以是整数或 None，在这种情况下，它将默认为模型可以接受的最大长度。如果模型没有特定的最大输入长度，则停用截断/填充到最大长度。

下面是一个表，总结了设置填充和截断的推荐方法。如果你在下面的例子中使用一对输入序列，你可以用[‘ only_first’，‘ only_second’，‘ longest_first’]中选择的一个策略替换 truncation = True，也就是截断 = ‘ only_second’或者截断 = ‘ longest_first’来控制两个序列如何被截断。

在这里插入图片描述

本文是抱抱脸（Hugging Face）教程中文翻译，仅学习使用

原文链接

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)