Transformers 4.37 中文文档（七十九）（5）

Transformers 4.37 中文文档（七十九）（4）https://developer.aliyun.com/article/1564173

TFWav2Vec2Model

class transformers.TFWav2Vec2Model

<来源>

( config: Wav2Vec2Config *inputs **kwargs )

参数

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

裸 TFWav2Vec2 模型变压器输出原始隐藏状态，没有特定的头部。

该模型继承自 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 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（形状为({0})的np.ndarray或tf.Tensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：

• 对于未屏蔽的标记，
  
• 对于被屏蔽的标记为 0。
  

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

• 0 对应于句子 A标记。
  
• 1 对应于句子 B标记。
  

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

• 1 表示头部未被屏蔽，
  
• 0 表示头部是屏蔽的。
  

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

返回

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

一个 transformers.modeling_tf_outputs.TFBaseModelOutput 或一个tf.Tensor元组（如果传递return_dict=False或config.return_dict=False时）包含根据配置(Wav2Vec2Config)和输入的各种元素。

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

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

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

示例:

>>> from transformers import AutoProcessor, TFWav2Vec2Model
>>> from datasets import load_dataset
>>> import soundfile as sf
>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = TFWav2Vec2Model.from_pretrained("facebook/wav2vec2-base-960h")
>>> 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

TFWav2Vec2ForSequenceClassification

class transformers.TFWav2Vec2ForSequenceClassification

<来源>

( config )

call

<来源>

( input_values: tf.Tensor attention_mask: tf.Tensor | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None labels: tf.Tensor | None = None training: bool = False )

TFWav2Vec2ForCTC

class transformers.TFWav2Vec2ForCTC

<来源>

( config: Wav2Vec2Config *inputs **kwargs )

参数

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

TFWav2Vec2 模型，在 Connectionist Temporal Classification (CTC)顶部具有语言建模头。

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

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

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

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

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于有了这种支持，当使用model.fit()等方法时，应该可以“正常工作” - 只需以model.fit()支持的任何格式传递输入和标签即可！但是，如果您想在 Keras 方法之外（如fit()和predict()）使用第二种格式，比如在使用 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（形状为({0})的np.ndarray或tf.Tensor，可选）—段标记索引，用于指示输入的第一部分和第二部分。索引选择在[0, 1]中：

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

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

• 1 表示头部是not masked。
  
• 0 表示头部被masked。
  

• inputs_embeds（形状为({0}, hidden_size)的np.ndarray或tf.Tensor，可选） — 可选地，可以直接传递嵌入表示，而不是传递input_values。如果您想要更多控制如何将input_values索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。
  
• output_attentions（bool，可选） — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。此参数仅在急切模式下使用，在图模式下将使用配置中的值。
  
• output_hidden_states（bool，可选） — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数仅在急切模式下使用，在图模式下将使用配置中的值。
  
• return_dict（bool，可选） — 是否返回一个 ModelOutput 而不是一个普通元组。此参数可在急切模式下使用，在图模式下该值将始终设置为 True。
  
• training（bool，可选，默认为False） — 是否在训练模式下使用模型（某些模块，如 dropout 模块，在训练和评估之间具有不同的行为）。
  
