Hugging Face's logo

Transformers 文档

SeamlessM4T

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

SeamlessM4T

PyTorch

概述

SeamlessM4T 模型是由 Meta AI 的 Seamless Communication 团队在 SeamlessM4T — 大规模多语种和多模态机器翻译 中提出的。

这是该模型的版本 1 发布。有关更新的版本 2 发布，请参阅 Seamless M4T v2 文档。

SeamlessM4T 是一系列旨在提供高质量翻译的模型集合，使来自不同语言社区的人们能够通过语音和文本轻松交流。

SeamlessM4T 无需依赖单独的模型即可实现多项任务

  • 语音到语音翻译 (S2ST)
  • 语音到文本翻译 (S2TT)
  • 文本到语音翻译 (T2ST)
  • 文本到文本翻译 (T2TT)
  • 自动语音识别 (ASR)

SeamlessM4TModel 可以执行上述所有任务，但每个任务也有其自己的专用子模型。

以下是论文的摘要

创建巴别鱼（一种可以帮助个人在任意两种语言之间翻译语音的工具）需要什么？虽然最近基于文本的模型的突破已将机器翻译的覆盖范围扩展到 200 多种语言，但统一的语音到语音翻译模型尚未取得类似的进展。更具体地说，传统的语音到语音翻译系统依赖于逐步执行翻译的级联系统，这使得高性能的统一系统遥不可及。为了解决这些差距，我们推出了 SeamlessM4T，这是一个单一模型，支持多达 100 种语言的语音到语音翻译、语音到文本翻译、文本到语音翻译、文本到文本翻译和自动语音识别。为了构建这个模型，我们使用了 100 万小时的开放语音音频数据，通过 w2v-BERT 2.0 学习自监督语音表示。随后，我们创建了一个自动对齐的语音翻译多模态语料库。经过过滤并与人工标记和伪标记数据相结合，我们开发了第一个能够进行英语和多种语言之间语音和文本互译的多语言系统。在 FLEURS 上，SeamlessM4T 为多种目标语言的翻译树立了新标准，在直接语音到文本翻译中实现了比以前的 SOTA 提高 20% BLEU。与强大的级联模型相比，SeamlessM4T 在语音到文本翻译中提高了 1.3 BLEU 点的英语翻译质量，在语音到语音翻译中提高了 2.6 ASR-BLEU 点。经过鲁棒性测试，与当前的 SOTA 模型相比，我们的系统在语音到文本任务中对背景噪声和说话人变化的表现更好。至关重要的是，我们评估了 SeamlessM4T 的性别偏见和添加的毒性，以评估翻译安全性。最后，这项工作中的所有贡献都是开源的，可以在 https://github.com/facebookresearch/seamless_communication 访问

用法

首先，加载处理器和模型的检查点

>>> from transformers import AutoProcessor, SeamlessM4TModel

>>> processor = AutoProcessor.from_pretrained("facebook/hf-seamless-m4t-medium")
>>> model = SeamlessM4TModel.from_pretrained("facebook/hf-seamless-m4t-medium")

您可以无缝地在文本或音频上使用此模型，以生成翻译后的文本或翻译后的音频。

以下是如何使用处理器处理文本和音频

>>> # let's load an audio sample from an Arabic speech corpus
>>> from datasets import load_dataset
>>> dataset = load_dataset("arabic_speech_corpus", split="test", streaming=True, trust_remote_code=True)
>>> audio_sample = next(iter(dataset))["audio"]

>>> # now, process it
>>> audio_inputs = processor(audios=audio_sample["array"], return_tensors="pt")

>>> # now, process some English test as well
>>> text_inputs = processor(text = "Hello, my dog is cute", src_lang="eng", return_tensors="pt")

语音

SeamlessM4TModel 可以无缝地生成文本或语音，只需进行少量或无需更改。让我们以俄语语音翻译为目标

>>> audio_array_from_text = model.generate(**text_inputs, tgt_lang="rus")[0].cpu().numpy().squeeze()
>>> audio_array_from_audio = model.generate(**audio_inputs, tgt_lang="rus")[0].cpu().numpy().squeeze()

基本上使用相同的代码，我已经将英语文本和阿拉伯语语音翻译成俄语语音样本。

文本

同样，您可以使用相同的模型从音频文件或文本生成翻译后的文本。您只需将 generate_speech=False 传递给 SeamlessM4TModel.generate()。这次，让我们翻译成法语。

>>> # from audio
>>> output_tokens = model.generate(**audio_inputs, tgt_lang="fra", generate_speech=False)
>>> translated_text_from_audio = processor.decode(output_tokens[0].tolist()[0], skip_special_tokens=True)

>>> # from text
>>> output_tokens = model.generate(**text_inputs, tgt_lang="fra", generate_speech=False)
>>> translated_text_from_text = processor.decode(output_tokens[0].tolist()[0], skip_special_tokens=True)

提示

1. 使用专用模型

SeamlessM4TModel 是用于生成语音和文本的顶级 transformers 模型，但您也可以使用执行任务而无需额外组件的专用模型，从而减少内存占用。例如，您可以将音频到音频生成代码段替换为专用于 S2ST 任务的模型，其余代码完全相同

>>> from transformers import SeamlessM4TForSpeechToSpeech
>>> model = SeamlessM4TForSpeechToSpeech.from_pretrained("facebook/hf-seamless-m4t-medium")

或者您可以将文本到文本生成代码段替换为专用于 T2TT 任务的模型，您只需删除 generate_speech=False 即可。

>>> from transformers import SeamlessM4TForTextToText
>>> model = SeamlessM4TForTextToText.from_pretrained("facebook/hf-seamless-m4t-medium")

请随时尝试 SeamlessM4TForSpeechToText 和 SeamlessM4TForTextToSpeech。

2. 更改说话人身份

您可以使用 spkr_id 参数更改用于语音合成的说话人。某些 spkr_id 对于某些语言的效果更好！

3. 更改生成策略

您可以对语音和文本生成使用不同的生成策略，例如 .generate(input_ids=input_ids, text_num_beams=4, speech_do_sample=True)，它将连续对文本模型执行束搜索解码，并对语音模型执行多项式采样。

4. 同时生成语音和文本

将 return_intermediate_token_ids=True 与 SeamlessM4TModel 一起使用可同时返回语音和文本！

模型架构

SeamlessM4T 具有通用的架构，可以流畅地处理文本和语音的顺序生成。此设置包括两个序列到序列 (seq2seq) 模型。第一个模型将输入模态翻译成翻译后的文本，而第二个模型从翻译后的文本生成语音标记，称为“单元标记”。

每种模态都有其自己专用的编码器，具有独特的架构。此外，对于语音输出，在第二个 seq2seq 模型之上放置了一个受 HiFi-GAN 架构启发的声码器。

以下是生成过程的工作原理

  • 输入文本或语音通过其特定的编码器进行处理。
  • 解码器以所需的语言创建文本标记。
  • 如果需要语音生成，则遵循标准编码器-解码器结构的第二个 seq2seq 模型会生成单元标记。
  • 然后，这些单元标记将通过最终的声码器以生成实际的语音。

此模型由 ylacombe 贡献。原始代码可以在此处找到。

SeamlessM4TModel

class transformers.SeamlessM4TModel

< >

( config current_modality = 'text' )

