Transformers 4.37 中文文档（七十六）（3）

Transformers 4.37 中文文档（七十六）（2）https://developer.aliyun.com/article/1564177

Pop2Piano

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/pop2piano

概述

Pop2Piano 模型由 Jongho Choi 和 Kyogu Lee 在Pop2Piano：基于流行音频的钢琴翻奏生成中提出。

流行音乐的钢琴翻奏广受欢迎，但从音乐中生成它们并不是一项简单的任务。这需要对弹奏钢琴有很高的专业知识，同时还要了解歌曲的不同特征和旋律。通过  Pop2Piano，您可以直接从歌曲的音频波形生成翻奏。这是第一个直接从流行音频生成钢琴翻奏的模型，而无需旋律和和弦提取模块。

Pop2Piano 是基于T5的编码器-解码器  Transformer 模型。输入音频被转换为其波形并传递给编码器，编码器将其转换为潜在表示。解码器使用这些潜在表示以自回归方式生成令牌  id。每个令牌 id 对应于四种不同的令牌类型之一：时间、速度、音符和“特殊”。然后将令牌 id 解码为其等效的 MIDI 文件。

论文摘要如下：

许多人喜欢流行音乐的钢琴翻奏。然而，自动生成流行音乐的钢琴翻奏的任务仍然未被充分研究。部分原因是缺乏同步的{流行音乐，钢琴翻奏}数据对，这使得应用最新的数据密集型基于深度学习的方法具有挑战性。为了利用数据驱动方法的力量，我们使用自动化流水线制作了大量配对和同步的{流行音乐，钢琴翻奏}数据。在本文中，我们提出了  Pop2Piano，这是一个 Transformer  网络，可以根据流行音乐的波形生成钢琴翻奏。据我们所知，这是第一个可以直接从流行音频生成钢琴翻奏的模型，而无需使用旋律和和弦提取模块。我们展示了使用我们的数据集训练的  Pop2Piano 能够生成合理的钢琴翻奏。

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

使用提示

• 要使用 Pop2Piano，您需要安装🤗 Transformers 库，以及以下第三方模块：

pip install pretty-midi==0.2.9 essentia==2.1b6.dev1034 librosa scipy

请注意，您可能需要在安装后重新启动运行时。

• Pop2Piano 是一种基于编码器-解码器的模型，类似于 T5。
  
• Pop2Piano 可用于为给定音频序列生成 midi 音频文件。
  
• 在Pop2PianoForConditionalGeneration.generate()中选择不同的作曲家可以产生不同结果的多样性。
  
• 在加载音频文件时将采样率设置为 44.1 kHz 可以获得良好的性能。
  
• 尽管 Pop2Piano 主要是在韩国流行音乐上进行训练的，但它在其他西方流行音乐或嘻哈歌曲上也表现不错。
  

示例

• 使用 HuggingFace 数据集的示例：

>>> from datasets import load_dataset
>>> from transformers import Pop2PianoForConditionalGeneration, Pop2PianoProcessor
>>> model = Pop2PianoForConditionalGeneration.from_pretrained("sweetcocoa/pop2piano")
>>> processor = Pop2PianoProcessor.from_pretrained("sweetcocoa/pop2piano")
>>> ds = load_dataset("sweetcocoa/pop2piano_ci", split="test")
>>> inputs = processor(
...     audio=ds["audio"][0]["array"], sampling_rate=ds["audio"][0]["sampling_rate"], return_tensors="pt"
... )
>>> model_output = model.generate(input_features=inputs["input_features"], composer="composer1")
>>> tokenizer_output = processor.batch_decode(
...     token_ids=model_output, feature_extractor_output=inputs
... )["pretty_midi_objects"][0]
>>> tokenizer_output.write("./Outputs/midi_output.mid")

• 使用您自己的音频文件示例：

>>> import librosa
>>> from transformers import Pop2PianoForConditionalGeneration, Pop2PianoProcessor
>>> audio, sr = librosa.load("<your_audio_file_here>", sr=44100)  # feel free to change the sr to a suitable value.
>>> model = Pop2PianoForConditionalGeneration.from_pretrained("sweetcocoa/pop2piano")
>>> processor = Pop2PianoProcessor.from_pretrained("sweetcocoa/pop2piano")
>>> inputs = processor(audio=audio, sampling_rate=sr, return_tensors="pt")
>>> model_output = model.generate(input_features=inputs["input_features"], composer="composer1")
>>> tokenizer_output = processor.batch_decode(
...     token_ids=model_output, feature_extractor_output=inputs
... )["pretty_midi_objects"][0]
>>> tokenizer_output.write("./Outputs/midi_output.mid")

