Transformers 数据预处理实战指南：用 Tokenizer、Feature Extractor 与 Processor 把文本、音频、图像变成模型张量-平芜编程栈

Transformers 数据预处理实战指南：用 Tokenizer、Feature Extractor 与 Processor 把文本、音频、图像变成模型张量

【免费下载链接】transformers🤗 Transformers: the model-definition framework for state-of-the-art machine learning models in text, vision, audio, and multimodal models, for both inference and training.项目地址: https://gitcode.com/GitHub_Trending/tra/transformers

在 Transformers 中使用模型之前，原始数据必须先转换为模型可接受的数值格式：模型无法直接理解原始文本、图片或音频，这些输入必须被转换并组装成张量。本指南围绕 Transformers 官方文档的数据预处理章节展开，完整覆盖三类典型场景——用 Tokenizer 处理文本、用 Feature Extractor 处理音频/图像、用 Processor 处理多模态任务，并结合仓库源码剖析 padding、truncation、张量转换的底层实现，读完即可独立完成任意模态数据的预处理流水线。

预处理总览

预处理的终极目标只有一条：生成模型可消费的数值序列（张量）。Transformers 为不同模态提供了三类对应的工具，均由Auto系列类统一加载：

模态	工具类	加载入口	输出字段
文本	Tokenizer	`AutoTokenizer`	`input_ids`、`attention_mask`、`token_type_ids`
音频	Feature Extractor	`AutoFeatureExtractor`	`input_values`
图像	Image Processor	`AutoImageProcessor`	`pixel_values`
多模态	Processor	`AutoProcessor`	组合上述输出（如`input_values`+`labels`）

一个关键原则：使用预训练模型时，必须同时使用该模型配套的预训练分词器/处理器。这样才能保证文本被切分的方式与预训练语料一致，并使用预训练时相同的 token 到索引的映射（即词表vocab）。

NLP：用 Tokenizer 预处理文本

最重要的文本预处理工具是 Tokenizer。它先将文本按一组规则拆分为token，再把 token 转换为可以构建输入张量的数字。模型所需的额外输入（如 attention mask）也由 Tokenizer 负责生成。

加载预训练 Tokenizer

用AutoTokenizer.from_pretrained加载预训练 Tokenizer，它会自动下载模型预训练时使用的词表：

>>> from transformers import AutoTokenizer >>> tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-cased")

分词（Tokenize）

把句子传给 Tokenizer：

>>> 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：每个 token 在词表中的索引；
attention_mask：指明哪些 token 需要被模型关注（真实 token 为 1，padding 位置为 0）；
token_type_ids：当存在多条序列（如 BERT 的 [A] [B] 句对）时，指明每个 token 属于哪条序列。

可以用decode把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 自动向句子添加了两个特殊 token——[CLS]（分类符）和[SEP]（分隔符）。并非所有模型都需要特殊 token；当模型需要时，Tokenizer 会自动代你添加，这正是add_special_tokens参数（__call__中默认值为True，见 src/transformers/tokenization_utils_base.py）的作用。

处理多个句子时，把句子以列表形式传入：

>>> 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, 0]], 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1]]}

Padding（填充）

批处理中一个核心问题：句子长度不一，而模型的输入张量必须具有统一（矩形）的形状。Padding的策略是向较短的句子追加专用padding token，使张量变成长度一致的矩形。

将参数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, 1, 0, 0, 0, 0, 0, 0, 0]]}

注意第一句和第三句被0补齐——而且它们的attention_mask在对应位置同步变为0，告诉模型忽略这些填充位置。

源码层面的实现：padding 的核心逻辑在PreTrainedTokenizerBase._pad方法中（src/transformers/tokenization_utils_base.py）。三种填充策略由PaddingStrategy枚举决定：

LONGEST：填充到批次中最长序列的长度（padding=True时）；
MAX_LENGTH：填充到模型允许的最大长度（padding="max_length"时）；
DO_NOT_PAD：不填充（默认）。

_pad还会根据padding_side决定填充位置（"right"时向序列尾部追加pad_token_id并同步追加attention_mask中的0，"left"时向头部前置）。另外，pad_to_multiple_of参数可把填充后的长度向上取整为该值的倍数，这在启用 Tensor Core（计算能力 ≥ 7.5 的 NVIDIA GPU）时尤其有用。

Truncation（截断）

与 padding 相反，序列有时会长过模型能接受的上限，此时必须截断。把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, 1, 0, 0, 0, 0, 0, 0, 0]]}

truncation还可以设为字符串策略（如"only_first"，只截断句对中的第一条序列）。__call__内部先通过_get_padding_truncation_strategies把padding/truncation/max_length统一解析为内部策略对象，再交给_encode_plus执行分词与填充/截断（见 src/transformers/tokenization_utils_base.py）。

创建张量

最后一步，让 Tokenizer 直接返回可直接喂给模型的张量：把return_tensors设为pt（PyTorch）或tf（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="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, 1, 0, 0, 0, 0, 0, 0, 0]])}