参数

  • config (~SeamlessM4TConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
  • current_modality (str, 可选, 默认为 "text") — 默认模态。用于初始化模型。

原始 SeamlessM4T 模型转换器，可用于所有可用任务 (S2ST、S2TT、T2TT、T2ST)。此模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。

generate

< >

( input_ids: typing.Optional[torch.Tensor] = None input_features: typing.Optional[torch.Tensor] = None return_intermediate_token_ids: typing.Optional[bool] = None tgt_lang: typing.Optional[str] = None spkr_id: typing.Optional[int] = 0 generate_speech: typing.Optional[bool] = True **kwargs ) → Union[SeamlessM4TGenerationOutput, Tuple[Tensor], ModelOutput]

参数

  • input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 词汇表中输入序列 tokens 的索引。

    索引可以使用 SeamlessM4TTokenizer 或 SeamlessM4TProcessor 获得。 请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 了解详情。

    什么是输入 IDs？

  • input_features (torch.FloatTensor，形状为 (batch_size, sequence_length, num_banks)，可选) — 输入音频特征。 这应该由 SeamlessM4TFeatureExtractor 类或 SeamlessM4TProcessor 类返回。 请参阅 SeamlessM4TFeatureExtractor.call() 了解详情。
  • return_intermediate_token_ids (bool，可选) — 如果为 True，还会返回中间生成的文本和单元 tokens。 如果您还想获取音频旁边的翻译文本，请设置为 True。 请注意，如果 generate_speech=True，此参数将被忽略。
  • tgt_lang (str，可选) — 用作翻译目标语言的语言。
  • spkr_id (int，可选，默认为 0) — 用于语音合成的说话人 ID。 必须低于 config.vocoder_num_spkrs。
  • generate_speech (bool，可选，默认为 True) — 如果为 False，则仅返回文本 tokens，并且不会生成语音。
  • kwargs (可选) — 将传递给 GenerationMixin.generate() 的剩余关键字参数字典。 关键字参数有两种类型：

    • 不带前缀的关键字参数将作为 **kwargs 输入到每个子模型的 generate 方法中，但 decoder_input_ids 除外，它将仅通过文本组件传递。
    • 带有 text_ 或 speech_ 前缀的关键字参数将分别作为文本模型和语音模型的 generate 方法的输入。 它优先于没有前缀的关键字。

    这意味着您可以例如为一个生成指定生成策略，但不为另一个生成指定生成策略。

返回

Union[SeamlessM4TGenerationOutput, Tuple[Tensor], ModelOutput]

  • 如果 generate_speech 和 return_intermediate_token_ids，则返回 SeamlessM4TGenerationOutput。
  • 如果 generate_speech 且不是 return_intermediate_token_ids，则返回由形状为 (batch_size, sequence_length) 的波形和提供每个样本长度的 waveform_lengths 组成的元组。
  • 如果 generate_speech=False，它将返回 ModelOutput。

生成翻译后的 token IDs 和/或翻译后的音频波形。

此方法依次调用两个不同子模型的 .generate 函数。 您可以在两个不同的级别指定关键字参数：将传递给两个模型的一般参数，或将传递给其中一个模型的带前缀的参数。

例如，调用 .generate(input_ids=input_ids, num_beams=4, speech_do_sample=True) 将在文本模型上依次执行束搜索解码，并在语音模型上执行多项式束搜索采样。

有关生成策略和代码示例的概述，请查看以下指南。

SeamlessM4TForTextToSpeech

class transformers.SeamlessM4TForTextToSpeech

< >

( config: SeamlessM4TConfig )

参数

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

用于 T2ST 的文本到语音 SeamlessM4T 模型转换器。 此模型是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。

generate

 < >

( input_ids: typing.Optional[torch.Tensor] = None return_intermediate_token_ids: typing.Optional[bool] = None tgt_lang: typing.Optional[str] = None spkr_id: typing.Optional[int] = 0 **kwargs ) → Union[SeamlessM4TGenerationOutput, Tuple[Tensor]]

参数

  • input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。

    索引可以使用 SeamlessM4TTokenizer 或 SeamlessM4TProcessor 获得。 请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 了解详情。

    什么是输入 IDs？

  • return_intermediate_token_ids (bool，可选) — 如果为 True，还会返回中间生成的文本和单元 tokens。 如果您还想获取音频旁边的翻译文本，请设置为 True。
  • tgt_lang (str，可选) — 用作翻译目标语言的语言。
  • spkr_id (int，可选，默认为 0) — 用于语音合成的说话人 ID。 必须低于 config.vocoder_num_spkrs。
  • kwargs (可选) — 将传递给 GenerationMixin.generate() 的剩余关键字参数字典。 关键字参数有两种类型：

    • 不带前缀的关键字参数将作为 **kwargs 输入到每个子模型的 generate 方法中，但 decoder_input_ids 除外，它将仅通过文本组件传递。
    • 带有 text_ 或 speech_ 前缀的关键字参数将分别作为文本模型和语音模型的 generate 方法的输入。 它优先于没有前缀的关键字。

    这意味着您可以例如为一个生成指定生成策略，但不为另一个生成指定生成策略。

返回

Union[SeamlessM4TGenerationOutput, Tuple[Tensor]]

  • 如果 return_intermediate_token_ids，则返回 SeamlessM4TGenerationOutput。
  • 如果不是 return_intermediate_token_ids，则返回由形状为 (batch_size, sequence_length) 的波形和提供每个样本长度的 waveform_lengths 组成的元组。

生成翻译后的音频波形。

此方法依次调用两个不同子模型的 .generate 函数。 您可以在两个不同的级别指定关键字参数：将传递给两个模型的一般参数，或将传递给其中一个模型的带前缀的参数。

例如，调用 .generate(input_ids, num_beams=4, speech_do_sample=True) 将在文本模型上依次执行束搜索解码，并在语音模型上执行多项式束搜索采样。

有关生成策略和代码示例的概述，请查看以下指南。

SeamlessM4TForSpeechToSpeech

class transformers.SeamlessM4TForSpeechToSpeech

 < >

( config )

参数

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

用于 S2ST 的语音到语音 SeamlessM4T 模型转换器。 此模型是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。

generate

 < >

( input_features: typing.Optional[torch.Tensor] = None return_intermediate_token_ids: typing.Optional[bool] = None tgt_lang: typing.Optional[str] = None spkr_id: typing.Optional[int] = 0 **kwargs ) → Union[SeamlessM4TGenerationOutput, Tuple[Tensor]]

参数

  • input_features (torch.FloatTensor，形状为 (batch_size, sequence_length, num_banks)) — 输入音频特征。 这应该由 SeamlessM4TFeatureExtractor 类或 SeamlessM4TProcessor 类返回。 请参阅 SeamlessM4TFeatureExtractor.call() 了解详情。
  • return_intermediate_token_ids (bool，可选) — 如果为 True，还会返回中间生成的文本和单元 tokens。 如果您还想获取音频旁边的翻译文本，请设置为 True。
  • tgt_lang (str，可选) — 用作翻译目标语言的语言。
  • spkr_id (int，可选，默认为 0) — 用于语音合成的说话人 ID。 必须低于 config.vocoder_num_spkrs。
  • kwargs (可选) — 剩余的关键字参数字典，将传递给 GenerationMixin.generate()。关键字参数有两种类型：

    • 不带前缀的关键字参数将作为 **kwargs 输入到每个子模型的 generate 方法中，但 decoder_input_ids 除外，它只会传递给文本组件。
    • 带有 text_ 或 speech_ 前缀的关键字参数将分别作为文本模型和语音模型的 generate 方法的输入。它比没有前缀的关键字参数具有更高的优先级。

    这意味着您可以例如为一个生成指定生成策略，但不为另一个生成指定生成策略。

返回

Union[SeamlessM4TGenerationOutput, Tuple[Tensor]]

  • 如果 return_intermediate_token_ids，则返回 SeamlessM4TGenerationOutput。
  • 如果不是 return_intermediate_token_ids，则返回由形状为 (batch_size, sequence_length) 的波形和提供每个样本长度的 waveform_lengths 组成的元组。

生成翻译后的音频波形。

此方法依次调用两个不同子模型的 .generate 函数。 您可以在两个不同的级别指定关键字参数：将传递给两个模型的一般参数，或将传递给其中一个模型的带前缀的参数。

例如，调用 .generate(input_features, num_beams=4, speech_do_sample=True) 将依次对文本模型执行束搜索解码，并对语音模型执行多项式束搜索采样。

有关生成策略和代码示例的概述，请查看以下指南。

SeamlessM4TForTextToText

class transformers.SeamlessM4TForTextToText

< >

( config: SeamlessM4TConfig )

参数

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

用于 T2TT 的文本到文本 SeamlessM4T 模型转换器。此模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。

forward

< >

( input_ids: LongTensor = None attention_mask: typing.Optional[torch.Tensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.LongTensor] = None encoder_outputs: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None **kwargs )

参数

  • input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 词汇表中输入序列标记的索引。

    可以使用 SeamlessM4TTokenizer 或 SeamlessM4TProcessor 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是输入 IDs？

  • attention_mask (torch.FloatTensor，形状为 (batch_size, sequence_length)，可选) — 掩码，用于避免在填充标记索引上执行注意力机制。掩码值在 [0, 1] 中选择：

    • 1 表示未被掩码的标记，
    • 0 表示被掩码的标记。

    什么是注意力掩码？

  • decoder_input_ids (torch.LongTensor，形状为 (batch_size, target_sequence_length)，可选) — 词汇表中解码器输入序列标记的索引。

    可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是解码器输入 IDs？

    Bart 使用 eos_token_id 作为 decoder_input_ids 生成的起始标记。如果使用 past_key_values，则可以选择仅输入最后一个 decoder_input_ids（请参阅 past_key_values）。

    对于翻译和摘要训练，应提供 decoder_input_ids。如果未提供 decoder_input_ids，则模型将通过将 input_ids 向右移动来创建此张量，以进行遵循论文的去噪预训练。

  • decoder_attention_mask (torch.LongTensor，形状为 (batch_size, target_sequence_length)，可选) — 默认行为：生成一个张量，该张量忽略 decoder_input_ids 中的 pad 标记。默认情况下也会使用因果掩码。

    如果您想更改填充行为，则应阅读 modeling_bart._prepare_decoder_attention_mask 并根据您的需要进行修改。有关默认策略的更多信息，请参见 论文 中的图 1 。

  • encoder_outputs (tuple(tuple(torch.FloatTensor)，可选) — 元组由 (last_hidden_state, 可选: hidden_states, 可选: attentions) 组成，last_hidden_state 的形状为 (batch_size, sequence_length, 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 输入）加速顺序解码。

    如果使用 past_key_values，则用户可以选择仅输入最后一个 decoder_input_ids（那些没有将其过去的键值状态提供给此模型的 decoder_input_ids），形状为 (batch_size, 1)，而不是所有形状为 (batch_size, sequence_length) 的 decoder_input_ids。

  • inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — （可选）您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您想比模型的内部嵌入查找矩阵更灵活地控制如何将 input_ids 索引转换为关联的向量，这将非常有用。
  • decoder_inputs_embeds (torch.FloatTensor，形状为 (batch_size, target_sequence_length, hidden_size)，可选) — （可选）您可以选择直接传递嵌入表示，而不是传递 decoder_input_ids。如果使用 past_key_values，则可以选择仅输入最后一个 decoder_inputs_embeds（请参阅 past_key_values）。如果您想比模型的内部嵌入查找矩阵更灵活地控制如何将 decoder_input_ids 索引转换为关联的向量，这将非常有用。

    如果 decoder_input_ids 和 decoder_inputs_embeds 均未设置，则 decoder_inputs_embeds 取 inputs_embeds 的值。

  • labels (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 用于计算掩码语言建模损失的标签。索引应在 [-100, 0, ..., config.vocab_size] 中（请参阅 input_ids 文档字符串）。索引设置为 -100 的标记将被忽略（掩码），损失仅针对标签在 [0, ..., config.vocab_size] 中的标记计算。
  • use_cache (bool，可选) — 如果设置为 True，则返回 past_key_values 键值状态，并且可以用于加速解码（请参阅 past_key_values）。
  • output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
  • return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。

SeamlessM4TForTextToText 的 forward 方法，覆盖了 __call__ 特殊方法。

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

generate

< >

( input_ids = None tgt_lang = None generation_config = None logits_processor = None stopping_criteria = None prefix_allowed_tokens_fn = None synced_gpus = False **kwargs ) → ModelOutput 或 torch.LongTensor

参数

  • input_ids (torch.Tensor，形状根据模态而变化，可选) — 词汇表中输入序列标记的索引。

    可以使用 SeamlessM4TTokenizer 或 SeamlessM4TProcessor 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是输入 IDs？

  • tgt_lang (str，可选) — 用作翻译目标语言的语言。
  • generation_config (~generation.GenerationConfig, 可选) — 用作生成调用的基本参数化的生成配置。传递给 generate 且与 generation_config 的属性匹配的 **kwargs 将覆盖它们。如果未提供 generation_config，将使用默认值，其加载优先级如下：1) 来自 generation_config.json 模型文件（如果存在）；2) 来自模型配置。请注意，未指定的参数将继承 GenerationConfig 的默认值，应查阅其文档以参数化生成。
  • logits_processor (LogitsProcessorList, 可选) — 自定义 logits 处理器，用于补充从参数和生成配置构建的默认 logits 处理器。如果传递的 logits 处理器已使用参数或生成配置创建，则会抛出错误。此功能适用于高级用户。
  • stopping_criteria (StoppingCriteriaList, 可选) — 自定义停止标准，用于补充从参数和生成配置构建的默认停止标准。如果传递的停止标准已使用参数或生成配置创建，则会抛出错误。此功能适用于高级用户。
  • prefix_allowed_tokens_fn (Callable[[int, torch.Tensor], List[int]], 可选) — 如果提供，此函数将 beam search 约束为每一步仅允许的 tokens。如果未提供，则不应用约束。此函数接受 2 个参数：批次 ID batch_id 和 input_ids。它必须返回一个列表，其中包含基于批次 ID batch_id 和先前生成的 tokens inputs_ids 的下一个生成步骤的允许 tokens。此参数对于基于前缀的约束生成非常有用，如 Autoregressive Entity Retrieval 中所述。
  • synced_gpus (bool, 可选, 默认为 False) — 是否继续运行 while 循环直到 max_length (避免与 FullyShardedDataParallel 和 DeepSpeed ZeRO Stage 3 死锁所必需)。
  • kwargs (Dict[str, Any], 可选) — generate_config 的特别参数化和/或将转发到模型的 forward 函数的其他模型特定 kwargs。

返回

ModelOutput 或 torch.LongTensor

一个 ModelOutput (如果 return_dict_in_generate=True 或当 config.return_dict_in_generate=True 时) 或一个 torch.FloatTensor。可能的 ModelOutput 类型是

生成 token id 序列。

大多数生成控制参数在 generation_config 中设置，如果未传递，则将其设置为模型的默认生成配置。您可以通过将相应的参数传递给 generate() 来覆盖任何 generation_config，例如 .generate(inputs, num_beams=4, do_sample=True)。

有关生成策略和代码示例的概述，请查看以下指南。

SeamlessM4TForSpeechToText

class transformers.SeamlessM4TForSpeechToText

< >

( config: SeamlessM4TConfig )

参数

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

speech-to-text SeamlessM4T 模型转换器，可用于 S2TT。此模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与通用用法和行为相关的所有事项。

forward

< >

( input_features: LongTensor = None attention_mask: typing.Optional[torch.Tensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.LongTensor] = None encoder_outputs: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None **kwargs )

参数

  • input_features (torch.FloatTensor，形状为 (batch_size, sequence_length, num_banks)) — 输入音频特征。这应该由 SeamlessM4TFeatureExtractor 类或 SeamlessM4TProcessor 类返回。有关详细信息，请参阅 SeamlessM4TFeatureExtractor.call()。
  • attention_mask (torch.FloatTensor，形状为 (batch_size, sequence_length), 可选) — 掩码，以避免在 padding token 索引上执行 attention。掩码值在 [0, 1] 中选择：

    • 1 表示 未被掩盖 的 token，
    • 0 表示 被掩盖 的 token。

    什么是 attention 掩码？

  • decoder_input_ids (torch.LongTensor，形状为 (batch_size, target_sequence_length), 可选) — 词汇表中 decoder 输入序列 tokens 的索引。

    可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是 decoder 输入 IDs？

    Bart 使用 eos_token_id 作为 decoder_input_ids 生成的起始 token。如果使用 past_key_values，则可以选择仅输入最后一个 decoder_input_ids（请参阅 past_key_values）。

    对于翻译和摘要训练，应提供 decoder_input_ids。如果未提供 decoder_input_ids，则模型将通过按照论文中的去噪预训练将 input_ids 向右移动来创建此张量。

  • decoder_attention_mask (torch.LongTensor，形状为 (batch_size, target_sequence_length), 可选) — 默认行为：生成一个张量，该张量忽略 decoder_input_ids 中的 pad tokens。默认情况下，还将使用因果掩码。

    如果要更改 padding 行为，则应阅读 modeling_bart._prepare_decoder_attention_mask 并根据您的需求进行修改。有关默认策略的更多信息，请参见 论文 中的图 1。

  • encoder_outputs (tuple(tuple(torch.FloatTensor), 可选) — 元组由 (last_hidden_state, 可选: hidden_states, 可选: attentions) 组成。last_hidden_state 的形状为 (batch_size, sequence_length, hidden_size), 可选)，是编码器最后一层的输出处的 hidden-states 序列。在 decoder 的 cross-attention 中使用。
  • past_key_values (tuple(tuple(torch.FloatTensor)), 可选, 当传递 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(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) 的附加张量。

    包含预先计算的 hidden-states（self-attention 块和 cross-attention 块中的键和值），可以用于（请参阅 past_key_values 输入）加速顺序解码。

    如果使用 past_key_values，则用户可以选择仅输入最后一个 decoder_input_ids（那些没有将其过去键值状态提供给此模型的）的形状为 (batch_size, 1) 而不是所有形状为 (batch_size, sequence_length) 的 decoder_input_ids。

  • inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更能控制如何将 input_ids 索引转换为关联向量，这将非常有用。
  • decoder_inputs_embeds (torch.FloatTensor，形状为 (batch_size, target_sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 decoder_input_ids。如果使用 past_key_values，则可以选择仅输入最后一个 decoder_inputs_embeds（请参阅 past_key_values）。如果您希望比模型的内部嵌入查找矩阵更能控制如何将 decoder_input_ids 索引转换为关联向量，这将非常有用。

    如果 decoder_input_ids 和 decoder_inputs_embeds 均未设置，则 decoder_inputs_embeds 采用 inputs_embeds 的值。

  • labels (torch.LongTensor，形状为 (batch_size, sequence_length), 可选) — 用于计算 masked language modeling loss 的标签。索引应在 [-100, 0, ..., config.vocab_size] 中（请参阅 input_ids 文档字符串）。索引设置为 -100 的 tokens 将被忽略（掩盖），loss 仅针对标签在 [0, ..., config.vocab_size] 中的 tokens 计算
  • use_cache (bool, 可选) — 如果设置为 True，则返回 past_key_values 键值状态，并且可以用于加速解码（请参阅 past_key_values）。
  • output_attentions (bool, 可选) — 是否返回所有 attention 层的 attentions 张量。有关更多详细信息，请参见返回张量下的 attentions。
  • output_hidden_states (bool, 可选) — 是否返回所有层的 hidden states。有关更多详细信息，请参见返回张量下的 hidden_states。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

SeamlessM4TForSpeechToText forward 方法，覆盖 __call__ 特殊方法。

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

generate

< >

( input_features = None tgt_lang = None generation_config = None logits_processor = None stopping_criteria = None prefix_allowed_tokens_fn = None synced_gpus = False **kwargs ) → ModelOutput 或 torch.LongTensor

参数

  • input_features (torch.FloatTensor，形状为 (batch_size, sequence_length, num_banks)) — 输入音频特征。这应该由 SeamlessM4TFeatureExtractor 类或 SeamlessM4TProcessor 类返回。 有关详细信息，请参阅 SeamlessM4TFeatureExtractor.call()。
  • tgt_lang (str, 可选) — 用作翻译目标语言的语言。
  • generation_config (~generation.GenerationConfig, 可选) — 用作生成调用的基本参数化的生成配置。 传递给 generate 的 **kwargs 若与 generation_config 的属性匹配，将会覆盖它们。 如果未提供 generation_config，将使用默认配置，其加载优先级如下：1) 来自 generation_config.json 模型文件（如果存在）；2) 来自模型配置。 请注意，未指定的参数将继承 GenerationConfig 的默认值，应查阅其文档以参数化生成。
  • logits_processor (LogitsProcessorList, 可选) — 自定义 logits 处理器，用于补充从参数和生成配置构建的默认 logits 处理器。 如果传递的 logits 处理器已使用参数或生成配置创建，则会抛出错误。 此功能供高级用户使用。
  • stopping_criteria (StoppingCriteriaList, 可选) — 自定义停止标准，用于补充从参数和生成配置构建的默认停止标准。 如果传递的停止标准已使用参数或生成配置创建，则会抛出错误。 此功能供高级用户使用。
  • prefix_allowed_tokens_fn (Callable[[int, torch.Tensor], List[int]], 可选) — 如果提供，此函数将 beam search 约束为每步仅允许的 token。 如果未提供，则不应用约束。 此函数接受 2 个参数：批次 ID batch_id 和 input_ids。 它必须返回一个列表，其中包含在批次 ID batch_id 和先前生成的 token inputs_ids 的条件下，下一步生成步骤允许的 token。 此参数对于基于前缀的约束生成非常有用，如 Autoregressive Entity Retrieval 中所述。
  • synced_gpus (bool, 可选, 默认为 False) — 是否继续运行 while 循环直到 max_length（需要避免与 FullyShardedDataParallel 和 DeepSpeed ZeRO Stage 3 死锁）。
  • kwargs (Dict[str, Any], 可选) — generate_config 的临时参数化和/或将转发到模型的 forward 函数的其他模型特定 kwargs。

返回

ModelOutput 或 torch.LongTensor

一个 ModelOutput (如果 return_dict_in_generate=True 或当 config.return_dict_in_generate=True 时) 或一个 torch.FloatTensor。可能的 ModelOutput 类型是

生成 token id 序列。

大多数生成控制参数在 generation_config 中设置，如果未传递，则将其设置为模型的默认生成配置。您可以通过将相应的参数传递给 generate() 来覆盖任何 generation_config，例如 .generate(inputs, num_beams=4, do_sample=True)。

有关生成策略和代码示例的概述，请查看以下指南。

SeamlessM4TConfig

class transformers.SeamlessM4TConfig

< >

( vocab_size = 256102 t2u_vocab_size = 10082 hidden_size = 1024 initializer_range = 0.02 layer_norm_eps = 1e-05 use_cache = True max_position_embeddings = 1024 is_encoder_decoder = True encoder_layerdrop = 0.05 decoder_layerdrop = 0.05 activation_function = 'relu' dropout = 0.1 attention_dropout = 0.1 activation_dropout = 0.0 scale_embedding = True encoder_layers = 24 encoder_ffn_dim = 8192 encoder_attention_heads = 16 decoder_layers = 24 decoder_ffn_dim = 8192 decoder_attention_heads = 16 decoder_start_token_id = 3 max_new_tokens = 256 pad_token_id = 0 bos_token_id = 2 eos_token_id = 3 speech_encoder_layers = 24 speech_encoder_attention_heads = 16 speech_encoder_intermediate_size = 4096 speech_encoder_hidden_act = 'swish' speech_encoder_dropout = 0.0 add_adapter = True speech_encoder_layerdrop = 0.1 feature_projection_input_dim = 160 num_conv_pos_embeddings = 128 num_conv_pos_embedding_groups = 16 adaptor_kernel_size = 8 adaptor_stride = 8 adaptor_dropout = 0.1 num_adapter_layers = 1 position_embeddings_type = 'relative' rotary_embedding_base = 10000 max_source_positions = 4096 conv_depthwise_kernel_size = 31 t2u_bos_token_id = 0 t2u_pad_token_id = 1 t2u_eos_token_id = 2 t2u_decoder_start_token_id = 2 t2u_max_new_tokens = 1024 t2u_encoder_layers = 6 t2u_encoder_ffn_dim = 8192 t2u_encoder_attention_heads = 16 t2u_decoder_layers = 6 t2u_decoder_ffn_dim = 8192 t2u_decoder_attention_heads = 16 t2u_max_position_embeddings = 2048 sampling_rate = 16000 upsample_initial_channel = 512 upsample_rates = [5, 4, 4, 2, 2] upsample_kernel_sizes = [11, 8, 8, 4, 4] resblock_kernel_sizes = [3, 7, 11] resblock_dilation_sizes = [[1, 3, 5], [1, 3, 5], [1, 3, 5]] leaky_relu_slope = 0.1 unit_hifi_gan_vocab_size = 10000 unit_embed_dim = 1280 lang_embed_dim = 256 spkr_embed_dim = 256 vocoder_num_langs = 36 vocoder_num_spkrs = 200 variance_predictor_kernel_size = 3 var_pred_dropout = 0.5 vocoder_offset = 4 **kwargs )

参数

参数在子模型之间共享

  • hidden_size (int, 可选, 默认为 1024) — 架构中“中间”层的维度。
  • initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • layer_norm_eps (float, 可选, 默认为 1e-05) — 层归一化层使用的 epsilon 值。
  • use_cache (bool, 可选, 默认为 True) — 模型是否应返回最后的 key/values attentions（并非所有模型都使用）。
  • max_position_embeddings (int, 可选, 默认为 1024) — 此模型文本编码器和解码器可能使用的最大序列长度。 通常将其设置为较大的值以防万一（例如，512 或 1024 或 2048）。
  • is_encoder_decoder (bool, optional, defaults to True) — 模型是否用作编码器/解码器。
  • encoder_layerdrop (float, optional, defaults to 0.05) — 编码器的 LayerDrop 概率。 有关更多详细信息，请参见 [LayerDrop 论文](see https://arxiv.org/abs/1909.11556)。
  • decoder_layerdrop (float, optional, defaults to 0.05) — 解码器的 LayerDrop 概率。 有关更多详细信息，请参见 [LayerDrop 论文](see https://arxiv.org/abs/1909.11556)。
  • activation_function (str 或 function, optional, defaults to "relu") — 解码器和前馈层中的非线性激活函数（函数或字符串）。 如果是字符串，则支持 "gelu"、"relu"、"selu"、"swish" 和 "gelu_new"。
  • dropout (float, optional, defaults to 0.1) — 嵌入、编码器、解码器和池化器中所有全连接层的 dropout 概率。
  • attention_dropout (float, optional, defaults to 0.1) — 所有注意力层的 dropout 概率。
  • activation_dropout (float, optional, defaults to 0.0) — 模型中所有激活层的 dropout 概率。
  • scale_embedding (bool, optional, defaults to True) — 是否通过除以 sqrt(d_model) 来缩放嵌入。

文本编码器和文本解码器特定参数

  • encoder_layers (int, optional, defaults to 24) — Transformer 文本编码器中隐藏层的数量。
  • encoder_ffn_dim (int, optional, defaults to 8192) — Transformer 文本编码器中“中间”（即，前馈）层的维度。
  • encoder_attention_heads (int, optional, defaults to 16) — Transformer 文本编码器中每个注意力层的注意力头数。
  • decoder_layers (int, optional, defaults to 24) — Transformer 文本解码器中隐藏层的数量。
  • decoder_ffn_dim (int, optional, defaults to 8192) — Transformer 文本解码器中“中间”（即，前馈）层的维度。
  • decoder_attention_heads (int, optional, defaults to 16) — Transformer 文本解码器中每个注意力层的注意力头数。
  • decoder_start_token_id (int, optional, defaults to 3) — 如果编码器-解码器模型以不同于 bos 的 token 开始解码，则为该 token 的 id。 仅应用于文本解码器。
  • max_new_tokens (int, optional, defaults to 256) — 要生成的最大文本 token 数，忽略 prompt 中的 token 数。
  • pad_token_id (int, optional, defaults to 0) — padding 文本 token 的 id。 仅应用于文本解码器模型。
  • bos_token_id (int, optional, defaults to 2) — beginning-of-stream 文本 token 的 id。 仅应用于文本解码器模型。
  • eos_token_id (int, optional, defaults to 3) — end-of-stream 文本 token 的 id。 仅应用于文本解码器模型。

语音编码器特定参数

  • speech_encoder_layers (int, optional, defaults to 24) — Transformer 语音编码器中隐藏层的数量。
  • speech_encoder_attention_heads (int, optional, defaults to 16) — Transformer 语音编码器中每个注意力层的注意力头数。
  • speech_encoder_intermediate_size (int, optional, defaults to 4096) — Transformer 语音编码器中“中间”（即，前馈）层的维度。
  • speech_encoder_hidden_act (str 或 function, optional, defaults to "swish") — 语音编码器中的非线性激活函数（函数或字符串）。 如果是字符串，则支持 "gelu"、"relu"、"selu"、"swish" 和 "gelu_new"。
  • speech_encoder_dropout (float, optional, defaults to 0.0) — 语音编码器中所有层的 dropout 概率。
  • add_adapter (bool, optional, defaults to True) — 在语音编码器之上添加一个适配器层。
  • speech_encoder_layerdrop (float, optional, defaults to 0.1) — 语音编码器的 LayerDrop 概率。 有关更多详细信息，请参见 [LayerDrop 论文](see https://arxiv.org/abs/1909.11556)。
  • feature_projection_input_dim (int, optional, defaults to 160) — 语音编码器的输入特征投影的输入维度，即使用 SeamlessM4TFeatureExtractor 处理输入音频后的维度。
  • num_conv_pos_embeddings (int, optional, defaults to 128) — 卷积位置嵌入的数量。 定义语音编码器的 1D 卷积位置嵌入层的内核大小。
  • num_conv_pos_embedding_groups (int, optional, defaults to 16) — 语音编码器的 1D 卷积位置嵌入层的组数。
  • adaptor_kernel_size (int, optional, defaults to 8) — 适配器网络中卷积层的核大小。仅当 add_adapter is True 时相关。
  • adaptor_stride (int, optional, defaults to 8) — 适配器网络中卷积层的步幅。仅当 add_adapter is True 时相关。
  • adaptor_dropout (float, optional, defaults to 0.1) — 语音适配器中所有层的 dropout 概率。
  • num_adapter_layers (int, optional, defaults to 1) — 适配器网络中应使用的卷积层数。仅当 add_adapter is True 时相关。
  • position_embeddings_type (str, optional, defaults to "relative") — 可以指定为 relative 或 rotary，分别表示相对位置嵌入或旋转位置嵌入。如果留为 None，则不应用相对位置嵌入。仅应用于语音编码器。
  • rotary_embedding_base (int, optional, defaults to 10000) — 如果使用 "rotary" 位置嵌入，则定义嵌入基的大小。仅应用于语音编码器。
  • max_source_positions (int, optional, defaults to 4096) — 如果使用 "relative" 位置嵌入，则定义最大源输入位置。仅应用于语音编码器。
  • conv_depthwise_kernel_size (int, optional, defaults to 31) — Conformer 模块中卷积深度可分离 1D 层的核大小。仅应用于语音编码器。

Text-To-Unit (t2u) 模型特定参数

  • t2u_bos_token_id (int, optional, defaults to 0) — 流开始 (beginning-of-stream) 单元 token 的 id。仅应用于文本到单元 (text-to-unit) seq2seq 模型。
  • t2u_pad_token_id (int, optional, defaults to 1) — padding 单元 token 的 id。仅应用于文本到单元 (text-to-unit) seq2seq 模型。
  • t2u_eos_token_id (int, optional, defaults to 2) — 流结束 (end-of-stream) 单元 token 的 id。仅应用于文本到单元 (text-to-unit) seq2seq 模型。
  • t2u_decoder_start_token_id (int, optional, defaults to 2) — 如果 encoder-decoder 模型以不同于 bos 的 token 开始解码，则为该 token 的 id。仅应用于文本到单元 (text-to-unit) seq2seq 模型。
  • t2u_max_new_tokens (int, optional, defaults to 1024) — 要生成的单元 token 的最大数量，忽略 prompt 中的 token 数量。仅应用于文本到单元 (text-to-unit) seq2seq 模型。
  • t2u_encoder_layers (int, optional, defaults to 6) — Transformer 文本到单元 (text-to-unit) 编码器中的隐藏层数。
  • t2u_encoder_ffn_dim (int, optional, defaults to 8192) — Transformer 文本到单元 (text-to-unit) 编码器中“中间”（即，前馈）层的维度。
  • t2u_encoder_attention_heads (int, optional, defaults to 16) — Transformer 文本到单元 (text-to-unit) 编码器中每个注意力层的注意力头数。
  • t2u_decoder_layers (int, optional, defaults to 6) — Transformer 文本到单元 (text-to-unit) 解码器中的隐藏层数。
  • t2u_decoder_ffn_dim (int, optional, defaults to 8192) — Transformer 文本到单元 (text-to-unit) 解码器中“中间”（即，前馈）层的维度。
  • t2u_decoder_attention_heads (int, optional, defaults to 16) — Transformer 文本到单元 (text-to-unit) 解码器中每个注意力层的注意力头数。
  • t2u_max_position_embeddings (int, optional, defaults to 2048) — 此模型文本到单元 (text-to-unit) 组件可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如，512 或 1024 或 2048）。

    Hifi-Gan 声码器特定参数
  • sampling_rate (int, optional, defaults to 16000) — 输出音频将被生成的采样率，以赫兹 (Hz) 表示。
  • upsample_initial_channel (int, optional, defaults to 512) — 进入 hifi-gan 上采样网络的输入通道数。仅适用于声码器。
  • upsample_rates (Tuple[int] or List[int], optional, defaults to [5, 4, 4, 2, 2]) — 定义声码器上采样网络中每个 1D 卷积层步幅的整数元组。upsample_rates 的长度定义了卷积层的数量，并且必须与 upsample_kernel_sizes 的长度匹配。仅适用于声码器。
  • upsample_kernel_sizes (Tuple[int] or List[int], optional, defaults to [11, 8, 8, 4, 4]) — 定义声码器上采样网络中每个 1D 卷积层核大小的整数元组。upsample_kernel_sizes 的长度定义了卷积层的数量，并且必须与 upsample_rates 的长度匹配。仅适用于声码器。
  • resblock_kernel_sizes (Tuple[int] or List[int], optional, defaults to [3, 7, 11]) — 定义多感受野融合 (MRF) 模块中声码器 1D 卷积层核大小的整数元组。仅适用于声码器。
  • resblock_dilation_sizes (Tuple[Tuple[int]] or List[List[int]], optional, defaults to [[1, 3, 5], [1, 3, 5], [1, 3, 5]]) — 定义多感受野融合 (MRF) 模块中声码器扩张 1D 卷积层扩张率的嵌套整数元组。仅适用于声码器。
  • leaky_relu_slope (float, 可选, 默认为 0.1) — Vocoder 中 leaky ReLU 激活函数负斜率的角度。仅适用于 vocoder。
  • unit_hifi_gan_vocab_size (int, 可选, 默认为 10000) — SeamlessM4T vocoder 的词汇表大小。定义了在调用 ~SeamlessM4TModel、~SeamlessM4TForSpeechToSpeech 或 ~SeamlessM4TForTextToSpeech 的 vocoder 时，可以通过 inputs_ids 传递的不同单元 token 的数量。
  • unit_embed_dim (int, 可选, 默认为 1280) — 提供给 hifi-gan vocoder 的输入 id 的投影维度。仅适用于 vocoder。
  • lang_embed_dim (int, 可选, 默认为 256) — 提供给 hifi-gan vocoder 的目标语言的投影维度。仅适用于 vocoder。
  • spkr_embed_dim (int, 可选, 默认为 256) — 提供给 hifi-gan vocoder 的说话人 id 的投影维度。仅适用于 vocoder。
  • vocoder_num_langs (int, 可选, 默认为 36) — vocoder 支持的语言数量。可能与 t2u_num_langs 不同。
  • vocoder_num_spkrs (int, 可选, 默认为 200) — vocoder 支持的说话人数量。
  • variance_predictor_kernel_size (int, 可选, 默认为 3) — 时长预测器的内核大小。仅适用于 vocoder。
  • var_pred_dropout (float, 可选, 默认为 0.5) — 时长预测器的 dropout 概率。仅适用于 vocoder。
  • vocoder_offset (int, 可选, 默认为 4) — 将单元 token id 偏移此数字以考虑符号 token。仅适用于 vocoder。

这是用于存储 ~SeamlessM4TModel 配置的配置类。它用于根据指定的参数实例化 SeamlessM4T 模型，从而定义模型架构。使用默认值实例化配置将产生与 SeamlessM4T “facebook/hf-seamless-m4t-medium” 架构类似的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

>>> from transformers import SeamlessM4TModel, SeamlessM4TConfig

>>> # Initializing a SeamlessM4T "facebook/hf-seamless-m4t-medium" style configuration
>>> configuration = SeamlessM4TConfig()

>>> # Initializing a model from the "facebook/hf-seamless-m4t-medium" style configuration
>>> model = SeamlessM4TModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

SeamlessM4TTokenizer

class transformers.SeamlessM4TTokenizer

< >

( vocab_file bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' tokenizer_file = None src_lang = 'eng' tgt_lang = 'fra' sp_model_kwargs: typing.Optional[typing.Dict[str, typing.Any]] = None additional_special_tokens = None add_prefix_space = True **kwargs )

参数

  • vocab_file (str) — 词汇表文件的路径。
  • bos_token (str, 可选, 默认为 "<s>") — 预训练期间使用的序列开始 token。可以用作序列分类器 token。

    当使用特殊 token 构建序列时，这不是用于序列开始的 token。使用的 token 是 cls_token。
  • eos_token (str, 可选, 默认为 "</s>") — 序列结束 token。

    当使用特殊 token 构建序列时，这不是用于序列结束的 token。使用的 token 是 sep_token。
  • sep_token (str, 可选, 默认为 "</s>") — 分隔符 token，用于从多个序列构建序列时，例如用于序列分类的两个序列，或者用于问答的文本和问题。它也用作使用特殊 token 构建的序列的最后一个 token。
  • cls_token (str, 可选, 默认为 "<s>") — 分类器 token，用于进行序列分类（对整个序列而不是每个 token 进行分类）。当使用特殊 token 构建序列时，它是序列的第一个 token。
  • unk_token (str, 可选, 默认为 "<unk>") — 未知 token。词汇表中不存在的 token 无法转换为 ID，而是设置为此 token。
  • pad_token (str, 可选, 默认为 "<pad>") — 用于 padding 的 token，例如在批处理不同长度的序列时。
  • tokenizer_file (str, 可选) — 用于代替词汇表文件的 tokenizer 文件的路径。
  • src_lang (str, 可选, 默认为 "eng") — 用作翻译源语言的语言。
  • tgt_lang (str, 可选, 默认为 "fra") — 用作翻译目标语言的语言。
  • sp_model_kwargs (Dict[str, Any], 可选) — 传递给模型初始化的其他关键字参数。
  • additional_special_tokens (tuple 或 list of str 或 tokenizers.AddedToken, optional) — 附加的特殊 token 的元组或列表。 可用于指定 tokenizer 将支持的语言列表。
  • add_prefix_space (bool, optional, defaults to True) — 是否在输入文本前添加一个初始空格。 这允许像处理其他单词一样处理首单词。

构建 SeamlessM4T tokenizer。

改编自 RobertaTokenizer 和 XLNetTokenizer。 基于 SentencePiece。

对于源语言文档，tokenization 方法是 <language code> <tokens> <eos>，对于目标语言文档，tokenization 方法是 <eos> <language code> <tokens> <eos>。

示例

>>> from transformers import SeamlessM4TTokenizer

>>> tokenizer = SeamlessM4TTokenizer.from_pretrained(
...     "facebook/hf-seamless-m4t-medium", src_lang="eng", tgt_lang="fra"
... )
>>> example_english_phrase = " UN Chief Says There Is No Military Solution in Syria"
>>> expected_translation_french = "Le chef de l'ONU affirme qu'il n'y a pas de solution militaire en Syrie."
>>> inputs = tokenizer(example_english_phrase, text_target=expected_translation_french, return_tensors="pt")

__call__

< >

( text: typing.Union[str, typing.List[str], typing.List[typing.List[str]]] = None text_pair: typing.Union[str, typing.List[str], typing.List[typing.List[str]], NoneType] = None text_target: typing.Union[str, typing.List[str], typing.List[typing.List[str]]] = None text_pair_target: typing.Union[str, typing.List[str], typing.List[typing.List[str]], NoneType] = None padding: typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = True pad_to_multiple_of: typing.Optional[int] = 2 src_lang: typing.Optional[str] = None tgt_lang: typing.Optional[str] = None **kwargs )

参数

  • text (str, List[str], List[List[str]], optional) — 要编码的序列或序列批次。 每个序列可以是字符串或字符串列表（预tokenize的字符串）。 如果序列以字符串列表（预tokenize）的形式提供，则必须设置 is_split_into_words=True（以消除与序列批次的歧义）。
  • text_pair (str, List[str], List[List[str]], optional) — 要编码的序列或序列批次。 每个序列可以是字符串或字符串列表（预tokenize的字符串）。 如果序列以字符串列表（预tokenize）的形式提供，则必须设置 is_split_into_words=True（以消除与序列批次的歧义）。
  • text_target (str, List[str], List[List[str]], optional) — 要编码为目标文本的序列或序列批次。 每个序列可以是字符串或字符串列表（预tokenize的字符串）。 如果序列以字符串列表（预tokenize）的形式提供，则必须设置 is_split_into_words=True（以消除与序列批次的歧义）。
  • text_pair_target (str, List[str], List[List[str]], optional) — 要编码为目标文本的序列或序列批次。 每个序列可以是字符串或字符串列表（预tokenize的字符串）。 如果序列以字符串列表（预tokenize）的形式提供，则必须设置 is_split_into_words=True（以消除与序列批次的歧义）。
  • padding (bool, str 或 PaddingStrategy, optional, defaults to True) — 选择一种策略来填充返回的序列（根据模型的填充侧和填充索引）：

    • True 或 'longest'：填充到批次中最长的序列（如果仅提供单个序列，则不填充）。
    • 'max_length'：填充到使用参数 max_length 指定的最大长度，如果未提供该参数，则填充到模型可接受的最大输入长度。
    • False 或 'do_not_pad' (默认)：不填充（即，可以输出具有不同长度序列的批次）。
  • pad_to_multiple_of (int, optional) — 如果设置，则将序列填充为所提供值的倍数。

    这对于在计算能力 >= 7.5 (Volta) 的 NVIDIA 硬件上启用 Tensor Cores 的使用尤其有用。

  • src_lang (str, optional) — 代表源语言的字符串。 如果未指定，将使用上次指定的 src_lang（在初始化期间或调用此 tokenizer 时指定）。
  • tgt_lang (str, optional) — 代表目标语言的字符串。 如果未指定，将使用上次指定的 tgt_lang（在初始化期间或调用此 tokenizer 时指定）。
  • kwargs (optional) — 剩余的关键字参数字典，将传递给 PreTrainedTokenizer.call()。

build_inputs_with_special_tokens

< >

( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None ) → List[int]

参数

  • token_ids_0 (List[int]) — 将在其中添加特殊 token 的 ID 列表。
  • token_ids_1 (List[int], optional) — 序列对的可选的第二个 ID 列表。

返回

List[int]

带有适当特殊 token 的 输入 ID 列表。

通过连接并添加特殊 token，从序列或序列对构建用于序列分类任务的模型输入。 NLLB 序列具有以下格式，其中 X 表示序列

  • input_ids (用于编码器) X [eos, src_lang_code]
  • decoder_input_ids: (用于解码器) X [eos, tgt_lang_code]

从不使用 BOS。 序列对不是预期的用例，但它们将在没有分隔符的情况下处理。

get_special_tokens_mask

< >

( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None already_has_special_tokens: bool = False ) → List[int]

参数

  • token_ids_0 (List[int]) — ID 列表。
  • token_ids_1 (List[int], optional) — 序列对的可选的第二个 ID 列表。
  • already_has_special_tokens (bool, optional, defaults to False) — 指示 token 列表是否已使用模型的特殊 token 格式化。

返回

List[int]

范围在 [0, 1] 内的整数列表：1 表示特殊 token，0 表示序列 token。

从没有添加特殊 token 的 token 列表中检索序列 ID。 当使用 tokenizer prepare_for_model 方法添加特殊 token 时，将调用此方法。

create_token_type_ids_from_sequences

< >

( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None ) → List[int]

参数

  • token_ids_0 (List[int]) — ID 列表。
  • token_ids_1 (List[int], optional) — 序列对的可选第二个ID列表。

返回

List[int]

零列表。

从传递的两个序列创建掩码，用于序列对分类任务。 nllb 不使用 token type ids，因此返回零列表。

save_vocabulary

< >

( save_directory: str filename_prefix: typing.Optional[str] = None )

SeamlessM4TTokenizerFast

class transformers.SeamlessM4TTokenizerFast

< >

( vocab_file = None tokenizer_file = None bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' src_lang = 'eng' tgt_lang = 'fra' additional_special_tokens = None **kwargs )

参数

  • vocab_file (str, optional) — 词汇表文件的路径。
  • tokenizer_file (str, optional) — 代替词汇表文件的 tokenizer 文件的路径。
  • bos_token (str, optional, defaults to "<s>") — 序列开始标记，在预训练期间使用。可以用作序列分类器标记。

    当使用特殊标记构建序列时，这不是用于序列开始的标记。使用的标记是 cls_token。
  • eos_token (str, optional, defaults to "</s>") — 序列结束标记。

    当使用特殊标记构建序列时，这不是用于序列结束的标记。使用的标记是 sep_token。
  • sep_token (str, optional, defaults to "</s>") — 分隔符标记，用于从多个序列构建序列时，例如用于序列分类的两个序列，或用于问答的文本和问题。它也用作使用特殊标记构建的序列的最后一个标记。
  • cls_token (str, optional, defaults to "<s>") — 分类器标记，用于进行序列分类（对整个序列而不是按 token 进行分类）。当使用特殊标记构建时，它是序列的第一个标记。
  • unk_token (str, optional, defaults to "<unk>") — 未知标记。词汇表中没有的标记无法转换为 ID，而是设置为此标记。
  • pad_token (str, optional, defaults to "<pad>") — 用于填充的标记，例如在批处理不同长度的序列时。
  • src_lang (str, optional, defaults to "eng") — 用作翻译源语言的语言。
  • tgt_lang (str, optional, defaults to "fra") — 用作翻译目标语言的语言。
  • additional_special_tokens (tuple or list of str or tokenizers.AddedToken, optional) — 附加特殊标记的元组或列表。

构建一个“快速” SeamlessM4T tokenizer（由 HuggingFace 的 tokenizers 库支持）。基于 BPE。

此 tokenizer 继承自 PreTrainedTokenizerFast，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。

对于源语言文档，tokenization 方法是 <language code> <tokens> <eos>，对于目标语言文档，tokenization 方法是 <eos> <language code> <tokens> <eos>。

示例

>>> from transformers import SeamlessM4TTokenizerFast

>>> tokenizer = SeamlessM4TTokenizerFast.from_pretrained(
...     "facebook/hf-seamless-m4t-medium", src_lang="eng", tgt_lang="fra"
... )
>>> example_english_phrase = " UN Chief Says There Is No Military Solution in Syria"
>>> expected_translation_french = "Le chef de l'ONU affirme qu'il n'y a pas de solution militaire en Syrie."
>>> inputs = tokenizer(example_english_phrase, text_target=expected_translation_french, return_tensors="pt")

__call__

< >

( text: typing.Union[str, typing.List[str], typing.List[typing.List[str]]] = None text_pair: typing.Union[str, typing.List[str], typing.List[typing.List[str]], NoneType] = None text_target: typing.Union[str, typing.List[str], typing.List[typing.List[str]]] = None text_pair_target: typing.Union[str, typing.List[str], typing.List[typing.List[str]], NoneType] = None padding: typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = True pad_to_multiple_of: typing.Optional[int] = 2 src_lang: typing.Optional[str] = None tgt_lang: typing.Optional[str] = None **kwargs )

参数

  • text (str, List[str], List[List[str]], optional) — 要编码的序列或序列批次。每个序列可以是字符串或字符串列表（预分词字符串）。如果序列以字符串列表（预分词）形式提供，则必须设置 is_split_into_words=True （以消除与序列批次的歧义）。
  • text_pair (str, List[str], List[List[str]], optional) — 要编码的序列或序列批次。每个序列可以是字符串或字符串列表（预分词字符串）。如果序列以字符串列表（预分词）形式提供，则必须设置 is_split_into_words=True （以消除与序列批次的歧义）。
  • text_target (str, List[str], List[List[str]], optional) — 要编码为目标文本的序列或序列批次。每个序列可以是字符串或字符串列表（预分词字符串）。如果序列以字符串列表（预分词）形式提供，则必须设置 is_split_into_words=True （以消除与序列批次的歧义）。
  • text_pair_target (str, List[str], List[List[str]], optional) — 要编码为目标文本的序列或序列批次。每个序列可以是字符串或字符串列表（预分词字符串）。如果序列以字符串列表（预分词）形式提供，则必须设置 is_split_into_words=True （以消除与序列批次的歧义）。
  • padding (bool, str or PaddingStrategy, optional, defaults to True) — 选择一种策略来填充返回的序列（根据模型的填充侧和填充索引），选项包括：

    • True 或 'longest'：填充到批次中最长的序列（如果仅提供单个序列，则不填充）。
    • 'max_length'：填充到参数 max_length 指定的最大长度，或者如果未提供该参数，则填充到模型可接受的最大输入长度。
    • False 或 'do_not_pad' (默认)：不填充（即，可以输出具有不同长度序列的批次）。
  • pad_to_multiple_of (int, optional) — 如果设置，将序列填充为提供值的倍数。

    这对于在计算能力 >= 7.5 (Volta) 的 NVIDIA 硬件上启用 Tensor Core 的使用尤其有用。

  • src_lang (str, optional) — 代表源语言的字符串。如果未指定，将使用上次指定的 src_lang（在初始化期间或调用此 tokenizer 时）。
  • tgt_lang (str, 可选) — 代表目标语言的字符串。如果未指定，将使用上次指定的 tgt_lang (在初始化期间或调用此分词器时)。
  • kwargs (可选) — 将传递给 PreTrainedTokenizerFast.call() 的剩余关键字参数字典。

SeamlessM4TFeatureExtractor

class transformers.SeamlessM4TFeatureExtractor

< >

( feature_size = 80 sampling_rate = 16000 num_mel_bins = 80 padding_value = 0.0 stride = 2 **kwargs )

参数

  • feature_size (int, 可选, 默认为 80) — 提取特征的特征维度。
  • sampling_rate (int, 可选, 默认为 16000) — 音频文件应被数字化的采样率，以赫兹 (Hz) 表示。
  • num_mel_bins (int, 可选, 默认为 80) — Mel 频率箱的数量。
  • padding_value (float, 可选, 默认为 0.0) — 用于填充 padding 向量的值。
  • stride (int, 可选, 默认为 2) — 用于将音频从形状 (batch_size,num_frames,num_mel_bins) 重塑为 (batch_size,num_frames//stride,num_mel_bins*stride) 的步幅。

构建 SeamlessM4T 特征提取器。

此特征提取器继承自 SequenceFeatureExtractor，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。

此类从原始语音中提取 mel 滤波器组特征。

__call__

< >

( raw_speech: typing.Union[numpy.ndarray, typing.List[float], typing.List[numpy.ndarray], typing.List[typing.List[float]]] padding: typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = True pad_to_multiple_of: typing.Optional[int] = 2 max_length: typing.Optional[int] = None truncation: bool = False return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None sampling_rate: typing.Optional[int] = None return_attention_mask: typing.Optional[bool] = None do_normalize_per_mel_bins: typing.Optional[bool] = True **kwargs )

参数

  • raw_speech (np.ndarray, torch.Tensor, List[float], List[np.ndarray], List[torch.Tensor], —
  • List[List[float]], List[List[List[float]]]) — 要填充的序列或批量序列。每个序列可以是 numpy 数组、torch 张量、浮点值列表、numpy 数组列表、torch 张量列表、浮点值列表的列表或浮点值列表的列表的列表。如果 raw_speech 是一维 np.ndarray、torch.Tensor 或 List[float]，则 raw_speech 被视为单声道、单样本声音。在所有其他情况下，raw_speech 的第一个维度，无论是来自 np.ndarray、torch.Tensor 还是 List[...]，都对应于批次中的样本数，而声道数（即单声道或立体声特性）则从其他维度导出（1D -> 单声道波形批次；2D-> 立体声波形批次）。
  • padding (bool, str 或 PaddingStrategy, 可选, 默认为 True) — 选择一种策略来填充返回的序列（根据模型的填充侧和填充索引），选项包括：

    • True 或 'longest'：填充到批次中最长的序列（如果仅提供单个序列，则不进行填充）。
    • 'max_length'：填充到使用参数 max_length 指定的最大长度，或者如果未提供该参数，则填充到模型可接受的最大输入长度。
    • False 或 'do_not_pad' (默认)：不填充（即，可以输出具有不同长度序列的批次）。
  • pad_to_multiple_of (int, 可选, 默认为 2) — 如果设置，则将序列填充为提供值的倍数。

    这对于在计算能力 >= 7.5 (Volta) 的 NVIDIA 硬件上或在受益于序列长度为 128 的倍数的 TPU 上启用 Tensor Cores 的使用尤其有用。

  • max_length (int, 可选) — 返回列表的最大长度和可选的填充长度（见上文）。
  • truncation (bool) — 激活截断以将长于 max_length 的输入序列截断为 max_length。
  • return_attention_mask (bool, 可选) — 是否返回 attention mask。如果保留为默认值，将根据特定 feature_extractor 的默认值返回 attention mask。

    什么是 attention mask？

    对于 SeamlessM4T 模型，应始终为批量推理传递 attention_mask，以避免细微的错误。
  • return_tensors (str 或 TensorType, 可选) — 如果设置，将返回张量而不是 python 整数列表。可接受的值为：

    • 'tf'：返回 TensorFlow tf.constant 对象。
    • 'pt'：返回 PyTorch torch.Tensor 对象。
    • 'np'：返回 Numpy np.ndarray 对象。
  • sampling_rate (int, 可选) — raw_speech 输入被采样的采样率。 强烈建议在前向调用时传递 sampling_rate 以防止出现静默错误。
  • do_normalize_per_mel_bins (bool, 可选, 默认为 True) — 是否对每个 mel 通道的输入执行零均值单位方差归一化。
  • kwargs (可选) — 将传递给分词器或特征提取器的剩余关键字参数字典。

featurize 和准备模型的一个或多个序列的主要方法。

SeamlessM4TProcessor

class transformers.SeamlessM4TProcessor

< >

( feature_extractor tokenizer )

参数

构建一个 SeamlessM4T 处理器，它将 SeamlessM4T 特征提取器和 SeamlessM4T 分词器封装到一个处理器中。

SeamlessM4TProcessor 提供了 SeamlessM4TFeatureExtractor 和 SeamlessM4TTokenizerFast 的所有功能。 有关更多信息，请参阅 call() 和 decode()。

__call__

< >

( text = None audios = None src_lang = None tgt_lang = None **kwargs ) → BatchEncoding

参数

  • text (str, List[str], List[List[str]]) — 要编码的序列或序列批次。每个序列可以是字符串或字符串列表（预分词字符串）。如果序列以字符串列表（预分词）形式提供，则必须设置 is_split_into_words=True（以消除与序列批次的歧义）。
  • audios (np.ndarray, torch.Tensor, List[np.ndarray], List[torch.Tensor]) — 要准备的音频或音频批次。每个音频可以是 NumPy 数组或 PyTorch 张量。在 NumPy 数组/PyTorch 张量的情况下，每个音频应具有形状 (C, T)，其中 C 是通道数，T 是音频的样本长度。
  • src_lang (str, optional) — 输入文本/音频的语言代码。如果未指定，将使用最后指定的 src_lang。
  • tgt_lang (str, optional) — 目标语言的代码。如果未指定，将使用最后指定的 tgt_lang。
  • kwargs (optional) — 将传递给特征提取器和/或分词器的剩余关键字参数字典。

返回

BatchEncoding

一个 BatchEncoding，包含以下字段

  • input_ids — 要馈送到模型的 token id 列表。当 text 不是 None 时返回。
  • attention_mask — 指定模型应关注哪些 token 的索引列表（当 return_attention_mask=True 或如果 “attention_mask” 在 self.model_input_names 中，且 text 不是 None 时）。
  • input_features — 要馈送到模型的音频输入特征。当 audios 不是 None 时返回。

准备模型的一个或多个序列和音频的主要方法。如果 text 不是 None 以编码文本，此方法将 text 和 kwargs 参数转发到 SeamlessM4TTokenizerFast 的 call()。要准备音频，如果 audios 不是 None，此方法将 audios 和 kwrags 参数转发到 SeamlessM4TFeatureExtractor 的 call()。有关更多信息，请参阅上述两种方法的文档字符串。

SeamlessM4TCodeHifiGan

class transformers.SeamlessM4TCodeHifiGan

< >

( config )

参数

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

如本存储库中所述的 Code HiFi-GAN 声码器。此模型继承自 PreTrainedModel。查看超类文档以获取库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。

forward

< >

( input_ids: LongTensor spkr_id: Tensor lang_id: Tensor )

参数

  • input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。

    可以使用 SeamlessM4TTextToUnitForConditionalGeneration 获取索引。什么是输入 ID？

  • spkr_id (int, optional) — 用于语音合成的说话人 ID。必须低于 config.vocoder_num_spkrs。
  • tgt_lang (str, optional) — 用作翻译目标语言的语言 ID。

SeamlessM4THifiGan

class transformers.SeamlessM4THifiGan

< >

( config: SeamlessM4TConfig )

forward

< >

( input_embeds: FloatTensor ) → torch.FloatTensor

参数

  • spectrogram (torch.FloatTensor) — 包含 log-mel 频谱图的张量。可以是批处理的，形状为 (batch_size, sequence_length, model_in_dim)，也可以是非批处理的，形状为 (sequence_length, model_in_dim)。请注意，model_in_dim 是 config.unit_embed_dim、config.lang_embed_dim 和 config.spkr_embed_dim 的总和。

返回

torch.FloatTensor

包含语音波形的张量。如果输入频谱图是批处理的，则形状为 (batch_size, num_frames,)。如果是非批处理的，则形状为 (num_frames,)。

将 log-mel 频谱图转换为语音波形。传递一批 log-mel 频谱图将返回一批语音波形。传递单个、非批处理的 log-mel 频谱图将返回单个、非批处理的语音波形。

SeamlessM4TTextToUnitModel

class transformers.SeamlessM4TTextToUnitModel

< >

( config: SeamlessM4TConfig embed_tokens_decoder: typing.Optional[torch.nn.modules.sparse.Embedding] = None )

参数

  • config (~SeamlessM4TConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
  • embed_tokens_decoder (nn.Embedding, optional) — 解码器的输入嵌入。

Transformer 裸文本到单元编码器-解码器。编码器是一个没有嵌入的 SeamlessM4TEncoder，解码器是一个 SeamlessM4TDecoder。此模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。

SeamlessM4TTextToUnitForConditionalGeneration

class transformers.SeamlessM4TTextToUnitForConditionalGeneration

< >

( config: SeamlessM4TConfig embed_tokens_decoder: typing.Optional[torch.nn.modules.sparse.Embedding] = None )

参数

  • config (~SeamlessM4TConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法来加载模型权重。
  • embed_tokens_decoder (nn.Embedding, optional) — 解码器的输入嵌入。

带有语言模型头的 Transformer 文本到单元编码器-解码器。基础编码器-解码器模型是 SeamlessM4TTextToUnit。此模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并查阅 PyTorch 文档以了解与通用用法和行为相关的所有事项。

forward

< >

( input_ids: LongTensor = None attention_mask: typing.Optional[torch.Tensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.LongTensor] = None encoder_outputs: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None )

参数

  • input_ids (形状为 (batch_size, sequence_length) 的 torch.LongTensor, optional) — 词汇表中输入序列 tokens 的索引。

    可以使用 SeamlessM4TTokenizer 或 SeamlessM4TProcessor 获取索引。 有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是 input IDs？

  • attention_mask (形状为 (batch_size, sequence_length) 的 torch.FloatTensor, optional) — 用于避免在 padding token 索引上执行 attention 的 Mask。 Mask 值在 [0, 1] 中选择：

    • 1 表示 未被 mask 的 tokens，
    • 0 表示 已被 mask 的 tokens。

    什么是 attention masks？

  • decoder_input_ids (形状为 (batch_size, target_sequence_length) 的 torch.LongTensor, optional) — 词汇表中解码器输入序列 tokens 的索引。

    可以使用 AutoTokenizer 获取索引。 有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是解码器输入 IDs？

    Bart 使用 eos_token_id 作为 decoder_input_ids 生成的起始 token。 如果使用 past_key_values，则可以选择仅输入最后的 decoder_input_ids （请参阅 past_key_values）。

    对于翻译和摘要训练，应提供 decoder_input_ids。 如果未提供 decoder_input_ids，则模型将通过将 input_ids 向右移动来创建此张量，以进行遵循论文的去噪预训练。

  • decoder_attention_mask (形状为 (batch_size, target_sequence_length) 的 torch.LongTensor, optional) — 默认行为：生成一个忽略 decoder_input_ids 中 pad tokens 的张量。默认情况下，还将使用因果 mask。

    如果要更改 padding 行为，则应阅读 modeling_bart._prepare_decoder_attention_mask 并根据您的需求进行修改。 有关默认策略的更多信息，请参见 论文 中的图 1。

  • encoder_outputs (tuple(tuple(torch.FloatTensor), optional) — Tuple 由 (last_hidden_state, optional: hidden_states, optional: attentions) 组成，其中 last_hidden_state 的形状为 (batch_size, sequence_length, hidden_size), optional)，是编码器最后一层输出的 hidden-states 序列。在解码器的交叉注意力中使用。
  • past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递 use_cache=True 或 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(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) 的附加张量。

    包含预先计算的 hidden-states （自注意力块和交叉注意力块中的键和值），这些状态可用于（请参阅 past_key_values 输入）加速顺序解码。

    如果使用 past_key_values，则用户可以选择仅输入最后的 decoder_input_ids （那些没有将其过去的键值状态提供给此模型的）形状为 (batch_size, 1)，而不是所有形状为 (batch_size, sequence_length) 的 decoder_input_ids。

  • inputs_embeds (形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor, optional) — （可选）您可以选择直接传递嵌入表示，而不是传递 input_ids。 如果您希望比模型的内部嵌入查找矩阵更精确地控制如何将 input_ids 索引转换为关联的向量，这将非常有用。
  • decoder_inputs_embeds (形状为 (batch_size, target_sequence_length, hidden_size) 的 torch.FloatTensor, optional) — （可选）您可以选择直接传递嵌入表示，而不是传递 decoder_input_ids。 如果使用 past_key_values，则可以选择仅输入最后的 decoder_inputs_embeds （请参阅 past_key_values）。 如果您希望比模型的内部嵌入查找矩阵更精确地控制如何将 decoder_input_ids 索引转换为关联的向量，这将非常有用。

    如果 decoder_input_ids 和 decoder_inputs_embeds 均未设置，则 decoder_inputs_embeds 取 inputs_embeds 的值。

  • labels (形状为 (batch_size, sequence_length) 的 torch.LongTensor, optional) — 用于计算 masked language modeling loss 的标签。 索引应在 [-100, 0, ..., config.vocab_size] 中（请参阅 input_ids 文档字符串）。索引设置为 -100 的 tokens 将被忽略（masked），loss 仅针对标签在 [0, ..., config.vocab_size] 中的 tokens 计算。
  • use_cache (bool, optional) — 如果设置为 True，则返回 past_key_values 键值状态，并可用于加速解码（请参阅 past_key_values）。
  • output_attentions (bool, optional) — 是否返回所有 attention 层的 attentions 张量。 有关更多详细信息，请参见返回的张量下的 attentions。
  • output_hidden_states (bool, optional) — 是否返回所有层的 hidden states。 有关更多详细信息，请参见返回的张量下的 hidden_states。
  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

SeamlessM4TTextToUnitForConditionalGeneration 的 forward 方法，覆盖了 __call__ 特殊方法。

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

< > Update on GitHub

←Pop2Piano SeamlessM4T-v2→