• 批量处理多个音频文件的示例：

>>> import librosa
>>> from transformers import Pop2PianoForConditionalGeneration, Pop2PianoProcessor
>>> # feel free to change the sr to a suitable value.
>>> audio1, sr1 = librosa.load("<your_first_audio_file_here>", sr=44100)  
>>> audio2, sr2 = librosa.load("<your_second_audio_file_here>", sr=44100)
>>> model = Pop2PianoForConditionalGeneration.from_pretrained("sweetcocoa/pop2piano")
>>> processor = Pop2PianoProcessor.from_pretrained("sweetcocoa/pop2piano")
>>> inputs = processor(audio=[audio1, audio2], sampling_rate=[sr1, sr2], return_attention_mask=True, return_tensors="pt")
>>> # Since we now generating in batch(2 audios) we must pass the attention_mask
>>> model_output = model.generate(
...     input_features=inputs["input_features"],
...     attention_mask=inputs["attention_mask"],
...     composer="composer1",
... )
>>> tokenizer_output = processor.batch_decode(
...     token_ids=model_output, feature_extractor_output=inputs
... )["pretty_midi_objects"]
>>> # Since we now have 2 generated MIDI files
>>> tokenizer_output[0].write("./Outputs/midi_output1.mid")
>>> tokenizer_output[1].write("./Outputs/midi_output2.mid")

• 批量处理多个音频文件的示例（使用Pop2PianoFeatureExtractor和Pop2PianoTokenizer）：

>>> import librosa
>>> from transformers import Pop2PianoForConditionalGeneration, Pop2PianoFeatureExtractor, Pop2PianoTokenizer
>>> # feel free to change the sr to a suitable value.
>>> audio1, sr1 = librosa.load("<your_first_audio_file_here>", sr=44100)  
>>> audio2, sr2 = librosa.load("<your_second_audio_file_here>", sr=44100)
>>> model = Pop2PianoForConditionalGeneration.from_pretrained("sweetcocoa/pop2piano")
>>> feature_extractor = Pop2PianoFeatureExtractor.from_pretrained("sweetcocoa/pop2piano")
>>> tokenizer = Pop2PianoTokenizer.from_pretrained("sweetcocoa/pop2piano")
>>> inputs = feature_extractor(
...     audio=[audio1, audio2], 
...     sampling_rate=[sr1, sr2], 
...     return_attention_mask=True, 
...     return_tensors="pt",
... )
>>> # Since we now generating in batch(2 audios) we must pass the attention_mask
>>> model_output = model.generate(
...     input_features=inputs["input_features"],
...     attention_mask=inputs["attention_mask"],
...     composer="composer1",
... )
>>> tokenizer_output = tokenizer.batch_decode(
...     token_ids=model_output, feature_extractor_output=inputs
... )["pretty_midi_objects"]
>>> # Since we now have 2 generated MIDI files
>>> tokenizer_output[0].write("./Outputs/midi_output1.mid")
>>> tokenizer_output[1].write("./Outputs/midi_output2.mid")

Pop2PianoConfig

class transformers.Pop2PianoConfig

<来源>

( vocab_size = 2400 composer_vocab_size = 21 d_model = 512 d_kv = 64 d_ff = 2048 num_layers = 6 num_decoder_layers = None num_heads = 8 relative_attention_num_buckets = 32 relative_attention_max_distance = 128 dropout_rate = 0.1 layer_norm_epsilon = 1e-06 initializer_factor = 1.0 feed_forward_proj = 'gated-gelu' is_encoder_decoder = True use_cache = True pad_token_id = 0 eos_token_id = 1 dense_act_fn = 'relu' **kwargs )

参数

• vocab_size（int，可选，默认为 2400）- Pop2PianoForConditionalGeneration模型的词汇量。定义了在调用 Pop2PianoForConditionalGeneration 时可以表示的不同令牌数量。
  
• composer_vocab_size（int，可选，默认为 21）- 表示作曲家的数量。
  
• d_model (int, 可选, 默认为 512) — 编码器层和池化层的大小。
  
• d_kv (int, 可选, 默认为 64) — 每个注意力头中键、查询、值投影的大小。投影层的inner_dim将定义为num_heads * d_kv。
  
• d_ff (int, 可选, 默认为 2048) — 每个Pop2PianoBlock中间级前馈层的大小。
  
• num_layers (int, 可选, 默认为 6) — Transformer 编码器中的隐藏层数量。
  
• num_decoder_layers (int, 可选) — Transformer 解码器中的隐藏层数量。如果未设置，将使用与num_layers相同的值。
  
• num_heads (int, 可选, 默认为 8) — Transformer 编码器中每个注意力层的注意力头数量。
  