张量转换的底层实现：return_tensors参数最终由BatchEncoding.convert_to_tensors处理（src/transformers/tokenization_utils_base.py）。它先校验对应框架已安装（如 PyTorch 不可用会抛出ImportError），再按框架选择转换函数——PyTorch 走torch.tensor，TensorFlow 走np.asarray等；未安装的框架会导致报错而不是静默降级，这一点在跨框架项目中值得注意。

Tokenizer 核心参数速查

综合__call__的签名（src/transformers/tokenization_utils_base.py），日常预处理最常用的参数如下：

参数	默认值	说明
`text`/`text_pair`	`None`	单条序列或字符串列表；`text_pair`用于句对任务
`add_special_tokens`	`True`	是否自动添加模型所需的特殊 token
`padding`	`False`	`True`填充到最长序列；`"max_length"`填充到模型最大长度；或传`max_length`对应的整数值
`truncation`	`None`	`True`截断到模型最大长度，或指定字符串策略
`max_length`	`None`	截断/填充的目标长度上限
`stride`	`0`	截断时每段之间的重叠步长（用于长文本分片）
`pad_to_multiple_of`	`None`	填充后长度取该值的倍数（利于 Tensor Core）
`padding_side`	类属性	`"left"`或`"right"`，生成式模型常用左侧填充
`return_tensors`	`None`	`"pt"`（PyTorch）或`"tf"`（TensorFlow）
`return_token_type_ids`/`return_attention_mask`	模型特定	控制是否返回对应字段
`tokenizer_kwargs`	`None`	额外传给底层 tokenizer 的参数字典

音频：用 Feature Extractor 预处理

音频输入的预处理方式与文本不同，但终点一致：生成模型可理解的数值序列。Feature Extractor 的明确职责就是：从原始图像或音频数据中提取特征并转换为张量。开始前先安装数据集库（本教程用它来加载音频数据）：

pip install datasets

加载 MInDS-14 数据集（英语通话数据，采样率 8kHz）：

>>> 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：采样率，即每秒测量的数据点数。

重采样（Resample）

本教程使用 Wav2Vec2 模型。其模型卡表明，Wav2Vec2 是在16kHz采样的语音音频上预训练的。音频数据的采样率必须与模型预训练时使用的采样率一致；不一致时，必须对音频数据重新采样。

MInDS-14 的采样率为 8000 Hz，要在其上使用 Wav2Vec2，需要把采样率提升到 16kHz：

>>> dataset = load_dataset("PolyAI/minds14", name="en-US", split="train") >>> 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}

操作步骤：

用cast_column把采样率提升到 16kHz：

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

再次读取音频文件验证：

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

采样率现在已经是 16kHz。

音频 Merkmalextraktor（特征提取器）

下一步加载 Feature Extractor，对输入做归一化与填充。文本填充时给较短序列补0；音频同理，音频 Feature Extractor 会在array中补0——对音频而言，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)]}

音频的填充与截断

与 Tokenizer 一样，批次中长度不一的序列可以通过填充或截断来统一。先看两条音频样本的序列长度：

>>> dataset[0]["audio"]["array"].shape (173398,) >>> dataset[1]["audio"]["array"].shape (106496,)

第一条明显比第二条长。编写一个批量预处理函数：给定最大长度，特征提取器会对每条序列进行填充或截断，使其与max_length一致：

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

把该函数应用到数据集的前几条样本上：

>>> processed_dataset = preprocess_function(dataset[:5])

再查看处理后样本的长度：

>>> processed_dataset["input_values"][0].shape (100000,) >>> processed_dataset["input_values"][1].shape (100000,)

前两条样本的长度现在都等于给定的最大长度——第一条被截断、第二条被填充，两者统一为矩形张量，可直接组成 batch。

图像：用 Image Processor 预处理

图像任务同样使用"提取器"类——在本仓库中由AutoImageProcessor加载。目标同样是把原始图像转换成张量。加载 food101 数据集；由于该数据集较大，用split参数只取训练集的一小段样本：

>>> from datasets import load_dataset >>> dataset = load_dataset("ethz/food101", split="train[:100]")

然后查看图像本身（数据集的image列返回 PIL 对象）：

>>> dataset[0]["image"]

图像处理器

用AutoImageProcessor.from_pretrained加载图像处理器：

>>> from transformers import AutoImageProcessor >>> image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224")

源码层面的输出约定：在 src/transformers/image_processing_utils.py 中，ImageProcessingBackend基类声明了model_input_names = ["pixel_values"]，其__call__最终把图像列表整理为带pixel_values键的BatchFeature返回。也就是说，图像预处理器与模型之间的"接口契约"就是pixel_values这一字段——这也是后文数据增强函数要生成它的原因。

数据增强

在计算机视觉任务中，通常会在预处理阶段给图像加入某种数据增强。增强可以用任意库实现，这里演示使用 torchvision 的transforms模块。

归一化图像，并用Compose把若干变换（RandomResizedCrop与ColorJitter）串联起来：

