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

Transformers 4.37 中文文档（七十五）（3）https://developer.aliyun.com/article/1564209

HubertForCTC

`class transformers.HubertForCTC`

( config target_lang: Optional = None )

参数

config (HubertConfig) — 模型的所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained()方法以加载模型权重。

带有顶部语言建模头部的 Hubert 模型，用于连接主义时间分类（CTC）。Hubert 是由 Wei-Ning Hsu、Benjamin Bolte、Yao-Hung Hubert Tsai、Kushal Lakhotia、Ruslan Salakhutdinov、Abdelrahman Mohamed 在《HuBERT:通过隐藏单元的掩码预测进行自监督语音表示学习》中提出的。

这个模型继承自 PreTrainedModel。查看超类文档以获取库实现的所有模型的通用方法（例如下载或保存等）。

这个模型是 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。

`forward`

<来源>

( input_values: Optional attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None labels: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.CausalLMOutput or tuple(torch.FloatTensor)

参数

input_values (torch.FloatTensor，形状为(batch_size, sequence_length)） — 输入原始语音波形的浮点值。值可以通过将 .flac 或 .wav 音频文件加载到 List[float] 类型的数组或 numpy.ndarray 中获得，例如通过 soundfile 库（pip install soundfile）。要将数组准备成 input_values，应使用 AutoProcessor 进行填充和转换为 torch.FloatTensor 类型的张量。有关详细信息，请参阅 Wav2Vec2Processor.call()。
attention_mask (torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 避免在填充标记索引上执行卷积和注意力的掩码。掩码值在 [0, 1] 中选择：

对于未被 masked 的标记为 1。
对于被 masked 的标记为 0。

什么是注意力掩码？
只有当相应的处理器具有 config.return_attention_mask == True 时才应传递 attention_mask。对于所有处理器具有 config.return_attention_mask == False 的模型，例如 hubert-base，在进行批量推断时应 不 传递 attention_mask 以避免性能下降。对于这些模型，input_values 应该简单地用 0 填充并在不带 attention_mask 的情况下传递。请注意，这些模型根据 input_values 是否填充会产生略微不同的结果。
output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量下的 attentions。
output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的 hidden_states。
return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。
标签 (torch.LongTensor，形状为(batch_size, target_length)，可选) — 连接主义时间分类的标签。请注意，target_length 必须小于或等于输出 logits 的序列长度。索引在 [-100, 0, ..., config.vocab_size - 1] 中选择。所有设置为 -100 的标签都被忽略（掩码），损失仅计算 [0, ..., config.vocab_size - 1] 中的标签。

transformers.modeling_outputs.CausalLMOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.CausalLMOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时）包含根据配置（HubertConfig）和输入而异的各种元素。

损失 (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 之后的注意力权重，用于计算自注意力头中的加权平均值。

HubertForCTC 的前向方法，覆盖了 __call__ 特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用 Module 实例而不是这个，因为前者会处理运行前后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoProcessor, HubertForCTC
>>> from datasets import load_dataset
>>> import torch
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> processor = AutoProcessor.from_pretrained("facebook/hubert-large-ls960-ft")
>>> model = HubertForCTC.from_pretrained("facebook/hubert-large-ls960-ft")
>>> # audio file is decoded on the fly
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> with torch.no_grad():
...     logits = model(**inputs).logits
>>> predicted_ids = torch.argmax(logits, dim=-1)
>>> # transcribe speech
>>> transcription = processor.batch_decode(predicted_ids)
>>> transcription[0]
'MISTER QUILTER IS THE APOSTLE OF THE MIDDLE CLASSES AND WE ARE GLAD TO WELCOME HIS GOSPEL'
>>> inputs["labels"] = processor(text=dataset[0]["text"], return_tensors="pt").input_ids
>>> # compute loss
>>> loss = model(**inputs).loss
>>> round(loss.item(), 2)
22.68

HubertForSequenceClassification

`class transformers.HubertForSequenceClassification`

< source >

( config )

参数

config (HubertConfig) — 模型的所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只加载配置。查看 from_pretrained() 方法以加载模型权重。

Hubert 模型在顶部具有序列分类头（池化输出上的线性层），用于类似 SUPERB 关键词检测的任务。

Hubert 是由 Wei-Ning Hsu, Benjamin Bolte, Yao-Hung Hubert Tsai, Kushal Lakhotia, Ruslan Salakhutdinov, Abdelrahman Mohamed 在 HuBERT: Self-Supervised Speech Representation Learning by Masked Prediction of Hidden Units 中提出的。

该模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（如下载或保存等）。

该模型是 PyTorch torch.nn.Module 的子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

`forward`

< source >

( input_values: Optional attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None labels: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.SequenceClassifierOutput or tuple(torch.FloatTensor)

参数

input_values (torch.FloatTensor，形状为 (batch_size, sequence_length)) — 输入原始语音波形的浮点值。值可以通过将 .flac 或 .wav 音频文件加载到类型为 List[float] 或 numpy.ndarray 的数组中获得，例如通过 soundfile 库（pip install soundfile）。为准备好输入值数组，应使用 AutoProcessor 进行填充和转换为 torch.FloatTensor 类型的张量。查看 Wav2Vec2Processor.call() 以获取详细信息。
attention_mask (torch.LongTensor，形状为 (batch_size, sequence_length)，可选的) — 避免在填充标记索引上执行卷积和注意力的掩码。掩码值选在 [0, 1]：

1 代表未被掩盖的标记，
0 代表被掩盖的标记。

什么是注意力掩码？
只有当相应的处理器具有 config.return_attention_mask == True 时才应传递 attention_mask。对于所有处理器具有 config.return_attention_mask == False 的模型，例如 hubert-base，在进行批量推断时应避免传递 attention_mask 以避免性能下降。对于这些模型，input_values 应该简单地用 0 填充并在不传递 attention_mask 的情况下传递。请注意，这些模型根据 input_values 是否填充会产生略有不同的结果。
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多细节，请参阅返回的张量中的 attentions。
output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多细节，请参阅返回的张量中的 hidden_states。
return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。
labels (torch.LongTensor，形状为 (batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels == 1，则计算回归损失（均方损失），如果 config.num_labels > 1，则计算分类损失（交叉熵）。

transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.SequenceClassifierOutput 或一个 torch.FloatTensor 元组（如果传递 return_dict=False 或 config.return_dict=False）包含各种元素，取决于配置（HubertConfig）和输入。

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, sequence_length, sequence_length) 的 torch.FloatTensor 元组（每层一个）。
注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

HubertForSequenceClassification 的前向方法，覆盖了 __call__ 特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在之后调用 Module 实例而不是这个，因为前者会负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoFeatureExtractor, HubertForSequenceClassification
>>> from datasets import load_dataset
>>> import torch
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("superb/hubert-base-superb-ks")
>>> model = HubertForSequenceClassification.from_pretrained("superb/hubert-base-superb-ks")
>>> # audio file is decoded on the fly
>>> inputs = feature_extractor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> with torch.no_grad():
...     logits = model(**inputs).logits
>>> predicted_class_ids = torch.argmax(logits, dim=-1).item()
>>> predicted_label = model.config.id2label[predicted_class_ids]
>>> predicted_label
'_unknown_'
>>> # compute loss - target_label is e.g. "down"
>>> target_label = model.config.id2label[0]
>>> inputs["labels"] = torch.tensor([model.config.label2id[target_label]])
>>> loss = model(**inputs).loss
>>> round(loss.item(), 2)
8.53

TensorFlowHide TensorFlow 内容

TFHubertModel

`class transformers.TFHubertModel`

< source >

( config: HubertConfig *inputs **kwargs )

参数

config (HubertConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained() 方法以加载模型权重。

裸的 TFHubert 模型变换器输出原始隐藏状态，没有特定的头部在顶部。

此模型继承自 TFPreTrainedModel。请查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存，调整输入嵌入，修剪头等）。

此模型还是一个 tf.keras.Model 子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取与一般用法和行为相关的所有内容。

transformers 中的 TensorFlow 模型和层接受两种格式的输入：

将所有输入作为关键字参数（类似于 PyTorch 模型），或
将所有输入作为列表、元组或字典放在第一个位置参数中。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于有此支持，当使用 model.fit() 等方法时，应该可以正常工作 - 只需以 model.fit() 支持的任何格式传递输入和标签！但是，如果您想在 Keras 方法之外使用第二种格式，例如在使用 Keras Functional API 创建自己的层或模型时，有三种可能性可用于在第一个位置参数中收集所有输入张量：

只有一个张量，其中仅包含 input_values，没有其他内容：model(input_values)
一个变长列表，其中包含文档字符串中给定顺序的一个或多个输入张量：model([input_values, attention_mask]) 或 model([input_values, attention_mask, token_type_ids])
一个字典，其中包含与文档字符串中给定的输入名称相关联的一个或多个输入张量：model({"input_values": input_values, "token_type_ids": token_type_ids})

请注意，当使用子类化创建模型和层时，您不需要担心任何这些，因为您可以像将输入传递给任何其他 Python 函数一样传递输入！

`call`

< source >

( input_values: tf.Tensor attention_mask: tf.Tensor | None = None token_type_ids: tf.Tensor | None = None position_ids: tf.Tensor | None = None head_mask: tf.Tensor | None = None inputs_embeds: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFBaseModelOutput or tuple(tf.Tensor)

参数

input_values (np.ndarray、tf.Tensor、List[tf.Tensor]、Dict[str, tf.Tensor] 或 Dict[str, np.ndarray]，每个示例的形状必须为 ({0})) — 词汇表中输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
什么是输入 ID？
attention_mask (np.ndarray 或 tf.Tensor，形状为 ({0})，可选) — 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值在 [0, 1] 中：

1 表示未被 masked 的标记，
0 表示被 masked 的标记。

什么是注意力掩码？
token_type_ids (np.ndarray 或 tf.Tensor，形状为 ({0})，可选) — 段标记索引，指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：

0 对应于一个 句子 A 标记，
1 对应于一个 句子 B 标记。

什么是标记类型 ID？
position_ids (np.ndarray或tf.Tensor，形状为({0})，optional) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。
什么是位置 ID？
head_mask (np.ndarray或tf.Tensor，形状为(num_heads,)或(num_layers, num_heads)，optional) — 用于使自注意力模块中选择的头部失效的掩码。掩码值选在[0, 1]之间：

1 表示头部是not masked，
0 表示头部是masked。

inputs_embeds (np.ndarray或tf.Tensor，形状为({0}, hidden_size)，optional) — 可选地，可以直接传递嵌入表示，而不是传递input_values。如果您想要更多控制如何将input_values索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。
output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。此参数仅在急切模式下可用，在图模式下将使用配置中的值。
output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数仅在急切模式下可用，在图模式下将使用配置中的值。
return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通元组。此参数可在急切模式下使用，在图模式下该值将始终设置为 True。
training (bool, optional，默认为`False“) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

transformers.modeling_tf_outputs.TFBaseModelOutput 或tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFBaseModelOutput 或一个tf.Tensor元组（如果传递return_dict=False或config.return_dict=False时）包含各种元素，取决于配置（HubertConfig）和输入。

last_hidden_state (tf.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。
hidden_states (tuple(tf.FloatTensor), 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

TFHubertModel 前向方法，覆盖了__call__特殊方法。

虽然前向传递的配方需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoProcessor, TFHubertModel
>>> from datasets import load_dataset
>>> import soundfile as sf
>>> processor = AutoProcessor.from_pretrained("facebook/hubert-large-ls960-ft")
>>> model = TFHubertModel.from_pretrained("facebook/hubert-large-ls960-ft")
>>> def map_to_array(batch):
...     speech, _ = sf.read(batch["file"])
...     batch["speech"] = speech
...     return batch
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.map(map_to_array)
>>> input_values = processor(ds["speech"][0], return_tensors="tf").input_values  # Batch size 1
>>> hidden_states = model(input_values).last_hidden_state

TFHubertForCTC

`class transformers.TFHubertForCTC`

<来源>

( config: HubertConfig *inputs **kwargs )

参数

config（HubertConfig）- 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

带有顶部“语言建模”头的 TFHubert 模型，用于连接主义时间分类（CTC）。

此模型继承自 TFPreTrainedModel。查看超类文档，了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

此模型也是一个tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取与一般用法和行为相关的所有信息。

transformers中的 TensorFlow 模型和层接受两种格式的输入：

将所有输入作为关键字参数（类似于 PyTorch 模型），或者
将所有输入作为列表、元组或字典放在第一个位置参数中。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于有了这种支持，当使用model.fit()等方法时，应该可以“正常工作” - 只需以model.fit()支持的任何格式传递输入和标签即可！但是，如果您想在 Keras 方法之外使用第二种格式，例如在使用 KerasFunctional API 创建自己的层或模型时，有三种可能性可用于在第一个位置参数中收集所有输入张量：

只有一个张量input_values，没有其他内容：model(input_values)
一个长度可变的列表，其中包含一个或多个输入张量，按照文档字符串中给定的顺序：model([input_values, attention_mask])或model([input_values, attention_mask, token_type_ids])
一个字典，其中包含一个或多个与文档字符串中给定的输入名称相关联的输入张量：model({"input_values": input_values, "token_type_ids": token_type_ids})

请注意，当使用子类化创建模型和层时，您无需担心这些问题，因为您可以像将输入传递给任何其他 Python 函数一样传递输入！

`call`

<来源>

( input_values: tf.Tensor attention_mask: tf.Tensor | None = None token_type_ids: tf.Tensor | None = None position_ids: tf.Tensor | None = None head_mask: tf.Tensor | None = None inputs_embeds: tf.Tensor | None = None output_attentions: Optional[bool] = None labels: tf.Tensor | None = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFCausalLMOutput or tuple(tf.Tensor)

参数

input_values（np.ndarray、tf.Tensor、List[tf.Tensor]、Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例的形状必须为({0})）- 词汇表中输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。
什么是输入 ID？
attention_mask（形状为({0})的np.ndarray或tf.Tensor，可选）- 用于避免在填充标记索引上执行注意力的掩码。选择在[0, 1]中的掩码值。

对于“未屏蔽”的标记为 1，
对于被“屏蔽”的标记为 0。

什么是注意力掩码？
token_type_ids (np.ndarray或tf.Tensor，形状为({0}), optional) — 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：

0 对应一个sentence A标记，
1 对应一个sentence B标记。

什么是标记类型 ID？
position_ids (np.ndarray或tf.Tensor，形状为({0}), optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。
什么是位置 ID？
head_mask (np.ndarray或tf.Tensor，形状为(num_heads,)或(num_layers, num_heads)，optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值在[0, 1]中选择：

1 表示头部未被掩码，
0 表示头部被掩码。

inputs_embeds (np.ndarray或tf.Tensor，形状为({0}, hidden_size)，optional) — 可选地，可以直接传递嵌入表示而不是传递input_values。如果您想要更多控制如何将input_values索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将很有用。
output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。此参数仅在急切模式下使用，在图模式下将使用配置中的值。
output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。此参数仅在急切模式下使用，在图模式下将使用配置中的值。
return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用，在图模式下该值将始终设置为 True。
training (bool, optional, defaults to `False“) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。
labels (tf.Tensor或np.ndarray，形状为(batch_size, sequence_length)，optional) — 用于计算掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]中（参见input_values文档字符串）索引设置为-100的标记将被忽略（掩码），损失仅计算具有标签在[0, ..., config.vocab_size]中的标记。

transformers.modeling_tf_outputs.TFCausalLMOutput 或tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFCausalLMOutput 或一个tf.Tensor元组（如果传递return_dict=False或当config.return_dict=False时）包括根据配置（HubertConfig）和输入的不同元素。

loss (tf.Tensor，形状为(n,), optional, 当提供labels时返回，其中 n 是非掩码标签的数量) — 语言建模损失（用于下一个标记预测）。
logits (tf.Tensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（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)，可选，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组。
在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

TFHubertForCTC 的前向方法覆盖了__call__特殊方法。

尽管前向传播的配方需要在此函数内定义，但应该在此之后调用Module实例，而不是在此函数内调用，因为前者负责运行预处理和后处理步骤，而后者则默默地忽略它们。

示例：

>>> import tensorflow as tf
>>> from transformers import AutoProcessor, TFHubertForCTC
>>> from datasets import load_dataset
>>> import soundfile as sf
>>> processor = AutoProcessor.from_pretrained("facebook/hubert-large-ls960-ft")
>>> model = TFHubertForCTC.from_pretrained("facebook/hubert-large-ls960-ft")
>>> def map_to_array(batch):
...     speech, _ = sf.read(batch["file"])
...     batch["speech"] = speech
...     return batch
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.map(map_to_array)
>>> input_values = processor(ds["speech"][0], return_tensors="tf").input_values  # Batch size 1
>>> logits = model(input_values).logits
>>> predicted_ids = tf.argmax(logits, axis=-1)
>>> transcription = processor.decode(predicted_ids[0])
>>> # compute loss
>>> target_transcription = "A MAN SAID TO THE UNIVERSE SIR I EXIST"
>>> # Pass the transcription as text to encode labels
>>> labels = processor(text=transcription, return_tensors="tf").input_values
>>> loss = model(input_values, labels=labels).loss

Transformers 4.37 中文文档（七十五）（5）https://developer.aliyun.com/article/1564215

Transformers 4.37 中文文档（七十五）（4）

HubertForCTC

`class transformers.HubertForCTC`

`forward`

HubertForSequenceClassification

`class transformers.HubertForSequenceClassification`

`forward`

TFHubertModel

`class transformers.TFHubertModel`

`call`

TFHubertForCTC

`class transformers.TFHubertForCTC`

`call`

热门文章

最新文章

相关电子书

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

训练营

直播

乘风者计划

下载

镜像站

技术资料

Transformers 4.37 中文文档（七十五）（4）

HubertForCTC

class transformers.HubertForCTC

forward

HubertForSequenceClassification

class transformers.HubertForSequenceClassification

forward

TFHubertModel

class transformers.TFHubertModel

call

TFHubertForCTC

class transformers.TFHubertForCTC

call

热门文章

最新文章

相关电子书

`class transformers.HubertForCTC`

`forward`

`class transformers.HubertForSequenceClassification`

`forward`

`class transformers.TFHubertModel`

`call`

`class transformers.TFHubertForCTC`

`call`