• relative_attention_num_buckets (int, 可选, 默认为 32) — 每个注意力层使用的桶数量。
  
• relative_attention_max_distance (int, 可选, 默认为 128) — 用于桶分离的较长序列的最大距离。
  
• dropout_rate (float, 可选, 默认为 0.1) — 所有 dropout 层的比率。
  
• layer_norm_epsilon (float, 可选, 默认为 1e-6) — 层归一化层使用的 epsilon。
  
• initializer_factor (float, 可选, 默认为 1.0) — 初始化所有权重矩阵的因子（应保持为 1.0，用于内部初始化测试）。
  
• feed_forward_proj (string, 可选, 默认为"gated-gelu") — 要使用的前馈层类型。应为"relu"或"gated-gelu"之一。
  
• use_cache (bool, 可选, 默认为True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。
  
• dense_act_fn (string, 可选, 默认为"relu") — 用于Pop2PianoDenseActDense和Pop2PianoDenseGatedActDense中的激活函数类型。
  

这是用于存储 Pop2PianoForConditionalGeneration 配置的配置类。根据指定的参数实例化一个  Pop2PianoForConditionalGeneration 模型，定义模型架构。使用默认值实例化配置将产生类似于 Pop2Piano sweetcocoa/pop2piano架构的配置。

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

Pop2PianoFeatureExtractor

class transformers.Pop2PianoFeatureExtractor

< source >

( *args **kwargs )

__call__

( *args **kwargs )

将自身作为函数调用。

Pop2PianoForConditionalGeneration

class transformers.Pop2PianoForConditionalGeneration

< source >

( config: Pop2PianoConfig )

参数

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

Pop2Piano 模型在顶部带有语言建模头。该模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

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

前向

<来源>

( input_ids: Optional = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None input_features: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqLMOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）—  词汇表中输入序列标记的索引。Pop2Piano 是一个带有相对位置嵌入的模型，因此您应该能够在右侧和左侧填充输入。可以使用  AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()以获取详细信息。什么是输入 ID？要了解有关如何为预训练准备input_ids的更多信息，请查看 Pop2Piano 训练。
  
• attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]之间：

• 对于未屏蔽的标记，
  
• 0 表示标记为屏蔽的标记。什么是注意力掩码？
  

• decoder_input_ids（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）— 词汇表中解码器输入序列标记的索引。可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()以获取详细信息。什么是解码器输入 ID？Pop2Piano 使用pad_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，则只需选择最后的decoder_input_ids输入（请参阅past_key_values）。要了解如何准备
  
• decoder_attention_mask（形状为(batch_size, target_sequence_length)的torch.BoolTensor，可选）— 默认行为：生成一个张量，忽略decoder_input_ids中的填充标记。默认情况下还将使用因果掩码。
  
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）— 用于使编码器中自注意力模块的选定头部失效的掩码。选择的掩码值在[0, 1]之间：

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

• decoder_head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）— 用于使解码器中自注意力模块的选定头部失效的掩码。选择的掩码值在[0, 1]之间：

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

• cross_attn_head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.Tensor，可选）— 用于使解码器中交叉注意力模块的选定头部失效的掩码。选择的掩码值在[0, 1]之间：

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

• encoder_outputs (tuple(tuple(torch.FloatTensor), optional) — 元组包括（last_hidden_state，可选：hidden_states，可选：attentions）last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
  
• past_key_values (tuple(tuple(torch.FloatTensor))，长度为config.n_layers，每个元组包含形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)的 4 个张量） — 包含注意力块的预计算的键和值隐藏状态。可用于加速解码。如果使用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)，optional) — 可选地，可以直接传递嵌入表示，而不是传递input_ids。如果要更好地控制如何将input_ids索引转换为相关向量，这很有用，而不是使用模型的内部嵌入查找矩阵。
  
