Transformers--4-37-中文文档-八-
Transformers 4.37 中文文档(八)
将🤗 Transformers 模型导出到 ONNX
原始文本:
huggingface.co/docs/transformers/v4.37.2/en/main_classes/onnx
🤗 Transformers 提供了一个transformers.onnx
包,通过利用配置对象,您可以将模型检查点转换为 ONNX 图。
查看有关导出🤗 Transformers 模型的更多详细信息的指南。
ONNX 配置
我们提供了三个抽象类,您应该根据希望导出的模型架构类型继承其中一个:
-
基于编码器的模型继承自 OnnxConfig
-
基于解码器的模型继承自 OnnxConfigWithPast
-
编码器-解码器模型继承自 OnnxSeq2SeqConfigWithPast
OnnxConfig
class transformers.onnx.OnnxConfig
( config: PretrainedConfig task: str = 'default' patching_specs: List = None )
用于描述通过 ONNX 格式导出模型的元数据的可导出模型的基类。
flatten_output_collection_property
( name: str field: Iterable ) → export const metadata = 'undefined';(Dict[str, Any])
返回
(Dict[str, Any])
具有扁平结构和映射到此新结构的键的输出。
展平任何潜在的嵌套结构,将字段的名称与结构中元素的索引扩展。
from_model_config
( config: PretrainedConfig task: str = 'default' )
为特定模型实例化一个 OnnxConfig
generate_dummy_inputs
( preprocessor: Union batch_size: int = -1 seq_length: int = -1 num_choices: int = -1 is_pair: bool = False framework: Optional = None num_channels: int = 3 image_width: int = 40 image_height: int = 40 sampling_rate: int = 22050 time_duration: float = 5.0 frequency: int = 220 tokenizer: PreTrainedTokenizerBase = None )
参数
-
batch_size
(int
, 可选,默认为-1) — 用于导出模型的批量大小(-1 表示动态轴)。 -
num_choices
(int
, 可选,默认为-1) — 为多选任务提供的候选答案数量(-1 表示动态轴)。 -
seq_length
(int
, 可选,默认为-1) — 为导出模型指定的序列长度(-1 表示动态轴)。 -
is_pair
(bool
, 可选,默认为False
) — 指示输入是否为一对(句子 1,句子 2) -
framework
(TensorType
, 可选,默认为None
) — 分词器将为其生成张量的框架(PyTorch 或 TensorFlow)。 -
num_channels
(int
, 可选,默认为 3) — 生成图像的通道数。 -
image_width
(int
, 可选,默认为 40) — 生成图像的宽度。 -
image_height
(int
, 可选,默认为 40) — 生成图像的高度。 -
sampling_rate
(int
, 可选 默认为 22050) — 用于音频数据生成的采样率。 -
time_duration
(float
, 可选 默认为 5.0) — 用于音频数据生成的采样总秒数。 -
frequency
(int
, 可选 默认为 220) — 生成音频的期望自然频率。
生成要提供给特定框架的 ONNX 导出器的输入
generate_dummy_inputs_onnxruntime
( reference_model_inputs: Mapping ) → export const metadata = 'undefined';Mapping[str, Tensor]
参数
reference_model_inputs
([Mapping[str, Tensor]
)— 模型的参考输入。
返回
Mapping[str, Tensor]
保存要提供给模型前向函数的 kwargs 的映射
使用参考模型输入为 ONNX Runtime 生成输入。覆盖此选项以使用将编码器和解码器导出为单独的 ONNX 文件的 seq2seq 模型进行推理。
use_external_data_format
( num_parameters: int )
标志,指示模型是否需要使用外部数据格式
OnnxConfigWithPast
class transformers.onnx.OnnxConfigWithPast
( config: PretrainedConfig task: str = 'default' patching_specs: List = None use_past: bool = False )
fill_with_past_key_values_
( inputs_or_outputs: Mapping direction: str inverted_values_shape: bool = False )
考虑填充具有过去键值动态轴的输入或输出映射。
with_past
( config: PretrainedConfig task: str = 'default' )
实例化一个具有 use_past
属性设置为 True 的 OnnxConfig
OnnxSeq2SeqConfigWithPast
class transformers.onnx.OnnxSeq2SeqConfigWithPast
( config: PretrainedConfig task: str = 'default' patching_specs: List = None use_past: bool = False )
ONNX 特性
每个 ONNX 配置都与一组 特性 关联,使您能够为不同类型的拓扑或任务导出模型。
FeaturesManager
class transformers.onnx.FeaturesManager
( )
check_supported_model_or_raise
( model: Union feature: str = 'default' )
检查模型是否具有请求的特征。
determine_framework
( model: str framework: str = None )
参数
-
model
(str
) — 要导出的模型的名称。 -
framework
(str
, 可选, 默认为None
) — 用于导出的框架。如果未提供,则参见上文的优先级。
确定用于导出的框架。
优先级按以下顺序排列:
-
通过
framework
的用户输入。 -
如果提供了本地检查点,则使用与检查点相同的框架。
-
环境中可用的框架,优先考虑 PyTorch。
get_config
( model_type: str feature: str ) → export const metadata = 'undefined';OnnxConfig
参数
-
model_type
(str
) — 要检索配置的模型类型。 -
feature
(str
) — 要检索配置的特征。
返回
OnnxConfig
用于组合的配置
获取模型类型和特征组合的 OnnxConfig。
get_model_class_for_feature
( feature: str framework: str = 'pt' )
参数
-
feature
(str
) — 所需的特征。 -
framework
(str
, 可选, 默认为"pt"
) — 用于导出的框架。
尝试从特征名称中检索 AutoModel 类。
get_model_from_feature
( feature: str model: str framework: str = None cache_dir: str = None )
参数
-
feature
(str
) — 所需的特征。 -
model
(str
) — 要导出的模型的名称。 -
framework
(str
, 可选, 默认为None
) — 用于导出的框架。如果未提供,则参见FeaturesManager.determine_framework
的优先级。
尝试从模型的名称和要启用的特征中检索模型。
get_supported_features_for_model_type
( model_type: str model_name: Optional = None )
参数
-
model_type
(str
) — 要检索支持特征的模型类型。 -
model_name
(str
, 可选) — 模型对象的名称属性,仅用于异常消息。
尝试从模型类型中检索特征 -> OnnxConfig 构造函数映射。
优化
原始文本:
huggingface.co/docs/transformers/v4.37.2/en/main_classes/optimizer_schedules
.optimization
模块提供:
-
一个带有固定权重衰减的优化器,可用于微调模型,以及
-
_LRSchedule
继承的形式有几个调度对象: -
一个梯度累积类,用于累积多个批次的梯度
AdamW(PyTorch)
class transformers.AdamW
( params: Iterable lr: float = 0.001 betas: Tuple = (0.9, 0.999) eps: float = 1e-06 weight_decay: float = 0.0 correct_bias: bool = True no_deprecation_warning: bool = False )
参数
-
params
(Iterable[nn.parameter.Parameter]
)— 要优化的参数的可迭代对象或定义参数组的字典。 -
lr
(float
,可选,默认为 0.001)— 要使用的学习率。 -
betas
(Tuple[float,float]
,可选,默认为(0.9, 0.999)
)— Adam 的 betas 参数(b1,b2)。 -
eps
(float
,可选,默认为 1e-06)— Adam 的数值稳定性 epsilon。 -
weight_decay
(float
,可选,默认为 0.0)— 要应用的解耦权重衰减。 -
correct_bias
(bool
,可选,默认为True
)— 是否在 Adam 中校正偏差(例如,在 Bert TF 存储库中,它们使用False
)。 -
no_deprecation_warning
(bool
,可选,默认为False
)— 用于禁用弃用警告的标志(设置为True
以禁用警告)。
实现了带有权重衰减修复的 Adam 算法,该算法在解耦权重衰减正则化中引入。
step
( closure: Callable = None )
参数
closure
(Callable
,可选)— 重新评估模型并返回损失的闭包。
执行单个优化步骤。
AdaFactor(PyTorch)
class transformers.Adafactor
( params lr = None eps = (1e-30, 0.001) clip_threshold = 1.0 decay_rate = -0.8 beta1 = None weight_decay = 0.0 scale_parameter = True relative_step = True warmup_init = False )
参数
-
params
(Iterable[nn.parameter.Parameter]
)— 要优化的参数的可迭代对象或定义参数组的字典。 -
lr
(float
,可选)— 外部学习率。 -
eps
(Tuple[float, float]
,可选,默认为(1e-30, 0.001)
)— 平方梯度和参数比例的正则化常数 -
clip_threshold
(float
,可选,默认为 1.0)— 最终梯度更新的均方根阈值 -
decay_rate
(float
,可选,默认为-0.8)— 用于计算平方运行平均值的系数 -
beta1
(float
,可选)— 用于计算梯度的运行平均值的系数 -
weight_decay
(float
,可选,默认为 0.0)— 权重衰减(L2 惩罚) -
scale_parameter
(bool
,可选,默认为True
)— 如果为 True,则学习率将按均方根缩放 -
relative_step
(bool
,可选,默认为True
)— 如果为 True,则计算时间相关的学习率,而不是外部学习率 -
warmup_init
(bool
,可选,默认为False
)— 时间相关的学习率计算取决于是否使用了热身初始化
AdaFactor 的 PyTorch 实现可用作 Adam 原始 fairseq 代码的替代品:github.com/pytorch/fairseq/blob/master/fairseq/optim/adafactor.py
论文:Adafactor:自适应学习率与亚线性内存成本 arxiv.org/abs/1804.04235
请注意,此优化器根据scale_parameter
、relative_step
和warmup_init
选项内部调整学习率。要使用手动(外部)学习率调度,您应将scale_parameter=False
和relative_step=False
。
此实现处理低精度(FP16,bfloat)值,但我们尚未进行彻底测试。
推荐的 T5 微调设置(discuss.huggingface.co/t/t5-finetuning-tips/684/3
):
-
不建议在没有 LR 热身或 clip_threshold 的情况下进行训练。
-
使用计划的 LR 热身到固定的 LR
-
使用 clip_threshold=1.0 (
arxiv.org/abs/1804.04235
)
-
-
禁用相对更新
-
使用 scale_parameter=False
-
不应该在 Adafactor 旁边使用额外的优化器操作,如梯度裁剪。
示例:
Adafactor(model.parameters(), scale_parameter=False, relative_step=False, warmup_init=False, lr=1e-3)
其他人报告以下组合效果很好:
Adafactor(model.parameters(), scale_parameter=True, relative_step=True, warmup_init=True, lr=None)
当使用lr=None
与 Trainer 时,您很可能需要使用AdafactorSchedule
调度器如下:
from transformers.optimization import Adafactor, AdafactorSchedule
optimizer = Adafactor(model.parameters(), scale_parameter=True, relative_step=True, warmup_init=True, lr=None)
lr_scheduler = AdafactorSchedule(optimizer)
trainer = Trainer(..., optimizers=(optimizer, lr_scheduler))
用法:
# replace AdamW with Adafactor
optimizer = Adafactor(
model.parameters(),
lr=1e-3,
eps=(1e-30, 1e-3),
clip_threshold=1.0,
decay_rate=-0.8,
beta1=None,
weight_decay=0.0,
relative_step=False,
scale_parameter=False,
warmup_init=False,
)
步骤
( closure = None )
参数
闭包
(可调用,可选)— 重新评估模型并返回损失的闭包。
执行单个优化步骤
AdamWeightDecay(TensorFlow)
class transformers.AdamWeightDecay
( learning_rate: Union = 0.001 beta_1: float = 0.9 beta_2: float = 0.999 epsilon: float = 1e-07 amsgrad: bool = False weight_decay_rate: float = 0.0 include_in_weight_decay: Optional = None exclude_from_weight_decay: Optional = None name: str = 'AdamWeightDecay' **kwargs )
参数
-
learning_rate
(Union[float, tf.keras.optimizers.schedules.LearningRateSchedule]
,可选,默认为 0.001)— 要使用的学习率或计划。 -
beta_1
(float
,可选,默认为 0.9)— Adam 中的 beta1 参数,即第 1 动量估计的指数衰减率。 -
beta_2
(float
,可选,默认为 0.999)— Adam 中的 beta2 参数,即第 2 动量估计的指数衰减率。 -
epsilon
(float
,可选,默认为 1e-07)— Adam 中的 epsilon 参数,这是用于数值稳定性的小常数。 -
amsgrad
(bool
,可选,默认为False
)— 是否应用 AMSGrad 变体的算法,参见关于 Adam 及其更多的收敛性。 -
weight_decay_rate
(float
,可选,默认为 0.0)— 要应用的权重衰减。 -
include_in_weight_decay
(List[str]
,可选)— 要应用权重衰减的参数名称(或 re 模式)的列表。如果没有传递,则默认情况下将权重衰减应用于所有参数(除非它们在exclude_from_weight_decay
中)。 -
exclude_from_weight_decay
(List[str]
,可选)— 要排除不应用权重衰减的参数名称(或 re 模式)的列表。如果传递了include_in_weight_decay
,则其中的名称将取代此列表。 -
name
(str
,可选,默认为"AdamWeightDecay"
)— 应用梯度时创建的操作的可选名称。 -
kwargs
(Dict[str, Any]
,可选)— 关键字参数。允许为{clipnorm
,clipvalue
,lr
,decay
}。clipnorm
是按范数裁剪梯度;clipvalue
是按值裁剪梯度,decay
包含了向后兼容性,允许学习率的时间反转衰减。lr
包含了向后兼容性,建议使用learning_rate
代替。
Adam 启用 L2 权重衰减和梯度的全局范数裁剪。只是将权重的平方添加到损失函数中不是使用 Adam 进行 L2 正则化/权重衰减的正确方式,因为这将以奇怪的方式与 m 和 v 参数交互,如解耦权重衰减正则化所示。
相反,我们希望以一种不会与 m/v 参数交互的方式衰减权重。这相当于使用纯(非动量)SGD 将权重的平方添加到损失中。
from_config
( config )
使用其配置创建具有 WarmUp 自定义对象的优化器。
transformers.create_optimizer
( init_lr: float num_train_steps: int num_warmup_steps: int min_lr_ratio: float = 0.0 adam_beta1: float = 0.9 adam_beta2: float = 0.999 adam_epsilon: float = 1e-08 adam_clipnorm: Optional = None adam_global_clipnorm: Optional = None weight_decay_rate: float = 0.0 power: float = 1.0 include_in_weight_decay: Optional = None )
参数
-
init_lr
(float
)—热身阶段结束时的期望学习率。 -
num_train_steps
(int
)—训练步骤的总数。 -
num_warmup_steps
(int
)—热身步骤的数量。 -
min_lr_ratio
(float
,可选,默认为 0)—线性衰减结束时的最终学习率将为init_lr * min_lr_ratio
。 -
adam_beta1
(float
,可选,默认为 0.9)—Adam 中使用的 beta1。 -
adam_beta2
(float
,可选,默认为 0.999)—Adam 中使用的 beta2。 -
adam_epsilon
(float
,可选,默认为 1e-8)—Adam 中使用的 epsilon。 -
adam_clipnorm
(float
,可选,默认为None
)—如果不是None
,则将每个权重张量的梯度范数剪裁为此值。 -
adam_global_clipnorm
(float
,可选,默认为None
)—如果不是None
,则将梯度范数剪裁为此值。使用此参数时,规范是在所有权重张量上计算的,就好像它们被连接成一个单一向量。 -
weight_decay_rate
(float
,可选,默认为 0)—要使用的权重衰减。 -
power
(float
,可选,默认为 1.0)—用于 PolynomialDecay 的幂。 -
include_in_weight_decay
(List[str]
,可选)—要应用权重衰减的参数名称(或 re 模式)的列表。如果未传递任何内容,则将权重衰减应用于除偏置和层归一化参数之外的所有参数。
创建一个使用热身阶段后跟线性衰减的学习率时间表的优化器。
时间表
学习率时间表(Pytorch)
class transformers.SchedulerType
( value names = None module = None qualname = None type = None start = 1 )
一个枚举。
transformers.get_scheduler
( name: Union optimizer: Optimizer num_warmup_steps: Optional = None num_training_steps: Optional = None scheduler_specific_kwargs: Optional = None )
参数
-
name
(str
或SchedulerType
)—要使用的调度程序的名称。 -
optimizer
(torch.optim.Optimizer
)—训练期间将使用的优化器。 -
num_warmup_steps
(int
,可选)—要执行的热身步骤数。并非所有调度程序都需要(因此参数是可选的),如果未设置并且调度程序类型需要,则函数将引发错误。 -
num_training_steps
(int
,可选)—要执行的训练步骤数。并非所有调度程序都需要(因此参数是可选的),如果未设置并且调度程序类型需要,则函数将引发错误。 -
scheduler_specific_kwargs
(dict
,可选)—用于诸如带重启的余弦等调度程序的额外参数。不匹配的调度程序类型和调度程序参数将导致调度程序函数引发 TypeError。
从其名称获取任何调度程序的统一 API。
transformers.get_constant_schedule
( optimizer: Optimizer last_epoch: int = -1 )
参数
-
optimizer
(~torch.optim.Optimizer
)—要为其调度学习率的优化器。 -
last_epoch
(int
,可选,默认为-1)—恢复训练时的最后一个时期的索引。
使用优化器中设置的学习率创建一个具有恒定学习率的时间表。
transformers.get_constant_schedule_with_warmup
( optimizer: Optimizer num_warmup_steps: int last_epoch: int = -1 )
参数
-
optimizer
(~torch.optim.Optimizer
)—要为其调度学习率的优化器。 -
num_warmup_steps
(int
)—热身阶段的步数。 -
last_epoch
(int
,可选,默认为-1)—恢复训练时的最后一个时期的索引。
创建一个具有恒定学习率的时间表,在此期间学习率在 0 和优化器中设置的初始 lr 之间线性增加的热身期之前。
####
transformers.get_cosine_schedule_with_warmup
( optimizer: Optimizer num_warmup_steps: int num_training_steps: int num_cycles: float = 0.5 last_epoch: int = -1 )
参数
-
optimizer
(~torch.optim.Optimizer
) — 要调整学习率的优化器。 -
num_warmup_steps
(int
) — 热身阶段的步数。 -
num_training_steps
(int
) — 总训练步数。 -
num_cycles
(float
, optional, defaults to 0.5) — 余弦计划中波数的数量(默认值是从最大值到 0 按照半余弦减少)。 -
last_epoch
(int
, optional, defaults to -1) — 恢复训练时的最后一个周期的索引。
创建一个学习率随余弦函数值下降的计划,从优化器中设置的初始 lr 到 0,经过一个热身阶段,在此期间学习率线性增加从 0 到优化器中设置的初始 lr。
####
transformers.get_cosine_with_hard_restarts_schedule_with_warmup
( optimizer: Optimizer num_warmup_steps: int num_training_steps: int num_cycles: int = 1 last_epoch: int = -1 )
参数
-
optimizer
(~torch.optim.Optimizer
) — 要调整学习率的优化器。 -
num_warmup_steps
(int
) — 热身阶段的步数。 -
num_training_steps
(int
) — 总训练步数。 -
num_cycles
(int
, optional, defaults to 1) — 要使用的硬重启次数。 -
last_epoch
(int
, optional, defaults to -1) — 恢复训练时的最后一个周期的索引。
创建一个学习率随余弦函数值下降的计划,从优化器中设置的初始 lr 到 0,经过几次硬重启,在此期间学习率线性增加从 0 到优化器中设置的初始 lr。
####
transformers.get_linear_schedule_with_warmup
( optimizer num_warmup_steps num_training_steps last_epoch = -1 )
参数
-
optimizer
(~torch.optim.Optimizer
) — 要调整学习率的优化器。 -
num_warmup_steps
(int
) — 热身阶段的步数。 -
num_training_steps
(int
) — 总训练步数。 -
last_epoch
(int
, optional, defaults to -1) — 恢复训练时的最后一个周期的索引。
创建一个学习率从优化器中设置的初始 lr 线性下降到 0 的计划,在此期间学习率从 0 线性增加到优化器中设置的初始 lr。
####
transformers.get_polynomial_decay_schedule_with_warmup
( optimizer num_warmup_steps num_training_steps lr_end = 1e-07 power = 1.0 last_epoch = -1 )
参数
-
optimizer
(~torch.optim.Optimizer
) — 要调整学习率的优化器。 -
num_warmup_steps
(int
) — 热身阶段的步数。 -
num_training_steps
(int
) — 总训练步数。 -
lr_end
(float
, optional, defaults to 1e-7) — 最终 LR。 -
power
(float
, optional, defaults to 1.0) — 功率因子。 -
last_epoch
(int
, optional, defaults to -1) — 恢复训练时的最后一个周期的索引。
创建一个学习率从优化器中设置的初始 lr 按多项式衰减到由lr_end定义的最终 lr 的计划,在此期间学习率从 0 线性增加到优化器中设置的初始 lr。
注意:power 默认为 1.0,与 fairseq 实现相同,fairseq 实现又基于原始 BERT 实现 github.com/google-research/bert/blob/f39e881b169b9d53bea03d2d341b31707a6c052b/optimization.py#L37
transformers.get_inverse_sqrt_schedule
( optimizer: Optimizer num_warmup_steps: int timescale: int = None last_epoch: int = -1 )
参数
-
optimizer
(~torch.optim.Optimizer
) — 要调整学习率的优化器。 -
num_warmup_steps
(int
) — 热身阶段的步数。 -
timescale
(int
, 可选, 默认为num_warmup_steps
) — 时间尺度。 -
last_epoch
(int
, 可选, 默认为 -1) — 恢复训练时的最后一个时代的索引。
创建一个具有反平方根学习率的调度,从优化器中设置的初始 lr 开始,在一个热身期间之后,该期间将使 lr 从 0 线性增加到优化器中设置的初始 lr。
Warmup(TensorFlow)
类 transformers.WarmUp
( initial_learning_rate: float decay_schedule_fn: Callable warmup_steps: int power: float = 1.0 name: str = None )
参数
-
initial_learning_rate
(float
) — 热身后调度的初始学习率(这将是热身结束时的学习率)。 -
decay_schedule_fn
(Callable
) — 在热身后应用于剩余训练的调度函数。 -
warmup_steps
(int
) — 训练中热身阶段的步数。 -
power
(float
, 可选, 默认为 1.0) — 用于多项式热身的幂(默认为线性热身)。 -
name
(str
, 可选) — 调度期间返回张量的可选名称前缀。
对给定学习率衰减调度应用热身调度。
梯度策略
GradientAccumulator(TensorFlow)
类 transformers.GradientAccumulator
( )
梯度累积实用程序。与分布策略一起使用时,应在副本上下文中调用累加器。梯度将在每个副本上本地累积,无需同步。然后用户应调用.gradients
,根据需要缩放梯度,并将结果传递给apply_gradients
。
重置
( )
重置当前副本上累积的梯度。
模型输出
原文链接:
huggingface.co/docs/transformers/v4.37.2/en/main_classes/output
所有模型的输出都是 ModelOutput 的子类实例。这些是包含模型返回的所有信息的数据结构,但也可以用作元组或字典。
让我们看一个示例:
from transformers import BertTokenizer, BertForSequenceClassification
import torch
tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")
model = BertForSequenceClassification.from_pretrained("bert-base-uncased")
inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
labels = torch.tensor([1]).unsqueeze(0) # Batch size 1
outputs = model(**inputs, labels=labels)
outputs
对象是一个 SequenceClassifierOutput,正如我们在下面该类的文档中所看到的,它包含一个可选的 loss
,一个 logits
,一个可选的 hidden_states
和一个可选的 attentions
属性。这里我们有 loss
,因为我们传递了 labels
,但是我们没有 hidden_states
和 attentions
,因为我们没有传递 output_hidden_states=True
或 output_attentions=True
。
当传递 output_hidden_states=True
时,您可以期望 outputs.hidden_states[-1]
与 outputs.last_hidden_states
完全匹配。然而,并非总是如此。当返回最后隐藏状态时,一些模型会应用归一化或后续处理。
您可以像通常一样访问每个属性,如果该属性未被模型返回,您将得到 None
。例如,在这里 outputs.loss
是模型计算的损失,而 outputs.attentions
是 None
。
将我们的 outputs
对象视为元组时,只考虑那些没有 None
值的属性。例如,在这里,它有两个元素,loss
然后 logits
,所以
outputs[:2]
例如,将返回元组 (outputs.loss, outputs.logits)
。
将我们的 outputs
对象视为字典时,只考虑那些没有 None
值的属性。例如,在这里,它有两个键,即 loss
和 logits
。
我们在这里记录了被多个模型类型使用的通用模型输出。特定的输出类型在其相应的模型页面上有文档。
ModelOutput
class transformers.utils.ModelOutput
( *args **kwargs )
作为数据类的所有模型输出的基类。具有 __getitem__
,允许按整数或切片(如元组)或字符串(如字典)进行索引,将忽略 None
属性。否则,行为类似于常规的 Python 字典。
你不能直接解包一个 ModelOutput
。在转换之前使用 to_tuple() 方法将其转换为元组。
to_tuple
( )
将自身转换为包含所有不是 None
的属性/键的元组。
BaseModelOutput
class transformers.modeling_outputs.BaseModelOutput
( last_hidden_state: FloatTensor = None hidden_states: Optional = None attentions: Optional = None )
参数
-
last_hidden_state
(torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
) — 模型最后一层的隐藏状态序列。 -
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组。模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions
(tuple(torch.FloatTensor)
, 可选的, 当output_attentions=True
被传递或者当config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。注意力权重在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
模型输出的基类,具有潜在的隐藏状态和注意力。
BaseModelOutputWithPooling
class transformers.modeling_outputs.BaseModelOutputWithPooling
( last_hidden_state: FloatTensor = None pooler_output: FloatTensor = None hidden_states: Optional = None attentions: Optional = None )
参数
-
last_hidden_state
(形状为
(batch_size, sequence_length, hidden_size)的
torch.FloatTensor`) — 模型最后一层的隐藏状态序列。 -
pooler_output
(形状为
(batch_size, hidden_size)的
torch.FloatTensor`) — 经过用于辅助预训练任务的层进一步处理后,序列中第一个标记(分类标记)的最后一层隐藏状态。例如,对于 BERT 系列模型,这返回经过线性层和 tanh 激活函数处理后的分类标记。线性层的权重是在预训练期间从下一个句子预测(分类)目标中训练的。 -
hidden_states
(tuple(torch.FloatTensor)
, 可选的, 当output_hidden_states=True
被传递或者当config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入输出的一个,加上每层的一个)。模型在每一层输出的隐藏状态加上可选的初始嵌入输出。
-
attentions
(tuple(torch.FloatTensor)
, 可选的, 当output_attentions=True
被传递或者当config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。注意力权重在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
模型输出的基类,还包含最后隐藏状态的池化。
BaseModelOutputWithCrossAttentions
class transformers.modeling_outputs.BaseModelOutputWithCrossAttentions
( last_hidden_state: FloatTensor = None hidden_states: Optional = None attentions: Optional = None cross_attentions: Optional = None )
参数
-
last_hidden_state
(形状为
(batch_size, sequence_length, hidden_size)的
torch.FloatTensor`) — 模型最后一层的隐藏状态序列。 -
hidden_states
(tuple(torch.FloatTensor)
, 可选的, 当output_hidden_states=True
被传递或者当config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入输出的一个,加上每层的一个)。模型在每一层输出的隐藏状态加上可选的初始嵌入输出。
-
attentions
(tuple(torch.FloatTensor)
, 可选的, 当output_attentions=True
被传递或者当config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。注意力权重在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
-
cross_attentions
(tuple(torch.FloatTensor)
, 可选的, 当output_attentions=True
和config.add_cross_attention=True
被传递或者当config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。
模型输出的基类,具有潜在的隐藏状态和注意力。
BaseModelOutputWithPoolingAndCrossAttentions
class transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions
( last_hidden_state: FloatTensor = None pooler_output: FloatTensor = None hidden_states: Optional = None past_key_values: Optional = None attentions: Optional = None cross_attentions: Optional = None )
参数
-
last_hidden_state
(torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
) — 模型最后一层的输出的隐藏状态序列。 -
pooler_output
(torch.FloatTensor
,形状为(batch_size, hidden_size)
) — 序列第一个标记(分类标记)的最后一层隐藏状态(经过用于辅助预训练任务的层进一步处理后)的输出。例如,对于 BERT 系列模型,这返回经过线性层和 tanh 激活函数处理后的分类标记。线性层的权重是从预训练期间的下一个句子预测(分类)目标中训练的。 -
hidden_states
(tuple(torch.FloatTensor)
, 可选的,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 元组的torch.FloatTensor
(如果模型有嵌入层,则为嵌入的输出+每一层的输出)的形状为(batch_size, sequence_length, hidden_size)
。模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions
(tuple(torch.FloatTensor)
, 可选的,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
的元组(每层一个)。注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
-
cross_attentions
(tuple(torch.FloatTensor)
, 可选的,当传递output_attentions=True
和config.add_cross_attention=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
的元组(每层一个)。解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。
-
past_key_values
(tuple(tuple(torch.FloatTensor))
, 可选的,当传递use_cache=True
或config.use_cache=True
时返回) — 长度为config.n_layers
的tuple(torch.FloatTensor)
的元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量,如果config.is_encoder_decoder=True
还有 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的张量。包含预先计算的隐藏状态(自注意力块中的键和值,以及如果
config.is_encoder_decoder=True
在交叉注意力块中)可用于加速顺序解码(请参见past_key_values
输入)。
模型输出的基类,还包含最后隐藏状态的池化。
BaseModelOutputWithPast
class transformers.modeling_outputs.BaseModelOutputWithPast
( last_hidden_state: FloatTensor = None past_key_values: Optional = None hidden_states: Optional = None attentions: Optional = None )
参数
-
last_hidden_state
(torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
) — 模型最后一层的输出的隐藏状态序列。如果使用
past_key_values
,则只输出形状为(batch_size, 1, hidden_size)
的序列的最后一个隐藏状态。 -
past_key_values
(tuple(tuple(torch.FloatTensor))
,可选,当传递use_cache=True
或config.use_cache=True
时返回)- 长度为config.n_layers
的tuple(torch.FloatTensor)
元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量,如果config.is_encoder_decoder=True
还有 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的张量。包含预先计算的隐藏状态(自注意力块中的键和值,以及在交叉注意力块中如果
config.is_encoder_decoder=True
的情况下)可以用来加速顺序解码。 -
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)- 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入的输出+每层的输出)。模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
模型输出的基类,可能还包含过去的键/值(用于加速顺序解码)。
BaseModelOutputWithPastAndCrossAttentions
class transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions
( last_hidden_state: FloatTensor = None past_key_values: Optional = None hidden_states: Optional = None attentions: Optional = None cross_attentions: Optional = None )
参数
-
last_hidden_state
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
)- 模型最后一层输出的隐藏状态序列。如果使用
past_key_values
,则只输出形状为(batch_size, 1, hidden_size)
的序列的最后一个隐藏状态。 -
past_key_values
(tuple(tuple(torch.FloatTensor))
,可选,当传递use_cache=True
或config.use_cache=True
时返回)- 长度为config.n_layers
的tuple(torch.FloatTensor)
元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量,如果config.is_encoder_decoder=True
还有 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的张量。包含预先计算的隐藏状态(自注意力块中的键和值,以及在交叉注意力块中如果
config.is_encoder_decoder=True
的情况下)可以用来加速顺序解码。 -
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)- 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入的输出+每层的输出)。模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
-
cross_attentions
(tuple(torch.FloatTensor)
, optional, 当output_attentions=True
和config.add_cross_attention=True
被传递或者当config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。
模型输出的基类,可能还包含过去的键/值(用于加速顺序解码)。
Seq2SeqModelOutput
class transformers.modeling_outputs.Seq2SeqModelOutput
( last_hidden_state: FloatTensor = None past_key_values: Optional = None decoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None )
参数
-
last_hidden_state
(torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
) — 模型解码器最后一层的隐藏状态序列。如果使用
past_key_values
,则只输出形状为(batch_size, 1, hidden_size)
的序列的最后隐藏状态。 -
past_key_values
(tuple(tuple(torch.FloatTensor))
, optional, 当use_cache=True
被传递或者当config.use_cache=True
时返回) — 长度为config.n_layers
的tuple(torch.FloatTensor)
元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的张量。包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码。
-
decoder_hidden_states
(tuple(torch.FloatTensor)
, optional, 当output_hidden_states=True
被传递或者当config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入层的输出加上每层的输出)。解码器在每一层输出的隐藏状态加上可选的初始嵌入输出。
-
decoder_attentions
(tuple(torch.FloatTensor)
, optional, 当output_attentions=True
被传递或者当config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
-
cross_attentions
(tuple(torch.FloatTensor)
, optional, 当output_attentions=True
被传递或者当config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state
(torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
,optional) — 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(torch.FloatTensor)
, optional, 当output_hidden_states=True
被传递或者当config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入层的输出加上每层的输出)。编码器在每一层输出的隐藏状态加上可选的初始嵌入输出。
-
encoder_attentions
(tuple(torch.FloatTensor)
, optional, 当output_attentions=True
被传递或者当config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。编码器的注意力权重,在注意力 softmax 后使用,用于计算自注意力头中的加权平均值。
模型编码器输出的基类,还包含:预先计算的隐藏状态,可以加速顺序解码。
CausalLMOutput
class transformers.modeling_outputs.CausalLMOutput
( loss: Optional = None logits: FloatTensor = None hidden_states: Optional = None attentions: Optional = None )
参数
-
loss
(torch.FloatTensor
,形状为(1,)
,可选,当提供labels
时返回) — 语言建模损失(用于下一个标记的预测)。 -
logits
(torch.FloatTensor
,形状为(batch_size, sequence_length, config.vocab_size)
) — 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。 -
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入输出的输出+每层的输出)。模型在每一层输出的隐藏状态,以及可选的初始嵌入输出。
-
attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
因果语言模型(或自回归)输出的基类。
CausalLMOutputWithCrossAttentions
class transformers.modeling_outputs.CausalLMOutputWithCrossAttentions
( loss: Optional = None logits: FloatTensor = None past_key_values: Optional = None hidden_states: Optional = None attentions: Optional = None cross_attentions: Optional = None )
参数
-
loss
(torch.FloatTensor
,形状为(1,)
,可选,当提供labels
时返回) — 语言建模损失(用于下一个标记的预测)。 -
logits
(torch.FloatTensor
,形状为(batch_size, sequence_length, config.vocab_size)
) — 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。 -
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入输出的输出+每层的输出)。模型在每一层输出的隐藏状态,以及可选的初始嵌入输出。
-
attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
-
cross_attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。交叉注意力 softmax 后的注意力权重,用于计算交叉注意力头中的加权平均值。
-
past_key_values
(tuple(tuple(torch.FloatTensor))
,可选,当传递use_cache=True
或config.use_cache=True
时返回) — 长度为config.n_layers
的torch.FloatTensor
元组,每个元组包含自注意力和交叉注意力层的缓存键、值状态,如果模型用于编码器-解码器设置,则相关。仅在config.is_decoder = True
时相关。包含预先计算的隐藏状态(注意力块中的键和值),可用于加速顺序解码。
因果语言模型(或自回归)输出的基类。
CausalLMOutputWithPast
class transformers.modeling_outputs.CausalLMOutputWithPast
( loss: Optional = None logits: FloatTensor = None past_key_values: Optional = None hidden_states: Optional = None attentions: Optional = None )
参数
-
loss
(形状为(1,)
的torch.FloatTensor
,可选,当提供labels
时返回)— 语言建模损失(用于下一个标记的预测)。 -
logits
(形状为(batch_size, sequence_length, config.vocab_size)
的torch.FloatTensor
)— 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。 -
past_key_values
(tuple(tuple(torch.FloatTensor))
,可选,当传递use_cache=True
或config.use_cache=True
时返回)— 长度为config.n_layers
的tuple(torch.FloatTensor)
元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量)包含预先计算的隐藏状态(自注意力块中的键和值),可用于加速顺序解码。
-
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)— 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入的输出+每层的输出)。模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
因果语言模型(或自回归)输出的基类。
MaskedLMOutput
class transformers.modeling_outputs.MaskedLMOutput
( loss: Optional = None logits: FloatTensor = None hidden_states: Optional = None attentions: Optional = None )
参数
-
loss
(形状为(1,)
的torch.FloatTensor
,可选,当提供labels
时返回)— 掩码语言建模(MLM)损失。 -
logits
(形状为(batch_size, sequence_length, config.vocab_size)
的torch.FloatTensor
)— 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。 -
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)— 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入的输出+每层的输出)。模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
掩码语言模型输出的基类。
Seq2SeqLMOutput
class transformers.modeling_outputs.Seq2SeqLMOutput
( loss: Optional = None logits: FloatTensor = None past_key_values: Optional = None decoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None )
参数
-
loss
(形状为(1,)
的torch.FloatTensor
,可选,当提供labels
时返回)— 语言建模损失。 -
logits
(形状为(batch_size, sequence_length, config.vocab_size)
的torch.FloatTensor
)— 语言建模头的预测分数(SoftMax 之前的每个词汇标记的分数)。 -
past_key_values
(tuple(tuple(torch.FloatTensor))
,可选,当传递use_cache=True
或config.use_cache=True
时返回)— 长度为config.n_layers
的tuple(torch.FloatTensor)
元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量,以及 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的张量。包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码(参见
past_key_values
输入)。 -
decoder_hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)— 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入输出的一个+每层输出的一个)。每层解码器的隐藏状态加上初始嵌入输出。
-
decoder_attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
-
cross_attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state
(torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
,可选)— 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)— 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入输出的一个+每层输出的一个)。每层编码器的隐藏状态加上初始嵌入输出。
-
encoder_attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
用于序列到序列语言模型输出的基类。
NextSentencePredictorOutput
class transformers.modeling_outputs.NextSentencePredictorOutput
( loss: Optional = None logits: FloatTensor = None hidden_states: Optional = None attentions: Optional = None )
参数
-
loss
(torch.FloatTensor
,形状为(1,)
,可选,当提供next_sentence_label
时返回)— 下一个序列预测(分类)损失。 -
logits
(形状为(batch_size, 2)
的torch.FloatTensor
)— 下一个序列预测(分类)头的预测分数(SoftMax 之前的 True/False 延续分数)。 -
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)— 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入输出的一个 + 每层的输出)。模型每层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
预测两个句子是否连续的模型输出的基类。
SequenceClassifierOutput
class transformers.modeling_outputs.SequenceClassifierOutput
( loss: Optional = None logits: FloatTensor = None hidden_states: Optional = None attentions: Optional = None )
参数
-
loss
(形状为(1,)
的torch.FloatTensor
,可选,在提供labels
时返回)— 分类(如果config.num_labels==1
则为回归)损失。 -
logits
(形状为(batch_size, config.num_labels)
的torch.FloatTensor
)— 分类(如果config.num_labels==1
则为回归)得分(SoftMax 之前)。 -
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)— 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入输出的一个 + 每层的输出)。模型每层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
句子分类模型输出的基类。
Seq2SeqSequenceClassifierOutput
class transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput
( loss: Optional = None logits: FloatTensor = None past_key_values: Optional = None decoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None )
参数
-
loss
(形状为(1,)
的torch.FloatTensor
,可选,在提供label
时返回)— 分类(如果config.num_labels==1
则为回归)损失。 -
logits
(形状为(batch_size, config.num_labels)
的torch.FloatTensor
)— 分类(如果config.num_labels==1
则为回归)得分(SoftMax 之前)。 -
past_key_values
(tuple(tuple(torch.FloatTensor))
,可选,当传递use_cache=True
或config.use_cache=True
时返回)— 长度为config.n_layers
的tuple(torch.FloatTensor)
元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的张量。包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码(见
past_key_values
输入)。 -
decoder_hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)— 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入输出的一个 + 每层的输出)。每层解码器的隐藏状态以及初始嵌入输出。
-
decoder_attentions
(tuple(torch.FloatTensor)
,可选的,当传递output_attentions=True
或当config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
-
cross_attentions
(tuple(torch.FloatTensor)
,可选的,当传递output_attentions=True
或当config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state
(torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
,可选的) — 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(torch.FloatTensor)
, 可选的, 当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入层的输出,如果模型有嵌入层,+ 一个用于每一层的输出)。每层编码器的隐藏状态加上初始嵌入输出。
-
encoder_attentions
(tuple(torch.FloatTensor)
,可选的,当传递output_attentions=True
或当config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
序列到序列句子分类模型输出的基类。
MultipleChoiceModelOutput
class transformers.modeling_outputs.MultipleChoiceModelOutput
( loss: Optional = None logits: FloatTensor = None hidden_states: Optional = None attentions: Optional = None )
参数
-
loss
(torch.FloatTensor
,形状为(1,),可选的,当提供labels
时返回) — 分类损失。 -
logits
(torch.FloatTensor
,形状为(batch_size, num_choices)
) — num_choices是输入张量的第二维度。(参见上面的input_ids)。分类得分(SoftMax 之前)。
-
hidden_states
(tuple(torch.FloatTensor)
,可选的,当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入层的输出,如果模型有嵌入层,+ 一个用于每一层的输出)。模型每一层的隐藏状态加上可选的初始嵌入输出。
-
attentions
(tuple(torch.FloatTensor)
,可选的,当传递output_attentions=True
或当config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
多选模型输出的基类。
TokenClassifierOutput
class transformers.modeling_outputs.TokenClassifierOutput
( loss: Optional = None logits: FloatTensor = None hidden_states: Optional = None attentions: Optional = None )
参数
-
loss
(torch.FloatTensor
,形状为(1,)
,可选的,当提供labels
时返回) — 分类损失。 -
logits
(torch.FloatTensor
,形状为(batch_size, sequence_length, config.num_labels)
) — 分类得分(SoftMax 之前)。 -
hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入输出和每层输出的总和)。模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
用于标记分类模型输出的基类。
QuestionAnsweringModelOutput
class transformers.modeling_outputs.QuestionAnsweringModelOutput
( loss: Optional = None start_logits: FloatTensor = None end_logits: FloatTensor = None hidden_states: Optional = None attentions: Optional = None )
参数
-
loss
(torch.FloatTensor
,形状为(1,)
,optional,当提供labels
时返回) — 总跨度提取损失是起始位置和结束位置的交叉熵之和。 -
start_logits
(torch.FloatTensor
,形状为(batch_size, sequence_length)
) — 跨度起始得分(SoftMax 之前)。 -
end_logits
(torch.FloatTensor
,形状为(batch_size, sequence_length)
) — 跨度结束得分(SoftMax 之前)。 -
hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入输出和每层输出的总和)。模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
用于问答模型输出的基类。
Seq2SeqQuestionAnsweringModelOutput
class transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput
( loss: Optional = None start_logits: FloatTensor = None end_logits: FloatTensor = None past_key_values: Optional = None decoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None )
参数
-
loss
(torch.FloatTensor
,形状为(1,)
,optional,当提供labels
时返回) — 总跨度提取损失是起始位置和结束位置的交叉熵之和。 -
start_logits
(torch.FloatTensor
,形状为(batch_size, sequence_length)
) — 跨度起始得分(SoftMax 之前)。 -
end_logits
(torch.FloatTensor
,形状为(batch_size, sequence_length)
) — 跨度结束得分(SoftMax 之前)。 -
past_key_values
(tuple(tuple(torch.FloatTensor))
, optional, 当传递use_cache=True
或config.use_cache=True
时返回) — 长度为config.n_layers
的tuple(torch.FloatTensor)
元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的张量。包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码(参见
past_key_values
输入)。 -
decoder_hidden_states
(tuple(torch.FloatTensor)
, 可选, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入输出的一个 + 每个层的输出的一个)。每层解码器的隐藏状态加上初始嵌入输出。
-
decoder_attentions
(tuple(torch.FloatTensor)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
-
cross_attentions
(tuple(torch.FloatTensor)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。解码器交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state
(torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
,可选) — 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(torch.FloatTensor)
, 可选, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入输出的一个 + 每个层的输出的一个)。每层编码器的隐藏状态加上初始嵌入输出。
-
encoder_attentions
(tuple(torch.FloatTensor)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
用于序列到序列问答模型输出的基类。
Seq2SeqSpectrogramOutput
class transformers.modeling_outputs.Seq2SeqSpectrogramOutput
( loss: Optional = None spectrogram: FloatTensor = None past_key_values: Optional = None decoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None )
参数
-
loss
(torch.FloatTensor
,形状为(1,)
,可选, 当提供labels
时返回) — 频谱生成损失。 -
spectrogram
(torch.FloatTensor
,形状为(batch_size, sequence_length, num_bins)
) — 预测的频谱图。 -
past_key_values
(tuple(tuple(torch.FloatTensor))
, 可选, 当传递use_cache=True
或config.use_cache=True
时返回) — 长度为config.n_layers
的tuple(torch.FloatTensor)
元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的张量。包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码(参见
past_key_values
输入)。 -
decoder_hidden_states
(tuple(torch.FloatTensor)
, 可选, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入输出的一个 + 每个层的输出的一个)。每层解码器的隐藏状态加上初始嵌入输出。
-
decoder_attentions
(tuple(torch.FloatTensor)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
-
cross_attentions
(tuple(torch.FloatTensor)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state
(torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
,可选) — 模型编码器最后一层的输出的隐藏状态序列。 -
encoder_hidden_states
(tuple(torch.FloatTensor)
, 可选, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入输出的一个 + 每一层的输出的一个)。每一层输出的编码器的隐藏状态加上初始嵌入输出。
-
encoder_attentions
(tuple(torch.FloatTensor)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
用于序列到序列频谱图输出的基类。
SemanticSegmenterOutput
class transformers.modeling_outputs.SemanticSegmenterOutput
( loss: Optional = None logits: FloatTensor = None hidden_states: Optional = None attentions: Optional = None )
参数
-
loss
(torch.FloatTensor
,形状为(1,)
,可选, 当提供labels
时返回) — 分类(如果config.num_labels==1
则为回归)损失。 -
logits
(torch.FloatTensor
,形状为(batch_size, config.num_labels, logits_height, logits_width)
) — 每个像素的分类分数。返回的 logits 不一定与传入的
pixel_values
大小相同。这是为了避免进行两次插值并在用户需要将 logits 调整为原始图像大小时丢失一些质量。您应该始终检查您的 logits 形状并根据需要调整大小。 -
hidden_states
(tuple(torch.FloatTensor)
, 可选, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, patch_size, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入输出的一个 + 每一层的输出的一个)。模型在每一层输出的隐藏状态加上可选的初始嵌入输出。
-
attentions
(tuple(torch.FloatTensor)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, patch_size, sequence_length)
的torch.FloatTensor
元组(每层一个)。注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
用于语义分割模型输出的基类。
ImageClassifierOutput
class transformers.modeling_outputs.ImageClassifierOutput
( loss: Optional = None logits: FloatTensor = None hidden_states: Optional = None attentions: Optional = None )
参数
-
loss
(torch.FloatTensor
,形状为(1,)
,可选,当提供labels
时返回) — 分类(如果config.num_labels==1
则为回归)损失。 -
logits
(torch.FloatTensor
,形状为(batch_size, config.num_labels)
) — 分类(如果config.num_labels==1
则为回归)得分(SoftMax 之前)。 -
hidden_states
(tuple(torch.FloatTensor)
, 可选, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组。模型在每个阶段输出的隐藏状态(也称为特征图)。 -
attentions
(tuple(torch.FloatTensor)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, patch_size, sequence_length)
的torch.FloatTensor
元组。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
图像分类模型输出的基类。
ImageClassifierOutputWithNoAttention
class transformers.modeling_outputs.ImageClassifierOutputWithNoAttention
( loss: Optional = None logits: FloatTensor = None hidden_states: Optional = None )
参数
-
loss
(torch.FloatTensor
,形状为(1,)
,可选,当提供labels
时返回) — 分类(如果config.num_labels==1
则为回归)损失。 -
logits
(torch.FloatTensor
,形状为(batch_size, config.num_labels)
) — 分类(如果config.num_labels==1
则为回归)得分(SoftMax 之前)。 -
hidden_states
(tuple(torch.FloatTensor)
, 可选, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, num_channels, height, width)
的torch.FloatTensor
元组。模型在每个阶段输出的隐藏状态(也称为特征图)。
图像分类模型输出的基类。
DepthEstimatorOutput
class transformers.modeling_outputs.DepthEstimatorOutput
( loss: Optional = None predicted_depth: FloatTensor = None hidden_states: Optional = None attentions: Optional = None )
参数
-
loss
(torch.FloatTensor
,形状为(1,)
,可选,当提供labels
时返回) — 分类(如果config.num_labels==1
则为回归)损失。 -
predicted_depth
(torch.FloatTensor
,形状为(batch_size, height, width)
) — 每个像素的预测深度。 -
hidden_states
(tuple(torch.FloatTensor)
, 可选, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, num_channels, height, width)
的torch.FloatTensor
元组。模型在每个层输出的隐藏状态加上可选的初始嵌入输出。
-
attentions
(tuple(torch.FloatTensor)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, patch_size, sequence_length)
的torch.FloatTensor
元组。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
深度估计模型输出的基类。
Wav2Vec2BaseModelOutput
class transformers.modeling_outputs.Wav2Vec2BaseModelOutput
( last_hidden_state: FloatTensor = None extract_features: FloatTensor = None hidden_states: Optional = None attentions: Optional = None )
参数
-
last_hidden_state
(torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
) — 模型最后一层输出的隐藏状态序列。 -
extract_features
(torch.FloatTensor
,形状为(batch_size, sequence_length, conv_dim[-1])
) — 模型最后一个卷积层提取的特征向量序列。 -
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每一层的输出)。模型在每一层输出的隐藏状态加上初始嵌入输出。
-
attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每一层一个)。注意力权重在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
用于使用 Wav2Vec2 损失目标进行训练的模型的基类。
XVectorOutput
class transformers.modeling_outputs.XVectorOutput
( loss: Optional = None logits: FloatTensor = None embeddings: FloatTensor = None hidden_states: Optional = None attentions: Optional = None )
参数
-
loss
(torch.FloatTensor
,形状为(1,)
,可选,当提供labels
时返回) — 分类损失。 -
logits
(torch.FloatTensor
,形状为(batch_size, config.xvector_output_dim)
) — AMSoftmax 之前的分类隐藏状态。 -
embeddings
(torch.FloatTensor
,形状为(batch_size, config.xvector_output_dim)
) — 用于基于向量相似性检索的话语嵌入。 -
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每一层的输出)。模型在每一层输出的隐藏状态加上初始嵌入输出。
-
attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每一层一个)。注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
Wav2Vec2ForXVector 的输出类型。
Seq2SeqTSModelOutput
class transformers.modeling_outputs.Seq2SeqTSModelOutput
( last_hidden_state: FloatTensor = None past_key_values: Optional = None decoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None loc: Optional = None scale: Optional = None static_features: Optional = None )
参数
-
last_hidden_state
(torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
) — 模型解码器最后一层的隐藏状态序列。如果使用了
past_key_values
,则只输出形状为(batch_size, 1, hidden_size)
的序列的最后隐藏状态。 -
past_key_values
(tuple(tuple(torch.FloatTensor))
,可选,当传递use_cache=True
或config.use_cache=True
时返回) — 长度为config.n_layers
的tuple(torch.FloatTensor)
元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的张量。包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码(参见
past_key_values
输入)。 -
decoder_hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) —torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入层的输出+每层的输出)的形状为(batch_size, sequence_length, hidden_size)
。解码器在每一层输出的隐藏状态以及可选的初始嵌入输出。
-
decoder_attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) —torch.FloatTensor
元组(每层一个)的形状为(batch_size, num_heads, sequence_length, sequence_length)
。解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
-
cross_attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) —torch.FloatTensor
元组(每层一个)的形状为(batch_size, num_heads, sequence_length, sequence_length)
。解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state
(torch.FloatTensor
of shape(batch_size, sequence_length, hidden_size)
, optional) — 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) —torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入层的输出+每层的输出)的形状为(batch_size, sequence_length, hidden_size)
。编码器在每一层输出的隐藏状态以及可选的初始嵌入输出。
-
encoder_attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) —torch.FloatTensor
元组(每层一个)的形状为(batch_size, num_heads, sequence_length, sequence_length)
。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
-
loc
(torch.FloatTensor
of shape(batch_size,)
or(batch_size, input_size)
, optional) — 每个时间序列上下文窗口的偏移值,用于给模型输入相同数量级的输入,然后用于将其偏移回原始数量级。 -
scale
(torch.FloatTensor
of shape(batch_size,)
or(batch_size, input_size)
, optional) — 每个时间序列上下文窗口的缩放值,用于给模型输入相同数量级的输入,然后用于将其重新缩放回原始数量级。 -
static_features
(torch.FloatTensor
of shape(batch_size, feature size)
, optional) — 每个时间序列在批处理中的静态特征,在推断时复制到协变量中。
时间序列模型编码器输出的基类,还包含可以加速顺序解码的预计算隐藏状态。
Seq2SeqTSPredictionOutput
class transformers.modeling_outputs.Seq2SeqTSPredictionOutput
( loss: Optional = None params: Optional = None past_key_values: Optional = None decoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None loc: Optional = None scale: Optional = None static_features: Optional = None )
参数
-
loss
(torch.FloatTensor
of shape(1,)
, optional, 当提供future_values
时返回) — 分布损失。 -
params
(torch.FloatTensor
of shape(batch_size, num_samples, num_params)
) — 所选分布的参数。 -
past_key_values
(tuple(tuple(torch.FloatTensor))
, optional, 当传递use_cache=True
或config.use_cache=True
时返回) — 长度为config.n_layers
的tuple(torch.FloatTensor)
元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的张量。包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码。
-
decoder_hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组。解码器每一层的输出隐藏状态加上初始嵌入输出。
-
decoder_attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组。解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
-
cross_attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组。解码器交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state
(torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
,optional) — 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组。编码器每一层的输出隐藏状态加上初始嵌入输出。
-
encoder_attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
-
loc
(torch.FloatTensor
,形状为(batch_size,)
或(batch_size, input_size)
,optional) — 每个时间序列上下文窗口的偏移值,用于给模型输入相同数量级的值,然后用于将其偏移回原始数量级。 -
scale
(torch.FloatTensor
,形状为(batch_size,)
或(batch_size, input_size)
,optional) — 每个时间序列上下文窗口的缩放值,用于给模型输入相同数量级的值,然后用于将其重新缩放回原始数量级。 -
static_features
(torch.FloatTensor
,形状为(batch_size, feature size)
,optional) — 每个时间序列批次的静态特征,在推断时复制到协变量中。
时间序列模型解码器输出的基类,还包含损失以及所选分布的参数。
SampleTSPredictionOutput
class transformers.modeling_outputs.SampleTSPredictionOutput
( sequences: FloatTensor = None )
参数
sequences
(torch.FloatTensor
,形状为(batch_size, num_samples, prediction_length)
或(batch_size, num_samples, prediction_length, input_size)
) — 从选择的分布中抽样的值。
时间序列模型预测输出的基类,包含从选择的分布中抽样的值。
TFBaseModelOutput
class transformers.modeling_tf_outputs.TFBaseModelOutput
( last_hidden_state: tf.Tensor = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None )
参数
-
last_hidden_state
(tf.Tensor
,形状为(batch_size, sequence_length, hidden_size)
) — 模型最后一层的隐藏状态序列。 -
hidden_states
(tuple(tf.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入输出 + 一个用于每一层的输出)。模型每一层的隐藏状态以及初始嵌入输出。
-
attentions
(tuple(tf.Tensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每一层一个)。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
模型输出的基类,具有潜在的隐藏状态和注意力。
TFBaseModelOutputWithPooling
class transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling
( last_hidden_state: tf.Tensor = None pooler_output: tf.Tensor = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None )
参数
-
last_hidden_state
(tf.Tensor
,形状为(batch_size, sequence_length, hidden_size)
) — 模型最后一层的隐藏状态序列。 -
pooler_output
(tf.Tensor
,形状为(batch_size, hidden_size)
) — 序列第一个标记(分类标记)的最后一层隐藏状态,进一步由线性层和 Tanh 激活函数处理。线性层的权重是在预训练期间从下一个句子预测(分类)目标中训练的。这个输出通常不是输入语义内容的好摘要,通常最好对整个输入序列的隐藏状态进行平均或池化。
-
hidden_states
(tuple(tf.Tensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入输出 + 一个用于每一层的输出)。模型每一层的隐藏状态以及初始嵌入输出。
-
attentions
(tuple(tf.Tensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每一层一个)。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
模型输出的基类,还包含最后隐藏状态的汇聚。
TFBaseModelOutputWithPoolingAndCrossAttentions
class transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions
( last_hidden_state: tf.Tensor = None pooler_output: tf.Tensor = None past_key_values: List[tf.Tensor] | None = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None cross_attentions: Tuple[tf.Tensor] | None = None )
参数
-
last_hidden_state
(tf.Tensor
,形状为(batch_size, sequence_length, hidden_size)
) — 模型最后一层的隐藏状态序列。 -
pooler_output
(tf.Tensor
,形状为(batch_size, hidden_size)
) — 序列第一个标记(分类标记)的最后一层隐藏状态,经过线性层和 Tanh 激活函数进一步处理。线性层的权重在预训练期间从下一个句子预测(分类)目标中训练。该输出通常不是输入语义内容的良好摘要,通常最好对整个输入序列的隐藏状态序列进行平均或池化。
-
past_key_values
(List[tf.Tensor]
, optional, 当传递use_cache=True
或config.use_cache=True
时返回) — 长度为config.n_layers
的tf.Tensor
列表,每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)
。包含预先计算的隐藏状态(注意力块中的键和值),可用于加速顺序解码(参见
past_key_values
输入)。 -
hidden_states
(tuple(tf.Tensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入的输出 + 一个用于每一层的输出)。模型每一层输出的隐藏状态以及初始嵌入输出。
-
attentions
(tuple(tf.Tensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每一层一个)。在自注意力头中使用注意力 softmax 后的注意力权重,用于计算加权平均值。
-
cross_attentions
(tuple(tf.Tensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每一层一个)。在解码器的交叉注意力层中使用注意力 softmax 后的注意力权重,用于计算交叉注意力头中的加权平均值。
模型输出的基类,还包含最后隐藏状态的池化。
TFBaseModelOutputWithPast
class transformers.modeling_tf_outputs.TFBaseModelOutputWithPast
( last_hidden_state: tf.Tensor = None past_key_values: List[tf.Tensor] | None = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None )
参数
-
last_hidden_state
(tf.Tensor
,形状为(batch_size, sequence_length, hidden_size)
) — 模型最后一层的隐藏状态序列。如果使用
past_key_values
,则只输出形状为(batch_size, 1, hidden_size)
的序列的最后隐藏状态。 -
past_key_values
(List[tf.Tensor]
, optional, 当传递use_cache=True
或config.use_cache=True
时返回) — 长度为config.n_layers
的tf.Tensor
列表,每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)
。包含预先计算的隐藏状态(注意力块中的键和值),可用于加速顺序解码(参见
past_key_values
输入)。 -
hidden_states
(tuple(tf.Tensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入的输出 + 一个用于每一层的输出)。模型每一层输出的隐藏状态以及初始嵌入输出。
-
attentions
(tuple(tf.Tensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每一层一个)。在自注意力头中使用注意力 softmax 后的注意力权重,用于计算加权平均值。
模型输出的基类,可能还包含过去的键/值(用于加速顺序解码)。
TFBaseModelOutputWithPastAndCrossAttentions
class transformers.modeling_tf_outputs.TFBaseModelOutputWithPastAndCrossAttentions
( last_hidden_state: tf.Tensor = None past_key_values: List[tf.Tensor] | None = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None cross_attentions: Tuple[tf.Tensor] | None = None )
参数
-
last_hidden_state
(形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
)- 模型最后一层的隐藏状态序列。如果仅使用
past_key_values
,则输出序列的最后一个隐藏状态的形状为(batch_size, 1, hidden_size)
。 -
past_key_values
(List[tf.Tensor]
,可选,当传递use_cache=True
或config.use_cache=True
时返回)- 长度为config.n_layers
的tf.Tensor
列表,每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)
。包含预计算的隐藏状态(注意力块中的键和值),可用于加速顺序解码。
-
hidden_states
(tuple(tf.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)- 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入的输出 + 一个用于每层的输出)。模型在每一层输出的隐藏状态加上初始嵌入输出。
-
attentions
(tuple(tf.Tensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每层一个)。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
-
cross_attentions
(tuple(tf.Tensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每层一个)。解码器的交叉注意力层的注意力权重,在注意力 softmax 后,用于计算交叉注意力头中的加权平均值。
模型输出的基类,可能还包含过去的键/值(用于加速顺序解码)。
TFSeq2SeqModelOutput
class transformers.modeling_tf_outputs.TFSeq2SeqModelOutput
( last_hidden_state: tf.Tensor = None past_key_values: List[tf.Tensor] | None = None decoder_hidden_states: Tuple[tf.Tensor] | None = None decoder_attentions: Tuple[tf.Tensor] | None = None cross_attentions: Tuple[tf.Tensor] | None = None encoder_last_hidden_state: tf.Tensor | None = None encoder_hidden_states: Tuple[tf.Tensor] | None = None encoder_attentions: Tuple[tf.Tensor] | None = None )
参数
-
last_hidden_state
(形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
)- 模型解码器最后一层的隐藏状态序列。如果仅使用
past_key_values
,则输出序列的最后一个隐藏状态的形状为(batch_size, 1, hidden_size)
。 -
past_key_values
(List[tf.Tensor]
,可选,当传递use_cache=True
或config.use_cache=True
时返回)- 长度为config.n_layers
的tf.Tensor
列表,每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)
。包含解码器的预计算隐藏状态(注意力块中的键和值),可用于加速顺序解码。
-
decoder_hidden_states
(tuple(tf.Tensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)- 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入的输出 + 一个用于每层的输出)。解码器在每一层输出的隐藏状态加上初始嵌入输出。
-
decoder_attentions
(tuple(tf.Tensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每层一个)。解码器的注意力权重,在注意力 softmax 后,用于计算自注意力头中的加权平均值。
-
cross_attentions
(tuple(tf.Tensor)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每个层一个)。解码器的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state
(tf.Tensor
,形状为(batch_size, sequence_length, hidden_size)
,可选) — 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(tf.Tensor)
, 可选, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。模型编码器在每个层的输出以及初始嵌入输出的隐藏状态。
-
encoder_attentions
(tuple(tf.Tensor)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每个层一个)。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
模型编码器输出的基类,还包含:可以加速顺序解码的预先计算的隐藏状态。
TFCausalLMOutput
class transformers.modeling_tf_outputs.TFCausalLMOutput
( loss: tf.Tensor | None = None logits: tf.Tensor = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None )
参数
-
loss
(tf.Tensor
,形状为(n,)
,可选, 当提供labels
时返回,其中 n 是非掩码标签的数量) — 语言建模损失(用于下一个标记的预测)。 -
logits
(tf.Tensor
,形状为(batch_size, sequence_length, config.vocab_size)
) — 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。 -
hidden_states
(tuple(tf.Tensor)
, 可选, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。模型在每个层的输出以及初始嵌入输出的隐藏状态。
-
attentions
(tuple(tf.Tensor)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每个层一个)。注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
因果语言模型(或自回归)输出的基类。
TFCausalLMOutputWithCrossAttentions
class transformers.modeling_tf_outputs.TFCausalLMOutputWithCrossAttentions
( loss: tf.Tensor | None = None logits: tf.Tensor = None past_key_values: List[tf.Tensor] | None = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None cross_attentions: Tuple[tf.Tensor] | None = None )
参数
-
loss
(tf.Tensor
,形状为(n,)
,可选, 当提供labels
时返回,其中 n 是非掩码标签的数量) — 语言建模损失(用于下一个标记的预测)。 -
logits
(tf.Tensor
,形状为(batch_size, sequence_length, config.vocab_size)
) — 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。 -
hidden_states
(tuple(tf.Tensor)
, 可选, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。模型在每个层的输出以及初始嵌入输出的隐藏状态。
-
attentions
(tuple(tf.Tensor)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每个层一个)。注意力权重在注意力 SoftMax 之后,用于计算自注意力头中的加权平均值。
-
cross_attentions
(tuple(tf.Tensor)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每个层一个)。解码器交叉注意力层的注意力权重,在注意力 SoftMax 之后,用于计算交叉注意力头中的加权平均值。
-
past_key_values
(List[tf.Tensor]
, 可选, 当传递use_cache=True
或config.use_cache=True
时返回) — 长度为config.n_layers
的tf.Tensor
列表,每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)
。包含预先计算的隐藏状态(注意力块中的键和值),可用于加速顺序解码。
用于因果语言模型(或自回归)输出的基类。
TFCausalLMOutputWithPast
class transformers.modeling_tf_outputs.TFCausalLMOutputWithPast
( loss: tf.Tensor | None = None logits: tf.Tensor = None past_key_values: List[tf.Tensor] | None = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None )
参数
-
loss
(tf.Tensor
of shape(n,)
, 可选, 其中 n 是非掩码标签的数量,当提供labels
时返回) — 语言建模损失(用于下一个标记预测)。 -
logits
(tf.Tensor
of shape(batch_size, sequence_length, config.vocab_size)
) — 语言建模头部的预测分数(SoftMax 之前每个词汇标记的分数)。 -
past_key_values
(List[tf.Tensor]
, 可选, 当传递use_cache=True
或config.use_cache=True
时返回) — 长度为config.n_layers
的tf.Tensor
列表,每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)
。包含预先计算的隐藏状态(注意力块中的键和值),可用于加速顺序解码。
-
hidden_states
(tuple(tf.Tensor)
, 可选, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。每个层输出的模型隐藏状态加上初始嵌入输出。
-
attentions
(tuple(tf.Tensor)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每个层一个)。注意力权重在注意力 SoftMax 之后,用于计算自注意力头中的加权平均值。
用于因果语言模型(或自回归)输出的基类。
TFMaskedLMOutput
class transformers.modeling_tf_outputs.TFMaskedLMOutput
( loss: tf.Tensor | None = None logits: tf.Tensor = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None )
参数
-
loss
(tf.Tensor
of shape(n,)
, 可选, 其中 n 是非掩码标签的数量,当提供labels
时返回) — 掩码语言建模(MLM)损失。 -
logits
(tf.Tensor
of shape(batch_size, sequence_length, config.vocab_size)
) — 语言建模头部的预测分数(SoftMax 之前每个词汇标记的分数)。 -
hidden_states
(tuple(tf.Tensor)
, 可选, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。模型在每一层输出的隐藏状态以及初始嵌入输出。
-
attentions
(tuple(tf.Tensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每层一个)。注意力权重在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
掩码语言模型输出的基类。
TFSeq2SeqLMOutput
class transformers.modeling_tf_outputs.TFSeq2SeqLMOutput
( loss: tf.Tensor | None = None logits: tf.Tensor = None past_key_values: List[tf.Tensor] | None = None decoder_hidden_states: Tuple[tf.Tensor] | None = None decoder_attentions: Tuple[tf.Tensor] | None = None cross_attentions: Tuple[tf.Tensor] | None = None encoder_last_hidden_state: tf.Tensor | None = None encoder_hidden_states: Tuple[tf.Tensor] | None = None encoder_attentions: Tuple[tf.Tensor] | None = None )
参数
-
loss
(tf.Tensor
,形状为(n,)
,可选,当提供labels
时返回) — 语言建模损失。 -
logits
(tf.Tensor
,形状为(batch_size, sequence_length, config.vocab_size)
) — 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。 -
past_key_values
(List[tf.Tensor]
,可选,当传递use_cache=True
或config.use_cache=True
时返回) — 长度为config.n_layers
的tf.Tensor
列表,每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)
。包含解码器的预先计算的隐藏状态(注意力块中的键和值),可用于加速顺序解码(参见
past_key_values
输入)。 -
decoder_hidden_states
(tuple(tf.Tensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入输出,一个用于每一层的输出)。解码器在每一层输出的隐藏状态以及初始嵌入输出。
-
decoder_attentions
(tuple(tf.Tensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每层一个)。解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
-
cross_attentions
(tuple(tf.Tensor)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每层一个)。解码器交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state
(tf.Tensor
,形状为(batch_size, sequence_length, hidden_size)
,可选) — 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(tf.Tensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入输出,一个用于每一层的输出)。编码器在每一层输出的隐藏状态以及初始嵌入输出。
-
encoder_attentions
(tuple(tf.Tensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每层一个)。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
用于序列到序列语言模型输出的基类。
TFNextSentencePredictorOutput
class transformers.modeling_tf_outputs.TFNextSentencePredictorOutput
( loss: tf.Tensor | None = None logits: tf.Tensor = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None )
参数
-
loss
(形状为(n,)
的tf.Tensor
,可选,其中 n 是未屏蔽标签的数量,当提供next_sentence_label
时返回)- 下一个句子预测损失。 -
logits
(形状为(batch_size, 2)
的tf.Tensor
)- 下一个序列预测(分类)头的预测分数(SoftMax 之前的 True/False 连续性分数)。 -
hidden_states
(tuple(tf.Tensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)- 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入输出,一个用于每一层的输出)。每一层模型的隐藏状态,加上初始嵌入输出。
-
attentions
(tuple(tf.Tensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每层一个)。注意力权重在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
模型输出的基类,用于预测两个句子是否连续。
TFSequenceClassifierOutput
class transformers.modeling_tf_outputs.TFSequenceClassifierOutput
( loss: tf.Tensor | None = None logits: tf.Tensor = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None )
参数
-
loss
(形状为(batch_size,)
的tf.Tensor
,可选,当提供labels
时返回)- 分类(如果config.num_labels==1
则为回归)损失。 -
logits
(形状为(batch_size, config.num_labels)
的tf.Tensor
)- 分类(如果config.num_labels==1
则为回归)分数(SoftMax 之前)。 -
hidden_states
(tuple(tf.Tensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)- 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入输出,一个用于每一层的输出)。每一层模型的隐藏状态,加上初始嵌入输出。
-
attentions
(tuple(tf.Tensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每层一个)。注意力权重在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
句子分类模型输出的基类。
TFSeq2SeqSequenceClassifierOutput
class transformers.modeling_tf_outputs.TFSeq2SeqSequenceClassifierOutput
( loss: tf.Tensor | None = None logits: tf.Tensor = None past_key_values: List[tf.Tensor] | None = None decoder_hidden_states: Tuple[tf.Tensor] | None = None decoder_attentions: Tuple[tf.Tensor] | None = None cross_attentions: Tuple[tf.Tensor] | None = None encoder_last_hidden_state: tf.Tensor | None = None encoder_hidden_states: Tuple[tf.Tensor] | None = None encoder_attentions: Tuple[tf.Tensor] | None = None )
参数
-
loss
(形状为(1,)
的tf.Tensor
,可选,当提供label
时返回)- 分类(如果config.num_labels==1
则为回归)损失。 -
logits
(形状为(batch_size, config.num_labels)
的tf.Tensor
)- 分类(如果config.num_labels==1
则为回归)分数(SoftMax 之前)。 -
past_key_values
(List[tf.Tensor]
,可选,当传递use_cache=True
或config.use_cache=True
时返回)- 长度为config.n_layers
的tf.Tensor
列表,每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)
。包含解码器的预计算隐藏状态(注意力块中的键和值),可用于加速顺序解码(参见
past_key_values
输入)。 -
decoder_hidden_states
(tuple(tf.Tensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)- 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入输出,一个用于每一层的输出)。每一层解码器的隐藏状态,加上初始嵌入输出。
-
decoder_attentions
(tuple(tf.Tensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每一层一个)。解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
-
cross_attentions
(tuple(tf.Tensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每一层一个)。 -
encoder_last_hidden_state
(tf.Tensor
,形状为(batch_size, sequence_length, hidden_size)
,可选) — 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(tf.Tensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入的输出 + 一个用于每一层的输出)。编码器在每一层输出的隐藏状态加上初始嵌入输出。
-
encoder_attentions
(tuple(tf.Tensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每一层一个)。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
序列到序列句子分类模型输出的基类。
TFMultipleChoiceModelOutput
class transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput
( loss: tf.Tensor | None = None logits: tf.Tensor = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None )
参数
-
loss
(tf.Tensor
,形状为(batch_size,),可选,当提供labels
时返回) — 分类损失。 -
logits
(tf.Tensor
,形状为(batch_size, num_choices)
) — num_choices是输入张量的第二维度。(参见上面的input_ids)。分类得分(SoftMax 之前)。
-
hidden_states
(tuple(tf.Tensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入的输出 + 一个用于每一层的输出)。模型在每一层输出的隐藏状态加上初始嵌入输出。
-
attentions
(tuple(tf.Tensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每一层一个)。注意力权重在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
多选模型输出的基类。
TFTokenClassifierOutput
class transformers.modeling_tf_outputs.TFTokenClassifierOutput
( loss: tf.Tensor | None = None logits: tf.Tensor = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None )
参数
-
loss
(tf.Tensor
,形状为(n,)
,可选,其中 n 是未屏蔽标签的数量,当提供labels
时返回) — 分类损失。 -
logits
(tf.Tensor
,形状为(batch_size, sequence_length, config.num_labels)
) — 分类得分(SoftMax 之前)。 -
hidden_states
(tuple(tf.Tensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入的输出 + 一个用于每一层的输出)。模型在每一层输出的隐藏状态加上初始嵌入输出。
-
attentions
(tuple(tf.Tensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每个层一个)。在自注意力头中用于计算加权平均值的注意力权重。
用于标记分类模型输出的基类。
TFQuestionAnsweringModelOutput
class transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput
( loss: tf.Tensor | None = None start_logits: tf.Tensor = None end_logits: tf.Tensor = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None )
参数
-
loss
(形状为
(batch_size, )的
tf.Tensor, *optional*, 当提供
start_positions和
end_positions`时返回) — 总跨度提取损失是开始和结束位置的交叉熵之和。 -
start_logits
(形状为
(batch_size, sequence_length)的
tf.Tensor`) — 跨度开始得分(SoftMax 之前)。 -
end_logits
(形状为
(batch_size, sequence_length)的
tf.Tensor`) — 跨度结束得分(SoftMax 之前)。 -
hidden_states
(tuple(tf.Tensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。模型在每一层输出的隐藏状态加上初始嵌入输出。
-
attentions
(tuple(tf.Tensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每个层一个)。在自注意力头中用于计算加权平均值的注意力权重。
用于问答模型输出的基类。
TFSeq2SeqQuestionAnsweringModelOutput
class transformers.modeling_tf_outputs.TFSeq2SeqQuestionAnsweringModelOutput
( loss: tf.Tensor | None = None start_logits: tf.Tensor = None end_logits: tf.Tensor = None past_key_values: List[tf.Tensor] | None = None decoder_hidden_states: Tuple[tf.Tensor] | None = None decoder_attentions: Tuple[tf.Tensor] | None = None encoder_last_hidden_state: tf.Tensor | None = None encoder_hidden_states: Tuple[tf.Tensor] | None = None encoder_attentions: Tuple[tf.Tensor] | None = None )
参数
-
loss
(形状为
(1,)的
tf.Tensor, *optional*, 当提供
labels`时返回) — 总跨度提取损失是开始和结束位置的交叉熵之和。 -
start_logits
(形状为
(batch_size, sequence_length)的
tf.Tensor`) — 跨度开始得分(SoftMax 之前)。 -
end_logits
(形状为
(batch_size, sequence_length)的
tf.Tensor`) — 跨度结束得分(SoftMax 之前)。 -
past_key_values
(List[tf.Tensor]
, optional, 当传递use_cache=True
或config.use_cache=True
时返回) — 长度为config.n_layers
的tf.Tensor
列表,每个张量形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)
。包含解码器预先计算的隐藏状态(注意力块中的键和值),可用于加速顺序解码(参见
past_key_values
输入)。 -
decoder_hidden_states
(tuple(tf.Tensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。解码器在每一层输出的隐藏状态加上初始嵌入输出。
-
decoder_attentions
(tuple(tf.Tensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每个层一个)。解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
-
encoder_last_hidden_state
(形状为
(batch_size, sequence_length, hidden_size)的
tf.Tensor`, optional) — 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(tf.Tensor)
,optional,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入输出,一个用于每一层的输出)。编码器在每一层输出的隐藏状态以及初始嵌入输出。
-
encoder_attentions
(tuple(tf.Tensor)
,optional,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每层一个)。编码器的注意力权重,在注意力 softmax 后,用于计算自注意力头中的加权平均值。
用于序列到序列问答模型输出的基类。
FlaxBaseModelOutput
class transformers.modeling_flax_outputs.FlaxBaseModelOutput
( last_hidden_state: Array = None hidden_states: Optional = None attentions: Optional = None )
参数
-
last_hidden_state
(jnp.ndarray
,形状为(batch_size, sequence_length, hidden_size)
) — 模型最后一层的隐藏状态序列输出。 -
hidden_states
(tuple(jnp.ndarray)
,optional,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
元组(一个用于嵌入输出,一个用于每一层的输出)。模型在每一层输出的隐藏状态以及初始嵌入输出。
-
attentions
(tuple(jnp.ndarray)
,optional,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每层一个)。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
模型输出的基类,具有潜在的隐藏状态和注意力。
replace
( **updates )
“返回一个用新值替换指定字段的新对象。
FlaxBaseModelOutputWithPast
class transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPast
( last_hidden_state: Array = None past_key_values: Optional = None hidden_states: Optional = None attentions: Optional = None )
参数
-
last_hidden_state
(jnp.ndarray
,形状为(batch_size, sequence_length, hidden_size)
) — 模型最后一层的隐藏状态序列输出。 -
past_key_values
(Dict[str, jnp.ndarray]
) — 预先计算的隐藏状态(注意力块中的键和值)的字典,可用于快速自回归解码。预先计算的键和值隐藏状态的形状为[batch_size, max_length]。 -
hidden_states
(tuple(jnp.ndarray)
,optional,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
元组(一个用于嵌入输出,一个用于每一层的输出)。模型在每一层输出的隐藏状态以及初始嵌入输出。
-
attentions
(tuple(jnp.ndarray)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每层一个)。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
模型输出的基类,具有潜在的隐藏状态和注意力。
replace
( **updates )
“返回一个用新值替换指定字段的新对象。
FlaxBaseModelOutputWithPooling
class transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling
( last_hidden_state: Array = None pooler_output: Array = None hidden_states: Optional = None attentions: Optional = None )
参数
-
last_hidden_state
(形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
)- 模型最后一层的隐藏状态序列。 -
pooler_output
(形状为(batch_size, hidden_size)
的jnp.ndarray
)- 序列的第一个标记(分类标记)的最后一层隐藏状态,进一步由线性层和 Tanh 激活函数处理。线性层的权重是通过预训练期间的下一个句子预测(分类)目标进行训练的。 -
hidden_states
(tuple(jnp.ndarray)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)- 形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
元组(一个用于嵌入输出,一个用于每一层的输出)。模型在每一层输出的隐藏状态加上初始嵌入输出。
-
attentions
(tuple(jnp.ndarray)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每层一个)。在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
模型输出的基类,还包含最后隐藏状态的池化。
replace
( **updates )
返回一个新对象,用新值替换指定的字段。
FlaxBaseModelOutputWithPastAndCrossAttentions
class transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions
( last_hidden_state: Array = None past_key_values: Optional = None hidden_states: Optional = None attentions: Optional = None cross_attentions: Optional = None )
参数
-
last_hidden_state
(形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
)- 模型最后一层的隐藏状态序列。如果使用
past_key_values
,则只输出形状为(batch_size, 1, hidden_size)
的序列的最后一个隐藏状态。 -
past_key_values
(tuple(tuple(jnp.ndarray))
,可选,当传递use_cache=True
或config.use_cache=True
时返回)- 长度为config.n_layers
的tuple(jnp.ndarray)
元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量,如果config.is_encoder_decoder=True
还有 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的张量。包含预先计算的隐藏状态(自注意力块中的键和值,以及可选地在交叉注意力块中,如果
config.is_encoder_decoder=True
)可以使用(参见past_key_values
输入)以加速顺序解码的基类。 -
hidden_states
(tuple(jnp.ndarray)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)- 形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
元组(一个用于嵌入输出,一个用于每一层的输出)。模型在每一层输出的隐藏状态加上初始嵌入输出。
-
attentions
(tuple(jnp.ndarray)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每层一个)。在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
-
cross_attentions
(tuple(jnp.ndarray)
, optional, 当传递output_attentions=True
和config.add_cross_attention=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每个层一个)。解码器交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。
模型输出的基类,可能还包含过去的键/值(用于加速顺序解码)。
replace
( **updates )
“返回一个新对象,用新值替换指定字段。
FlaxSeq2SeqModelOutput
class transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput
( last_hidden_state: Array = None past_key_values: Optional = None decoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None )
参数
-
last_hidden_state
(jnp.ndarray
,形状为(batch_size, sequence_length, hidden_size)
) — 模型解码器最后一层的隐藏状态序列。如果仅使用
past_key_values
,则输出形状为(batch_size, 1, hidden_size)
的序列的最后一个隐藏状态。 -
past_key_values
(tuple(tuple(jnp.ndarray))
, optional, 当传递use_cache=True
或config.use_cache=True
时返回) — 长度为config.n_layers
的tuple(jnp.ndarray)
元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的张量。包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码(参见
past_key_values
输入)。 -
decoder_hidden_states
(tuple(jnp.ndarray)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。解码器在每一层的隐藏状态加上初始嵌入输出。
-
decoder_attentions
(tuple(jnp.ndarray)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每个层一个)。解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
-
cross_attentions
(tuple(jnp.ndarray)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每个层一个)。解码器交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state
(jnp.ndarray
,形状为(batch_size, sequence_length, hidden_size)
,optional) — 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(jnp.ndarray)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。编码器在每一层的隐藏状态加上初始嵌入输出。
-
encoder_attentions
(tuple(jnp.ndarray)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每个层一个)。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
模型编码器输出的基类,还包含:预先计算的隐藏状态,可加速顺序解码。
replace
( **updates )
“返回一个用新值替换指定字段的新对象。
FlaxCausalLMOutputWithCrossAttentions
class transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions
( logits: Array = None past_key_values: Optional = None hidden_states: Optional = None attentions: Optional = None cross_attentions: Optional = None )
参数
-
logits
(jnp.ndarray
,形状为(batch_size, sequence_length, config.vocab_size)
)— 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。 -
hidden_states
(tuple(jnp.ndarray)
, 可选的,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)— 形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。模型在每个层输出的隐藏状态加上初始嵌入输出。
-
attentions
(tuple(jnp.ndarray)
, 可选的,当传递output_attentions=True
或config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每个层一个)。自注意力头中的注意力权重在注意力 softmax 之后,用于计算加权平均值。
-
cross_attentions
(tuple(jnp.ndarray)
, 可选的,当传递output_attentions=True
或config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每个层一个)。交叉注意力 softmax 之后的注意力权重,用于计算交叉注意力头中的加权平均值。
-
past_key_values
(tuple(tuple(jnp.ndarray))
, 可选的,当传递use_cache=True
或config.use_cache=True
时返回)— 长度为config.n_layers
的jnp.ndarray
元组的元组,每个元组包含自注意力和交叉注意力层的缓存键、值状态。仅在config.is_decoder = True
时相关。包含预先计算的隐藏状态(注意力块中的键和值),可用于加速顺序解码(参见
past_key_values
输入)。
因果语言模型(或自回归)输出的基类。
replace
( **updates )
“返回一个用新值替换指定字段的新对象。
FlaxMaskedLMOutput
class transformers.modeling_flax_outputs.FlaxMaskedLMOutput
( logits: Array = None hidden_states: Optional = None attentions: Optional = None )
参数
-
logits
(jnp.ndarray
,形状为(batch_size, sequence_length, config.vocab_size)
)— 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。 -
hidden_states
(tuple(jnp.ndarray)
, 可选的,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)— 形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。模型在每个层输出的隐藏状态加上初始嵌入输出。
-
attentions
(tuple(jnp.ndarray)
, 可选的,当传递output_attentions=True
或config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每个层一个)。注意力权重在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
掩码语言模型输出的基类。
replace
( **updates )
“返回一个用新值替换指定字段的新对象。
FlaxSeq2SeqLMOutput
class transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput
( logits: Array = None past_key_values: Optional = None decoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None )
参数
-
logits
(jnp.ndarray
,形状为(batch_size, sequence_length, config.vocab_size)
) — 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。 -
past_key_values
(tuple(tuple(jnp.ndarray))
,可选,当传递use_cache=True
或config.use_cache=True
时返回) — 长度为config.n_layers
的tuple(jnp.ndarray)
元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量和 2 个额外形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的张量。包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码(见
past_key_values
输入)。 -
decoder_hidden_states
(tuple(jnp.ndarray)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
元组(一个用于嵌入输出,一个用于每一层的输出)。解码器在每一层输出的隐藏状态加上初始嵌入输出。
-
decoder_attentions
(tuple(jnp.ndarray)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每层一个)。解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
-
cross_attentions
(tuple(jnp.ndarray)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每层一个)。解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state
(jnp.ndarray
,形状为(batch_size, sequence_length, hidden_size)
,可选) — 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(jnp.ndarray)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
元组(一个用于嵌入输出,一个用于每一层的输出)。编码器在每一层输出的隐藏状态加上初始嵌入输出。
-
encoder_attentions
(tuple(jnp.ndarray)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每层一个)。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
用于序列到序列语言模型输出的基类。
replace
( **updates )
“返回一个用新值替换指定字段的新对象。
FlaxNextSentencePredictorOutput
class transformers.modeling_flax_outputs.FlaxNextSentencePredictorOutput
( logits: Array = None hidden_states: Optional = None attentions: Optional = None )
参数
-
logits
(jnp.ndarray
,形状为(batch_size, 2)
) — 下一个序列预测(分类)头的预测得分(SoftMax 之前的 True/False 连续得分)。 -
hidden_states
(tuple(jnp.ndarray)
, 可选的, 当传递output_hidden_states=True
或者config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
元组(嵌入输出和每一层输出各一个)。模型在每一层输出的隐藏状态以及初始嵌入输出。
-
attentions
(tuple(jnp.ndarray)
, 可选的, 当传递output_attentions=True
或者config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每层一个)。自注意力头中用于计算加权平均值的注意力权重 softmax 后的值。
预测两个句子是否连续的模型输出的基类。
replace
( **updates )
“返回一个用新值替换指定字段的新对象。
FlaxSequenceClassifierOutput
class transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput
( logits: Array = None hidden_states: Optional = None attentions: Optional = None )
参数
-
logits
(jnp.ndarray
,形状为(batch_size, config.num_labels)
) — 分类(如果config.num_labels==1
则为回归)得分(SoftMax 之前)。 -
hidden_states
(tuple(jnp.ndarray)
, 可选的, 当传递output_hidden_states=True
或者config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
元组(嵌入输出和每一层输出各一个)。模型在每一层输出的隐藏状态以及初始嵌入输出。
-
attentions
(tuple(jnp.ndarray)
, 可选的, 当传递output_attentions=True
或者config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每层一个)。自注意力头中用于计算加权平均值的注意力权重 softmax 后的值。
句子分类模型输出的基类。
replace
( **updates )
“返回一个用新值替换指定字段的新对象。
FlaxSeq2SeqSequenceClassifierOutput
class transformers.modeling_flax_outputs.FlaxSeq2SeqSequenceClassifierOutput
( logits: Array = None past_key_values: Optional = None decoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None )
参数
-
logits
(jnp.ndarray
,形状为(batch_size, config.num_labels)
) — 分类(如果config.num_labels==1
则为回归)得分(SoftMax 之前)。 -
past_key_values
(tuple(tuple(jnp.ndarray))
, 可选的, 当传递use_cache=True
或者config.use_cache=True
时返回) — 长度为config.n_layers
的tuple(jnp.ndarray)
元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的张量。包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码(参见
past_key_values
输入)。 -
decoder_hidden_states
(tuple(jnp.ndarray)
, 可选的, 当传递output_hidden_states=True
或者config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
元组(嵌入输出和每一层输出各一个)。解码器在每一层输出的隐藏状态以及初始嵌入输出。
-
decoder_attentions
(tuple(jnp.ndarray)
, 可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每层一个)。解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
-
cross_attentions
(tuple(jnp.ndarray)
, 可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每层一个)。解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state
(jnp.ndarray
,形状为(batch_size, sequence_length, hidden_size)
,可选) — 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(jnp.ndarray)
, 可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
元组(一个用于嵌入输出,一个用于每一层的输出)。编码器在每一层输出的隐藏状态以及初始嵌入输出。
-
encoder_attentions
(tuple(jnp.ndarray)
, 可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每层一个)。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
用于序列到序列句子分类模型输出的基类。
replace
( **updates )
“用新值替换指定字段的新对象。
FlaxMultipleChoiceModelOutput
class transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput
( logits: Array = None hidden_states: Optional = None attentions: Optional = None )
参数
-
logits
(jnp.ndarray
,形状为(batch_size, num_choices)
) — num_choices是输入张量的第二维度。(参见上面的input_ids)。分类得分(SoftMax 之前)。
-
hidden_states
(tuple(jnp.ndarray)
, 可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
元组(一个用于嵌入输出,一个用于每一层的输出)。模型在每一层输出的隐藏状态以及初始嵌入输出。
-
attentions
(tuple(jnp.ndarray)
, 可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每层一个)。注意力权重在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
多选模型输出的基类。
replace
( **updates )
“用新值替换指定字段的新对象。
FlaxTokenClassifierOutput
class transformers.modeling_flax_outputs.FlaxTokenClassifierOutput
( logits: Array = None hidden_states: Optional = None attentions: Optional = None )
参数
-
logits
(jnp.ndarray
,形状为(batch_size, sequence_length, config.num_labels)
) — 分类得分(SoftMax 之前)。 -
hidden_states
(tuple(jnp.ndarray)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)— 形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。模型在每个层的输出以及初始嵌入输出的隐藏状态。
-
attentions
(tuple(jnp.ndarray)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每个层一个)。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
用于标记分类模型输出的基类。
replace
( **updates )
“返回一个新对象,用新值替换指定的字段。
FlaxQuestionAnsweringModelOutput
class transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutput
( start_logits: Array = None end_logits: Array = None hidden_states: Optional = None attentions: Optional = None )
参数
-
start_logits
(形状为(batch_size, sequence_length)
的jnp.ndarray
)— SoftMax 之前的跨度起始分数。 -
end_logits
(形状为(batch_size, sequence_length)
的jnp.ndarray
)— SoftMax 之前的跨度结束分数。 -
hidden_states
(tuple(jnp.ndarray)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)— 形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。模型在每个层的输出以及初始嵌入输出的隐藏状态。
-
attentions
(tuple(jnp.ndarray)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每个层一个)。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
用于问答模型输出的基类。
replace
( **updates )
“返回一个新对象,用新值替换指定的字段。
FlaxSeq2SeqQuestionAnsweringModelOutput
class transformers.modeling_flax_outputs.FlaxSeq2SeqQuestionAnsweringModelOutput
( start_logits: Array = None end_logits: Array = None past_key_values: Optional = None decoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None )
参数
-
start_logits
(形状为(batch_size, sequence_length)
的jnp.ndarray
)— SoftMax 之前的跨度起始分数。 -
end_logits
(形状为(batch_size, sequence_length)
的jnp.ndarray
)— SoftMax 之前的跨度结束分数。 -
past_key_values
(tuple(tuple(jnp.ndarray))
,可选,当传递use_cache=True
或config.use_cache=True
时返回)— 长度为config.n_layers
的tuple(jnp.ndarray)
元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量,以及 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的张量。包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可以用来加速顺序解码(请参见
past_key_values
输入)。 -
decoder_hidden_states
(tuple(jnp.ndarray)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)— 形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。解码器在每个层的输出以及初始嵌入输出的隐藏状态。
-
decoder_attentions
(tuple(jnp.ndarray)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每层一个)。解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
-
cross_attentions
(tuple(jnp.ndarray)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每层一个)。解码器交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state
(jnp.ndarray
,形状为(batch_size, sequence_length, hidden_size)
,可选) — 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(jnp.ndarray)
, 可选, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
元组(一个用于嵌入输出,一个用于每一层的输出)。编码器每一层输出的隐藏状态加上初始嵌入输出。
-
encoder_attentions
(tuple(jnp.ndarray)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每层一个)。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
用于序列到序列问答模型输出的基类。
replace
( **updates )
“返回一个新对象,用新值替换指定字段。
管道
原文链接:
huggingface.co/docs/transformers/v4.37.2/en/main_classes/pipelines
管道是使用模型进行推断的一种很好且简单的方式。这些管道是抽象出库中大部分复杂代码的对象,提供了专门用于多个任务的简单 API,包括命名实体识别、掩码语言建模、情感分析、特征提取和问答。查看任务摘要以获取使用示例。
有两种要注意的管道抽象类别:
-
pipeline() 是封装所有其他管道的最强大对象。
-
针对音频、计算机视觉、自然语言处理和多模态任务提供了特定任务的管道。
管道抽象
pipeline 抽象是围绕所有其他可用管道的包装器。它像任何其他管道一样实例化,但可以提供额外的生活质量。
简单调用一个项目:
>>> pipe = pipeline("text-classification")
>>> pipe("This restaurant is awesome")
[{'label': 'POSITIVE', 'score': 0.9998743534088135}]
如果要使用来自hub的特定模型,可以忽略任务,如果 hub 上的模型已经定义了它:
>>> pipe = pipeline(model="roberta-large-mnli")
>>> pipe("This restaurant is awesome")
[{'label': 'NEUTRAL', 'score': 0.7313136458396912}]
要在多个项目上调用管道,可以使用列表调用它。
>>> pipe = pipeline("text-classification")
>>> pipe(["This restaurant is awesome", "This restaurant is awful"])
[{'label': 'POSITIVE', 'score': 0.9998743534088135},
{'label': 'NEGATIVE', 'score': 0.9996669292449951}]
要遍历完整数据集,建议直接使用dataset
。这意味着您不需要一次性分配整个数据集,也不需要自己进行批处理。这应该与 GPU 上的自定义循环一样快。如果不是,请不要犹豫创建一个问题。
import datasets
from transformers import pipeline
from transformers.pipelines.pt_utils import KeyDataset
from tqdm.auto import tqdm
pipe = pipeline("automatic-speech-recognition", model="facebook/wav2vec2-base-960h", device=0)
dataset = datasets.load_dataset("superb", name="asr", split="test")
# KeyDataset (only *pt*) will simply return the item in the dict returned by the dataset item
# as we're not interested in the *target* part of the dataset. For sentence pair use KeyPairDataset
for out in tqdm(pipe(KeyDataset(dataset, "file"))):
print(out)
# {"text": "NUMBER TEN FRESH NELLY IS WAITING ON YOU GOOD NIGHT HUSBAND"}
# {"text": ....}
# ....
为了方便使用,也可以使用生成器:
from transformers import pipeline
pipe = pipeline("text-classification")
def data():
while True:
# This could come from a dataset, a database, a queue or HTTP request
# in a server
# Caveat: because this is iterative, you cannot use `num_workers > 1` variable
# to use multiple threads to preprocess data. You can still have 1 thread that
# does the preprocessing while the main runs the big inference
yield "This is a test"
for out in pipe(data()):
print(out)
# {"text": "NUMBER TEN FRESH NELLY IS WAITING ON YOU GOOD NIGHT HUSBAND"}
# {"text": ....}
# ....
transformers.pipeline
( task: str = None model: Union = None config: Union = None tokenizer: Union = None feature_extractor: Union = None image_processor: Union = None framework: Optional = None revision: Optional = None use_fast: bool = True token: Union = None device: Union = None device_map = None torch_dtype = None trust_remote_code: Optional = None model_kwargs: Dict = None pipeline_class: Optional = None **kwargs ) → export const metadata = 'undefined';Pipeline
参数
-
task
(str
) — 定义将返回哪个管道的任务。当前接受的任务有:-
"audio-classification"
: 将返回一个 AudioClassificationPipeline。 -
"automatic-speech-recognition"
: 将返回一个 AutomaticSpeechRecognitionPipeline。 -
"conversational"
: 将返回一个 ConversationalPipeline。 -
"depth-estimation"
: 将返回一个 DepthEstimationPipeline。 -
"document-question-answering"
: 将返回一个 DocumentQuestionAnsweringPipeline。 -
"feature-extraction"
: 将返回一个 FeatureExtractionPipeline。 -
"fill-mask"
: 将返回一个 FillMaskPipeline。 -
"image-classification"
: 将返回一个 ImageClassificationPipeline。 -
"image-segmentation"
: 将返回一个 ImageSegmentationPipeline。 -
"image-to-image"
: 将返回一个 ImageToImagePipeline。 -
"image-to-text"
: 将返回一个 ImageToTextPipeline。 -
"mask-generation"
: 将返回一个 MaskGenerationPipeline。 -
"object-detection"
:将返回一个 ObjectDetectionPipeline。 -
"question-answering"
:将返回一个 QuestionAnsweringPipeline。 -
"summarization"
:将返回一个 SummarizationPipeline。 -
"table-question-answering"
:将返回一个 TableQuestionAnsweringPipeline。 -
"text2text-generation"
:将返回一个 Text2TextGenerationPipeline。 -
"text-classification"
(别名"sentiment-analysis"
可用):将返回一个 TextClassificationPipeline。 -
"text-generation"
:将返回一个 TextGenerationPipeline。 -
"text-to-audio"
(别名"text-to-speech"
可用):将返回一个 TextToAudioPipeline。 -
"token-classification"
(别名"ner"
可用):将返回一个 TokenClassificationPipeline。 -
"translation"
:将返回一个 TranslationPipeline。 -
"translation_xx_to_yy"
:将返回一个 TranslationPipeline。 -
"video-classification"
:将返回一个 VideoClassificationPipeline。 -
"visual-question-answering"
:将返回一个 VisualQuestionAnsweringPipeline。 -
"zero-shot-classification"
:将返回一个 ZeroShotClassificationPipeline。 -
"zero-shot-image-classification"
:将返回一个 ZeroShotImageClassificationPipeline。 -
"zero-shot-audio-classification"
:将返回一个 ZeroShotAudioClassificationPipeline。 -
"zero-shot-object-detection"
:将返回一个 ZeroShotObjectDetectionPipeline。
-
-
model
(str
或 PreTrainedModel 或 TFPreTrainedModel,可选)— 该模型将被管道用于进行预测。这可以是一个模型标识符或一个实际的继承自 PreTrainedModel(对于 PyTorch)或 TFPreTrainedModel(对于 TensorFlow)的预训练模型实例。如果未提供,
task
的默认值将被加载。 -
config
(str
或 PretrainedConfig,可选)— 该配置将被管道用于实例化模型。这可以是模型标识符或实际的预训练模型配置,继承自 PretrainedConfig。如果未提供,则将使用请求的模型的默认配置文件。这意味着如果提供了
model
,将使用其默认配置。但是,如果未提供model
,则将使用此task
的默认模型配置。 -
tokenizer
(str
或 PreTrainedTokenizer,可选)— 该分词器将被管道用于对模型的数据进行编码。这可以是模型标识符或实际的预训练分词器,继承自 PreTrainedTokenizer。如果未提供,则将加载给定
model
的默认分词器(如果是字符串)。如果未指定model
或不是字符串,则将加载config
的默认分词器(如果是字符串)。但是,如果也未提供config
或不是字符串,则将加载给定task
的默认分词器。 -
feature_extractor
(str
或PreTrainedFeatureExtractor
,可选)— 该特征提取器将被管道用于对模型的数据进行编码。这可以是模型标识符或实际的预训练特征提取器,继承自PreTrainedFeatureExtractor
。特征提取器用于非 NLP 模型,例如语音或视觉模型以及多模态模型。多模态模型还需要传递一个分词器。
如果未提供,则将加载给定
model
的默认特征提取器(如果是字符串)。如果未指定model
或不是字符串,则将加载config
的默认特征提取器(如果是字符串)。但是,如果也未提供config
或不是字符串,则将加载给定task
的默认特征提取器。 -
framework
(str
,可选)— 要使用的框架,可以是"pt"
表示 PyTorch,也可以是"tf"
表示 TensorFlow。指定的框架必须已安装。如果未指定框架,将默认使用当前安装的框架。如果未指定框架并且两个框架都已安装,则将默认使用
model
的框架,或者如果未提供模型,则将默认使用 PyTorch。 -
revision
(str
,可选,默认为"main"
)— 当传递任务名称或字符串模型标识符时:要使用的特定模型版本。它可以是分支名称、标签名称或提交 ID,因为我们在 huggingface.co 上使用基于 git 的系统存储模型和其他工件,所以revision
可以是 git 允许的任何标识符。 -
use_fast
(bool
,可选,默认为True
)— 是否尽可能使用快速分词器(PreTrainedTokenizerFast)。 -
use_auth_token
(str
或bool,可选)— 用作远程文件的 HTTP bearer 授权的令牌。如果为True
,将使用运行huggingface-cli login
时生成的令牌(存储在~/.huggingface
中)。 -
device
(int
或str
或torch.device
)— 定义此管道将分配到的设备(例如,"cpu"
,"cuda:1"
,"mps"
,或类似1
的 GPU 序数等)。 -
device_map
(str
或Dict[str, Union[int, str, torch.device]
,可选)— 直接作为model_kwargs
发送(只是一个更简单的快捷方式)。当存在accelerate
库时,设置device_map="auto"
以自动计算最优化的device_map
(有关更多信息,请参见这里)。不要同时使用
device_map
和device
,因为它们会发生冲突 -
torch_dtype
(str
或torch.dtype
,可选)- 直接发送为model_kwargs
(只是一个更简单的快捷方式)以使用此模型的可用精度(torch.float16
,torch.bfloat16
,...或"auto"
)。 -
trust_remote_code
(bool
,可选,默认为False
)- 是否允许在 Hub 上定义的自定义代码在其自己的建模、配置、标记化甚至管道文件中执行。此选项应仅对您信任的存储库设置为True
,并且您已经阅读了代码,因为它将在本地机器上执行 Hub 上存在的代码。 -
model_kwargs
(Dict[str, Any]
,可选)- 传递给模型的from_pretrained(..., **model_kwargs)
函数的其他关键字参数字典。 -
kwargs
(Dict[str, Any]
,可选)- 传递给特定管道初始化的其他关键字参数(请参阅相应管道类的文档以获取可能的值)。
返回
Pipeline
适合任务的管道。
构建 Pipeline 的实用工厂方法。
管道由以下组成:
-
负责将原始文本输入映射到标记的分词器。
-
从输入中进行预测的模型。
-
一些(可选的)后处理以增强模型的输出。
示例:
>>> from transformers import pipeline, AutoModelForTokenClassification, AutoTokenizer
>>> # Sentiment analysis pipeline
>>> analyzer = pipeline("sentiment-analysis")
>>> # Question answering pipeline, specifying the checkpoint identifier
>>> oracle = pipeline(
... "question-answering", model="distilbert-base-cased-distilled-squad", tokenizer="bert-base-cased"
... )
>>> # Named entity recognition pipeline, passing in a specific model and tokenizer
>>> model = AutoModelForTokenClassification.from_pretrained("dbmdz/bert-large-cased-finetuned-conll03-english")
>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
>>> recognizer = pipeline("ner", model=model, tokenizer=tokenizer)
管道批处理
所有管道都可以使用批处理。每当管道使用其流式处理能力时(因此当传递列表或Dataset
或generator
时),它将起作用。
from transformers import pipeline
from transformers.pipelines.pt_utils import KeyDataset
import datasets
dataset = datasets.load_dataset("imdb", name="plain_text", split="unsupervised")
pipe = pipeline("text-classification", device=0)
for out in pipe(KeyDataset(dataset, "text"), batch_size=8, truncation="only_first"):
print(out)
# [{'label': 'POSITIVE', 'score': 0.9998743534088135}]
# Exactly the same output as before, but the content are passed
# as batches to the model
然而,这并不自动意味着性能提升。它可能是 10 倍的加速或 5 倍的减速,取决于硬件、数据和实际使用的模型。
主要是加速的示例:
from transformers import pipeline
from torch.utils.data import Dataset
from tqdm.auto import tqdm
pipe = pipeline("text-classification", device=0)
class MyDataset(Dataset):
def __len__(self):
return 5000
def __getitem__(self, i):
return "This is a test"
dataset = MyDataset()
for batch_size in [1, 8, 64, 256]:
print("-" * 30)
print(f"Streaming batch_size={batch_size}")
for out in tqdm(pipe(dataset, batch_size=batch_size), total=len(dataset)):
pass
# On GTX 970
------------------------------
Streaming no batching
100%|██████████████████████████████████████████████████████████████████████| 5000/5000 [00:26<00:00, 187.52it/s]
------------------------------
Streaming batch_size=8
100%|█████████████████████████████████████████████████████████████████████| 5000/5000 [00:04<00:00, 1205.95it/s]
------------------------------
Streaming batch_size=64
100%|█████████████████████████████████████████████████████████████████████| 5000/5000 [00:02<00:00, 2478.24it/s]
------------------------------
Streaming batch_size=256
100%|█████████████████████████████████████████████████████████████████████| 5000/5000 [00:01<00:00, 2554.43it/s]
(diminishing returns, saturated the GPU)
主要是减速的示例:
class MyDataset(Dataset):
def __len__(self):
return 5000
def __getitem__(self, i):
if i % 64 == 0:
n = 100
else:
n = 1
return "This is a test" * n
与其他句子相比,这是一个偶尔非常长的句子。在这种情况下,整个批次将需要 400 个标记长,因此整个批次将是[64, 400]而不是[64, 4],导致严重减速。更糟糕的是,在更大的批次上,程序会直接崩溃。
------------------------------
Streaming no batching
100%|█████████████████████████████████████████████████████████████████████| 1000/1000 [00:05<00:00, 183.69it/s]
------------------------------
Streaming batch_size=8
100%|█████████████████████████████████████████████████████████████████████| 1000/1000 [00:03<00:00, 265.74it/s]
------------------------------
Streaming batch_size=64
100%|██████████████████████████████████████████████████████████████████████| 1000/1000 [00:26<00:00, 37.80it/s]
------------------------------
Streaming batch_size=256
0%| | 0/1000 [00:00<?, ?it/s]
Traceback (most recent call last):
File "/home/nicolas/src/transformers/test.py", line 42, in <module>
for out in tqdm(pipe(dataset, batch_size=256), total=len(dataset)):
....
q = q / math.sqrt(dim_per_head) # (bs, n_heads, q_length, dim_per_head)
RuntimeError: CUDA out of memory. Tried to allocate 376.00 MiB (GPU 0; 3.95 GiB total capacity; 1.72 GiB already allocated; 354.88 MiB free; 2.46 GiB reserved in total by PyTorch)
对于这个问题没有好的(通用)解决方案,您的使用情况可能会有所不同。经验法则:
对于用户,一个经验法则是:
-
在您的负载上测量性能,使用您的硬件。测量,测量,继续测量。真实数字是唯一的方法。
-
如果您受到延迟约束(进行推断的实时产品),则不要批处理。
-
如果您正在使用 CPU,则不要批处理。
-
如果您正在使用吞吐量(希望在一堆静态数据上运行模型),在 GPU 上,则:
-
如果您对序列长度的大小一无所知(“自然”数据),默认情况下不要批处理,测量并尝试试探性地添加它,添加 OOM 检查以在失败时恢复(如果您不控制序列长度,它将在某个时候失败)。
-
如果您的序列长度非常规则,则批处理更有可能非常有趣,测量并推动它直到出现 OOM。
-
GPU 越大,批处理就越有可能更有趣
-
-
一旦启用批处理,请确保您可以很好地处理 OOM。
管道块批处理
zero-shot-classification
和question-answering
在某种意义上略有特殊,因为单个输入可能会导致模型的多次前向传递。在正常情况下,这将导致batch_size
参数出现问题。
为了规避这个问题,这两个管道都有点特殊,它们是ChunkPipeline
而不是常规的Pipeline
。简而言之:
preprocessed = pipe.preprocess(inputs)
model_outputs = pipe.forward(preprocessed)
outputs = pipe.postprocess(model_outputs)
现在变成了:
all_model_outputs = []
for preprocessed in pipe.preprocess(inputs):
model_outputs = pipe.forward(preprocessed)
all_model_outputs.append(model_outputs)
outputs = pipe.postprocess(all_model_outputs)
这对您的代码应该非常透明,因为管道的使用方式相同。
这是一个简化的视图,因为管道可以自动处理批处理!这意味着您无需关心实际将触发多少前向传递,您可以独立于输入优化batch_size
。前一节中的注意事项仍然适用。
管道自定义代码
如果要覆盖特定管道。
不要犹豫为您手头的任务创建一个问题,管道的目标是易于使用并支持大多数情况,因此transformers
可能支持您的用例。
如果您只想简单尝试,可以:
- 子类化您选择的管道
class MyPipeline(TextClassificationPipeline):
def postprocess():
# Your code goes here
scores = scores * 100
# And here
my_pipeline = MyPipeline(model=model, tokenizer=tokenizer, ...)
# or if you use *pipeline* function, then:
my_pipeline = pipeline(model="xxxx", pipeline_class=MyPipeline)
这应该使您能够执行所有您想要的自定义代码。
实现管道
实现新管道
音频
音频任务可用的管道包括以下内容。
音频分类管道
class transformers.AudioClassificationPipeline
( *args **kwargs )
参数
-
model
(PreTrainedModel 或 TFPreTrainedModel) — 该模型将由管道用于进行预测。这需要是继承自 PreTrainedModel(对于 PyTorch)和 TFPreTrainedModel(对于 TensorFlow)的模型。 -
tokenizer
(PreTrainedTokenizer) — 该 tokenizer 将被管道用于为模型编码数据。此对象继承自 PreTrainedTokenizer。 -
modelcard
(str
或ModelCard
, 可选) — 为此管道的模型指定的模型卡。 -
framework
(str
, 可选) — 要使用的框架,可以是"pt"
表示 PyTorch 或"tf"
表示 TensorFlow。指定的框架必须已安装。如果未指定框架,将默认使用当前安装的框架。如果未指定框架并且两个框架都已安装,则将默认使用
model
的框架,或者如果未提供模型,则将默认使用 PyTorch。 -
task
(str
, 默认为""
) — 管道的任务标识符。 -
num_workers
(int
, 可选, 默认为 8) — 当管道将使用DataLoader(在传递数据集时,在 Pytorch 模型的 GPU 上),要使用的工作程序数量。 -
batch_size
(int
, 可选, 默认为 1) — 当管道将使用DataLoader(在传递数据集时,在 Pytorch 模型的 GPU 上),要使用的批次大小,对于推断,这并不总是有益的,请阅读使用管道进行批处理。 -
args_parser
(ArgumentHandler, 可选) — 负责解析提供的管道参数的对象的引用。 -
device
(int
, 可选, 默认为 -1) — CPU/GPU 支持的设备序数。将其设置为 -1 将利用 CPU,正数将在关联的 CUDA 设备 ID 上运行模型。您也可以传递本机torch.device
或str
。 -
binary_output
(bool
, 可选, 默认为False
) — 指示管道输出是否应以二进制格式(即 pickle)或原始文本格式发生的标志。
使用任何AutoModelForAudioClassification
的音频分类管道。该管道预测原始波形或音频文件的类别。在音频文件的情况下,应安装 ffmpeg 以支持多种音频格式。
示例:
>>> from transformers import pipeline
>>> classifier = pipeline(model="superb/wav2vec2-base-superb-ks")
>>> classifier("https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/1.flac")
[{'score': 0.997, 'label': '_unknown_'}, {'score': 0.002, 'label': 'left'}, {'score': 0.0, 'label': 'yes'}, {'score': 0.0, 'label': 'down'}, {'score': 0.0, 'label': 'stop'}]
了解有关在 pipeline 教程中使用管道的基础知识
目前可以使用以下任务标识符从 pipeline()加载此管道:"audio-classification"。
在huggingface.co/models上查看可用模型的列表。
__call__
( inputs: Union **kwargs ) → export const metadata = 'undefined';A list of dict with the following keys
参数
-
inputs
(np.ndarray
或bytes
或str
或dict
) — 输入可以是:-
str
— 音频文件的文件名,文件将以正确的采样率读取以获取波形,使用ffmpeg。这需要在系统上安装ffmpeg。 -
bytes
应该是音频文件的内容,并由ffmpeg以相同方式解释。 -
(
np.ndarray
,形状为(n, ),类型为np.float32
或np.float64
) — 在正确的采样率下的原始音频(不会进行进一步检查) -
dict
— 可以用于传递以任意sampling_rate
采样的原始音频,并让此管道进行重新采样。字典必须是以下格式之一:{"sampling_rate": int, "raw": np.array}
或{"sampling_rate": int, "array": np.array}
,其中键"raw"
或"array"
用于表示原始音频波形。
-
-
top_k
(int
,可选,默认为 None) — 管道将返回的顶部标签数。如果提供的数字为None
或高于模型配置中可用标签的数量,则默认为标签数。
返回
一个带有以下键的dict
列表
-
label
(str
) — 预测的标签。 -
score
(float
) — 相应的概率。
对给定的输入序列进行分类。有关更多信息,请参阅 AutomaticSpeechRecognitionPipeline 文档。
AutomaticSpeechRecognitionPipeline
class transformers.AutomaticSpeechRecognitionPipeline
( model: PreTrainedModel feature_extractor: Union = None tokenizer: Optional = None decoder: Union = None device: Union = None torch_dtype: Union = None **kwargs )
参数
-
model
(PreTrainedModel 或 TFPreTrainedModel) — 该模型将被管道用于进行预测。这需要是一个继承自 PreTrainedModel(对于 PyTorch)或 TFPreTrainedModel(对于 TensorFlow)的模型。 -
feature_extractor
(SequenceFeatureExtractor) — 该特征提取器将被管道用于为模型编码波形。 -
tokenizer
(PreTrainedTokenizer) — 该分词器将被管道用于为模型编码数据。该对象继承自 PreTrainedTokenizer。 -
decoder
(pyctcdecode.BeamSearchDecoderCTC
, 可选) — 可以传递PyCTCDecode 的 BeamSearchDecoderCTC以进行语言模型增强解码。有关更多信息,请参阅 Wav2Vec2ProcessorWithLM。 -
chunk_length_s
(float
,可选,默认为 0) — 每个块中的输入长度。如果chunk_length_s = 0
,则禁用分块(默认)。有关如何有效使用
chunk_length_s
的更多信息,请查看ASR 分块博文。 -
stride_length_s
(float
, 可选, 默认为chunk_length_s / 6
) — 每个块左右两侧的步幅长度。仅在chunk_length_s > 0
时使用。这使得模型能够看到更多的上下文,并比没有上下文更好地推断字母,但管道会丢弃末尾的步幅位,以使最终重构尽可能完美。有关如何有效使用
stride_length_s
的更多信息,请查看ASR 分块博文。 -
framework
(str
, 可选) — 要使用的框架,可以是"pt"
代表 PyTorch 或"tf"
代表 TensorFlow。指定的框架必须已安装。如果未指定框架,将默认使用当前安装的框架。如果未指定框架且两个框架都已安装,则默认使用model
的框架,或者如果未提供模型,则默认使用 PyTorch。 -
device
(Union[int
,torch.device
], 可选) — CPU/GPU 支持的设备序数。将其设置为None
将使用 CPU,将其设置为正数将在关联的 CUDA 设备上运行模型。 -
torch_dtype
(Union[int
,torch.dtype
], 可选) — 计算的数据类型(dtype)。将其设置为None
将使用 float32 精度。设置为torch.float16
或torch.bfloat16
将使用相应 dtype 的半精度。
旨在从某些音频中提取包含的口语文本的管道。
输入可以是原始波形或音频文件。在音频文件的情况下,需要安装 ffmpeg 以支持多种音频格式
示例:
>>> from transformers import pipeline
>>> transcriber = pipeline(model="openai/whisper-base")
>>> transcriber("https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/1.flac")
{'text': ' He hoped there would be stew for dinner, turnips and carrots and bruised potatoes and fat mutton pieces to be ladled out in thick, peppered flour-fatten sauce.'}
了解有关在 pipeline 教程中使用管道的基础知识
__call__
( inputs: Union **kwargs ) → export const metadata = 'undefined';Dict
参数
-
inputs
(np.ndarray
或bytes
或str
或dict
) — 输入可以是:-
str
,可以是本地音频文件的文件名,也可以是下载音频文件的公共 URL 地址。文件将以正确的采样率读取,以使用ffmpeg获取波形。这需要系统上安装ffmpeg。 -
bytes
应该是音频文件内容,并由ffmpeg以相同方式解释。 -
(
np.ndarray
的形状为 (n, ),类型为np.float32
或np.float64
) — 以正确采样率的原始音频(不会进行进一步检查) -
可以使用
dict
形式传递以任意sampling_rate
采样的原始音频,并让此管道进行重新采样。字典必须采用格式{"sampling_rate": int, "raw": np.array}
,可选地包含一个"stride": (left: int, right: int)
,可以要求管道在解码时忽略前left
个样本和最后right
个样本(但在推理中使用以向模型提供更多上下文)。仅在 CTC 模型中使用stride
。
-
-
return_timestamps
(可选,str
或bool
) — 仅适用于纯 CTC 模型(Wav2Vec2、HuBERT 等)和 Whisper 模型。不适用于其他序列到序列模型。对于 CTC 模型,时间戳可以采用以下两种格式之一:
-
"char"
: 管道将为文本中的每个字符返回时间戳。例如,如果您得到[{"text": "h", "timestamp": (0.5, 0.6)}, {"text": "i", "timestamp": (0.7, 0.9)}]
,则表示模型预测字母“h”在0.5
秒后和0.6
秒前被发音。 -
"word"
: 管道将为文本中的每个单词返回时间戳。例如,如果您得到[{"text": "hi ", "timestamp": (0.5, 0.9)}, {"text": "there", "timestamp": (1.0, 1.5)}]
,则表示模型预测单词“hi”在0.5
秒后和0.9
秒前被发音。
对于 Whisper 模型,时间戳可以采用以下两种格式之一:
-
"word"
: 与单词级 CTC 时间戳相同。单词级时间戳通过动态时间规整(DTW)算法预测,通过检查交叉注意力权重来近似单词级时间戳。 -
True
:管道将在文本中为单词段返回时间戳。例如,如果您获得[{"text": " Hi there!", "timestamp": (0.5, 1.5)}]
,则表示模型预测段“Hi there!”在0.5
秒后和1.5
秒前被说出。请注意,文本段指的是一个或多个单词的序列,而不是单词级时间戳。
-
-
generate_kwargs
(dict
, 可选) — 用于生成调用的generate_config
的自定义参数字典。有关 generate 的完整概述,请查看以下指南。 -
max_new_tokens
(int
, 可选) — 要生成的最大标记数,忽略提示中的标记数。
返回
Dict
具有以下键的字典:
-
text
(str
): 识别的文本。 -
chunks
(*可选(,List[Dict]
) 当使用return_timestamps
时,chunks
将变成一个包含模型识别的各种文本块的列表,例如[{"text": "hi ", "timestamp": (0.5, 0.9)}, {"text": "there", "timestamp": (1.0, 1.5)}]
。原始完整文本可以通过"".join(chunk["text"] for chunk in output["chunks"])
来粗略恢复。
将给定的音频序列转录为文本。有关更多信息,请参阅 AutomaticSpeechRecognitionPipeline 文档。
文本到音频管道
class transformers.TextToAudioPipeline
( *args vocoder = None sampling_rate = None **kwargs )
使用任何AutoModelForTextToWaveform
或AutoModelForTextToSpectrogram
的文本到音频生成管道。此管道从输入文本和可选的其他条件输入生成音频文件。
示例:
>>> from transformers import pipeline
>>> pipe = pipeline(model="suno/bark-small")
>>> output = pipe("Hey it's HuggingFace on the phone!")
>>> audio = output["audio"]
>>> sampling_rate = output["sampling_rate"]
了解有关在 pipeline tutorial 中使用管道的基础知识
您可以通过使用TextToAudioPipeline.__call__.forward_params
或TextToAudioPipeline.__call__.generate_kwargs
来指定传递给模型的参数。
示例:
>>> from transformers import pipeline
>>> music_generator = pipeline(task="text-to-audio", model="facebook/musicgen-small", framework="pt")
>>> # diversify the music generation by adding randomness with a high temperature and set a maximum music length
>>> generate_kwargs = {
... "do_sample": True,
... "temperature": 0.7,
... "max_new_tokens": 35,
... }
>>> outputs = music_generator("Techno music with high melodic riffs", generate_kwargs=generate_kwargs)
此管道目前可以使用以下任务标识符从 pipeline()加载:"text-to-speech"
或"text-to-audio"
。
在huggingface.co/models上查看可用模型列表。
__call__
( text_inputs: Union **forward_params ) → export const metadata = 'undefined';A dict or a list of dict
参数
-
text_inputs
(str
或List[str]
) — 要生成的文本。 -
forward_params
(dict
, 可选) — 传递给模型生成/前向方法的参数。forward_params
始终传递给底层模型。 -
generate_kwargs
(dict
, 可选) — 用于生成调用的generate_config
的自定义参数字典。有关 generate 的完整概述,请查看以下指南。generate_kwargs
仅在底层模型是生成模型时才传递给底层模型。
返回
一个dict
或dict
的列表
字典有两个键:
-
audio
(np.ndarray
,形状为(nb_channels, audio_length)
) — 生成的音频波形。 -
sampling_rate
(int
) — 生成的音频波形的采样率。
从输入生成语音/音频。有关更多信息,请参阅 TextToAudioPipeline 文档。
ZeroShotAudioClassificationPipeline
class transformers.ZeroShotAudioClassificationPipeline
( **kwargs )
参数
-
model
(PreTrainedModel 或 TFPreTrainedModel) — 管道将用于进行预测的模型。这需要是继承自 PreTrainedModel 的模型,用于 PyTorch,以及继承自 TFPreTrainedModel 的模型,用于 TensorFlow。 -
tokenizer
(PreTrainedTokenizer) — 管道将用于为模型编码数据的分词器。此对象继承自 PreTrainedTokenizer。 -
modelcard
(str
或ModelCard
, 可选) — 为此管道的模型指定的模型卡。 -
framework
(str
, 可选) — 要使用的框架,可以是"pt"
代表 PyTorch 或"tf"
代表 TensorFlow。指定的框架必须已安装。如果未指定框架,将默认使用当前安装的框架。如果未指定框架并且两个框架都已安装,将默认使用
model
的框架,或者如果未提供模型,则默认使用 PyTorch。 -
task
(str
, 默认为""
) — 用于管道的任务标识符。 -
num_workers
(int
, 可选, 默认为 8) — 当管道将使用 DataLoader(传递数据集时,在 Pytorch 模型的 GPU 上),要使用的工作人员数量。 -
batch_size
(int
, 可选, 默认为 1) — 当管道将使用 DataLoader(传递数据集时,在 Pytorch 模型的 GPU 上),要使用的批次大小,对于推断来说,这并不总是有益的,请阅读使用管道进行批处理。 -
args_parser
(ArgumentHandler, 可选) — 负责解析提供的管道参数的对象的引用。 -
device
(int
, 可选, 默认为-1) — CPU/GPU 支持的设备序数。将其设置为-1 将利用 CPU,正数将在关联的 CUDA 设备 ID 上运行模型。您也可以传递本机torch.device
或str
。 -
binary_output
(bool
, 可选, 默认为False
) — 指示管道输出是否应以二进制格式(即 pickle)或原始文本格式发生的标志。
使用ClapModel
进行零射击音频分类管道。此管道在提供音频和一组candidate_labels
时预测音频的类。
示例:
>>> from transformers import pipeline
>>> from datasets import load_dataset
>>> dataset = load_dataset("ashraq/esc50")
>>> audio = next(iter(dataset["train"]["audio"]))["array"]
>>> classifier = pipeline(task="zero-shot-audio-classification", model="laion/clap-htsat-unfused")
>>> classifier(audio, candidate_labels=["Sound of a dog", "Sound of vaccum cleaner"])
[{'score': 0.9996, 'label': 'Sound of a dog'}, {'score': 0.0004, 'label': 'Sound of vaccum cleaner'}]
在 pipeline 教程中了解如何使用管道的基础知识。此音频分类管道目前可以通过以下任务标识符从 pipeline()加载:"zero-shot-audio-classification"。在huggingface.co/models上查看可用模型的列表。
__call__
( audios: Union **kwargs )
参数
-
audios
(str
,List[str]
,np.array
或List[np.array]
) — 管道处理三种类型的输入:-
包含指向音频的 http 链接的字符串
-
包含音频本地路径的字符串
-
加载在 numpy 中的音频
-
-
candidate_labels
(List[str]
) — 此音频的候选标签 -
hypothesis_template
(str
,可选,默认为"This is a sound of {}"
)- 与candidate_labels一起使用的句子,通过将占位符替换为 candidate_labels 尝试音频分类。然后通过使用 logits_per_audio 来估计可能性。
为传入的音频分配标签。
计算机视觉
计算机视觉任务可用的管道包括以下内容。
DepthEstimationPipeline
class transformers.DepthEstimationPipeline
( *args **kwargs )
参数
-
model
(PreTrainedModel 或 TFPreTrainedModel)- 该模型将被管道用于进行预测。这需要是一个继承自 PreTrainedModel(对于 PyTorch)和 TFPreTrainedModel(对于 TensorFlow)的模型。 -
tokenizer
(PreTrainedTokenizer)- 该 tokenizer 将被管道用于对数据进行编码以供模型使用。该对象继承自 PreTrainedTokenizer。 -
modelcard
(str
或ModelCard
,可选)- 为此管道的模型分配的模型卡。 -
framework
(str
,可选)- 要使用的框架,可以是"pt"
表示 PyTorch 或"tf"
表示 TensorFlow。指定的框架必须已安装。如果未指定框架,将默认使用当前安装的框架。如果未指定框架并且两个框架都已安装,则将默认使用
model
的框架,或者如果未提供模型,则将默认使用 PyTorch。 -
task
(str
,默认为""
)- 管道的任务标识符。 -
num_workers
(int
,可选,默认为 8)- 当管道将使用DataLoader(在传递数据集时,在 PyTorch 模型的 GPU 上)时,要使用的工作人员数量。 -
batch_size
(int
,可选,默认为 1)- 当管道将使用DataLoader(在传递数据集时,在 PyTorch 模型的 GPU 上)时,要使用的批次大小,对于推断,这并不总是有益的,请阅读使用管道进行批处理。 -
args_parser
(ArgumentHandler,可选)- 负责解析提供的管道参数的对象的引用。 -
device
(int
,可选,默认为-1)- CPU/GPU 支持的设备序数。将其设置为-1 将利用 CPU,正数将在关联的 CUDA 设备 ID 上运行模型。您也可以传递本机torch.device
或str
。 -
binary_output
(bool
,可选,默认为False
)- 指示管道输出是否应以二进制格式(即 pickle)或原始文本格式发生的标志。
使用任何AutoModelForDepthEstimation
的深度估计管道。该管道预测图像的深度。
示例:
>>> from transformers import pipeline
>>> depth_estimator = pipeline(task="depth-estimation", model="Intel/dpt-large")
>>> output = depth_estimator("http://images.cocodataset.org/val2017/000000039769.jpg")
>>> # This is a tensor with the values being the depth expressed in meters for each pixel
>>> output["predicted_depth"].shape
torch.Size([1, 384, 384])
了解有关在 pipeline 教程中使用管道的基础知识。
此深度估计管道目前可以使用以下任务标识符从 pipeline()中加载:"depth-estimation"。
在huggingface.co/models上查看可用模型的列表。
__call__
( images: Union **kwargs )
参数
-
images
(str
,List[str]
,PIL.Image
或List[PIL.Image]
) — 管道处理三种类型的图像:-
包含指向图像的 http 链接的字符串
-
包含指向图像的本地路径的字符串
-
直接加载的 PIL 图像
该管道接受单个图像或一批图像,然后必须将它们作为字符串传递。批处理中的图像必须全部采用相同的格式:全部作为 http 链接,全部作为本地路径,或全部作为 PIL 图像。
-
-
top_k
(int
, 可选, 默认为 5) — 管道将返回的前几个标签的数量。如果提供的数字高于模型配置中可用的标签数量,则将默认为标签数量。 -
timeout
(float
, 可选, 默认为 None) — 从网络获取图像的最长等待时间(以秒为单位)。如果为 None,则不设置超时,调用可能会永远阻塞。
为传递的图像分配标签。
ImageClassificationPipeline
class transformers.ImageClassificationPipeline
( *args **kwargs )
参数
-
model
(PreTrainedModel 或 TFPreTrainedModel) — 管道将用于进行预测的模型。这需要是继承自 PreTrainedModel 的模型,对于 PyTorch 和继承自 TFPreTrainedModel 的模型。 -
tokenizer
(PreTrainedTokenizer) — 管道将用于为模型编码数据的分词器。该对象继承自 PreTrainedTokenizer。 -
modelcard
(str
或ModelCard
, 可选) — 为此管道的模型指定的模型卡。 -
framework
(str
, 可选) — 要使用的框架,可以是"pt"
表示 PyTorch,也可以是"tf"
表示 TensorFlow。指定的框架必须已安装。如果未指定框架,将默认使用当前安装的框架。如果未指定框架并且两个框架都已安装,则将默认使用
model
的框架,或者如果未提供模型,则将默认使用 PyTorch 框架。 -
task
(str
, 默认为""
) — 管道的任务标识符。 -
num_workers
(int
, 可选, 默认为 8) — 当管道将使用DataLoader(在传递数据集时,在 Pytorch 模型的 GPU 上),要使用的工作程序数量。 -
batch_size
(int
, 可选, 默认为 1) — 当管道将使用DataLoader(在传递数据集时,在 Pytorch 模型的 GPU 上),要使用的批次大小,对于推断,这并不总是有益,请阅读使用管道进行批处理。 -
args_parser
(ArgumentHandler, 可选) — 负责解析提供的管道参数的对象的引用。 -
device
(int
, 可选, 默认为-1) — CPU/GPU 支持的设备序数。将其设置为-1 将利用 CPU,正数将在关联的 CUDA 设备 ID 上运行模型。您也可以传递本机torch.device
或str
。 -
binary_output
(bool
, 可选, 默认为False
) — 指示管道输出是否应以二进制格式(即 pickle)或原始文本格式发生的标志。 -
function_to_apply
(str
, 可选, 默认为"default"
) — 用于从模型输出中提取分数的函数。接受四个不同的值:-
"default"
: 如果模型只有一个标签,将在输出上应用 sigmoid 函数。如果模型有多个标签,将在输出上应用 softmax 函数。 -
sigmoid
: 在输出上应用 sigmoid 函数。 -
"softmax"
: 在输出上应用 softmax 函数。 -
"none"
: 不在输出上应用任何函数。
-
使用任何 AutoModelForImageClassification
的图像分类管道。此管道预测图像的类别。
示例:
>>> from transformers import pipeline
>>> classifier = pipeline(model="microsoft/beit-base-patch16-224-pt22k-ft22k")
>>> classifier("https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png")
[{'score': 0.442, 'label': 'macaw'}, {'score': 0.088, 'label': 'popinjay'}, {'score': 0.075, 'label': 'parrot'}, {'score': 0.073, 'label': 'parodist, lampooner'}, {'score': 0.046, 'label': 'poll, poll_parrot'}]
了解有关在 pipeline 教程 中使用管道的基础知识。
这个图像分类管道目前可以通过 pipeline() 使用以下任务标识符进行加载:"image-classification"
。
查看 huggingface.co/models 上可用模型的列表。
__call__
( images: Union **kwargs )
参数
-
images
(str
,List[str]
,PIL.Image
或List[PIL.Image]
) — 管道处理三种类型的图像:-
包含指向图像的 http 链接的字符串
-
包含指向图像的本地路径的字符串
-
直接加载的 PIL 图像
管道接受单个图像或一批图像,然后必须将它们作为字符串传递。批处理中的图像必须全部采用相同的格式:全部作为 http 链接,全部作为本地路径,或全部作为 PIL 图像。
-
-
function_to_apply
(str
, 可选, 默认为"default"
) — 应用于模型输出以检索分数的函数。接受四个不同的值:如果未指定此参数,则将根据标签数应用以下函数:
-
如果模型只有一个标签,将在输出上应用 sigmoid 函数。
-
如果模型有多个标签,将在输出上应用 softmax 函数。
可能的值有:
-
sigmoid
: 在输出上应用 sigmoid 函数。 -
"softmax"
: 在输出上应用 softmax 函数。 -
"none"
: 不在输出上应用任何函数。
-
-
top_k
(int
, 可选, 默认为 5) — 管道将返回的前 k 个标签数。如果提供的数字高于模型配置中可用的标签数,则默认为标签数。 -
timeout
(float
, 可选, 默认为 None) — 从网络获取图像的最长等待时间(以秒为单位)。如果为 None,则不设置超时,调用可能永远阻塞。
为传入的图像分配标签。
ImageSegmentationPipeline
class transformers.ImageSegmentationPipeline
( *args **kwargs )
参数
-
model
(PreTrainedModel 或 TFPreTrainedModel) — 管道将用于进行预测的模型。这需要是继承自 PreTrainedModel 的模型,对于 PyTorch 是 TFPreTrainedModel 是 TensorFlow。 -
tokenizer
(PreTrainedTokenizer) — 管道将用于为模型编码数据的分词器。此对象继承自 PreTrainedTokenizer。 -
modelcard
(str
或ModelCard
, 可选) — 为此管道的模型指定的模型卡。 -
framework
(str
, 可选) — 要使用的框架,可以是"pt"
代表 PyTorch,或者"tf"
代表 TensorFlow。指定的框架必须已安装。如果未指定框架,将默认使用当前安装的框架。如果未指定框架并且两个框架都已安装,则将默认使用
model
的框架,或者如果未提供模型,则将默认使用 PyTorch。 -
task
(str
, defaults to""
) — 管道的任务标识符。 -
num_workers
(int
, optional, defaults to 8) — 当管道将使用DataLoader(在传递数据集时,对于 Pytorch 模型在 GPU 上),要使用的工作程序数量。 -
batch_size
(int
, optional, defaults to 1) — 当管道将使用DataLoader(在传递数据集时,对于 Pytorch 模型在 GPU 上),要使用的批处理大小,对于推断,这并不总是有益的,请阅读使用管道进行批处理。 -
args_parser
(ArgumentHandler, optional) — 负责解析提供的管道参数的对象的引用。 -
device
(int
, optional, defaults to -1) — CPU/GPU 支持的设备序数。将其设置为-1 将利用 CPU,将其设置为正数将在关联的 CUDA 设备 ID 上运行模型。您也可以传递本机torch.device
或str
。 -
binary_output
(bool
, optional, defaults toFalse
) — 指示管道输出应以二进制格式(即 pickle)还是原始文本格式发生的标志。
使用任何AutoModelForXXXSegmentation
的图像分割管道。该管道预测对象及其类别的掩模。
示例:
>>> from transformers import pipeline
>>> segmenter = pipeline(model="facebook/detr-resnet-50-panoptic")
>>> segments = segmenter("https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png")
>>> len(segments)
2
>>> segments[0]["label"]
'bird'
>>> segments[1]["label"]
'bird'
>>> type(segments[0]["mask"]) # This is a black and white mask showing where is the bird on the original image.
<class 'PIL.Image.Image'>
>>> segments[0]["mask"].size
(768, 512)
此图像分割管道目前可以使用以下任务标识符从 pipeline()加载:"image-segmentation"。
在huggingface.co/models上查看可用模型的列表。
__call__
( images **kwargs )
参数
-
images
(str
,List[str]
,PIL.Image
或List[PIL.Image]
) — 该管道处理三种类型的图像:-
包含指向图像的 HTTP(S)链接的字符串
-
包含图像本地路径的字符串
-
直接在 PIL 中加载的图像
该管道接受单个图像或一批图像。批处理中的图像必须全部采用相同的格式:全部作为 HTTP(S)链接,全部作为本地路径,或全部作为 PIL 图像。
-
-
subtask
(str
, optional) — 要执行的分割任务,根据模型的能力选择[semantic
、instance
和panoptic
]。如果未设置,管道将尝试按以下顺序解析:panoptic
、instance
、semantic
。 -
threshold
(float
, optional, defaults to 0.9) — 用于过滤预测掩模的概率阈值。 -
mask_threshold
(float
, optional, defaults to 0.5) — 在将预测掩模转换为二进制值时使用的阈值。 -
overlap_mask_area_threshold
(float
, optional, defaults to 0.5) — 用于消除小的、不连续段的掩模重叠阈值。 -
timeout
(float
, optional, defaults to None) — 从网络获取图像的最长等待时间(以秒为单位)。如果为 None,则不设置超时,并且调用可能会永远阻塞。
在作为输入传递的图像中执行分割(检测掩模和类别)。
ImageToImagePipeline
class transformers.ImageToImagePipeline
( *args **kwargs )
参数
-
model
(PreTrainedModel 或 TFPreTrainedModel) — 管道将用于进行预测的模型。这需要是继承自 PreTrainedModel 的模型,用于 PyTorch,以及继承自 TFPreTrainedModel 的模型,用于 TensorFlow。 -
tokenizer
(PreTrainedTokenizer) — 该 tokenizer 将被管道用于为模型编码数据。此对象继承自 PreTrainedTokenizer。 -
modelcard
(str
或ModelCard
, 可选) — 为此管道的模型指定的模型卡。 -
framework
(str
, 可选) — 要使用的框架,可以是"pt"
表示 PyTorch,也可以是"tf"
表示 TensorFlow。指定的框架必须已安装。如果未指定框架,将默认使用当前安装的框架。如果未指定框架,并且两个框架都已安装,则将默认使用
model
的框架,或者如果未提供模型,则默认使用 PyTorch。 -
task
(str
, 默认为""
) — 用于管道的任务标识符。 -
num_workers
(int
, 可选, 默认为 8) — 当管道将使用DataLoader(在传递数据集时,在 PyTorch 模型的 GPU 上),要使用的工作程序数量。 -
batch_size
(int
, 可选, 默认为 1) — 当管道将使用DataLoader(在传递数据集时,在 PyTorch 模型的 GPU 上),要使用的批处理大小,对于推断,这并不总是有益的,请阅读使用管道进行批处理。 -
args_parser
(ArgumentHandler, 可选) — 负责解析提供的管道参数的对象的引用。 -
device
(int
, 可选, 默认为-1) — CPU/GPU 支持的设备序数。将其设置为-1 将利用 CPU,正数将在关联的 CUDA 设备 ID 上运行模型。您也可以传递本机torch.device
或str
。 -
binary_output
(bool
, 可选, 默认为False
) — 指示管道输出是否应以二进制格式(即 pickle)或原始文本格式发生的标志。
使用任何AutoModelForImageToImage
的图像到图像管道。该管道基于先前的图像输入生成图像。
示例:
>>> from PIL import Image
>>> import requests
>>> from transformers import pipeline
>>> upscaler = pipeline("image-to-image", model="caidas/swin2SR-classical-sr-x2-64")
>>> img = Image.open(requests.get("http://images.cocodataset.org/val2017/000000039769.jpg", stream=True).raw)
>>> img = img.resize((64, 64))
>>> upscaled_img = upscaler(img)
>>> img.size
(64, 64)
>>> upscaled_img.size
(144, 144)
此图像到图像管道目前可以从 pipeline()中使用以下任务标识符加载:"image-to-image"
。
查看huggingface.co/models上可用模型的列表。
__call__
( images: Union **kwargs )
参数
-
images
(str
,List[str]
,PIL.Image
或List[PIL.Image]
) — 该管道处理三种类型的图像:-
包含指向图像的 http 链接的字符串
-
包含本地图像路径的字符串
-
直接加载的 PIL 图像
管道接受单个图像或一批图像,然后必须将它们作为字符串传递。批处理中的图像必须全部采用相同的格式:全部作为 http 链接,全部作为本地路径,或全部作为 PIL 图像。
-
-
timeout
(float
, 可选, 默认为 None) — 从网络获取图像的最长等待时间(以秒为单位)。如果为 None,则不使用超时,调用可能会永远阻塞。
转换传递的图像。
ObjectDetectionPipeline
class transformers.ObjectDetectionPipeline
( *args **kwargs )
参数
-
model
(PreTrainedModel 或 TFPreTrainedModel) — 管道将用于进行预测的模型。这需要是继承自 PreTrainedModel 的模型,用于 PyTorch,以及继承自 TFPreTrainedModel 的模型,用于 TensorFlow。 -
tokenizer
(PreTrainedTokenizer) — 管道将用于为模型编码数据的分词器。此对象继承自 PreTrainedTokenizer。 -
modelcard
(str
或ModelCard
, optional) — 为此管道的模型指定的模型卡。 -
framework
(str
, optional) — 要使用的框架,可以是"pt"
代表 PyTorch,也可以是"tf"
代表 TensorFlow。指定的框架必须已安装。如果未指定框架,将默认使用当前安装的框架。如果未指定框架并且两个框架都已安装,则将默认使用
model
的框架,或者如果未提供模型,则将默认使用 PyTorch。 -
task
(str
, 默认为""
) — 管道的任务标识符。 -
num_workers
(int
, optional, 默认为 8) — 当管道将使用 DataLoader(在传递数据集时,在 Pytorch 模型的 GPU 上),要使用的工作人员数量。 -
batch_size
(int
, optional, defaults to 1) — 当管道将使用 DataLoader(在传递数据集时,在 Pytorch 模型的 GPU 上),要使用的批次大小,对于推理来说,这并不总是有益的,请阅读 Batching with pipelines。 -
args_parser
(ArgumentHandler, optional) — 负责解析提供的管道参数的对象的引用。 -
device
(int
, optional, 默认为 -1) — 用于 CPU/GPU 支持的设备序数。将其设置为 -1 将利用 CPU,正数将在关联的 CUDA 设备 id 上运行模型。您也可以传递原生的torch.device
或一个str
。 -
binary_output
(bool
, optional, 默认为False
) — 指示管道输出应以二进制格式(即 pickle)还是原始文本格式发生的标志。
使用任何 AutoModelForObjectDetection
的对象检测管道。此管道预测对象的边界框和它们的类别。
示例:
>>> from transformers import pipeline
>>> detector = pipeline(model="facebook/detr-resnet-50")
>>> detector("https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png")
[{'score': 0.997, 'label': 'bird', 'box': {'xmin': 69, 'ymin': 171, 'xmax': 396, 'ymax': 507}}, {'score': 0.999, 'label': 'bird', 'box': {'xmin': 398, 'ymin': 105, 'xmax': 767, 'ymax': 507}}]
>>> # x, y are expressed relative to the top left hand corner.
在 pipeline 教程 中了解有关使用管道的基础知识
此对象检测管道目前可以通过以下任务标识符从 pipeline() 加载:"object-detection"。
查看 huggingface.co/models 上可用模型的列表。
__call__
( *args **kwargs )
参数
-
images
(str
,List[str]
,PIL.Image
或List[PIL.Image]
) — 管道处理三种类型的图像:-
包含指向图像的 HTTP(S) 链接的字符串
-
包含本地图像路径的字符串
-
直接加载的 PIL 图像
管道接受单个图像或一批图像。批处理中的图像必须全部采用相同的格式:全部作为 HTTP(S) 链接,全部作为本地路径,或全部作为 PIL 图像。
-
-
threshold
(float
, optional, 默认为 0.9) — 进行预测所需的概率。 -
timeout
(float
,可选,默认为 None)— 从网络获取图像的最大等待时间(以秒为单位)。如果为 None,则不设置超时,调用可能永远阻塞。
检测作为输入传递的图像中的对象(边界框和类)。
视频分类管道
class transformers.VideoClassificationPipeline
( *args **kwargs )
参数
-
model
(PreTrainedModel 或 TFPreTrainedModel)— 该模型将被管道用于进行预测。这需要是继承自 PreTrainedModel 的模型,对于 TensorFlow 是继承自 TFPreTrainedModel。 -
tokenizer
(PreTrainedTokenizer)— 该管道将用于为模型编码数据的分词器。此对象继承自 PreTrainedTokenizer。 -
modelcard
(str
或ModelCard
,可选)— 为此管道的模型指定的模型卡。 -
framework
(str
,可选)— 要使用的框架,可以是"pt"
代表 PyTorch 或"tf"
代表 TensorFlow。指定的框架必须已安装。如果未指定框架,将默认使用当前安装的框架。如果未指定框架并且两个框架都已安装,则将默认使用
model
的框架,或者如果未提供模型,则默认使用 PyTorch。 -
task
(str
,默认为""
)— 管道的任务标识符。 -
num_workers
(int
,可选,默认为 8)— 当管道将使用 DataLoader(传递数据集时,在 Pytorch 模型的 GPU 上),要使用的工作程序数量。 -
batch_size
(int
,可选,默认为 1)— 当管道将使用 DataLoader(传递数据集时,在 Pytorch 模型的 GPU 上),要使用的批次大小,对于推断,这并不总是有益的,请阅读 Batching with pipelines 。 -
args_parser
(ArgumentHandler,可选)— 负责解析提供的管道参数的对象的引用。 -
device
(int
,可选,默认为 -1)— 用于 CPU/GPU 支持的设备序数。将其设置为 -1 将利用 CPU,正数将在关联的 CUDA 设备 id 上运行模型。您也可以传递本机torch.device
或str
。 -
binary_output
(bool
,可选,默认为False
)— 指示管道输出是否以二进制格式(即 pickle)或原始文本格式发生的标志。
使用任何 AutoModelForVideoClassification
的视频分类管道。此管道预测视频的类别。
当前可以使用以下任务标识符从 pipeline() 加载此视频分类管道:"video-classification"
。
查看 huggingface.co/models 上可用模型的列表。
__call__
( videos: Union **kwargs )
参数
-
videos
(str
,List[str]
)— 管道处理三种类型的视频:-
包含指向视频的 http 链接的字符串
-
包含视频本地路径的字符串
该管道接受单个视频或一批视频,然后必须将其作为字符串传递。批处理中的视频必须全部采用相同的格式:全部作为 http 链接或全部作为本地路径。
-
-
top_k
(int
, optional, defaults to 5) — 管道将返回的前 k 个标签的数量。如果提供的数字高于模型配置中可用的标签数量,则默认为标签数量。 -
num_frames
(int
, optional, defaults toself.model.config.num_frames
) — 从视频中采样的帧数,用于进行分类。如果未提供,则将默认为模型配置中指定的帧数。 -
frame_sampling_rate
(int
, optional, defaults to 1) — 用于从视频中选择帧的采样率。如果未提供,则将默认为 1,即将使用每一帧。
为传入的视频分配标签。
ZeroShotImageClassificationPipeline
class transformers.ZeroShotImageClassificationPipeline
( **kwargs )
参数
-
model
(PreTrainedModel or TFPreTrainedModel) — 该管道将用于进行预测的模型。这需要是继承自 PreTrainedModel 的 PyTorch 模型和 TFPreTrainedModel 的 TensorFlow 模型。 -
tokenizer
(PreTrainedTokenizer) — 该 tokenizer 将被管道用于对数据进行编码以供模型使用。该对象继承自 PreTrainedTokenizer。 -
modelcard
(str
orModelCard
, optional) — 为该管道的模型指定的模型卡。 -
framework
(str
, optional) — 要使用的框架,可以是"pt"
表示 PyTorch 或"tf"
表示 TensorFlow。指定的框架必须已安装。如果未指定框架,则将默认为当前安装的框架。如果未指定框架且两个框架都已安装,则将默认为
model
的框架,或者如果未提供模型,则将默认为 PyTorch。 -
task
(str
, defaults to""
) — 用于管道的任务标识符。 -
num_workers
(int
, optional, defaults to 8) — 当管道将使用DataLoader(传递数据集时,在 Pytorch 模型的 GPU 上),要使用的工作人员数量。 -
batch_size
(int
, optional, defaults to 1) — 当管道将使用DataLoader(传递数据集时,在 Pytorch 模型的 GPU 上),要使用的批处理大小,对于推断,这并不总是有益的,请阅读使用管道进行批处理。 -
args_parser
(ArgumentHandler, optional) — 负责解析提供的管道参数的对象的引用。 -
device
(int
, optional, defaults to -1) — CPU/GPU 支持的设备序数。将其设置为-1 将利用 CPU,正数将在关联的 CUDA 设备 ID 上运行模型。您也可以传递原生的torch.device
或str
。 -
binary_output
(bool
, optional, defaults toFalse
) — 指示管道输出是否应以二进制格式(即 pickle)或原始文本形式发生的标志。
使用CLIPModel
进行零样本图像分类管道。该管道在提供图像和一组candidate_labels
时预测图像的类别。
示例:
>>> from transformers import pipeline
>>> classifier = pipeline(model="openai/clip-vit-large-patch14")
>>> classifier(
... "https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png",
... candidate_labels=["animals", "humans", "landscape"],
... )
[{'score': 0.965, 'label': 'animals'}, {'score': 0.03, 'label': 'humans'}, {'score': 0.005, 'label': 'landscape'}]
>>> classifier(
... "https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png",
... candidate_labels=["black and white", "photorealist", "painting"],
... )
[{'score': 0.996, 'label': 'black and white'}, {'score': 0.003, 'label': 'photorealist'}, {'score': 0.0, 'label': 'painting'}]
在 pipeline tutorial 中了解有关使用管道的基础知识
当前可以使用 pipeline()从中加载此图像分类管道的任务标识符为:"zero-shot-image-classification"。
在huggingface.co/models上查看可用模型列表。
__call__
( images: Union **kwargs )
参数
-
images
(str
,List[str]
,PIL.Image
orList[PIL.Image]
) — 管道处理三种类型的图像:-
包含指向图像的 http 链接的字符串
-
包含指向图像的本地路径的字符串
-
直接在 PIL 中加载的图像
-
-
candidate_labels
(List[str]
) — 该图像的候选标签 -
hypothesis_template
(str
, 可选, 默认为"This is a photo of {}"
) — 与candidate_labels一起使用的句子,通过替换占位符与候选标签尝试图像分类。然后通过使用 logits_per_image 来估计可能性 -
timeout
(float
, 可选, 默认为 None) — 从网络获取图像的最长等待时间(以秒为单位)。如果为 None,则不设置超时,调用可能会永远阻塞。
为传入的图像分配标签。
ZeroShotObjectDetectionPipeline
class transformers.ZeroShotObjectDetectionPipeline
( **kwargs )
参数
-
model
(PreTrainedModel 或 TFPreTrainedModel) — 该管道将用于进行预测的模型。这需要是继承自 PreTrainedModel 的模型,对于 TensorFlow,需要是继承自 TFPreTrainedModel 的模型。 -
tokenizer
(PreTrainedTokenizer) — 该 tokenizer 将被管道用于对数据进行编码以供模型使用。该对象继承自 PreTrainedTokenizer。 -
modelcard
(str
orModelCard
, 可选) — 为该管道的模型指定的模型卡。 -
framework
(str
, 可选) — 要使用的框架,可以是"pt"
表示 PyTorch 或"tf"
表示 TensorFlow。指定的框架必须已安装。如果未指定框架,将默认使用当前安装的框架。如果未指定框架并且两个框架都已安装,则将默认使用
model
的框架,或者如果未提供模型,则将默认使用 PyTorch。 -
task
(str
, 默认为""
) — 管道的任务标识符。 -
num_workers
(int
, 可选, 默认为 8) — 当管道将使用DataLoader(当传递数据集时,对于 PyTorch 模型在 GPU 上),要使用的工作人员数量。 -
batch_size
(int
, 可选, 默认为 1) — 当管道将使用DataLoader(当传递数据集时,对于 PyTorch 模型在 GPU 上),要使用的批次大小,对于推断,这并不总是有益的,请阅读Batching with pipelines。 -
args_parser
(ArgumentHandler, 可选) — 负责解析提供的管道参数的对象的引用。 -
device
(int
, 可选, 默认为-1) — CPU/GPU 支持的设备序数。将其设置为-1 将利用 CPU,正数将在关联的 CUDA 设备 id 上运行模型。您也可以传递本机的torch.device
或str
。 -
binary_output
(bool
, 可选, 默认为False
) — 指示管道输出是否应以二进制格式(即 pickle)或原始文本格式发生的标志。
使用OwlViTForObjectDetection
进行零击目标检测管道。当您提供一张图像和一组candidate_labels
时,此管道会预测对象的边界框。
示例:
>>> from transformers import pipeline
>>> detector = pipeline(model="google/owlvit-base-patch32", task="zero-shot-object-detection")
>>> detector(
... "http://images.cocodataset.org/val2017/000000039769.jpg",
... candidate_labels=["cat", "couch"],
... )
[{'score': 0.287, 'label': 'cat', 'box': {'xmin': 324, 'ymin': 20, 'xmax': 640, 'ymax': 373}}, {'score': 0.254, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 315, 'ymax': 472}}, {'score': 0.121, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 642, 'ymax': 476}}]
>>> detector(
... "https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png",
... candidate_labels=["head", "bird"],
... )
[{'score': 0.119, 'label': 'bird', 'box': {'xmin': 71, 'ymin': 170, 'xmax': 410, 'ymax': 508}}]
了解有关在 pipeline 教程中使用管道的基础知识
这个目标检测管道目前可以从 pipeline()中加载,使用以下任务标识符:"zero-shot-object-detection"。
在huggingface.co/models上查看可用模型列表。
__call__
( image: Union candidate_labels: Union = None **kwargs )
参数
-
image
(str
,PIL.Image
或List[Dict[str, Any]]
) — 该管道处理三种类型的图像:-
包含指向图像的 http url 的字符串
-
包含指向图像的本地路径的字符串
-
直接加载的 PIL 图像
您可以使用此参数直接发送图像列表,数据集或生成器,如下所示:
-
检测传入的图像中的对象(边界框和类)。
自然语言处理
用于自然语言处理任务的管道包括以下内容。
对话管道
class transformers.Conversation
( messages: Union = None conversation_id: UUID = None **deprecated_kwargs )
参数
-
messages
(Union[str, List[Dict[str, str]]], 可选) — 开始对话的初始消息,可以是一个字符串,也可以是包含“role”和“content”键的字典列表。如果传递了一个字符串,它将被解释为具有“user”角色的单个消息。 -
conversation_id
(uuid.UUID
, 可选) — 对话的唯一标识符。如果未提供,将为对话分配一个随机的 UUID4 id。
包含对话及其历史记录的实用类。此类旨在用作 ConversationalPipeline 的输入。对话包含几个实用函数,用于管理新用户输入和生成模型响应的添加。
用法:
conversation = Conversation("Going to the movies tonight - any suggestions?")
conversation.add_message({"role": "assistant", "content": "The Big lebowski."})
conversation.add_message({"role": "user", "content": "Is it good?"})
add_user_input
( text: str overwrite: bool = False )
为下一轮对话添加用户输入。这是一个传统方法,假设输入必须交替用户/助手/用户/助手,因此不会连续添加多个用户消息。我们建议只使用带有“user”角色的add_message
。
append_response
( response: str )
这是一个传统方法。我们建议只使用带有适当角色的add_message
。
mark_processed
( )
这是一个传统方法,因为 Conversation 不再区分已处理和未处理的用户输入。我们在这里设置一个计数器,以保持行为大体向后兼容,但通常在编写新代码时,您应该直接阅读消息。
class transformers.ConversationalPipeline
( *args **kwargs )
参数
-
model
(PreTrainedModel 或 TFPreTrainedModel) — 管道将用于进行预测的模型。这需要是继承自 PreTrainedModel 的模型,对于 TensorFlow,需要是继承自 TFPreTrainedModel 的模型。 -
tokenizer
(PreTrainedTokenizer) — 管道将用于为模型编码数据的分词器。此对象继承自 PreTrainedTokenizer。 -
modelcard
(str
或ModelCard
,可选) — 为此管道的模型指定的模型卡。 -
framework
(str
, 可选) — 要使用的框架,可以是"pt"
表示 PyTorch,也可以是"tf"
表示 TensorFlow。指定的框架必须已安装。如果未指定框架,将默认使用当前安装的框架。如果未指定框架且两个框架都已安装,则将默认使用
model
的框架,或者如果未提供模型,则将默认使用 PyTorch。 -
task
(str
,默认为""
) — 用于管道的任务标识符。 -
num_workers
(int
, 可选, 默认为 8) — 当管道将使用DataLoader(当传递数据集时,在 PyTorch 模型的 GPU 上),要使用的工作程序数。 -
batch_size
(int
, 可选, 默认为 1) — 当管道将使用DataLoader(当传递数据集时,在 PyTorch 模型的 GPU 上),要使用的批次大小,对于推断,这并不总是有益的,请阅读使用管道进行批处理。 -
args_parser
(ArgumentHandler,可选) — 负责解析提供的管道参数的对象的引用。 -
device
(int
, 可选, 默认为-1) — 用于 CPU/GPU 支持的设备序数。将其设置为-1 将利用 CPU,正数将在关联的 CUDA 设备 ID 上运行模型。您也可以传递原生的torch.device
或str
。 -
binary_output
(bool
, 可选, 默认为False
) — 指示管道输出是否应以二进制格式(即 pickle)或原始文本格式发生的标志。 -
min_length_for_response
(int
, 可选, 默认为 32) — 响应的最小长度(标记数)。 -
minimum_tokens
(int
, 可选, 默认为 10) — 留给响应的最小标记长度。
多轮对话管道。
示例:
>>> from transformers import pipeline, Conversation
# Any model with a chat template can be used in a ConversationalPipeline.
>>> chatbot = pipeline(model="facebook/blenderbot-400M-distill")
>>> # Conversation objects initialized with a string will treat it as a user message
>>> conversation = Conversation("I'm looking for a movie - what's your favourite one?")
>>> conversation = chatbot(conversation)
>>> conversation.messages[-1]["content"]
"I don't really have a favorite movie, but I do like action movies. What about you?"
>>> conversation.add_message({"role": "user", "content": "That's interesting, why do you like action movies?"})
>>> conversation = chatbot(conversation)
>>> conversation.messages[-1]["content"]
" I think it's just because they're so fast-paced and action-fantastic."
学习有关在 pipeline 教程中使用管道的基础知识
当前可以使用以下任务标识符从 pipeline()加载此对话管道:"conversational"
。
此管道可与具有聊天模板设置的任何模型一起使用。
__call__
( conversations: Union num_workers = 0 **kwargs ) → export const metadata = 'undefined';Conversation or a list of Conversation
参数
-
conversations
(一个 Conversation 或 Conversation 列表) — 用于生成响应的对话。输入也可以作为带有role
和content
键的字典列表传递 - 在这种情况下,它们将自动转换为Conversation
对象。可以作为列表传递任何格式的多个对话。 -
clean_up_tokenization_spaces
(bool
,可选,默认为False
)— 是否清除文本输出中可能存在的额外空格。generate_kwargs — 要传递给模型的 generate 方法的其他关键字参数(请参阅与您的框架对应的 generate 方法此处)。
返回
对话或对话列表
包含新用户输入的对话的更新生成响应的对话。
为输入的对话生成响应。
FillMaskPipeline
class transformers.FillMaskPipeline
( model: Union tokenizer: Optional = None feature_extractor: Optional = None image_processor: Optional = None modelcard: Optional = None framework: Optional = None task: str = '' args_parser: ArgumentHandler = None device: Union = None torch_dtype: Union = None binary_output: bool = False **kwargs )
参数
-
model
(PreTrainedModel 或 TFPreTrainedModel)— 流水线将用于进行预测的模型。这需要是继承自 PreTrainedModel(对于 PyTorch)和 TFPreTrainedModel(对于 TensorFlow)的模型。 -
tokenizer
(PreTrainedTokenizer)— 流水线将用于为模型编码数据的分词器。该对象继承自 PreTrainedTokenizer。 -
modelcard
(str
或ModelCard
,可选)— 为该流水线的模型指定的模型卡。 -
framework
(str
,可选)— 要使用的框架,可以是"pt"
表示 PyTorch 或"tf"
表示 TensorFlow。指定的框架必须已安装。如果未指定框架,将默认使用当前安装的框架。如果未指定框架并且两个框架都已安装,则将默认使用
model
的框架,或者如果未提供模型,则默认使用 PyTorch。 -
task
(str
,默认为""
)— 用于流水线的任务标识符。 -
num_workers
(int
,可选,默认为 8)— 当流水线将使用DataLoader(在传递数据集时,在 PyTorch 模型的 GPU 上),要使用的工作人员数量。 -
batch_size
(int
,可选,默认为 1)— 当流水线将使用DataLoader(在传递数据集时,在 PyTorch 模型的 GPU 上),要使用的批次大小,对于推断,这并不总是有益的,请阅读使用流水线进行批处理。 -
args_parser
(ArgumentHandler,可选)— 负责解析提供的流水线参数的对象的引用。 -
device
(int
,可选,默认为-1)— CPU/GPU 支持的设备序数。将其设置为-1 将利用 CPU,正数将在关联的 CUDA 设备 ID 上运行模型。您也可以传递原生的torch.device
或str
。 -
binary_output
(bool
,可选,默认为False
)— 指示流水线输出是否应以二进制格式(即 pickle)或原始文本格式发生的标志。 -
top_k
(int
,默认为 5)— 要返回的预测数量。 -
targets
(str
或List[str]
,可选)— 当传递时,模型将限制分数到传递的目标,而不是在整个词汇表中查找。如果提供的目标不在模型词汇表中,它们将被标记化,第一个生成的标记将被使用(带有警告,可能会更慢)。
使用任何ModelWithLMHead
的掩码语言建模预测管道。有关更多信息,请参阅掩码语言建模示例。
示例:
>>> from transformers import pipeline
>>> fill_masker = pipeline(model="bert-base-uncased")
>>> fill_masker("This is a simple [MASK].")
[{'score': 0.042, 'token': 3291, 'token_str': 'problem', 'sequence': 'this is a simple problem.'}, {'score': 0.031, 'token': 3160, 'token_str': 'question', 'sequence': 'this is a simple question.'}, {'score': 0.03, 'token': 8522, 'token_str': 'equation', 'sequence': 'this is a simple equation.'}, {'score': 0.027, 'token': 2028, 'token_str': 'one', 'sequence': 'this is a simple one.'}, {'score': 0.024, 'token': 3627, 'token_str': 'rule', 'sequence': 'this is a simple rule.'}]
了解有关在 pipeline 教程中使用管道的基础知识
此掩码填充管道目前可以使用 pipeline()从以下任务标识符加载:"fill-mask"。
此管道可以使用已经使用掩码语言建模目标进行训练的模型,其中包括库中的双向模型。请查看huggingface.co/models上可用模型的最新列表。
此管道仅适用于具有一个掩码标记的输入。实验性:我们添加了对多个掩码的支持。返回的值是原始模型输出,并对应于不相交的概率,其中一个可能期望联合概率(请参见讨论)。
此管道现在支持 tokenizer_kwargs。例如尝试:
>>> from transformers import pipeline
>>> fill_masker = pipeline(model="bert-base-uncased")
>>> tokenizer_kwargs = {"truncation": True}
>>> fill_masker(
... "This is a simple [MASK]. " + "...with a large amount of repeated text appended. " * 100,
... tokenizer_kwargs=tokenizer_kwargs,
... )
__call__
( inputs *args **kwargs ) → export const metadata = 'undefined';A list or a list of list of dict
参数
-
args
(str
或List[str]
)- 一个或多个文本(或一个提示列表)带有掩码标记。 -
targets
(str
或List[str]
,可选)- 当传递时,模型将限制分数到传递的目标,而不是在整个词汇表中查找。如果提供的目标不在模型词汇表中,它们将被标记化,并且将使用第一个生成的标记(带有警告,并且可能会更慢)。 -
top_k
(int
,可选)- 当传递时,将覆盖要返回的预测数量。
返回
一个字典列表或字典列表
每个结果都以字典列表的形式呈现,具有以下键:
-
sequence
(str
)- 具有掩码标记预测的相应输入。 -
score
(float
)- 相应的概率。 -
token
(int
)- 预测的标记 id(用于替换掩码标记)。 -
token_str
(str
)- 预测的标记(用于替换掩码标记)。
填充作为输入的文本中的掩码标记。
QuestionAnsweringPipeline
class transformers.QuestionAnsweringPipeline
( model: Union tokenizer: PreTrainedTokenizer modelcard: Optional = None framework: Optional = None task: str = '' **kwargs )
参数
-
model
(PreTrainedModel 或 TFPreTrainedModel)- 该模型将被管道用于进行预测。这需要是继承自 PreTrainedModel(对于 PyTorch)和 TFPreTrainedModel(对于 TensorFlow)的模型。 -
tokenizer
(PreTrainedTokenizer)- 该 tokenizer 将被管道用于为模型编码数据。此对象继承自 PreTrainedTokenizer。 -
modelcard
(str
或ModelCard
,可选)- 为此管道的模型指定的模型卡。 -
framework
(str
,可选)- 要使用的框架,可以是"pt"
表示 PyTorch 或"tf"
表示 TensorFlow。指定的框架必须已安装。如果未指定框架,则将默认使用当前安装的框架。如果未指定框架并且两个框架都已安装,则将默认使用
model
的框架,或者如果未提供模型,则将默认使用 PyTorch。 -
task
(str
,默认为""
)- 用于管道的任务标识符。 -
num_workers
(int
, optional, 默认为 8) — 当管道将使用 DataLoader(在传递数据集时,在 Pytorch 模型的 GPU 上),要使用的工作人员数量。 -
batch_size
(int
, optional, 默认为 1) — 当管道将使用 DataLoader(在传递数据集时,在 Pytorch 模型的 GPU 上),要使用的批次大小,对于推理来说,这并不总是有益的,请阅读使用管道进行批处理。 -
args_parser
(ArgumentHandler, optional) — 负责解析提供的管道参数的对象的引用。 -
device
(int
, optional, 默认为-1) — 用于 CPU/GPU 支持的设备序数。将其设置为-1 将利用 CPU,正数将在关联的 CUDA 设备 id 上运行模型。您也可以传递原生的torch.device
或一个str
。 -
binary_output
(bool
, optional, 默认为False
) — 指示管道输出是否应以二进制格式(即 pickle)或原始文本格式发生的标志。
使用任何 ModelForQuestionAnswering
的问答管道。有关更多信息,请参阅问答示例。
示例:
>>> from transformers import pipeline
>>> oracle = pipeline(model="deepset/roberta-base-squad2")
>>> oracle(question="Where do I live?", context="My name is Wolfgang and I live in Berlin")
{'score': 0.9191, 'start': 34, 'end': 40, 'answer': 'Berlin'}
了解如何在 pipeline tutorial 中使用管道的基础知识。
此问答管道目前可以使用以下任务标识符从 pipeline()中加载:"question-answering"。
此管道可以使用已在问答任务上进行了微调的模型。请查看huggingface.co/models上可用模型的最新列表。
__call__
( *args **kwargs ) → export const metadata = 'undefined';A dict or a list of dict
参数
-
args
(SquadExample
或SquadExample
列表) — 包含问题和上下文的一个或多个SquadExample
。 -
X
(SquadExample
或SquadExample
列表, optional) — 包含问题和上下文的一个或多个SquadExample
(将被视为第一个位置参数传递时的相同方式)。 -
data
(SquadExample
或SquadExample
列表, optional) — 包含问题和上下文的一个或多个SquadExample
(将被视为第一个位置参数传递时的相同方式)。 -
question
(str
或List[str]
) — 一个或多个问题(必须与context
参数一起使用)。 -
context
(str
或List[str]
) — 与问题相关联的一个或多个上下文(必须与question
参数一起使用)。 -
topk
(int
, optional, 默认为 1) — 要返回的答案数量(将按可能性顺序选择)。请注意,如果在上下文中没有足够的选项可用,我们将返回少于 topk 个答案。 -
doc_stride
(int
, optional, 默认为 128) — 如果上下文对于模型来说太长而无法与问题匹配,它将被分成几个具有一些重叠的块。此参数控制该重叠的大小。 -
max_answer_len
(int
, optional, 默认为 15) — 预测答案的最大长度(例如,只考虑长度较短的答案)。 -
max_seq_len
(int
, optional, 默认为 384) — 每个传递给模型的块中的总句子长度(上下文 + 问题)的最大长度。如果需要,上下文将被分成几个块(使用doc_stride
作为重叠)。 -
max_question_len
(int
, optional, 默认为 64) — 在标记化后问题的最大长度。如果需要,它将被截断。 -
handle_impossible_answer
(bool
, optional, 默认为False
) — 是否接受不可能作为答案。 -
align_to_words
(bool
, 可选, 默认为True
) — 尝试将答案与实际单词对齐。提高了空格分隔语言的质量。可能会对非空格分隔的语言(如日语或中文)造成伤害
返回
一个 dict
或一个 dict
的列表
每个结果都作为一个带有以下键的字典:
-
score
(float
) — 与答案相关联的概率。 -
start
(int
) — 答案的字符起始索引(在输入的标记化版本中)。 -
end
(int
) — 答案的字符结束索引(在输入的标记化版本中)。 -
answer
(str
) — 问题的答案。
通过使用输入的上下文回答提出的问题。
create_sample
( question: Union context: Union ) → export const metadata = 'undefined';One or a list of SquadExample
参数
-
question
(str
或List[str]
) — 提出的问题。 -
context
(str
或List[str]
) — 我们将在其中寻找答案的上下文。
返回
一个或多个 SquadExample
相应的 SquadExample
分组问题和上下文。
QuestionAnsweringPipeline 在内部利用 SquadExample
。这个辅助方法封装了将问题和上下文转换为 SquadExample
的所有逻辑。
我们目前支持抽取式问答。
span_to_answer
( text: str start: int end: int ) → export const metadata = 'undefined';Dictionary like `{‘answer’
参数
-
text
(str
) — 从中提取答案的实际上下文。 -
start
(int
) — 答案起始标记索引。 -
end
(int
) — 答案结束标记索引。
返回
类似于 `{‘answer’
str, ‘start’: int, ‘end’: int}`
从标记概率解码时,此方法将标记索引映射到初始上下文中的实际单词。
SummarizationPipeline
class transformers.SummarizationPipeline
( *args **kwargs )
参数
-
model
(PreTrainedModel 或 TFPreTrainedModel) — 流水线将用于进行预测的模型。这需要是继承自 PreTrainedModel 的模型,对于 PyTorch 是 TFPreTrainedModel。 -
tokenizer
(PreTrainedTokenizer) — 流水线将用于为模型编码数据的分词器。此对象继承自 PreTrainedTokenizer。 -
modelcard
(str
或ModelCard
, 可选) — 为此流水线的模型指定的模型卡。 -
framework
(str
, 可选) — 要使用的框架,可以是"pt"
代表 PyTorch 或"tf"
代表 TensorFlow。指定的框架必须已安装。如果未指定框架,将默认使用当前安装的框架。如果未指定框架并且两个框架都已安装,则将默认使用
model
的框架,或者如果未提供模型,则默认使用 PyTorch。 -
task
(str
, 默认为""
) — 用于流水线的任务标识符。 -
num_workers
(int
, 可选, 默认为 8) — 当流水线将使用 DataLoader(当传递数据集时,在 Pytorch 模型的 GPU 上),要使用的工作人员数量。 -
batch_size
(int
, 可选, 默认为 1) — 当流水线将使用 DataLoader(当传递数据集时,在 Pytorch 模型的 GPU 上),要使用的批量大小,对于推断,这并不总是有益的,请阅读 使用流水线进行批处理 。 -
args_parser
(ArgumentHandler, 可选) — 负责解析提供的管道参数的对象的引用。 -
device
(int
, 可选, 默认为 -1) — CPU/GPU 支持的设备序号。将其设置为-1 将利用 CPU,设置为正数将在关联的 CUDA 设备 ID 上运行模型。您也可以传递原生的torch.device
或str
。 -
binary_output
(bool
, 可选, 默认为False
) — 指示管道输出是否应以二进制格式(即 pickle)或原始文本格式进行的标志。
总结新闻文章和其他文档。
当前可以使用以下任务标识符从 pipeline() 加载此总结管道: "summarization"
.
此管道可以使用已在摘要任务上进行了微调的模型,目前有 ’bart-large-cnn’, ’t5-small’, ’t5-base’, ’t5-large’, ’t5-3b’, ’t5-11b’。查看huggingface.co/models上可用模型的最新列表。有关可用参数的列表,请参阅以下文档
用法:
# use bart in pytorch
summarizer = pipeline("summarization")
summarizer("An apple a day, keeps the doctor away", min_length=5, max_length=20)
# use t5 in tf
summarizer = pipeline("summarization", model="t5-base", tokenizer="t5-base", framework="tf")
summarizer("An apple a day, keeps the doctor away", min_length=5, max_length=20)
__call__
( *args **kwargs ) → export const metadata = 'undefined';A list or a list of list of dict
参数
-
documents
(str 或List[str]
) — 要总结的一个或多个文章(或一组文章)。 -
return_text
(bool
, 可选, 默认为True
) — 是否在输出中包含解码后的文本 -
return_tensors
(bool
, 可选, 默认为False
) — 是否在输出中包含预测的张量(作为标记索引)。 -
clean_up_tokenization_spaces
(bool
, 可选, 默认为False
) — 是否清除文本输出中可能存在的额外空格。generate_kwargs — 传递给模型的 generate 方法的额外关键字参数(请参阅您框架对应的 generate 方法此处)。
返回
一个 dict
列表或 dict
列表的列表
每个结果都以以下键的字典形式呈现:
-
summary_text
(str
, 当return_text=True
时存在) — 相应输入的摘要。 -
summary_token_ids
(torch.Tensor
或tf.Tensor
, 当return_tensors=True
时存在) — 摘要的标记 ID。
将输入的文本进行总结。
TableQuestionAnsweringPipeline
class transformers.TableQuestionAnsweringPipeline
( args_parser = <transformers.pipelines.table_question_answering.TableQuestionAnsweringArgumentHandler object at 0x7f3b448d5f30> *args **kwargs )
参数
-
model
(PreTrainedModel 或 TFPreTrainedModel) — 该管道将用于进行预测的模型。这需要是继承自 PreTrainedModel 的模型,对于 TensorFlow 是继承自 TFPreTrainedModel。 -
tokenizer
(PreTrainedTokenizer) — 该管道将用于为模型编码数据的分词器。此对象继承自 PreTrainedTokenizer。 -
modelcard
(str
或ModelCard
, 可选) — 为此管道的模型指定的模型卡。 -
framework
(str
, 可选) — 要使用的框架,可以是"pt"
代表 PyTorch 或"tf"
代表 TensorFlow。指定的框架必须已安装。如果未指定框架,将默认使用当前安装的框架。如果未指定框架并且两个框架都已安装,则将默认使用
model
的框架,或者如果未提供模型,则将默认使用 PyTorch。 -
task
(str
, defaults to""
) — 用于管道的任务标识符。 -
num_workers
(int
, optional, defaults to 8) — 当管道将使用 DataLoader(传递数据集时,在 Pytorch 模型的 GPU 上),要使用的工作人员数量。 -
batch_size
(int
, optional, defaults to 1) — 当管道将使用 DataLoader(传递数据集时,在 Pytorch 模型的 GPU 上),要使用的批次大小,对于推理来说,这并不总是有益的,请阅读 Batching with pipelines 。 -
args_parser
(ArgumentHandler, optional) — 负责解析提供的管道参数的对象的引用。 -
device
(int
, optional, defaults to -1) — 用于 CPU/GPU 支持的设备序数。将其设置为 -1 将利用 CPU,正数将在关联的 CUDA 设备 id 上运行模型。您也可以传递原生torch.device
或str
。 -
binary_output
(bool
, optional, defaults toFalse
) — 标志,指示管道输出应以二进制格式(即 pickle)或原始文本形式发生。
使用 ModelForTableQuestionAnswering
的表格问答管道。此管道仅在 PyTorch 中可用。
示例:
>>> from transformers import pipeline
>>> oracle = pipeline(model="google/tapas-base-finetuned-wtq")
>>> table = {
... "Repository": ["Transformers", "Datasets", "Tokenizers"],
... "Stars": ["36542", "4512", "3934"],
... "Contributors": ["651", "77", "34"],
... "Programming language": ["Python", "Python", "Rust, Python and NodeJS"],
... }
>>> oracle(query="How many stars does the transformers repository have?", table=table)
{'answer': 'AVERAGE > 36542', 'coordinates': [(0, 1)], 'cells': ['36542'], 'aggregator': 'AVERAGE'}
了解有关在 pipeline 教程 中使用管道的基础知识
此表格问答管道目前可以从 pipeline() 中加载,使用以下任务标识符:"table-question-answering"
。
此管道可以使用已在表格问答任务上进行了微调的模型。请查看 huggingface.co/models 上提供的可用模型的最新列表。
__call__
( *args **kwargs ) → export const metadata = 'undefined';A dictionary or a list of dictionaries containing results
参数
-
table
(pd.DataFrame
或Dict
) — 将转换为包含所有表格值的 DataFrame 的 Pandas DataFrame 或字典。请参阅上面的字典示例。 -
query
(str
或List[str]
) — 将发送到模型的查询或查询列表,以及表格一起。 -
sequential
(bool
, optional, defaults toFalse
) — 是否按顺序进行推理还是批处理。批处理更快,但像 SQA 这样的模型需要按顺序进行推理,以提取序列中的关系,考虑到它们的对话性质。 -
padding
(bool
,str
或 PaddingStrategy, optional, defaults toFalse
) — 激活和控制填充。接受以下值:-
True
或'longest'
: 填充到批次中最长的序列(如果只提供单个序列,则不填充)。 -
'max_length'
: 填充到使用参数max_length
指定的最大长度或模型的最大可接受输入长度(如果未提供该参数)。 -
False
或'do_not_pad'
(默认): 不填充(即可以输出具有不同长度序列的批次)。
-
-
truncation
(bool
,str
或TapasTruncationStrategy
, optional, defaults toFalse
) — 激活和控制截断。接受以下值:-
True
或'drop_rows_to_fit'
: 截断到使用参数max_length
指定的最大长度或模型的最大可接受输入长度(如果未提供该参数)。这将逐行截断,从表中删除行。 -
False
或'do_not_truncate'
(默认):不截断(即,可以输出序列长度大于模型最大可接受输入大小的批次)。
-
返回
包含结果的字典或字典列表
每个结果是一个带有以下键的字典:
-
answer
(str
)— 给定表格的查询答案。如果有聚合器,答案将以AGGREGATOR >
开头。 -
coordinates
(List[Tuple[int, int]]
)— 答案单元格的坐标。 -
cells
(List[str]
)— 由答案单元格值组成的字符串列表。 -
aggregator
(str
)— 如果模型有聚合器,则返回聚合器。
根据表格回答查询。管道接受以下几种类型的输入,详细信息如下:
-
pipeline(table, query)
-
pipeline(table, [query])
-
pipeline(table=table, query=query)
-
pipeline(table=table, query=[query])
-
pipeline({"table": table, "query": query})
-
pipeline({"table": table, "query": [query]})
-
pipeline([{"table": table, "query": query}, {"table": table, "query": query}])
table
参数应该是一个从该字典构建的字典或 DataFrame,包含整个表格:
示例:
data = {
"actors": ["brad pitt", "leonardo di caprio", "george clooney"],
"age": ["56", "45", "59"],
"number of movies": ["87", "53", "69"],
"date of birth": ["7 february 1967", "10 june 1996", "28 november 1967"],
}
可以将此字典作为参数传递,或者可以将其转换为 pandas DataFrame:
示例:
import pandas as pd
table = pd.DataFrame.from_dict(data)
TextClassificationPipeline
class transformers.TextClassificationPipeline
( **kwargs )
参数
-
model
(PreTrainedModel 或 TFPreTrainedModel)— 该模型将被管道用于进行预测。这需要是继承自 PreTrainedModel 的模型,对于 PyTorch 是 TFPreTrainedModel。 -
tokenizer
(PreTrainedTokenizer)— 该 tokenizer 将被管道用于为模型编码数据。该对象继承自 PreTrainedTokenizer。 -
modelcard
(str
或ModelCard
,可选)— 为该管道的模型指定的模型卡。 -
framework
(str
,可选)— 要使用的框架,可以是"pt"
表示 PyTorch 或"tf"
表示 TensorFlow。指定的框架必须已安装。如果未指定框架,将默认使用当前安装的框架。如果未指定框架并且两个框架都已安装,则将默认使用
model
的框架,或者如果未提供模型,则默认使用 PyTorch。 -
task
(str
,默认为""
)— 用于管道的任务标识符。 -
num_workers
(int
,可选,默认为 8)— 当管道将使用DataLoader(在 PyTorch 模型的 GPU 上传递数据集时),要使用的工作程序数量。 -
batch_size
(int
,可选,默认为 1)— 当管道将使用DataLoader(传递数据集时,在 PyTorch 模型的 GPU 上),要使用的批次大小,对于推断,这并不总是有益的,请阅读使用管道进行批处理。 -
args_parser
(ArgumentHandler,可选)— 负责解析提供的管道参数的对象的引用。 -
device
(int
,可选,默认为-1)— CPU/GPU 支持的设备序数。将其设置为-1 将利用 CPU,正数将在关联的 CUDA 设备 ID 上运行模型。您也可以传递原生的torch.device
或str
。 -
binary_output
(bool
,可选,默认为False
)— 指示管道输出应以二进制格式(即 pickle)还是原始文本格式发生的标志。 -
return_all_scores
(bool
,可选,默认为False
)— 是否返回所有预测分数还是仅返回预测类的分数。 -
function_to_apply
(str
,可选,默认为"default"
)— 用于应用于模型输出以检索分数的函数。接受四个不同的值:-
"default"
:如果模型有一个标签,则将在输出上应用 sigmoid 函数。如果模型有多个标签,则将在输出上应用 softmax 函数。 -
"sigmoid"
:在输出上应用 sigmoid 函数。 -
"softmax"
:在输出上应用 softmax 函数。 -
"none"
:不在输出上应用任何函数。
-
使用任何ModelForSequenceClassification
的文本分类管道。有关更多信息,请参阅序列分类示例。
例:
>>> from transformers import pipeline
>>> classifier = pipeline(model="distilbert-base-uncased-finetuned-sst-2-english")
>>> classifier("This movie is disgustingly good !")
[{'label': 'POSITIVE', 'score': 1.0}]
>>> classifier("Director tried too much.")
[{'label': 'NEGATIVE', 'score': 0.996}]
了解有关在 pipeline 教程中使用管道的基础知识
此文本分类管道目前可以从 pipeline()中使用以下任务标识符加载:"sentiment-analysis"
(用于根据积极或消极情绪对序列进行分类)。
如果有多个分类标签可用(model.config.num_labels >= 2
),则管道将对结果运行 softmax。如果只有一个标签,则管道将对结果运行 sigmoid。
此管道可以使用已在序列分类任务上进行了微调的模型。请查看huggingface.co/models上可用模型的最新列表。
__call__
( *args **kwargs ) → export const metadata = 'undefined';A list or a list of list of dict
参数
-
args
(str
或List[str]
或Dict[str]
或List[Dict[str]]
)— 要分类的一个或多个文本。为了在分类中使用文本对,可以发送包含{"text","text_pair"}
键的字典,或者这些字典的列表。 -
top_k
(int
,可选,默认为1
)— 要返回多少结果。 -
function_to_apply
(str
,可选,默认为"default"
)— 用于应用于模型输出以检索分数的函数。接受四个不同的值:如果未指定此参数,则将根据标签数应用以下函数:
-
如果模型有一个标签,将在输出上应用 sigmoid 函数。
-
如果模型有多个标签,将在输出上应用 softmax 函数。
可能的值为:
-
"sigmoid"
:在输出上应用 sigmoid 函数。 -
"softmax"
:在输出上应用 softmax 函数。 -
"none"
:不在输出上应用任何函数。
-
返回
一个列表或dict
的列表
每个结果都作为带有以下键的字典列表:
-
label
(str
)— 预测的标签。 -
score
(float
)— 相应的概率。
如果使用top_k
,则每个标签返回一个这样的字典。
对给定的文本进行分类。
TextGenerationPipeline
class transformers.TextGenerationPipeline
( *args **kwargs )
参数
-
model
(PreTrainedModel 或 TFPreTrainedModel) — 该 pipeline 将用于进行预测的模型。这需要是继承自 PreTrainedModel 的模型,对于 PyTorch 和 TFPreTrainedModel 的 TensorFlow。 -
tokenizer
(PreTrainedTokenizer) — 该 pipeline 将用于为模型编码数据的分词器。该对象继承自 PreTrainedTokenizer。 -
modelcard
(str
或ModelCard
, 可选) — 为此 pipeline 的模型指定的模型卡。 -
framework
(str
, 可选) — 要使用的框架,可以是"pt"
代表 PyTorch 或"tf"
代表 TensorFlow。指定的框架必须已安装。如果未指定框架,将默认使用当前安装的框架。如果未指定框架并且两个框架都已安装,则将默认使用
model
的框架,或者如果未提供模型,则默认使用 PyTorch。 -
task
(str
, 默认为""
) — 用于该 pipeline 的任务标识符。 -
num_workers
(int
, 可选, 默认为 8) — 当 pipeline 将使用DataLoader(在传递数据集时,在 Pytorch 模型的 GPU 上),要使用的工作人员数量。 -
batch_size
(int
, 可选, 默认为 1) — 当 pipeline 将使用DataLoader(在传递数据集时,在 Pytorch 模型的 GPU 上),要使用的批次大小,对于推断来说,这并不总是有益的,请阅读使用 pipeline 进行批处理。 -
args_parser
(ArgumentHandler, 可选) — 负责解析提供的 pipeline 参数的对象的引用。 -
device
(int
, 可选, 默认为 -1) — CPU/GPU 支持的设备序数。将其设置为 -1 将使用 CPU,设置为正数将在关联的 CUDA 设备上运行模型。您也可以传递原生的torch.device
或一个str
。 -
binary_output
(bool
, 可选, 默认为False
) — 指示 pipeline 输出是否应以二进制格式(即 pickle)或原始文本形式发生的标志。
使用任何 ModelWithLMHead
的语言生成 pipeline。该 pipeline 预测将跟随指定文本提示的单词。
示例:
>>> from transformers import pipeline
>>> generator = pipeline(model="gpt2")
>>> generator("I can't believe you did such a ", do_sample=False)
[{'generated_text': "I can't believe you did such a icky thing to me. I'm so sorry. I'm so sorry. I'm so sorry. I'm so sorry. I'm so sorry. I'm so sorry. I'm so sorry. I"}]
>>> # These parameters will return suggestions, and only the newly created text making it easier for prompting suggestions.
>>> outputs = generator("My tart needs some", num_return_sequences=4, return_full_text=False)
了解有关在 pipeline 教程中使用 pipeline 的基础知识。您可以将文本生成参数传递给此 pipeline 以控制停止标准、解码策略等。在文本生成策略和文本生成中了解更多关于文本生成参数的信息。
目前可以使用以下任务标识符从 pipeline() 加载此语言生成 pipeline: "text-generation"
.
该 pipeline 可以使用已经训练过自回归语言建模目标的模型,包括库中的单向模型(例如 gpt2)。查看huggingface.co/models上可用模型的列表。
__call__
( text_inputs **kwargs ) → export const metadata = 'undefined';A list or a list of list of dict
参数
-
args
(str
或List[str]
) — 一个或多个提示(或一个提示列表)以完成。 -
return_tensors
(bool
, 可选, 默认为False
) — 是否在输出中返回预测的张量(作为标记索引)。如果设置为True
,则不返回解码后的文本。 -
return_text
(bool
, 可选, 默认为True
) — 是否返回输出中解码后的文本。 -
return_full_text
(bool
, 可选, 默认为True
) — 如果设置为False
,则只返回添加的文本,否则返回完整的文本。仅在 return_text 设置为 True 时有意义。 -
clean_up_tokenization_spaces
(bool
, 可选, 默认为False
) — 是否清除文本输出中的潜在额外空格。 -
prefix
(str
, 可选) — 添加到提示的前缀。 -
handle_long_generation
(str
, 可选) — 默认情况下,此管道不处理长生成(超过模型最大长度的生成)。没有完美的解决方法(更多信息:github.com/huggingface/transformers/issues/14033#issuecomment-948385227
)。这提供了根据您的用例解决该问题的常见策略。-
None
:默认策略,没有特别的操作 -
"hole"
:截断输入的左侧,并留下足够宽的间隙以进行生成(可能会截断大部分提示,当生成超出模型容量时不适用)
generate_kwargs — 传递给模型的 generate 方法的额外关键字参数(查看您框架对应的 generate 方法这里)。
-
返回
一个 dict
或 dict
的列表
返回以下字典之一(不能返回 generated_text
和 generated_token_ids
的组合):
-
generated_text
(str
, 当return_text=True
时存在) — 生成的文本。 -
generated_token_ids
(torch.Tensor
或tf.Tensor
, 当return_tensors=True
时存在) — 生成文本的标记 id。
完成给定的提示作为输入。
文本到文本生成管道
class transformers.Text2TextGenerationPipeline
( *args **kwargs )
参数
-
model
(PreTrainedModel 或 TFPreTrainedModel) — 该管道将用于进行预测的模型。这需要是继承自 PreTrainedModel 的模型,对于 TensorFlow 则是继承自 TFPreTrainedModel。 -
tokenizer
(PreTrainedTokenizer) — 该管道将用于为模型编码数据的分词器。该对象继承自 PreTrainedTokenizer。 -
modelcard
(str
或ModelCard
, 可选) — 为该管道的模型指定的模型卡片。 -
framework
(str
, 可选) — 要使用的框架,可以是"pt"
代表 PyTorch 或"tf"
代表 TensorFlow。指定的框架必须已安装。如果未指定框架,将默认使用当前安装的框架。如果未指定框架且两个框架都已安装,则默认使用
model
的框架,或者如果未提供模型,则默认使用 PyTorch。 -
task
(str
, 默认为""
) — 用于该管道的任务标识符。 -
num_workers
(int
, 可选, 默认为 8) — 当管道将使用 DataLoader(在传递数据集时,在 PyTorch 模型的 GPU 上)时,要使用的工作人员数量。 -
batch_size
(int
, 可选, 默认为 1) — 当管道将使用 DataLoader(传递数据集时,在 Pytorch 模型的 GPU 上),要使用的批次大小,对于推断来说,这并不总是有益的,请阅读 使用管道进行批处理 。 -
args_parser
(ArgumentHandler, 可选) — 负责解析提供的管道参数的对象的引用。 -
device
(int
, 可选, 默认为 -1) — CPU/GPU 支持的设备序数。将其设置为 -1 将利用 CPU,正数将在关联的 CUDA 设备 id 上运行模型。您也可以传递原生的torch.device
或str
。 -
binary_output
(bool
, 可选, 默认为False
) — 指示管道输出是否应以二进制格式(即 pickle)或原始文本格式发生的标志。
使用 seq2seq 模型进行文本到文本生成的管道。
示例:
>>> from transformers import pipeline
>>> generator = pipeline(model="mrm8488/t5-base-finetuned-question-generation-ap")
>>> generator(
... "answer: Manuel context: Manuel has created RuPERTa-base with the support of HF-Transformers and Google"
... )
[{'generated_text': 'question: Who created the RuPERTa-base?'}]
了解如何在 管道教程 中使用管道的基础知识。您可以将文本生成参数传递给此管道,以控制停止条件、解码策略等。在 文本生成策略 和 文本生成 中了解更多关于文本生成参数的信息。
此 Text2TextGenerationPipeline 管道目前可以通过以下任务标识符从 pipeline() 加载:"text2text-generation"。
此管道可以使用已在翻译任务上进行了微调的模型。请查看 huggingface.co/models 上可用模型的最新列表。有关可用参数的列表,请参阅 以下文档
用法:
text2text_generator = pipeline("text2text-generation")
text2text_generator("question: What is 42 ? context: 42 is the answer to life, the universe and everything")
__call__
( *args **kwargs ) → export const metadata = 'undefined';A list or a list of list of dict
参数
-
args
(str
或List[str]
) — 编码器的输入文本。 -
return_tensors
(bool
, 可选, 默认为False
) — 是否在输出中包含预测的张量(作为标记索引)。 -
return_text
(bool
, 可选, 默认为True
) — 是否在输出中包含解码后的文本。 -
clean_up_tokenization_spaces
(bool
, 可选, 默认为False
) — 是否清除文本输出中可能存在的额外空格。 -
truncation
(TruncationStrategy
, 可选, 默认为TruncationStrategy.DO_NOT_TRUNCATE
) — 管道内部标记化的截断策略。TruncationStrategy.DO_NOT_TRUNCATE
(默认)永远不会截断,但有时希望将输入截断以适应模型的max_length
而不是在后续出错。generate_kwargs — 传递给模型的 generate 方法的其他关键字参数(请参阅您的框架对应的 generate 方法 此处)。
返回
一个字典列表或字典列表
每个结果都作为一个带有以下键的字典。
-
generated_text
(str
, 当return_text=True
时存在) — 生成的文本。 -
generated_token_ids
(torch.Tensor
或tf.Tensor
, 当return_tensors=True
时存在) — 生成文本的标记 id。
使用给定的文本作为输入生成输出文本。
check_inputs
( input_length: int min_length: int max_length: int )
检查给定输入与模型相关是否存在问题。
TokenClassificationPipeline
class transformers.TokenClassificationPipeline
( args_parser = <transformers.pipelines.token_classification.TokenClassificationArgumentHandler object at 0x7f3b448d6350> *args **kwargs )
参数
-
model
(PreTrainedModel 或 TFPreTrainedModel)— 流水线将用于进行预测的模型。这需要是继承自 PreTrainedModel 的 PyTorch 模型和继承自 TFPreTrainedModel 的 TensorFlow 模型。 -
tokenizer
(PreTrainedTokenizer)— 流水线将用于对数据进行编码的分词器。此对象继承自 PreTrainedTokenizer。 -
modelcard
(str
或ModelCard
,可选)— 为此流水线的模型指定的模型卡。 -
framework
(str
,可选)— 要使用的框架,可以是"pt"
代表 PyTorch 或"tf"
代表 TensorFlow。指定的框架必须已安装。如果未指定框架,将默认使用当前安装的框架。如果未指定框架且两个框架都已安装,则将默认使用
model
的框架,或者如果未提供模型,则将默认使用 PyTorch。 -
task
(str
,默认为""
)— 用于流水线的任务标识符。 -
num_workers
(int
,可选,默认为 8)— 当流水线将使用DataLoader(传递数据集时,在 PyTorch 模型的 GPU 上)时,要使用的工作人员数量。 -
batch_size
(int
,可选,默认为 1)— 当流水线将使用DataLoader(传递数据集时,在 PyTorch 模型的 GPU 上)时,要使用的批次大小,对于推断,这并不总是有益的,请阅读使用流水线进行批处理。 -
args_parser
(ArgumentHandler,可选)— 负责解析提供的流水线参数的对象的引用。 -
device
(int
,可选,默认为-1)— 用于 CPU/GPU 支持的设备序数。将其设置为-1 将利用 CPU,正数将在关联的 CUDA 设备 ID 上运行模型。您也可以传递原生的torch.device
或str
。 -
binary_output
(bool
,可选,默认为False
)— 指示流水线输出是否应以二进制格式(即 pickle)或原始文本格式发生的标志。 -
ignore_labels
(List[str]
,默认为["O"]
)— 要忽略的标签列表。 -
grouped_entities
(bool
,可选,默认为False
)— 已弃用,请改用aggregation_strategy
。是否将对应于相同实体的标记分组在预测中一起还是不分组。 -
stride
(int
,可选)— 如果提供了步幅,流水线将应用于所有文本。文本将被分割成大小为 model_max_length 的块。仅适用于快速分词器和aggregation_strategy
不同于NONE
的情况。此参数的值定义了块之间重叠标记的数量。换句话说,模型将在每一步中向前移动tokenizer.model_max_length - stride
个标记。 -
aggregation_strategy
(str
,可选,默认为"none"
)— 基于模型预测融合(或不融合)标记的策略。-
“none”:将简单地不执行任何聚合,并直接从模型返回原始结果
-
“simple”:将尝试按照默认模式对实体进行分组。(A,B-TAG),(B,I-TAG),(C,I-TAG),(D,B-TAG2)(E,B-TAG2)最终将成为[{“word”:ABC,“entity”:“TAG”},{“word”:“D”,“entity”:“TAG2”},{“word”:“E”,“entity”:“TAG2”}]请注意,两个连续的 B 标签将成为不同的实体。在基于单词的语言中,我们可能会不希望将单词拆分:想象一下将 Microsoft 标记为[{“word”:“Micro”,“entity”:“企业”},{“word”:“soft”,“entity”:“名称”}]。查找 FIRST、MAX、AVERAGE 以了解减轻这种情况并消除单词歧义的方法(在支持该含义的语言上,基本上是由空格分隔的标记)。这些减轻措施仅适用于真实单词,“New york”可能仍然会被标记为两个不同的实体。
-
“first”:(仅适用于基于单词的模型)将使用
SIMPLE
策略,除非单词不能以不同的标签结束。当存在歧义时,单词将简单地使用单词的第一个标记的标签。 -
“average”:(仅适用于基于单词的模型)将使用
SIMPLE
策略,除非单词不能以不同的标签结束。分数将首先在标记之间平均,然后应用最大标签。 -
“max”:(仅适用于基于单词的模型)将使用
SIMPLE
策略,除非单词不能以不同的标签结束。单词实体将简单地是具有最高分数的标记。
-
使用任何ModelForTokenClassification
来进行命名实体识别管道。有关更多信息,请参阅命名实体识别示例。
示例:
>>> from transformers import pipeline
>>> token_classifier = pipeline(model="Jean-Baptiste/camembert-ner", aggregation_strategy="simple")
>>> sentence = "Je m'appelle jean-baptiste et je vis à montréal"
>>> tokens = token_classifier(sentence)
>>> tokens
[{'entity_group': 'PER', 'score': 0.9931, 'word': 'jean-baptiste', 'start': 12, 'end': 26}, {'entity_group': 'LOC', 'score': 0.998, 'word': 'montréal', 'start': 38, 'end': 47}]
>>> token = tokens[0]
>>> # Start and end provide an easy way to highlight words in the original text.
>>> sentence[token["start"] : token["end"]]
' jean-baptiste'
>>> # Some models use the same idea to do part of speech.
>>> syntaxer = pipeline(model="vblagoje/bert-english-uncased-finetuned-pos", aggregation_strategy="simple")
>>> syntaxer("My name is Sarah and I live in London")
[{'entity_group': 'PRON', 'score': 0.999, 'word': 'my', 'start': 0, 'end': 2}, {'entity_group': 'NOUN', 'score': 0.997, 'word': 'name', 'start': 3, 'end': 7}, {'entity_group': 'AUX', 'score': 0.994, 'word': 'is', 'start': 8, 'end': 10}, {'entity_group': 'PROPN', 'score': 0.999, 'word': 'sarah', 'start': 11, 'end': 16}, {'entity_group': 'CCONJ', 'score': 0.999, 'word': 'and', 'start': 17, 'end': 20}, {'entity_group': 'PRON', 'score': 0.999, 'word': 'i', 'start': 21, 'end': 22}, {'entity_group': 'VERB', 'score': 0.998, 'word': 'live', 'start': 23, 'end': 27}, {'entity_group': 'ADP', 'score': 0.999, 'word': 'in', 'start': 28, 'end': 30}, {'entity_group': 'PROPN', 'score': 0.999, 'word': 'london', 'start': 31, 'end': 37}]
了解有关在 pipeline 教程中使用管道的基础知识
此标记识别管道目前可以从 pipeline()中加载,使用以下任务标识符:"ner"(用于预测序列中的标记类别:人物、组织、地点或其他)。
此管道可以使用已在标记分类任务上进行了微调的模型。请查看huggingface.co/models上可用模型的最新列表。
__call__
( inputs: Union **kwargs ) → export const metadata = 'undefined';A list or a list of list of dict
参数
inputs
(str
或List[str]
)—一个或多个文本(或一个文本列表)用于标记分类。
返回
一个字典列表或字典列表的列表
每个结果都作为字典列表(对应于相应输入中的每个标记,或者如果使用聚合策略实例化此管道,则对应于每个实体)返回,具有以下键:
-
word
(str
)—分类的标记/单词。这是通过解码所选标记获得的。如果要获得原始句子中的确切字符串,请使用start
和end
。 -
score
(float
)—entity
的相应概率。 -
entity
(str
)—为该标记/单词预测的实体(当aggregation_strategy不是"none"
时,它被命名为entity_group)。 -
index
(int
,仅在aggregation_strategy="none"
时存在)—句子中对应标记的索引。 -
start
(int
,可选)—句子中对应实体的起始索引。仅当分词器中存在偏移量时才存在 -
end
(int
,可选)—句子中对应实体的结束索引。仅当分词器中存在偏移量时才存在
对给定的文本的每个标记进行分类。
aggregate_words
( entities: List aggregation_strategy: AggregationStrategy )
覆盖给定单词中不同意的标记,以强制在单词边界上达成一致。
示例:micro|soft| com|pany| B-ENT I-NAME I-ENT I-ENT 将使用第一种策略重写为 microsoft| company| B-ENT I-ENT
gather_pre_entities
( sentence: str input_ids: ndarray scores: ndarray offset_mapping: Optional special_tokens_mask: ndarray aggregation_strategy: AggregationStrategy )
将各种 numpy 数组融合成包含所有聚合所需信息的字典
group_entities
( entities: List )
参数
entities
(dict
)— 管道预测的实体。
查找并将预测相同实体的相邻标记组合在一起。
group_sub_entities
( entities: List )
参数
entities
(dict
)— 管道预测的实体。
将预测相同实体的相邻标记组合在一起。
TranslationPipeline
class transformers.TranslationPipeline
( *args **kwargs )
参数
-
model
(PreTrainedModel 或 TFPreTrainedModel)— 管道将用于进行预测的模型。这需要是继承自 PreTrainedModel 的模型,用于 PyTorch,以及继承自 TFPreTrainedModel 的模型,用于 TensorFlow。 -
tokenizer
(PreTrainedTokenizer)— 管道将用于为模型编码数据的分词器。此对象继承自 PreTrainedTokenizer。 -
modelcard
(str
或ModelCard
,可选)— 为此管道的模型指定的模型卡。 -
framework
(str
,可选)— 要使用的框架,可以是"pt"
表示 PyTorch,也可以是"tf"
表示 TensorFlow。指定的框架必须已安装。如果未指定框架,将默认使用当前安装的框架。如果未指定框架并且两个框架都已安装,将默认使用
model
的框架,或者如果未提供模型,则默认使用 PyTorch。 -
task
(str
,默认为""
)— 管道的任务标识符。 -
num_workers
(int
,可选,默认为 8)— 当管道将使用DataLoader(当传递数据集时,在 Pytorch 模型的 GPU 上),要使用的工作程序数量。 -
batch_size
(int
,可选,默认为 1)— 当管道将使用DataLoader(当传递数据集时,在 Pytorch 模型的 GPU 上),要使用的批量大小,对于推断,这并不总是有益,请阅读使用管道进行批处理。 -
args_parser
(ArgumentHandler,可选)— 负责解析提供的管道参数的对象的引用。 -
device
(int
,可选,默认为-1)— CPU/GPU 支持的设备序数。将其设置为-1 将利用 CPU,正数将在关联的 CUDA 设备 ID 上运行模型。您也可以传递原生的torch.device
或str
。 -
binary_output
(bool
,可选,默认为False
)— 指示管道输出是否应以二进制格式(即 pickle)或原始文本格式发生的标志。
从一种语言翻译成另一种语言。
目前可以使用以下任务标识符从 pipeline()加载此翻译管道:"translation_xx_to_yy"
。
该 pipeline 可以使用的模型是在翻译任务上进行了微调的模型。请查看 huggingface.co/models 上的可用模型的最新列表。有关可用参数的列表,请参阅以下文档
用法:
en_fr_translator = pipeline("translation_en_to_fr")
en_fr_translator("How old are you?")
__call__
( *args **kwargs ) → export const metadata = 'undefined';A list or a list of list of dict
参数
-
args
(str
或List[str]
) — 要翻译的文本。 -
return_tensors
(bool
, optional, 默认为False
) — 是否在输出中包含预测的张量(作为 token 索引)。 -
return_text
(bool
, optional, 默认为True
) — 是否在输出中包含解码后的文本。 -
clean_up_tokenization_spaces
(bool
, optional, 默认为False
) — 是否清理文本输出中的潜在额外空格。 -
src_lang
(str
, optional) — 输入文本的语言。对于多语言模型可能是必需的。对于单对翻译模型没有任何效果 -
tgt_lang
(str
, optional) — 期望输出的语言。对于多语言模型可能是必需的。对于单对翻译模型没有任何效果 generate_kwargs — 传递给模型的 generate 方法的其他关键字参数(请参阅您框架对应的 generate 方法此处)。
返回值
一个 dict
列表或 dict
列表的列表
每个结果都作为一个带有以下键的字典:
-
translation_text
(str
, 当return_text=True
时存在) — 翻译结果。 -
translation_token_ids
(torch.Tensor
或tf.Tensor
, 当return_tensors=True
时存在) — 翻译的 token ids。
翻译给定的文本。
ZeroShotClassificationPipeline
class transformers.ZeroShotClassificationPipeline
( args_parser = <transformers.pipelines.zero_shot_classification.ZeroShotClassificationArgumentHandler object at 0x7f3b4482b130> *args **kwargs )
参数
-
model
(PreTrainedModel 或 TFPreTrainedModel) — 该 pipeline 将用于进行预测的模型。这需要是继承自 PreTrainedModel 的模型,对于 TensorFlow 则是 TFPreTrainedModel。 -
tokenizer
(PreTrainedTokenizer) — 该 pipeline 将用于为模型编码数据的分词器。该对象继承自 PreTrainedTokenizer。 -
modelcard
(str
或ModelCard
, optional) — 为该 pipeline 的模型指定的模型卡片。 -
framework
(str
, optional) — 要使用的框架,可以是"pt"
代表 PyTorch 或"tf"
代表 TensorFlow。指定的框架必须已安装。如果未指定框架,将默认使用当前安装的框架。如果未指定框架并且两个框架都已安装,则将默认使用
model
的框架,或者如果未提供模型,则将默认使用 PyTorch。 -
task
(str
, 默认为""
) — 用于标识 pipeline 的任务。 -
num_workers
(int
, optional, 默认为 8) — 当 pipeline 将使用 DataLoader(在传递数据集时,在 PyTorch 模型的 GPU 上),要使用的工作程序数量。 -
batch_size
(int
, 可选, 默认为 1) — 当管道将使用 DataLoader(当传递数据集时,在 Pytorch 模型的 GPU 上),要使用的批量大小,对于推理来说,这并不总是有益的,请阅读 使用管道进行批处理。 -
args_parser
(ArgumentHandler, 可选) — 负责解析提供的管道参数的对象的引用。 -
device
(int
, 可选, 默认为 -1) — 用于 CPU/GPU 支持的设备序数。将其设置为 -1 将利用 CPU,正数将在关联的 CUDA 设备 id 上运行模型。您也可以传递原生torch.device
或str
。 -
binary_output
(bool
, 可选, 默认为False
) — 标志,指示管道输出是否应以二进制格式(即 pickle)或原始文本格式发生。
基于 NLI 的零样本分类管道使用在 NLI(自然语言推理)任务上训练的 ModelForSequenceClassification
。相当于 text-classification
管道,但这些模型不需要预先确定的潜在类别数量,可以在运行时选择。这通常意味着速度较慢,但更灵活。
可以传递任意序列和标签的组合,每个组合将被视为前提/假设对,并传递给预训练模型。然后,蕴涵 的逻辑被视为候选标签有效的逻辑。可以使用任何 NLI 模型,但 蕴涵 标签的 id 必须包含在模型配置的 :attr:~transformers.PretrainedConfig.label2id 中。
示例:
>>> from transformers import pipeline
>>> oracle = pipeline(model="facebook/bart-large-mnli")
>>> oracle(
... "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]}
>>> oracle(
... "I have a problem with my iphone that needs to be resolved asap!!",
... candidate_labels=["english", "german"],
... )
{'sequence': 'I have a problem with my iphone that needs to be resolved asap!!', 'labels': ['english', 'german'], 'scores': [0.814, 0.186]}
在 pipeline 教程 中了解有关使用管道的基础知识
此 NLI 管道目前可以从 pipeline() 中使用以下任务标识符加载:"zero-shot-classification"
。
此管道可以使用已在 NLI 任务上进行了微调的模型。请查看 huggingface.co/models 上可用模型的最新列表。
__call__
( sequences: Union *args **kwargs ) → export const metadata = 'undefined';A dict or a list of dict
参数
-
sequences
(str
orList[str]
) — 要分类的序列,如果模型输入过大,将被截断。 -
candidate_labels
(str
orList[str]
) — 用于将每个序列分类的可能类标签集。可以是单个标签、逗号分隔的标签字符串或标签列表。 -
hypothesis_template
(str
, 可选, 默认为"This example is {}."
) — 用于将每个标签转换为 NLI 风格假设的模板。此模板必须包含一个 {} 或类似的语法,以便将候选标签插入模板中。例如,默认模板是"This example is {}."
,使用候选标签"sports"
,这将被馈送到模型中"<cls> sequence to classify <sep> This example is sports . <sep>"
。默认模板在许多情况下效果很好,但根据任务设置的不同,尝试不同模板可能是值得的。 -
multi_label
(bool
, 可选, 默认为False
) — 是否可以存在多个候选标签为真。如果为False
,则对每个序列的标签可能性进行归一化,使得每个序列的标签可能性之和为 1。如果为True
,则将标签视为独立的,并通过对蕴涵分数与矛盾分数进行 softmax,对每个候选进行概率归一化。
返回
一个 dict
或 dict
列表
每个结果都作为一个带有以下键的字典:
-
sequence
(str
) — 这是输出的序列。 -
labels
(List[str]
) — 按可能性顺序排序的标签。 -
scores
(List[float]
) — 每个标签的概率。
对给定的序列进行分类。有关更多信息,请参阅 ZeroShotClassificationPipeline 文档。
多模态
可用于多模态任务的管道包括以下内容。
文档问答管道
class transformers.DocumentQuestionAnsweringPipeline
( *args **kwargs )
参数
-
model
(PreTrainedModel 或 TFPreTrainedModel) — 管道将用于进行预测的模型。这需要是继承自 PreTrainedModel 的模型,对于 PyTorch 是 TFPreTrainedModel。 -
tokenizer
(PreTrainedTokenizer) — 管道将用于为模型编码数据的分词器。此对象继承自 PreTrainedTokenizer。 -
modelcard
(str
或ModelCard
, optional) — 为此管道的模型指定的模型卡。 -
framework
(str
, optional) — 要使用的框架,可以是"pt"
代表 PyTorch 或"tf"
代表 TensorFlow。指定的框架必须已安装。如果未指定框架,将默认使用当前安装的框架。如果未指定框架并且两个框架都已安装,则将默认使用
model
的框架,或者如果未提供模型,则将默认使用 PyTorch。 -
task
(str
,默认为""
) — 管道的任务标识符。 -
num_workers
(int
, optional, 默认为 8) — 当管道将使用DataLoader(在传递数据集时,对于 Pytorch 模型在 GPU 上),要使用的工作人员数量。 -
batch_size
(int
, optional, 默认为 1) — 当管道将使用DataLoader(在传递数据集时,对于 Pytorch 模型在 GPU 上),要使用的批次大小,对于推断,这并不总是有益的,请阅读使用管道进行批处理。 -
args_parser
(ArgumentHandler, optional) — 负责解析提供的管道参数的对象的引用。 -
device
(int
, optional, 默认为 -1) — CPU/GPU 支持的设备序数。将其设置为-1 将利用 CPU,正数将在关联的 CUDA 设备 ID 上运行模型。您也可以传递本机torch.device
或str
。 -
binary_output
(bool
, optional, 默认为False
) — 指示管道输出是否应以二进制格式(即 pickle)或原始文本格式发生的标志。
使用任何AutoModelForDocumentQuestionAnswering
的文档问答管道。输入/输出与(抽取式)问答管道类似;但是,该管道将图像(和可选的 OCR 单词/框)作为输入,而不是文本上下文。
示例:
>>> from transformers import pipeline
>>> document_qa = pipeline(model="impira/layoutlm-document-qa")
>>> document_qa(
... image="https://huggingface.co/spaces/impira/docquery/resolve/2359223c1837a7587402bda0f2643382a6eefeab/invoice.png",
... question="What is the invoice number?",
... )
[{'score': 0.425, 'answer': 'us-001', 'start': 16, 'end': 16}]
了解有关在 pipeline 教程中使用管道的基础知识
此文档问答管道目前可以使用以下任务标识符从 pipeline()加载:"document-question-answering"
。
此管道可以使用已在文档问答任务上进行了微调的模型。请查看huggingface.co/models上可用模型的最新列表。
__call__
( image: Union question: Optional = None word_boxes: Tuple = None **kwargs ) → export const metadata = 'undefined';A dict or a list of dict
参数
-
image
(str
或PIL.Image
) — 管道处理三种类型的图像:-
包含指向图像的 http 链接的字符串
-
包含图像本地路径的字符串
-
直接在 PIL 中加载的图像
管道接受单个图像或一批图像。如果给定单个图像,则可以广播到多个问题。
-
-
question
(str
) — 要问的问题。 -
word_boxes
(List[str, Tuple[float, float, float, float]]
, 可选) — 一组单词和边界框(标准化为 0->1000)。如果提供此可选输入,则管道将使用这些单词和框,而不是在图像上运行 OCR 来为需要它们的模型(例如 LayoutLM)派生它们。这允许您在管道的许多调用之间重用 OCR 的结果,而无需每次重新运行它。 -
top_k
(int
, 可选, 默认为 1) — 要返回的答案数量(将按可能性顺序选择)。请注意,如果在上下文中没有足够的选项可用,我们将返回少于 top_k 个答案。 -
doc_stride
(int
, 可选, 默认为 128) — 如果文档中的单词太长,无法与模型的问题匹配,它将被分成几个具有一些重叠的块。此参数控制该重叠的大小。 -
max_answer_len
(int
, 可选, 默认为 15) — 预测答案的最大长度(例如,只考虑长度较短的答案)。 -
max_seq_len
(int
, 可选, 默认为 384) — 每个传递给模型的块中的总句子长度(上下文+问题)的最大长度(以标记为单位)。如果需要,上下文将被分成几个块(使用doc_stride
作为重叠)。 -
max_question_len
(int
, 可选, 默认为 64) — 问题在标记化后的最大长度。如果需要,将被截断。 -
handle_impossible_answer
(bool
, 可选, 默认为False
) — 是否接受不可能作为答案。 -
lang
(str
, 可选) — 运行 OCR 时要使用的语言。默认为英语。 -
tesseract_config
(str
, 可选) — 在运行 OCR 时传递给 tesseract 的附加标志。 -
timeout
(float
, 可选, 默认为 None) — 从网络获取图像的最长等待时间(以秒为单位)。如果为 None,则不设置超时,调用可能会永远阻塞。
返回
一个dict
或一个dict
列表
每个结果都作为一个带有以下键的字典:
-
score
(float
) — 与答案相关联的概率。 -
start
(int
) — 答案的开始单词索引(在输入的 OCR 版本或提供的word_boxes
中)。 -
end
(int
) — 答案的结束单词索引(在输入的 OCR 版本或提供的word_boxes
中)。 -
answer
(str
) — 问题的答案。 -
words
(list[int]
) — 答案中每个单词/框对的索引
通过使用文档回答输入的问题。文档被定义为一幅图像和一个可选的(单词,框)元组列表,表示文档中的文本。如果未提供word_boxes
,它将使用 Tesseract OCR 引擎(如果可用)自动提取单词和框,以供需要它们作为输入的 LayoutLM 类似模型使用。对于 Donut,不运行 OCR。
您可以以多种方式调用管道:
-
pipeline(image=image, question=question)
-
pipeline(image=image, question=question, word_boxes=word_boxes)
-
pipeline([{"image": image, "question": question}])
-
pipeline([{"image": image, "question": question, "word_boxes": word_boxes}])
FeatureExtractionPipeline
class transformers.FeatureExtractionPipeline
( model: Union tokenizer: Optional = None feature_extractor: Optional = None image_processor: Optional = None modelcard: Optional = None framework: Optional = None task: str = '' args_parser: ArgumentHandler = None device: Union = None torch_dtype: Union = None binary_output: bool = False **kwargs )
参数
-
模型
(PreTrainedModel 或 TFPreTrainedModel) — 流水线将使用的模型来进行预测。这需要是一个继承自 PreTrainedModel 的模型,对于 PyTorch 是 TFPreTrainedModel。 -
分词器
(PreTrainedTokenizer) — 流水线将用于为模型编码数据的分词器。此对象继承自 PreTrainedTokenizer。 -
模型卡
(str
或ModelCard
,可选) — 为此流水线的模型指定的模型卡。 -
框架
(str
,可选) — 要使用的框架,可以是"pt"
代表 PyTorch 或"tf"
代表 TensorFlow。指定的框架必须已安装。如果未指定框架,将默认使用当前安装的框架。如果未指定框架并且两个框架都已安装,则将默认使用模型的框架,或者如果未提供模型,则默认使用 PyTorch。
-
return_tensors
(bool
,可选) — 如果为True
,则根据指定的框架返回一个张量,否则返回一个列表。 -
任务
(str
,默认为""
) — 用于流水线的任务标识符。 -
args_parser
(ArgumentHandler,可选) — 负责解析提供的流水线参数的对象的引用。 -
设备
(int
,可选,默认为 -1) — 用于 CPU/GPU 支持的设备序数。将其设置为 -1 将利用 CPU,正数将在关联的 CUDA 设备 id 上运行模型。 -
tokenize_kwargs
(dict
,可选) — 传递给分词器的额外关键字参数的字典。
使用没有模型头的特征提取流水线。此流水线从基础变换器中提取隐藏状态,可以用作下游任务中的特征。
示例:
>>> from transformers import pipeline
>>> extractor = pipeline(model="bert-base-uncased", task="feature-extraction")
>>> result = extractor("This is a simple test.", return_tensors=True)
>>> result.shape # This is a tensor of shape [1, sequence_lenth, hidden_dimension] representing the input string.
torch.Size([1, 8, 768])
了解有关在 流水线教程 中使用流水线的基础知识
当前可以使用任务标识符 "feature-extraction"
从 pipeline() 加载此特征提取流水线。
所有模型都可以用于此流水线。查看包括社区贡献模型在内的所有模型列表,请访问 huggingface.co/models。
__call__
( *args **kwargs ) → export const metadata = 'undefined';A nested list of float
参数
args
(str
或List[str]
) — 一个或多个文本(或一个文本列表)以获取特征。
返回
一个嵌套的 float
列表
模型计算的特征。
提取输入的特征。
ImageToTextPipeline
class transformers.ImageToTextPipeline
( *args **kwargs )
参数
-
模型
(PreTrainedModel 或 TFPreTrainedModel) — 流水线将使用的模型来进行预测。这需要是一个继承自 PreTrainedModel 的模型,对于 PyTorch 是 TFPreTrainedModel。 -
tokenizer
(PreTrainedTokenizer) — 管道将用于为模型编码数据的分词器。此对象继承自 PreTrainedTokenizer。 -
modelcard
(str
或ModelCard
,optional) — 为此管道的模型指定的模型卡。 -
framework
(str
,optional) — 要使用的框架,可以是"pt"
表示 PyTorch 或"tf"
表示 TensorFlow。指定的框架必须已安装。如果未指定框架,将默认使用当前安装的框架。如果未指定框架并且两个框架都已安装,则将默认使用
model
的框架,或者如果未提供模型,则将默认使用 PyTorch。 -
task
(str
,默认为""
) — 管道的任务标识符。 -
num_workers
(int
, optional, 默认为 8) — 当管道将使用DataLoader(在传递数据集时,在 Pytorch 模型的 GPU 上),要使用的工作程序数量。 -
batch_size
(int
, optional, 默认为 1) — 当管道将使用DataLoader(在传递数据集时,在 Pytorch 模型的 GPU 上),要使用的批次大小,对于推断,这并不总是有益的,请阅读使用管道进行批处理。 -
args_parser
(ArgumentHandler,optional) — 负责解析提供的管道参数的对象的引用。 -
device
(int
, optional, 默认为-1) — 用于 CPU/GPU 支持的设备序数。将其设置为-1 将利用 CPU,正数将在关联的 CUDA 设备 ID 上运行模型。您也可以传递本机的torch.device
或str
。 -
binary_output
(bool
, optional, 默认为False
) — 指示管道输出是否应以二进制格式(即 pickle)或原始文本格式发生的标志。
使用AutoModelForVision2Seq
的图像到文本管道。此管道为给定图像预测标题。
示例:
>>> from transformers import pipeline
>>> captioner = pipeline(model="ydshieh/vit-gpt2-coco-en")
>>> captioner("https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png")
[{'generated_text': 'two birds are standing next to each other '}]
了解有关在 pipeline 教程中使用管道的基础知识
目前可以使用以下任务标识符从 pipeline()加载此图像到文本管道:“image-to-text”。
在huggingface.co/models上查看可用模型列表。
__call__
( images: Union **kwargs ) → export const metadata = 'undefined';A list or a list of list of dict
参数
-
images
(str
,List[str]
,PIL.Image
或List[PIL.Image]
) — 管道处理三种类型的图像:-
包含指向图像的 HTTP(s)链接的字符串
-
包含指向图像的本地路径的字符串
-
直接加载的 PIL 图像
该管道接受单个图像或一批图像。
-
-
max_new_tokens
(int
, optional) — 要生成的最大标记数量。默认情况下,它将使用generate
的默认值。 -
generate_kwargs
(Dict
, optional) — 将其传递给generate
,以便直接将所有这些参数发送到generate
,从而完全控制此函数。 -
timeout
(float
, optional, 默认为 None) — 从网络获取图像的最长等待时间(以秒为单位)。如果为 None,则不设置超时,并且调用可能会永远阻塞。
返回
一个字典列表或字典列表
每个结果都以包含以下键的字典形式呈现:
generated_text
(str
) — 生成的文本。
为传入的图像分配标签。
MaskGenerationPipeline
class transformers.MaskGenerationPipeline
( **kwargs )
参数
-
model
(PreTrainedModel 或 TFPreTrainedModel)- 该模型将被管道用于进行预测。这需要是一个继承自 PreTrainedModel(对于 PyTorch)和 TFPreTrainedModel(对于 TensorFlow)的模型。 -
tokenizer
(PreTrainedTokenizer)- 该分词器将被管道用于为模型编码数据。该对象继承自 PreTrainedTokenizer。 -
feature_extractor
(SequenceFeatureExtractor)- 该特征提取器将被管道用于对输入进行编码。 -
points_per_batch
(可选,int,默认为 64)- 设置模型同时运行的点数。较高的数字可能更快,但会使用更多的 GPU 内存。 -
output_bboxes_mask
(bool
,可选,默认为False
)- 是否输出边界框预测。 -
output_rle_masks
(bool
,可选,默认为False
)- 是否输出RLE
格式的掩码 -
model
(PreTrainedModel 或 TFPreTrainedModel)- 该模型将被管道用于进行预测。这需要是一个继承自 PreTrainedModel(对于 PyTorch)和 TFPreTrainedModel(对于 TensorFlow)的模型。 -
tokenizer
(PreTrainedTokenizer)- 该分词器将被管道用于为模型编码数据。该对象继承自 PreTrainedTokenizer。 -
modelcard
(str
或ModelCard
,可选)- 为该管道的模型指定的模型卡。 -
framework
(str
,可选)- 要使用的框架,可以是"pt"
代表 PyTorch 或"tf"
代表 TensorFlow。指定的框架必须已安装。如果未指定框架,将默认使用当前安装的框架。如果未指定框架且两个框架都已安装,则将默认使用
model
的框架,或者如果未提供模型,则默认使用 PyTorch。 -
task
(str
,默认为""
)- 用于该管道的任务标识符。 -
num_workers
(int
,可选,默认为 8)- 当管道将使用DataLoader(在传递数据集时,对于 PyTorch 模型在 GPU 上),要使用的工作程序数量。 -
batch_size
(int
,可选,默认为 1)- 当管道将使用DataLoader(在传递数据集时,对于 PyTorch 模型在 GPU 上),要使用的批次大小,对于推断,这并不总是有益的,请阅读使用管道进行批处理。 -
args_parser
(ArgumentHandler,可选)- 负责解析提供的管道参数的对象的引用。 -
device
(int
,可选,默认为-1)- CPU/GPU 支持的设备序数。将其设置为-1 将利用 CPU,正数将在关联的 CUDA 设备 ID 上运行模型。您也可以传递原生的torch.device
或一个str
。 -
binary_output
(bool
,可选,默认为False
)—指示流水线输出是否以二进制格式(即 pickle)或原始文本格式发生的标志。
使用SamForMaskGeneration
为图像生成自动蒙版。该流水线预测图像的二进制蒙版,给定一个图像。这是一个ChunkPipeline
,因为您可以将小批量中的点分开,以避免 OOM 问题。使用points_per_batch
参数来控制同时处理的点数。默认值为64
。
该流水线分为 3 个步骤:
-
preprocess
:生成 1024 个均匀分隔的点网格,以及边界框和点标签。有关如何创建点和边界框的详细信息,请检查_generate_crop_boxes
函数。还使用image_processor
对图像进行预处理。此函数yield
一个points_per_batch
的小批量。 -
forward
:将preprocess
的输出馈送到模型。图像嵌入仅计算一次。调用self.model.get_image_embeddings
并确保不计算梯度,张量和模型在同一设备上。 -
postprocess
:自动蒙版生成的最重要部分发生在这里。引入了三个步骤:-
image_processor.postprocess_masks(在每个小批量循环中运行):接受原始输出蒙版,根据图像大小调整其大小,并将其转换为二进制蒙版。
-
image_processor.filter_masks(在每个小批量循环中):同时使用
pred_iou_thresh
和stability_scores
。还应用基于非最大抑制的各种过滤器,以消除不良蒙版。 -
image_processor.postprocess_masks_for_amg 将 NSM 应用于蒙版,仅保留相关的蒙版。
-
示例:
>>> from transformers import pipeline
>>> generator = pipeline(model="facebook/sam-vit-base", task="mask-generation")
>>> outputs = generator(
... "http://images.cocodataset.org/val2017/000000039769.jpg",
... )
>>> outputs = generator(
... "https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png", points_per_batch=128
... )
了解有关在 pipeline 教程中使用流水线的基础知识
当前可以使用以下任务标识符从 pipeline()加载此分割流水线:"mask-generation"
。
在huggingface.co/models上查看可用模型的列表。
__call__
( image *args num_workers = None batch_size = None **kwargs ) → export const metadata = 'undefined';Dict
参数
-
inputs
(np.ndarray
或bytes
或str
或dict
)—图像或图像列表。 -
mask_threshold
(float
,可选,默认为 0.0)—将预测的蒙版转换为二进制值时使用的阈值。 -
pred_iou_thresh
(float
,可选,默认为 0.88)—在[0,1]
上应用于模型预测的蒙版质量的过滤阈值。 -
stability_score_thresh
(float
,可选,默认为 0.95)—在[0,1]
中的过滤阈值,使用蒙版在截止值变化下的稳定性来对模型的蒙版预测进行二值化。 -
stability_score_offset
(int
,可选,默认为 1)—在计算稳定性分数时,偏移截止值的量。 -
crops_nms_thresh
(float
,可选,默认为 0.7)—非极大值抑制使用的框 IoU 截止值,用于过滤重复蒙版。 -
crops_n_layers
(int
,可选,默认为 0)—如果crops_n_layers>0
,将再次在图像的裁剪上运行蒙版预测。设置要运行的层数,其中每一层具有 2**i_layer 数量的图像裁剪。 -
crop_overlap_ratio
(float
,可选,默认为512 / 1500
)—设置裁剪重叠的程度。在第一层裁剪中,裁剪将以图像长度的这一部分重叠。具有更多裁剪的后续层会缩小此重叠。 -
crop_n_points_downscale_factor
(int
,可选,默认为1
)—在第 n 层中采样的每边点数按crop_n_points_downscale_factor**n
缩小。 -
timeout
(float
,可选,默认为 None)—从网络获取图像的最长时间(以秒为单位)。如果为 None,则不设置超时,调用可能永远阻塞。
返回
Dict
一个具有以下键的字典:
-
mask
(PIL.Image
) — 检测到的对象的二进制掩模,作为原始图像的形状为(width, height)
的 PIL 图像。如果未找到对象,则返回填充有零的掩模。 -
score
(可选float
) — 可选地,当模型能够估计由标签和掩模描述的“对象”的置信度时。
生成二进制分割掩模
VisualQuestionAnsweringPipeline
class transformers.VisualQuestionAnsweringPipeline
( *args **kwargs )
参数
-
model
(PreTrainedModel 或 TFPreTrainedModel) — 管道将用于进行预测的模型。这需要是继承自 PreTrainedModel(对于 PyTorch)和 TFPreTrainedModel(对于 TensorFlow)的模型。 -
tokenizer
(PreTrainedTokenizer) — 管道将用于为模型编码数据的分词器。此对象继承自 PreTrainedTokenizer。 -
modelcard
(str
或ModelCard
, 可选) — 为此管道的模型指定的模型卡。 -
framework
(str
, 可选) — 要使用的框架,可以是"pt"
表示 PyTorch 或"tf"
表示 TensorFlow。指定的框架必须已安装。如果未指定框架,将默认使用当前安装的框架。如果未指定框架并且两个框架都已安装,则将默认使用
model
的框架,或者如果未提供模型,则将默认使用 PyTorch。 -
task
(str
, 默认为""
) — 管道的任务标识符。 -
num_workers
(int
, 可选, 默认为 8) — 当管道将使用DataLoader(在 GPU 上为 Pytorch 模型传递数据集时)时,要使用的工作程序数量。 -
batch_size
(int
, 可选, 默认为 1) — 当管道将使用DataLoader(在 GPU 上为 Pytorch 模型传递数据集时)时,要使用的批次大小,对于推断,这并不总是有益的,请阅读使用管道进行批处理。 -
args_parser
(ArgumentHandler, 可选) — 负责解析提供的管道参数的对象的引用。 -
device
(int
, 可选, 默认为 -1) — CPU/GPU 支持的设备序数。将其设置为-1 将利用 CPU,正数将在关联的 CUDA 设备 ID 上运行模型。您也可以传递原生的torch.device
或str
。 -
binary_output
(bool
, 可选, 默认为False
) — 标志指示管道输出是否以二进制格式(即 pickle)或原始文本形式发生。
使用AutoModelForVisualQuestionAnswering
的视觉问答管道。此管道目前仅在 PyTorch 中可用。
示例:
>>> from transformers import pipeline
>>> oracle = pipeline(model="dandelin/vilt-b32-finetuned-vqa")
>>> image_url = "https://huggingface.co/datasets/Narsil/image_dummy/raw/main/lena.png"
>>> oracle(question="What is she wearing ?", image=image_url)
[{'score': 0.948, 'answer': 'hat'}, {'score': 0.009, 'answer': 'fedora'}, {'score': 0.003, 'answer': 'clothes'}, {'score': 0.003, 'answer': 'sun hat'}, {'score': 0.002, 'answer': 'nothing'}]
>>> oracle(question="What is she wearing ?", image=image_url, top_k=1)
[{'score': 0.948, 'answer': 'hat'}]
>>> oracle(question="Is this a person ?", image=image_url, top_k=1)
[{'score': 0.993, 'answer': 'yes'}]
>>> oracle(question="Is this a man ?", image=image_url, top_k=1)
[{'score': 0.996, 'answer': 'no'}]
在 pipeline 教程中了解如何使用管道的基础知识
此视觉问答管道目前可以从 pipeline()中加载,使用以下任务标识符:"visual-question-answering", "vqa"。
此管道可以使用已在视觉问答任务上进行了微调的模型。请查看huggingface.co/models上可用模型的最新列表。
__call__
( image: Union question: str = None **kwargs ) → export const metadata = 'undefined';A dictionary or a list of dictionaries containing the result. The dictionaries contain the following keys
参数
-
image
(str
,List[str]
,PIL.Image
或List[PIL.Image]
) — 管道处理三种类型的图像:-
包含指向图像的 http 链接的字符串
-
包含本地图像路径的字符串
-
直接加载的 PIL 图像
该管道接受单个图像或一批图像。如果给定单个图像,则可以广播到多个问题。
-
-
question
(str
,List[str]
) — 提出的问题。如果给定单个问题,则可以广播到多个图像。 -
top_k
(int
, optional, 默认为 5) — 管道将返回的前 k 个标签的数量。如果提供的数字高于模型配置中可用的标签数量,则默认为标签数量。 -
timeout
(float
, optional, 默认为 None) — 从网络获取图像的最长等待时间(以秒为单位)。如果为 None,则不设置超时,调用可能会永远阻塞。
返回
包含结果的字典或字典列表。字典包含以下键
-
label
(str
) — 模型识别的标签。 -
score
(int
) — 模型为该标签分配的分数。
回答关于图像的开放性问题。该管道接受下面详细说明的几种类型的输入:
-
pipeline(image=image, question=question)
-
pipeline({"image": image, "question": question})
-
pipeline([{"image": image, "question": question}])
-
pipeline([{"image": image, "question": question}, {"image": image, "question": question}])
父类:Pipeline
class transformers.Pipeline
( model: Union tokenizer: Optional = None feature_extractor: Optional = None image_processor: Optional = None modelcard: Optional = None framework: Optional = None task: str = '' args_parser: ArgumentHandler = None device: Union = None torch_dtype: Union = None binary_output: bool = False **kwargs )
参数
-
model
(PreTrainedModel 或 TFPreTrainedModel) — 管道将用于进行预测的模型。这需要是一个继承自 PreTrainedModel 的模型,对于 PyTorch 是 TFPreTrainedModel。 -
tokenizer
(PreTrainedTokenizer) — 管道将用于为模型编码数据的分词器。该对象继承自 PreTrainedTokenizer。 -
modelcard
(str
或ModelCard
, optional) — 为该管道的模型分配的模型卡。 -
framework
(str
, optional) — 要使用的框架,可以是"pt"
代表 PyTorch 或"tf"
代表 TensorFlow。指定的框架必须已安装。如果未指定框架,将默认使用当前安装的框架。如果未指定框架并且两个框架都已安装,将默认使用
model
的框架,或者如果未提供模型,则默认使用 PyTorch。 -
task
(str
, 默认为""
) — 用于管道的任务标识符。 -
num_workers
(int
, optional, 默认为 8) — 当管道将使用 DataLoader(在传递数据集时,在 Pytorch 模型上使用 GPU),要使用的工作进程数。 -
batch_size
(int
, optional, defaults to 1) — 当管道将使用 DataLoader(在传递数据集时,在 Pytorch 模型上使用 GPU),要使用的批次大小,对于推理来说,这并不总是有益的,请阅读 Batching with pipelines 。 -
args_parser
(ArgumentHandler,可选)-负责解析提供的流水线参数的对象的引用。 -
device
(int
,可选,默认为-1)-CPU/GPU 支持的设备序数。将其设置为-1 将利用 CPU,正数将在关联的 CUDA 设备 ID 上运行模型。您也可以传递本机torch.device
或str
。 -
binary_output
(bool
,可选,默认为False
)-指示流水线输出应以二进制格式(即 pickle)或原始文本发生的标志。
Pipeline 类是所有流水线继承的类。请参考此类以获取不同流水线共享的方法。
实现流水线操作的基类。流水线工作流定义为以下操作序列:
输入->标记化->模型推断->后处理(任务相关)->输出
Pipeline 支持通过设备参数在 CPU 或 GPU 上运行(见下文)。
某些流水线,例如 FeatureExtractionPipeline('feature-extraction'
)将大张量对象输出为嵌套列表。为了避免将这样大的结构转储为文本数据,我们提供了binary_output
构造参数。如果设置为True
,输出将以 pickle 格式存储。
check_model_type
( supported_models: Union )
参数
supported_models
(List[str]
或dict
)-流水线支持的模型列表,或具有模型类值的字典。
检查模型类是否受流水线支持。
device_placement
( )
上下文管理器,以框架不可知的方式在用户指定的设备上分配张量。
示例:
# Explicitly ask for tensor allocation on CUDA device :0
pipe = pipeline(..., device=0)
with pipe.device_placement():
# Every framework specific tensor allocation will be done on the request device
output = pipe(...)
ensure_tensor_on_device
( **inputs ) → export const metadata = 'undefined';Dict[str, torch.Tensor]
参数
-
inputs
(应为torch.Tensor
的关键字参数,其余部分将被忽略)-要放置在self.device
上的张量。 -
仅对列表进行递归。
返回
Dict[str, torch.Tensor]
与inputs
相同,但在适当的设备上。
确保 PyTorch 张量位于指定设备上。
postprocess
( model_outputs: ModelOutput **postprocess_parameters: Dict )
后处理将接收_forward
方法的原始输出,通常是张量,并将其重新格式化为更友好的形式。通常它将输出一个包含字符串和数字的列表或结果字典。
predict
( X )
Scikit / Keras 接口到 transformers 的流水线。此方法将转发到call()。
preprocess
( input_: Any **preprocess_parameters: Dict )
预处理将获取特定流水线的input_
并返回一个包含一切必要内容以使_forward
正确运行的字典。它应至少包含一个张量,但可能有任意其他项目。
save_pretrained
( save_directory: str safe_serialization: bool = True )
参数
-
save_directory
(str
)-要保存的目录的路径。如果不存在,将创建它。 -
safe_serialization
(str
)-是否使用safetensors
保存模型,还是使用 PyTorch 或 Tensorflow 的传统方式。
保存流水线的模型和分词器。
transform
( X )
Scikit / Keras 接口到 transformers 的管道。这种方法将转发到call()。
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】博客园社区专享云产品让利特惠,阿里云新客6.5折上折
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步
· DeepSeek “源神”启动!「GitHub 热点速览」
· 我与微信审核的“相爱相杀”看个人小程序副业
· 微软正式发布.NET 10 Preview 1:开启下一代开发框架新篇章
· 如何使用 Uni-app 实现视频聊天(源码,支持安卓、iOS)
· C# 集成 DeepSeek 模型实现 AI 私有化(本地部署与 API 调用教程)