• labels（形状为(batch_size, sequence_length)的tf.Tensor或np.ndarray，可选） — 用于计算掩码语言建模损失的标签。索引应在[-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时）包含各种元素，具体取决于配置（Wav2Vec2Config）和输入。

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

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

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

示例：

>>> import tensorflow as tf
>>> from transformers import AutoProcessor, TFWav2Vec2ForCTC
>>> from datasets import load_dataset
>>> import soundfile as sf
>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = TFWav2Vec2ForCTC.from_pretrained("facebook/wav2vec2-base-960h")
>>> 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 transcription as `text` to encode labels
>>> labels = processor(text=transcription, return_tensors="tf").input_ids
>>> loss = model(input_values, labels=labels).loss

JAXHide JAX 内容

FlaxWav2Vec2Model

class transformers.FlaxWav2Vec2Model

<来源>

( config: Wav2Vec2Config input_shape: Tuple = (1, 1024) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

• config（Wav2Vec2Config）- 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。
  
• dtype（jax.numpy.dtype，可选，默认为jax.numpy.float32）- 计算的数据类型。可以是jax.numpy.float32、jax.numpy.float16（在 GPU 上）和jax.numpy.bfloat16（在 TPU 上）之一。
  这可用于在 GPU 或 TPU 上启用混合精度训练或半精度推断。如果指定了dtype，则所有计算将使用给定的dtype执行。
  请注意，这仅指定计算的 dtype，不影响模型参数的 dtype。
  如果要更改模型参数的 dtype，请参阅 to_fp16()和 to_bf16()。
  

裸 Wav2Vec2 模型变压器输出原始隐藏状态，没有特定的头部。Wav2Vec2 是由 Alexei Baevski、Henry Zhou、Abdelrahman Mohamed、Michael Auli 在wav2vec 2.0:自监督学习语音表示的框架中提出的。

此模型继承自 FlaxPreTrainedModel。检查超类文档以获取库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

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

最后，此模型支持 JAX 的固有功能，例如：

• 即时（JIT）编译
  
• 自动微分
  
• 矢量化
  
• 并行化
  

__call__

<来源>

( input_values attention_mask = None mask_time_indices = None params: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None freeze_feature_encoder: bool = False return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2BaseModelOutput or tuple(torch.FloatTensor)

参数

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

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

• 什么是注意力掩码？ … 警告:: 只有当相应的处理器具有config.return_attention_mask == True时，才应传递attention_mask。对于所有处理器具有config.return_attention_mask == False的模型，例如wav2vec2-base，在进行批量推理时，应不传递attention_mask以避免性能下降。对于这样的模型，input_values应该简单地用 0 填充并在不传递attention_mask的情况下传递。请注意，这些模型根据input_values是否填充会产生略有不同的结果。
  
• mask_time_indices（形状为(batch_size, sequence_length)的jnp.ndarray，可选）- 用于对比损失中掩码提取特征的索引。在训练模式下，模型学习在config.proj_codevector_dim空间中预测掩码提取特征。
  
• output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多细节，请查看返回的张量下的attentions。
  
• output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多细节，请查看返回的张量下的hidden_states。
  
• return_dict（bool，可选）- 是否返回一个 ModelOutput 而不是一个普通的元组。
  

返回

transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2BaseModelOutput 或者tuple(torch.FloatTensor)

一个 transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2BaseModelOutput 或者一个torch.FloatTensor的元组（如果传递了return_dict=False或者config.return_dict=False）包含不同的元素，取决于配置（）和输入。

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray）- 模型最后一层的隐藏状态序列。
  
• extract_features（形状为(batch_size, sequence_length, last_conv_dim)的jnp.ndarray）- 模型最后一个卷积层的提取特征向量序列，其中last_conv_dim是最后一个卷积层的维度。
  
• 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 之后的注意力权重，用于计算自注意力头中的加权平均值。
  

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

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

示例：

>>> from transformers import AutoProcessor, FlaxWav2Vec2Model
>>> from datasets import load_dataset
>>> import soundfile as sf
>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-large-lv60")
>>> model = FlaxWav2Vec2Model.from_pretrained("facebook/wav2vec2-large-lv60")
>>> 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], sampling_rate=16_000, return_tensors="np"
... ).input_values  # Batch size 1
>>> hidden_states = model(input_values).last_hidden_state

FlaxWav2Vec2ForCTC

class transformers.FlaxWav2Vec2ForCTC

<来源>

( config: Wav2Vec2Config input_shape: Tuple = (1, 1024) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

• config (Wav2Vec2Config) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained() 方法以加载模型权重。
  
• dtype（jax.numpy.dtype，可选，默认为 jax.numpy.float32） — 计算的数据类型。可以是 jax.numpy.float32、jax.numpy.float16（在 GPU 上）和 jax.numpy.bfloat16（在 TPU 上）之一。
  这可用于在 GPU 或 TPU 上启用混合精度训练或半精度推断。如果指定，所有计算将使用给定的 dtype 执行。
  请注意，这仅指定计算的数据类型，不会影响模型参数的数据类型。
  如果要更改模型参数的数据类型，请参阅 to_fp16() 和 to_bf16()。
  

Wav2Vec2 模型在顶部带有“语言建模”头部，用于 Connectionist Temporal Classification  (CTC)。Wav2Vec2 是由 Alexei Baevski、Henry Zhou、Abdelrahman Mohamed、Michael  Auli 在 wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations 中提出的。

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

此模型还是 Flax Linen flax.nn.Module 子类。将其用作常规 Flax 模块，并参考 Flax 文档以了解所有与一般用法和行为相关的事项。

最后，此模型支持 JAX 的内在特性，例如：

• 即时 (JIT) 编译
  
• 自动微分
  
• 矢量化
  
• 并行化
  

__call__

<来源>

( input_values attention_mask = None mask_time_indices = None params: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None freeze_feature_encoder: bool = False return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxMaskedLMOutput or tuple(torch.FloatTensor)

参数

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

• 1 用于“未掩码”标记，
  
• 0 用于“掩码”标记。
  

• 什么是注意力掩码？ … 警告:: 只有当相应的处理器具有 config.return_attention_mask == True 时才应传递 attention_mask。对于所有处理器具有 config.return_attention_mask == False 的模型，例如 wav2vec2-base，在进行批量推理时，应该 不 传递 attention_mask 以避免性能下降。对于这样的模型，input_values 应该简单地用 0 填充并在不传递 attention_mask 的情况下传递。请注意，这些模型根据 input_values 是否填充会产生略有不同的结果。
  
• mask_time_indices (jnp.ndarray，形状为 (batch_size, sequence_length)，可选) — 用于对比损失掩盖提取特征的索引。在训练模式下，模型学习在 config.proj_codevector_dim 空间中预测掩盖的提取特征。
  
• output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多细节，请参阅返回张量下的 attentions。
  
• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多细节，请参阅返回张量下的 hidden_states。
  
• return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。
  

返回

transformers.modeling_flax_outputs.FlaxMaskedLMOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxMaskedLMOutput 或一个 torch.FloatTensor 元组（如果传递 return_dict=False 或 config.return_dict=False）包含不同元素，取决于配置（）和输入。

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

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

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

示例：

>>> import jax.numpy as jnp
>>> from transformers import AutoProcessor, FlaxWav2Vec2ForCTC
>>> from datasets import load_dataset
>>> import soundfile as sf
>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-large-960h-lv60")
>>> model = FlaxWav2Vec2ForCTC.from_pretrained("facebook/wav2vec2-large-960h-lv60")
>>> 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], sampling_rate=16_000, return_tensors="np"
... ).input_values  # Batch size 1
>>> logits = model(input_values).logits
>>> predicted_ids = jnp.argmax(logits, axis=-1)
>>> transcription = processor.decode(predicted_ids[0])
>>> # should give:  "A MAN SAID TO THE UNIVERSE SIR I EXIST"

FlaxWav2Vec2ForPreTraining

class transformers.FlaxWav2Vec2ForPreTraining

< source >

( config: Wav2Vec2Config input_shape: Tuple = (1, 1024) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

• config (Wav2Vec2Config) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。查看 from_pretrained()方法以加载模型权重。
  
• dtype (jax.numpy.dtype, 可选, 默认为jax.numpy.float32) — 计算的数据类型。可以是jax.numpy.float32、jax.numpy.float16（在 GPU 上）和jax.numpy.bfloat16（在 TPU 上）之一。
  这可用于在 GPU 或 TPU 上启用混合精度训练或半精度推断。如果指定，所有计算将使用给定的dtype进行。
  请注意，这仅指定计算的数据类型，不会影响模型参数的数据类型。
  如果要更改模型参数的数据类型，请参阅 to_fp16()和 to_bf16()。
  

带有量化器和顶部VQ头的 Wav2Vec2 模型。Wav2Vec2 是由 Alexei Baevski、Henry Zhou、Abdelrahman Mohamed、Michael Auli 提出的wav2vec 2.0:自监督学习语音表示的框架。

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

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

最后，此模型支持 JAX 的固有特性，例如：

• 即时（JIT）编译
  
• 自动微分
  
• 矢量化
  
• 并行化
  

__call__

<来源>

( input_values attention_mask = None mask_time_indices = None gumbel_temperature: int = 1 params: dict = None dropout_rng: PRNGKey = None gumbel_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None freeze_feature_encoder: bool = False return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2ForPreTrainingOutput or tuple(torch.FloatTensor)

参数

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

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

• 什么是注意力掩码？ … 警告:: 只有当相应的处理器具有config.return_attention_mask == True时，才应传递attention_mask。对于所有处理器具有config.return_attention_mask == False的模型，例如wav2vec2-base，在进行批量推断时，应避免传递attention_mask以避免性能下降。对于这些模型，input_values应该简单地用 0 填充并在不传递attention_mask的情况下传递。请注意，这些模型根据input_values是否填充会产生略有不同的结果。
  
• mask_time_indices (jnp.ndarray，形状为(batch_size, sequence_length)，optional） — 用于对比损失中掩码提取特征的索引。在训练模式下，模型学习在config.proj_codevector_dim空间中预测掩码提取特征。
  
• output_attentions (bool, *optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions`。
  
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
  
• return_dict (bool, optional） — 是否返回 ModelOutput 而不是普通元组。
  

返回

transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2ForPreTrainingOutput 或 tuple(torch.FloatTensor)

transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2ForPreTrainingOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（）和输入的不同元素。

• loss (optional，在训练模式下返回，形状为(1,)的jnp.ndarray) — 总损失，作为对比损失（L_m）和多样性损失（L_d）的总和，如官方论文中所述。 （分类）损失。
  
• projected_states (jnp.ndarray，形状为(batch_size, sequence_length, config.proj_codevector_dim)） — 模型的隐藏状态投影到config.proj_codevector_dim，可用于预测掩码的投影量化状态。
  
• projected_quantized_states (jnp.ndarray，形状为(batch_size, sequence_length, config.proj_codevector_dim)） — 量化提取的特征向量投影到config.proj_codevector_dim，表示对比损失的正目标向量。
  
• 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 后的注意力权重，用于计算自注意力头中的加权平均值。
  

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

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

示例：

>>> import optax
>>> import numpy as np
>>> import jax.numpy as jnp
>>> from transformers import AutoFeatureExtractor, FlaxWav2Vec2ForPreTraining
>>> from transformers.models.wav2vec2.modeling_flax_wav2vec2 import _compute_mask_indices
>>> from datasets import load_dataset
>>> import soundfile as sf
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-large-lv60")
>>> model = FlaxWav2Vec2ForPreTraining.from_pretrained("facebook/wav2vec2-large-lv60")
>>> 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 = feature_extractor(ds["speech"][0], return_tensors="np").input_values  # Batch size 1
>>> # compute masked indices
>>> batch_size, raw_sequence_length = input_values.shape
>>> sequence_length = model._get_feat_extract_output_lengths(raw_sequence_length)
>>> mask_time_indices = _compute_mask_indices((batch_size, sequence_length), mask_prob=0.2, mask_length=2)
>>> outputs = model(input_values, mask_time_indices=mask_time_indices)
>>> # compute cosine similarity between predicted (=projected_states) and target (=projected_quantized_states)
>>> cosine_sim = optax.cosine_similarity(outputs.projected_states, outputs.projected_quantized_states)
>>> # show that cosine similarity is much higher than random
>>> assert np.asarray(cosine_sim)[mask_time_indices].mean() > 0.5