>>> from torchvision.transforms import Compose, Normalize, RandomResizedCrop, ColorJitter, ToTensor >>> normalize = Normalize(mean=image_processor.image_mean, std=image_processor.image_std) >>> _transforms = Compose( ... [RandomResizedCrop(image_processor.size["height"]), ColorJitter(brightness=0.5, hue=0.5), ToTensor(), normalize] ... )

注意两点：Normalize的均值/方差直接取自image_processor.image_mean/image_processor.image_std，与模型预训练时的归一化保持一致；RandomResizedCrop的目标尺寸取自image_processor.size["height"]（ViT-base-patch16-224 即 224）。

模型接受的输入是pixel_values，该值由"提取器"产生。编写一个函数，从变换结果生成pixel_values：

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

用set_transform让变换在访问数据集时即时应用：

>>> dataset.set_transform(transforms)

此时再访问图像，就会发现多出了模型输入pixel_values：

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

可以看到，图像经过预处理后已被随机裁剪，色彩属性也发生了变化——这正是所施加的增强变换（RandomResizedCrop+ColorJitter）的直接效果。用 matplotlib 可视化预处理后的图像：

>>> import numpy as np >>> import matplotlib.pyplot as plt >>> img = dataset[0]["pixel_values"] >>> plt.imshow(img.permute(1, 2, 0))

多模态：用 Processor 组合音频与文本

多模态任务需要把前面所学的内容组合起来。这里以**自动语音识别（ASR）**为例：需要一个 Feature Extractor 处理音频，一个 Tokenizer 处理文本（即目标转录文本）。

加载 LJ Speech 数据集：

>>> from datasets import load_dataset >>> lj_speech = load_dataset("lj_speech", split="train")

由于只关心audio和text两列，删除其余列：

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

回忆音频部分的经验：音频采样率必须与模型预训练时使用的采样率一致，因此先把采样率重采样为 16kHz：

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

Processor

Processor 把 Feature Extractor 和 Tokenizer 组合在一起。用AutoProcessor.from_pretrained加载：

>>> from transformers import AutoProcessor >>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-base-960h")

编写函数：把音频转成input_values，把文本分词为labels，作为模型的输入：

>>> def prepare_dataset(example): ... audio = example["audio"] ... example.update(processor(audio=audio["array"], text=example["text"], sampling_rate=16000)) ... return example

对单条样本应用该函数：

>>> prepare_dataset(lj_speech[0])

可以看到 Processor 自动添加了input_values和labels两个字段，采样率也已被正确重采样到 16kHz。到此，任何单模态或多模态数据的预处理都已具备完整能力，得到的input_values/labels即可直接用于后续的微调训练。

底层实现：Auto 系列如何选择正确的处理类

从源码结构看，四个Auto入口（AutoTokenizer、AutoFeatureExtractor、AutoImageProcessor、AutoProcessor，分别位于 src/transformers/models/auto/tokenization_auto.py、src/transformers/models/auto/feature_extraction_auto.py、src/transformers/models/auto/image_processing_auto.py、src/transformers/models/auto/processing_auto.py）都不允许直接实例化，只能通过from_pretrained类方法加载。以AutoProcessor.from_pretrained为例，其类选择逻辑（src/transformers/models/auto/processing_auto.py）是一条优先级递减的探测链：

先查仓库中的 processor config，读取其中的processor_class字段；
若不存在，依次检查图像处理器配置、视频处理器配置、feature extractor 配置；
再查 tokenizer config 中的processor_class；
最后回退到模型config.json的processor_class属性；
若都未命中，则尝试按model_type查PROCESSOR_MAPPING注册表；
作为最后手段，按顺序尝试AutoTokenizer、AutoImageProcessor、AutoVideoProcessor、AutoFeatureExtractor（见 src/transformers/models/auto/processing_auto.py），全部失败才抛出ValueError。

此外，from_pretrained支持token（访问私有仓库时传True）、revision（指定分支/tag/commit）、trust_remote_code（允许执行 Hub 仓库中的自定义处理器代码）等参数；对不可信的远程仓库，trust_remote_code应保持False。理解了这条探测链，就能解释"为什么某些纯文本模型用AutoProcessor也能加载（它回退到了 Tokenizer）"这类现象。

小结

本文基于 Transformers 官方预处理文档与仓库源码，完整走通了三条预处理流水线：

文本：AutoTokenizer分词 →padding=True补齐 →truncation=True截断 →return_tensors="pt"生成张量；核心实现在PreTrainedTokenizerBase._pad与convert_to_tensors；
音频：cast_column把采样率对齐到模型预训练值（16kHz）→AutoFeatureExtractor归一化并输出input_values→ 用max_length/padding/truncation统一批次长度；
图像：AutoImageProcessor提供image_mean/image_std/size等预训练约定 → torchvisionCompose串联裁剪、颜色抖动与归一化 → 生成pixel_values；
多模态：AutoProcessor组合 Feature Extractor 与 Tokenizer，一次调用同时产出input_values（音频）与labels（文本），并以配置探测链保证在缺失显式 processor 配置时自动回退。