• input_features (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 执行与inputs_embeds相同的任务。如果不存在inputs_embeds但存在input_features，则将input_features视为inputs_embeds。
  
• decoder_inputs_embeds (torch.FloatTensor，形状为(batch_size, target_sequence_length, hidden_size)，optional) — 可选地，可以直接传递嵌入表示，而不是传递decoder_input_ids。如果使用past_key_values，可以选择仅输入最后的decoder_inputs_embeds（参见past_key_values）。如果decoder_input_ids和decoder_inputs_embeds都未设置，则decoder_inputs_embeds取inputs_embeds的值。
  
• use_cache (bool, optional) — 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。
  
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量下的attentions。
  
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的hidden_states。
  
• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通元组。
  
• labels (torch.LongTensor，形状为(batch_size,)，optional) — 用于计算序列分类/回归损失的标签。索引应在[-100, 0, ..., config.vocab_size - 1]内。所有标签设置为-100的将被忽略（掩码），损失仅计算标签在[0, ..., config.vocab_size]内的。
  

返回

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

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

• loss (torch.FloatTensor，形状为(1,)，optional，在提供labels时返回) — 语言建模损失。
  
• logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
  
• past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递use_cache=True或config.use_cache=True时返回 — 长度为config.n_layers的元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。
  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可以用于加速顺序解码（参见past_key_values输入）。
  
• decoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回 — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。
  解码器在每一层的输出隐藏状态以及初始嵌入输出。
  
• decoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回 — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。
  解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  
• cross_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回 — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。
  解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
  
• encoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 模型编码器最后一层的隐藏状态序列。
  
• encoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回 — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。
  编码器在每一层的输出隐藏状态以及初始嵌入输出。
  
• encoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回 — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。
  编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  

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

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

generate

<来源>

( input_features attention_mask = None composer = 'composer1' generation_config = None **kwargs ) → export const metadata = 'undefined';ModelOutput or torch.LongTensor

参数

• input_features (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，optional) — 这是由 Pop2PianoFeatureExtractor 生成的音频的特征化版本。attention_mask — 对于批量生成，input_features 被填充以使所有示例具有相同的形状。attention_mask 有助于确定哪些区域被填充，哪些没有被填充。

• 1 用于 未填充 的标记。
  
• 0 用于 填充 的标记。
  

• composer (str, optional, defaults to "composer1") — 传递给 Pop2PianoConcatEmbeddingToMel 的值，用于为每个 "composer" 生成不同的嵌入。请确保 composer 值在 generation_config 的 composer_to_feature_token 中存在。例如，请参阅 huggingface.co/sweetcocoa/pop2piano/blob/main/generation_config.json。
  
• generation_config (~generation.GenerationConfig, optional) — 用作生成调用的基本参数化的生成配置。传递给 generate 的 **kwargs 匹配 generation_config 的属性将覆盖它们。如果未提供 generation_config，将使用默认值，其加载优先级如下：1) 从 generation_config.json 模型文件中，如果存在；2) 从模型配置中。请注意，未指定的参数将继承 GenerationConfig 的默认值，其文档应该被检查以参数化生成。kwargs — generate_config 的特定参数化和/或将转发到模型的 forward 函数的其他模型特定 kwargs。如果模型是编码器-解码器模型，则编码器特定的 kwargs 不应该有前缀，解码器特定的 kwargs 应该以 decoder_ 为前缀。
  

返回

ModelOutput 或 torch.LongTensor

一个 ModelOutput（如果 return_dict_in_generate=True 或当 config.return_dict_in_generate=True 时）或一个 torch.FloatTensor。由于 Pop2Piano 是一个编码器-解码器模型（model.config.is_encoder_decoder=True），可能的 ModelOutput 类型为：

• GenerateEncoderDecoderOutput,
  
• GenerateBeamEncoderDecoderOutput
  

为 MIDI 输出生成标记 ID。

大多数控制生成的参数都在 generation_config 中设置，如果未传递，则将设置为模型的默认生成配置。您可以通过传递相应的参数到 generate() 来覆盖任何 generation_config，例如 .generate(inputs, num_beams=4, do_sample=True)。有关生成策略和代码示例的概述，请查看以下指南。

Pop2PianoTokenizer

class transformers.Pop2PianoTokenizer

< source >

( *args **kwargs )

__call__

( *args **kwargs )

将自身作为函数调用。

Pop2PianoProcessor

class transformers.Pop2PianoProcessor

< source >

( *args **kwargs )

__call__

( *args **kwargs )

将自身作为函数调用。

SeamlessM4T

原文：huggingface.co/docs/transformers/v4.37.2/en/model_doc/seamless_m4t

概述

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 为多种目标语言的翻译设定了一个新标准，直接语音到文本翻译的 BLEU 值比之前的 SOTA 提高了  20%。与强级联模型相比，SeamlessM4T 在语音到文本翻译中将英语翻译质量提高了 1.3 个 BLEU 点，在语音到语音翻译中将  ASR-BLEU 值提高了 2.6 个点。在鲁棒性测试中，我们的系统在语音到文本任务中对抗背景噪音和说话者变化的表现优于当前的 SOTA  模型。关键是，我们评估了 SeamlessM4T 的性别偏见和添加了毒性以评估翻译安全性。最后，本工作中的所有贡献都是开源的，可在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)
>>> 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. 同时生成语音和文本

使用 SeamlessM4TModel 的 return_intermediate_token_ids=True 来返回语音和文本！

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