原始文本:
huggingface.co/docs/transformers/v4.37.2/en/model_doc/mms
MMS 模型是由 Vineel Pratap、Andros Tjandra、Bowen Shi、Paden Tomasello、Arun Babu、Sayani Kundu、Ali Elkahky、Zhaoheng Ni、Apoorv Vyas、Maryam Fazel-Zarandi、Alexei Baevski、Yossi Adi、Xiaohui Zhang、Wei-Ning Hsu、Alexis Conneau、Michael Auli 在将语音技术扩展到 1000 多种语言中提出的。
论文的摘要如下:
扩大语音技术的语言覆盖范围有可能提高更多人获取信息的机会。然而,当前的语音技术仅限于大约 100 种语言,这只是全球约 7000 种语言中的一小部分。大规模多语言语音(MMS)项目通过 10-40 倍增加了支持的语言数量,具体取决于任务。主要成分是基于公开可用宗教文本的新数据集,并有效地利用自监督学习。我们构建了覆盖 1406 种语言的预训练 wav2vec 2.0 模型,一种单一的支持 1107 种语言的多语言自动语音识别模型,以及相同数量语言的语音合成模型,以及支持 4017 种语言的语言识别模型。实验表明,我们的多语言语音识别模型在 FLEURS 基准测试的 54 种语言上将 Whisper 的词错误率减少了一半以上,同时在训练时仅使用了少量标记数据。
以下是 MMS 项目中开源的不同模型。这些模型和代码最初发布在这里。我们已将它们添加到transformers
框架中,使其更易于使用。
ASR 模型的检查点可以在这里找到:mms-1b-fl102,mms-1b-l1107,mms-1b-all。为了获得最佳准确性,请使用mms-1b-all
模型。
提示:
默认情况下,MMS 会加载英语的适配器权重。如果您想加载另一种语言的适配器权重,请确保指定target_lang=<your-chosen-target-lang>
以及"ignore_mismatched_sizes=True
。必须传递ignore_mismatched_sizes=True
关键字,以允许语言模型头根据指定语言的词汇重新调整大小。同样,处理器应该加载相同的目标语言。
from transformers import Wav2Vec2ForCTC, AutoProcessor
model_id = "facebook/mms-1b-all"
target_lang = "fra"
processor = AutoProcessor.from_pretrained(model_id, target_lang=target_lang)
model = Wav2Vec2ForCTC.from_pretrained(model_id, target_lang=target_lang, ignore_mismatched_sizes=True)
您可以安全地忽略警告,例如:
Some weights of Wav2Vec2ForCTC were not initialized from the model checkpoint at facebook/mms-1b-all and are newly initialized because the shapes did not match:
- lm_head.bias: found shape torch.Size([154]) in the checkpoint and torch.Size([314]) in the model instantiated
- lm_head.weight: found shape torch.Size([154, 1280]) in the checkpoint and torch.Size([314, 1280]) in the model instantiated
You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.
如果要使用 ASR 流程,可以按如下方式加载所选的目标语言:
from transformers import pipeline
model_id = "facebook/mms-1b-all"
target_lang = "fra"
pipe = pipeline(model=model_id, model_kwargs={"target_lang": "fra", "ignore_mismatched_sizes": True})
接下来,让我们看看如何在调用~PretrainedModel.from_pretrained
之后运行 MMS 的推理并更改适配器层。首先,我们使用Datasets加载不同语言的音频数据。
from datasets import load_dataset, Audio
# English
stream_data = load_dataset("mozilla-foundation/common_voice_13_0", "en", split="test", streaming=True)
stream_data = stream_data.cast_column("audio", Audio(sampling_rate=16000))
en_sample = next(iter(stream_data))["audio"]["array"]
# French
stream_data = load_dataset("mozilla-foundation/common_voice_13_0", "fr", split="test", streaming=True)
stream_data = stream_data.cast_column("audio", Audio(sampling_rate=16000))
fr_sample = next(iter(stream_data))["audio"]["array"]
接下来,我们加载模型和处理器
from transformers import Wav2Vec2ForCTC, AutoProcessor
import torch
model_id = "facebook/mms-1b-all"
processor = AutoProcessor.from_pretrained(model_id)
model = Wav2Vec2ForCTC.from_pretrained(model_id)
现在我们处理音频数据,将处理后的音频数据传递给模型并转录模型输出,就像我们通常为 Wav2Vec2ForCTC 所做的那样。
inputs = processor(en_sample, sampling_rate=16_000, return_tensors="pt")
with torch.no_grad():
outputs = model(**inputs).logits
ids = torch.argmax(outputs, dim=-1)[0]
transcription = processor.decode(ids)
# 'joe keton disapproved of films and buster also had reservations about the media'
现在我们可以将相同的模型保留在内存中,并通过调用方便的 load_adapter()函数为模型和 set_target_lang()为分词器切换语言适配器。我们将目标语言作为输入传递 - "fra"
表示法语。
processor.tokenizer.set_target_lang("fra")
model.load_adapter("fra")
inputs = processor(fr_sample, sampling_rate=16_000, return_tensors="pt")
with torch.no_grad():
outputs = model(**inputs).logits
ids = torch.argmax(outputs, dim=-1)[0]
transcription = processor.decode(ids)
# "ce dernier est volé tout au long de l'histoire romaine"
以同样的方式,语言可以切换为所有其他支持的语言。请查看:
processor.tokenizer.vocab.keys()
查看所有支持的语言。
为了进一步提高 ASR 模型的性能,可以使用语言模型解码。有关更多详细信息,请参阅此处的文档here。
MMS-TTS 使用与 VITS 相同的模型架构,该架构在 v4.33 中添加到🤗 Transformers 中。MMS 为项目中的 1100 多种语言中的每种语言训练了一个单独的模型检查点。所有可用的检查点都可以在 Hugging Face Hub 上找到:facebook/mms-tts,以及VITS下的推理文档。
要使用 MMS 模型,首先更新到 Transformers 库的最新版本:
pip install --upgrade transformers accelerate
由于 VITS 中的基于流的模型是非确定性的,因此最好设置一个种子以确保输出的可重现性。
import torch
from transformers import VitsTokenizer, VitsModel, set_seed
tokenizer = VitsTokenizer.from_pretrained("facebook/mms-tts-eng")
model = VitsModel.from_pretrained("facebook/mms-tts-eng")
inputs = tokenizer(text="Hello - my dog is cute", return_tensors="pt")
set_seed(555) # make deterministic
with torch.no_grad():
outputs = model(**inputs)
waveform = outputs.waveform[0]
生成的波形可以保存为.wav
文件:
import scipy
scipy.io.wavfile.write("synthesized_speech.wav", rate=model.config.sampling_rate, data=waveform)
或者在 Jupyter Notebook / Google Colab 中显示:
from IPython.display import Audio
Audio(waveform, rate=model.config.sampling_rate)
对于具有非罗马字母表的某些语言,例如阿拉伯语、普通话或印地语,需要使用uroman
perl 包对文本输入进行预处理为罗马字母表。
您可以通过检查预训练的tokenizer
的is_uroman
属性来检查您的语言是否需要uroman
包:
from transformers import VitsTokenizer
tokenizer = VitsTokenizer.from_pretrained("facebook/mms-tts-eng")
print(tokenizer.is_uroman)
如果需要,在将文本输入传递给VitsTokenizer
之前,应该将 uroman 包应用于您的文本输入之前,因为目前分词器不支持执行预处理。
为了做到这一点,首先将 uroman 存储库克隆到本地计算机,并将 bash 变量UROMAN
设置为本地路径:
git clone https://github.com/isi-nlp/uroman.git
cd uroman
export UROMAN=$(pwd)
然后,您可以使用以下代码片段对文本输入进行预处理。您可以依赖使用 bash 变量UROMAN
指向 uroman 存储库,或者可以将 uroman 目录作为参数传递给uromaize
函数:
import torch
from transformers import VitsTokenizer, VitsModel, set_seed
import os
import subprocess
tokenizer = VitsTokenizer.from_pretrained("facebook/mms-tts-kor")
model = VitsModel.from_pretrained("facebook/mms-tts-kor")
def uromanize(input_string, uroman_path):
"""Convert non-Roman strings to Roman using the `uroman` perl package."""
script_path = os.path.join(uroman_path, "bin", "uroman.pl")
command = ["perl", script_path]
process = subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
# Execute the perl command
stdout, stderr = process.communicate(input=input_string.encode())
if process.returncode != 0:
raise ValueError(f"Error {process.returncode}: {stderr.decode()}")
# Return the output as a string and skip the new-line character at the end
return stdout.decode()[:-1]
text = "이봐 무슨 일이야"
uromaized_text = uromanize(text, uroman_path=os.environ["UROMAN"])
inputs = tokenizer(text=uromaized_text, return_tensors="pt")
set_seed(555) # make deterministic
with torch.no_grad():
outputs = model(inputs["input_ids"])
waveform = outputs.waveform[0]
提示:
VitsTokenizer
通过删除任何大小写和标点来规范化输入,以避免将超出词汇表的字符传递给模型。因此,模型对大小写和标点不敏感,因此应避免在文本提示中使用它们。您可以通过在调用分词器时设置noramlize=False
来禁用规范化,但这将导致意外行为,不建议这样做。
model.speaking_rate
设置为所选值,可以改变说话速度。同样,噪声的随机性由model.noise_scale
控制:
import torch
from transformers import VitsTokenizer, VitsModel, set_seed
tokenizer = VitsTokenizer.from_pretrained("facebook/mms-tts-eng")
model = VitsModel.from_pretrained("facebook/mms-tts-eng")
inputs = tokenizer(text="Hello - my dog is cute", return_tensors="pt")
# make deterministic
set_seed(555)
# make speech faster and more noisy
model.speaking_rate = 1.5
model.noise_scale = 0.8
with torch.no_grad():
outputs = model(**inputs)
根据能够识别的语言数量,提供不同的 LID 模型 - 126,256,512,1024,2048,4017。
首先,我们安装 transformers 和其他一些库
pip install torch accelerate datasets[audio]
pip install --upgrade transformers
接下来,我们通过datasets
加载一些音频样本。确保音频数据采样率为 16000 kHz。
from datasets import load_dataset, Audio
# English
stream_data = load_dataset("mozilla-foundation/common_voice_13_0", "en", split="test", streaming=True)
stream_data = stream_data.cast_column("audio", Audio(sampling_rate=16000))
en_sample = next(iter(stream_data))["audio"]["array"]
# Arabic
stream_data = load_dataset("mozilla-foundation/common_voice_13_0", "ar", split="test", streaming=True)
stream_data = stream_data.cast_column("audio", Audio(sampling_rate=16000))
ar_sample = next(iter(stream_data))["audio"]["array"]
接下来,我们加载模型和处理器
from transformers import Wav2Vec2ForSequenceClassification, AutoFeatureExtractor
import torch
model_id = "facebook/mms-lid-126"
processor = AutoFeatureExtractor.from_pretrained(model_id)
model = Wav2Vec2ForSequenceClassification.from_pretrained(model_id)
现在我们处理音频数据,将处理后的音频数据传递给模型进行分类,就像我们通常对 Wav2Vec2 音频分类模型进行的操作一样,比如ehcalabres/wav2vec2-lg-xlsr-en-speech-emotion-recognition
# English
inputs = processor(en_sample, sampling_rate=16_000, return_tensors="pt")
with torch.no_grad():
outputs = model(**inputs).logits
lang_id = torch.argmax(outputs, dim=-1)[0].item()
detected_lang = model.config.id2label[lang_id]
# 'eng'
# Arabic
inputs = processor(ar_sample, sampling_rate=16_000, return_tensors="pt")
with torch.no_grad():
outputs = model(**inputs).logits
lang_id = torch.argmax(outputs, dim=-1)[0].item()
detected_lang = model.config.id2label[lang_id]
# 'ara'
查看检查点支持的所有语言,可以按照以下方式打印语言标识符:
processor.id2label.values()
ASR 架构的 MMS 基于 Wav2Vec2 模型,请参考 Wav2Vec2 的文档页面以获取有关如何针对各种下游任务微调模型的更多详细信息。
MMS-TTS 使用与 VITS 相同的模型架构,请参考 VITS 的文档页面获取 API 参考。
原始文本:
huggingface.co/docs/transformers/v4.37.2/en/model_doc/musicgen
MusicGen 模型是由 Jade Copet、Felix Kreuk、Itai Gat、Tal Remez、David Kant、Gabriel Synnaeve、Yossi Adi 和 Alexandre Défossez 在论文Simple and Controllable Music Generation中提出的。
MusicGen 是一个单阶段自回归 Transformer 模型,能够生成高质量的音乐样本,其条件是文本描述或音频提示。文本描述通过一个冻结的文本编码器模型传递,以获得一系列隐藏状态表示。然后训练 MusicGen 来预测离散的音频标记,或称为音频代码,这些标记是通过音频压缩模型(如 EnCodec)解码以恢复音频波形。
通过高效的标记交错模式,MusicGen 不需要自监督的文本/音频提示语义表示,从而消除了预测一组码书(例如分层或上采样)所需级联多个模型的需要。相反,它能够在单次前向传递中生成所有码书。
论文摘要如下:
我们解决了条件音乐生成的任务。我们引入了 MusicGen,一个单一语言模型(LM),它在几个流的压缩离散音乐表示(即标记)上运行。与以往的工作不同,MusicGen 由单阶段 Transformer LM 和高效的标记交错模式组成,消除了级联多个模型的需要,例如分层或上采样。遵循这种方法,我们展示了 MusicGen 如何能够生成高质量的样本,同时在文本描述或旋律特征的条件下,允许更好地控制生成的输出。我们进行了广泛的实证评估,考虑了自动和人类研究,显示所提出的方法在标准文本到音乐基准上优于评估的基线。通过消融研究,我们阐明了构成 MusicGen 的每个组件的重要性。
该模型由sanchit-gandhi贡献。原始代码可以在这里找到。预训练检查点可以在Hugging Face Hub上找到。
src/transformers/models/musicgen/convert_musicgen_transformers.py
的转换脚本进行转换,命令如下:python src/transformers/models/musicgen/convert_musicgen_transformers.py \
--checkpoint small --pytorch_dump_folder /output/path --safe_serialization
MusicGen 兼容两种生成模式:贪婪和抽样。实际上,抽样比贪婪产生的结果显著更好,因此我们鼓励尽可能使用抽样模式。抽样默认启用,并且可以通过在调用MusicgenForConditionalGeneration.generate()
时设置do_sample=True
来明确指定,或通过覆盖模型的生成配置(见下文)来指定。
生成受正弦位置嵌入的限制,输入限制为 30 秒。也就是说,MusicGen 不能生成超过 30 秒的音频(1503 个标记),输入音频通过音频提示生成也会对此限制有所贡献,因此,给定 20 秒的音频输入,MusicGen 不能生成超过额外 10 秒的音频。
Transformers 支持 MusicGen 的单声道(1 通道)和立体声(2 通道)变体。单声道版本生成一组代码书。立体声版本生成 2 组代码书,每个通道(左/右)各一个,并且每组代码书通过音频压缩模型独立解码。每个通道的音频流合并以产生最终的立体声输出。
无条件(或’null’)生成的输入可以通过方法MusicgenForConditionalGeneration.get_unconditional_inputs()
获得:
>>> from transformers import MusicgenForConditionalGeneration
>>> model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small")
>>> unconditional_inputs = model.get_unconditional_inputs(num_samples=1)
>>> audio_values = model.generate(**unconditional_inputs, do_sample=True, max_new_tokens=256)
音频输出是一个形状为(batch_size, num_channels, sequence_length)
的三维 Torch 张量。要听生成的音频样本,可以在 ipynb 笔记本中播放它们:
from IPython.display import Audio
sampling_rate = model.config.audio_encoder.sampling_rate
Audio(audio_values[0].numpy(), rate=sampling_rate)
或者使用第三方库(例如scipy
)将它们保存为.wav
文件:
>>> import scipy
>>> sampling_rate = model.config.audio_encoder.sampling_rate
>>> scipy.io.wavfile.write("musicgen_out.wav", rate=sampling_rate, data=audio_values[0, 0].numpy())
模型可以通过使用 MusicgenProcessor 预处理输入来生成受文本提示条件的音频样本:
>>> from transformers import AutoProcessor, MusicgenForConditionalGeneration
>>> processor = AutoProcessor.from_pretrained("facebook/musicgen-small")
>>> model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small")
>>> inputs = processor(
... text=["80s pop track with bassy drums and synth", "90s rock song with loud guitars and heavy drums"],
... padding=True,
... return_tensors="pt",
... )
>>> audio_values = model.generate(**inputs, do_sample=True, guidance_scale=3, max_new_tokens=256)
guidance_scale
用于分类器自由引导(CFG),设置条件对数(从文本提示预测)和无条件对数(从无条件或’null’提示预测)之间的权重。更高的引导比例鼓励模型生成更与输入提示密切相关的样本,通常以音频质量较差为代价。通过设置guidance_scale > 1
启用 CFG。为获得最佳结果,请使用guidance_scale=3
(默认值)。
相同的 MusicgenProcessor 可用于预处理用于音频延续的音频提示。在以下示例中,我们使用🤗 Datasets 库加载音频文件,可以通过以下命令进行 pip 安装:
pip install --upgrade pip
pip install datasets[audio]
>>> from transformers import AutoProcessor, MusicgenForConditionalGeneration
>>> from datasets import load_dataset
>>> processor = AutoProcessor.from_pretrained("facebook/musicgen-small")
>>> model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small")
>>> dataset = load_dataset("sanchit-gandhi/gtzan", split="train", streaming=True)
>>> sample = next(iter(dataset))["audio"]
>>> # take the first half of the audio sample
>>> sample["array"] = sample["array"][: len(sample["array"]) // 2]
>>> inputs = processor(
... audio=sample["array"],
... sampling_rate=sample["sampling_rate"],
... text=["80s blues track with groovy saxophone"],
... padding=True,
... return_tensors="pt",
... )
>>> audio_values = model.generate(**inputs, do_sample=True, guidance_scale=3, max_new_tokens=256)
对于批量音频提示生成,可以通过使用 MusicgenProcessor 类对生成的audio_values
进行后处理,以去除填充:
>>> from transformers import AutoProcessor, MusicgenForConditionalGeneration
>>> from datasets import load_dataset
>>> processor = AutoProcessor.from_pretrained("facebook/musicgen-small")
>>> model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small")
>>> dataset = load_dataset("sanchit-gandhi/gtzan", split="train", streaming=True)
>>> sample = next(iter(dataset))["audio"]
>>> # take the first quarter of the audio sample
>>> sample_1 = sample["array"][: len(sample["array"]) // 4]
>>> # take the first half of the audio sample
>>> sample_2 = sample["array"][: len(sample["array"]) // 2]
>>> inputs = processor(
... audio=[sample_1, sample_2],
... sampling_rate=sample["sampling_rate"],
... text=["80s blues track with groovy saxophone", "90s rock song with loud guitars and heavy drums"],
... padding=True,
... return_tensors="pt",
... )
>>> audio_values = model.generate(**inputs, do_sample=True, guidance_scale=3, max_new_tokens=256)
>>> # post-process to remove padding from the batched audio
>>> audio_values = processor.batch_decode(audio_values, padding_mask=inputs.padding_mask)
控制生成过程的默认参数,例如采样、引导比例和生成的标记数量,可以在模型的生成配置中找到,并根据需要进行更新:
>>> from transformers import MusicgenForConditionalGeneration
>>> model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small")
>>> # inspect the default generation config
>>> model.generation_config
>>> # increase the guidance scale to 4.0
>>> model.generation_config.guidance_scale = 4.0
>>> # decrease the max length to 256 tokens
>>> model.generation_config.max_length = 256
请注意,传递给生成方法的任何参数都将覆盖生成配置中的参数,因此在调用生成时设置do_sample=False
将覆盖生成配置中model.generation_config.do_sample
的设置。
MusicGen 模型可以分解为三个不同的阶段:
因此,MusicGen 模型可以作为独立的解码器模型使用,对应于类 MusicgenForCausalLM,或作为包含文本编码器和音频编码器/解码器的复合模型使用,对应于类 MusicgenForConditionalGeneration。如果只需从预训练检查点加载解码器,则可以首先指定正确的配置,或通过复合模型的.decoder
属性访问:
>>> from transformers import AutoConfig, MusicgenForCausalLM, MusicgenForConditionalGeneration
>>> # Option 1: get decoder config and pass to `.from_pretrained`
>>> decoder_config = AutoConfig.from_pretrained("facebook/musicgen-small").decoder
>>> decoder = MusicgenForCausalLM.from_pretrained("facebook/musicgen-small", **decoder_config)
>>> # Option 2: load the entire composite model, but only return the decoder
>>> decoder = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small").decoder
由于文本编码器和音频编码器/解码器模型在训练期间被冻结,MusicGen 解码器 MusicgenForCausalLM 可以在编码器隐藏状态和音频代码的数据集上独立训练。对于推断,训练好的解码器可以与冻结的文本编码器和音频编码器/解码器结合,以恢复复合 MusicgenForConditionalGeneration 模型。
提示:
MusicgenForConditionalGeneration.generate()
时使用变量do_sample
切换采样。
class transformers.MusicgenDecoderConfig
( vocab_size = 2048 max_position_embeddings = 2048 num_hidden_layers = 24 ffn_dim = 4096 num_attention_heads = 16 layerdrop = 0.0 use_cache = True activation_function = 'gelu' hidden_size = 1024 dropout = 0.1 attention_dropout = 0.0 activation_dropout = 0.0 initializer_factor = 0.02 scale_embedding = False num_codebooks = 4 audio_channels = 1 pad_token_id = 2048 bos_token_id = 2048 eos_token_id = None tie_word_embeddings = False **kwargs )
参数
vocab_size
(int
,可选,默认为 2048)— MusicgenDecoder 模型的词汇量。定义了在调用MusicgenDecoder
时传递的inputs_ids
可以表示的不同标记数量。
hidden_size
(int
,可选,默认为 1024)— 层和池化层的维度。
num_hidden_layers
(int
,可选,默认为 24)— 解码器层数。
num_attention_heads
(int
,可选,默认为 16)— Transformer 块中每个注意力层的注意力头数。
ffn_dim
(int
,可选,默认为 4096)— Transformer 块中“中间”(通常称为前馈)层的维度。
activation_function
(str
或function
,可选,默认为"gelu"
)— 解码器和池化器中的非线性激活函数(函数或字符串)。如果是字符串,支持"gelu"
、"relu"
、"silu"
和"gelu_new"
。
dropout
(float
,可选,默认为 0.1)— 嵌入、文本编码器和池化器中所有全连接层的 dropout 概率。
attention_dropout
(float
,可选,默认为 0.0)— 注意力概率的 dropout 比率。
activation_dropout
(float
,可选,默认为 0.0)— 全连接层内部激活的 dropout 比率。
max_position_embeddings
(int
,可选,默认为 2048)— 该模型可能被使用的最大序列长度。通常情况下,将其设置为一个较大的值以防万一(例如 512、1024 或 2048)。
initializer_factor
(float
,可选,默认为 0.02)— 用于初始化所有权重矩阵的截断正态初始化器的标准差。
layerdrop
(float
,可选,默认为 0.0)— 解码器的 LayerDrop 概率。有关更多详细信息,请参阅 LayerDrop 论文)。
scale_embedding
(bool
,可选,默认为False
)— 通过将其除以 sqrt(hidden_size)来缩放嵌入。
use_cache
(bool
,可选,默认为True
)— 模型是否应返回最后的键/值注意力(并非所有模型都使用)。
num_codebooks
(int
,可选,默认为 4)— 转发到模型的并行码书的数量。
tie_word_embeddings(bool,
可选,默认为False
)— 输入和输出词嵌入是否应该绑定。
audio_channels
(int
,可选,默认为 1)— 音频数据中的通道数。单声道为 1,立体声为 2。立体声模型为左/右输出通道生成单独的音频流。单声道模型生成单个音频流输出。
这是用于存储 MusicgenDecoder
配置的配置类。根据指定的参数实例化一个 MusicGen 解码器,定义模型架构。使用默认值实例化配置将产生类似于 MusicGen facebook/musicgen-small 架构的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档获取更多信息。
class transformers.MusicgenConfig
( **kwargs )
参数
kwargs
(optional) — 关键字参数的字典。特别是:
text_encoder
(PretrainedConfig, optional) — 定义文本编码器配置的配置对象实例。
audio_encoder
(PretrainedConfig, optional) — 定义音频编码器配置的配置对象实例。
decoder
(PretrainedConfig, optional) — 定义解码器配置的配置对象实例。
这是用于存储 MusicgenModel 配置的配置类。根据指定的参数实例化一个 MusicGen 模型,定义文本编码器、音频编码器和 MusicGen 解码器配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档获取更多信息。
示例:
>>> from transformers import (
... MusicgenConfig,
... MusicgenDecoderConfig,
... T5Config,
... EncodecConfig,
... MusicgenForConditionalGeneration,
... )
>>> # Initializing text encoder, audio encoder, and decoder model configurations
>>> text_encoder_config = T5Config()
>>> audio_encoder_config = EncodecConfig()
>>> decoder_config = MusicgenDecoderConfig()
>>> configuration = MusicgenConfig.from_sub_models_config(
... text_encoder_config, audio_encoder_config, decoder_config
... )
>>> # Initializing a MusicgenForConditionalGeneration (with random weights) from the facebook/musicgen-small style configuration
>>> model = MusicgenForConditionalGeneration(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
>>> config_text_encoder = model.config.text_encoder
>>> config_audio_encoder = model.config.audio_encoder
>>> config_decoder = model.config.decoder
>>> # Saving the model, including its configuration
>>> model.save_pretrained("musicgen-model")
>>> # loading model and config from pretrained folder
>>> musicgen_config = MusicgenConfig.from_pretrained("musicgen-model")
>>> model = MusicgenForConditionalGeneration.from_pretrained("musicgen-model", config=musicgen_config)
from_sub_models_config
( text_encoder_config: PretrainedConfig audio_encoder_config: PretrainedConfig decoder_config: MusicgenDecoderConfig **kwargs ) → export const metadata = 'undefined';MusicgenConfig
返回
MusicgenConfig
配置对象实例
从文本编码器、音频编码器和解码器配置实例化一个 MusicgenConfig(或派生类)。
class transformers.MusicgenProcessor
( feature_extractor tokenizer )
参数
feature_extractor
(EncodecFeatureExtractor
) — 一个 EncodecFeatureExtractor 的实例。特征提取器是一个必需的输入。
tokenizer
(T5Tokenizer
) — 一个 T5Tokenizer 的实例。这是一个必需的输入。
构建一个 MusicGen 处理器,将 EnCodec 特征提取器和 T5 分词器封装成一个单一的处理器类。
MusicgenProcessor 提供了 EncodecFeatureExtractor 和 TTokenizer
的所有功能。查看 __call__()
和 decode() 获取更多信息。
batch_decode
( *args **kwargs )
此方法用于解码来自 MusicGen 模型的音频输出批次或来自标记器的标记 id 批次。在解码标记 id 的情况下,此方法将其所有参数转发到 T5Tokenizer 的 batch_decode()。请参考此方法的文档字符串以获取更多信息。
decode
( *args **kwargs )
此方法将其所有参数转发到 T5Tokenizer 的 decode()。请参考此方法的文档字符串以获取更多信息。
class transformers.MusicgenModel
( config: MusicgenDecoderConfig )
参数
config
(MusicgenConfig)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。裸的 Musicgen 解码器模型,输出没有特定头部的原始隐藏状态。
Musicgen 模型是由 Jade Copet、Felix Kreuk、Itai Gat、Tal Remez、David Kant、Gabriel Synnaeve、Yossi Adi、Alexandre Défossez 在Simple and Controllable Music Generation中提出的。它是一个在条件音乐生成任务上训练的编码器解码器变换器。
该模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
该模型还是一个 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
( input_ids: LongTensor = None attention_mask: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None head_mask: Optional = None cross_attn_head_mask: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )
参数
input_ids
(形状为(batch_size * num_codebooks, sequence_length)
的torch.LongTensor
)— 词汇表中输入序列标记的索引,对应于音频代码序列。
通过使用音频编码器模型对音频提示进行编码以预测音频代码,可以获得索引,例如使用 EncodecModel。有关详细信息,请参阅 EncodecModel.encode()。
什么是输入 ID?
input_ids
将在前向传递中自动从形状(batch_size * num_codebooks, target_sequence_length)
转换为(batch_size, num_codebooks, target_sequence_length)
。如果您从音频编码模型(如 EncodecModel)获取音频代码,请确保帧数等于 1,并且在将其作为input_ids
传递之前,将音频代码从(frames, batch_size, num_codebooks, target_sequence_length)
重塑为(batch_size * num_codebooks, target_sequence_length)
。
attention_mask
(形状为(batch_size, sequence_length)
的torch.Tensor
,可选)— 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]
中:
masked
的标记为 1,
masked
的标记为 0。
什么是注意力掩码?
encoder_hidden_states
(形状为(batch_size, encoder_sequence_length, hidden_size)
的torch.FloatTensor
,可选)— 编码器最后一层的隐藏状态序列的输出。用于解码器的交叉注意力。
encoder_attention_mask
(形状为(batch_size, encoder_sequence_length)
的torch.LongTensor
,可选)— 用于避免在编码器输入标记的填充标记索引上执行交叉注意力的掩码。掩码值选在[0, 1]
中:
masked
的标记为 1,
masked
的标记为 0。
什么是注意力掩码?
head_mask
(形状为(decoder_layers, decoder_attention_heads)
的torch.Tensor
,可选)— 用于使注意力模块的选定头部失效的掩码。掩码值选在[0, 1]
中:
masked
,
masked
。
cross_attn_head_mask
(形状为(decoder_layers, decoder_attention_heads)
的torch.Tensor
,可选)— 用于使解码器中交叉注意力模块的选定头部失效的掩码,以避免在隐藏头部上执行交叉注意力。掩码值选在[0, 1]
中:
masked
,
masked
。
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
,用户可以选择仅输入最后一个形状为(batch_size, 1)
的decoder_input_ids
(那些没有将它们的过去键值状态提供给此模型的)而不是形状为(batch_size, sequence_length)
的所有decoder_input_ids
。
inputs_embeds
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选)— 可选地,可以直接传递嵌入表示而不是传递input_ids
。如果您想要更多控制如何将input_ids
索引转换为相关向量,而不是模型的内部嵌入查找矩阵,则这很有用。
output_attentions
(bool
,可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions
。
output_hidden_states
(bool
,可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
。
return_dict
(bool
,可选)— 是否返回一个 ModelOutput 而不是一个普通的元组。
MusicgenModel 的前向方法,覆盖了__call__
特殊方法。
尽管前向传递的配方需要在此函数内定义,但应该在此之后调用Module
实例,而不是这个,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。
class transformers.MusicgenForCausalLM
( config: MusicgenDecoderConfig )
参数
config
(MusicgenConfig)— 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。MusicGen 解码器模型在顶部带有语言建模头。
Musicgen 模型由 Jade Copet、Felix Kreuk、Itai Gat、Tal Remez、David Kant、Gabriel Synnaeve、Yossi Adi、Alexandre Défossez 在Simple and Controllable Music Generation中提出。这是一个在条件音乐生成任务上训练的编码器解码器变换器。
该模型继承自 PreTrainedModel。查看超类文档以了解库实现的通用方法,例如下载或保存,调整输入嵌入大小,修剪头等。
该模型也是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
( input_ids: LongTensor = None attention_mask: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None head_mask: Optional = None cross_attn_head_mask: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )
参数
input_ids
(形状为(batch_size * num_codebooks, sequence_length)
的torch.LongTensor
)— 词汇表中输入序列标记的索引,对应于音频代码序列。
可以通过使用音频编码器模型对音频提示进行编码来获取索引,以预测音频代码,例如使用 EncodecModel。查看 EncodecModel.encode()获取详细信息。
什么是输入 ID?
input_ids
将在前向传递中自动从形状(batch_size * num_codebooks, target_sequence_length)
转换为(batch_size, num_codebooks, target_sequence_length)
。如果您从音频编码模型(例如 EncodecModel)获取音频代码,请确保帧数等于 1,并且在将音频代码从(frames, batch_size, num_codebooks, target_sequence_length)
重塑为(batch_size * num_codebooks, target_sequence_length)
之前,将其作为input_ids
传递。
attention_mask
(形状为(batch_size, sequence_length)
的torch.Tensor
,可选)— 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]
中:
未被掩盖
的标记,
被掩盖
的标记。
什么是注意力掩码?
encoder_hidden_states
(形状为(batch_size, encoder_sequence_length, hidden_size)
的torch.FloatTensor
,可选)— 编码器最后一层的隐藏状态序列。用于解码器的交叉注意力。
encoder_attention_mask
(形状为(batch_size, encoder_sequence_length)
的torch.LongTensor
,可选)— 用于避免在编码器输入 ID 的填充标记索引上执行交叉注意力的掩码。掩码值选在[0, 1]
中:
未被掩盖
的标记,
被掩盖
的标记。
什么是注意力掩码?
head_mask
(形状为(decoder_layers, decoder_attention_heads)
的torch.Tensor
,可选)— 用于使注意力模块的选定头部无效的掩码。掩码值选在[0, 1]
中:
未被掩盖
,
掩盖
。
cross_attn_head_mask
(torch.Tensor
of shape (decoder_layers, decoder_attention_heads)
, optional) — 用于将解码器中交叉注意力模块的选定头部置零的掩码,以避免在隐藏头部上执行交叉注意力。掩码值在[0, 1]
中选择:
masked
。
masked
。
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
输入)。
如果使用了past_key_values
,用户可以选择仅输入形状为(batch_size, 1)
的最后decoder_input_ids
(那些没有将它们的过去键值状态提供给此模型的)而不是形状为(batch_size, sequence_length)
的所有decoder_input_ids
。
inputs_embeds
(torch.FloatTensor
of shape (batch_size, sequence_length, hidden_size)
, optional) — 可选地,您可以直接传递嵌入表示,而不是传递input_ids
。如果您想要更多控制如何将input_ids
索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,则这很有用。
output_attentions
(bool
, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。
output_hidden_states
(bool
, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。
return_dict
(bool
, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。
labels
(torch.LongTensor
of shape (batch_size, sequence_length)
, optional) — 用于语言建模的标签。请注意,模型内部移动标签,即您可以设置labels = input_ids
。索引在[-100, 0, ..., config.vocab_size]
中选择。所有设置为-100
的标签都被忽略(被masked
),损失仅计算标签在[0, ..., config.vocab_size]
中的标签。
返回:transformers.modeling_outputs.Seq2SeqLMOutput 或tuple(torch.FloatTensor)
:一个 transformers.modeling_outputs.Seq2SeqLMOutput 或一个torch.FloatTensor
元组(如果传递了return_dict=False
或config.return_dict=False
,或者当config.return_dict=False
时)包含根据配置(MusicgenConfig)和输入的各种元素。
loss
(torch.FloatTensor
of shape (1,)
, optional, 当提供labels
时返回) — 语言建模损失。
logits
(torch.FloatTensor
of shape (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 之后,用于计算自注意力头中的加权平均值。
MusicgenForCausalLM 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的方法需要在此函数内定义,但应该在此之后调用Module
实例,而不是这个,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。
class transformers.MusicgenForConditionalGeneration
( config: Optional = None text_encoder: Optional = None audio_encoder: Optional = None decoder: Optional = None )
参数
config
(MusicgenConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。具有文本编码器、音频编码器和 Musicgen 解码器的复合 MusicGen 模型,用于具有文本和/或音频提示的音乐生成任务。
Musicgen 模型由 Jade Copet、Felix Kreuk、Itai Gat、Tal Remez、David Kant、Gabriel Synnaeve、Yossi Adi、Alexandre Défossez 在Simple and Controllable Music Generation中提出。它是一个在条件音乐生成任务上训练的编码器解码器 transformer。
该模型继承自 PreTrainedModel。请查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入、修剪头等)。
该模型还是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
( input_ids: Optional = None attention_mask: Optional = None input_values: Optional = None padding_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None past_key_values: Tuple = None inputs_embeds: 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 **kwargs ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqLMOutput or tuple(torch.FloatTensor)
参数
input_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
)— 词汇表中输入序列标记的索引。默认情况下将忽略填充。如果提供填充,则默认将忽略。
可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call
()。
什么是输入 ID?
attention_mask
(形状为(batch_size, sequence_length)
的torch.Tensor
,可选)— 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值为[0, 1]
:
masked
的标记。
masked
的标记。
什么是注意力掩码?
decoder_input_ids
(形状为(batch_size * num_codebooks, target_sequence_length)
的torch.LongTensor
,可选)— 词汇表中解码器输入序列标记的索引,对应于音频代码序列。
可以通过使用音频编码器模型对音频提示进行编码以预测音频代码来获取索引,例如使用 EncodecModel。有关详细信息,请参阅 EncodecModel.encode()。
什么是解码器输入 ID?
decoder_input_ids
将在前向传递中自动从形状(batch_size * num_codebooks, target_sequence_length)
转换为(batch_size, num_codebooks, target_sequence_length)
。如果您从音频编码模型(如 EncodecModel)获取音频代码,请确保帧数等于 1,并且在将音频代码从(frames, batch_size, num_codebooks, target_sequence_length)
重塑为(batch_size * num_codebooks, target_sequence_length)
之前,将其作为decoder_input_ids
传递。
decoder_attention_mask
(形状为(batch_size, target_sequence_length)
的torch.LongTensor
,可选)— 默认行为:生成一个忽略decoder_input_ids
中填充标记的张量。因果掩码也将默认使用。
head_mask
(形状为(encoder_layers, encoder_attention_heads)
的torch.Tensor
,可选)— 用于使编码器中注意力模块的选定头部失效的掩码。选择的掩码值为[0, 1]
。
masked
。
masked
。
decoder_head_mask
(形状为(decoder_layers, decoder_attention_heads)
的torch.Tensor
,可选)— 用于使解码器中注意力模块的选定头部失效的掩码。选择的掩码值为[0, 1]
。
masked
。
masked
。
cross_attn_head_mask
(torch.Tensor
of shape (decoder_layers, decoder_attention_heads)
, optional) — 在解码器中将交叉注意力模块的选定头部置零的掩码。掩码值选定在[0, 1]
中:
encoder_outputs
(tuple(tuple(torch.FloatTensor)
, optional) — 元组包括(last_hidden_state
, optional: hidden_states
, optional: attentions
) last_hidden_state
的形状为(batch_size, sequence_length, hidden_size)
,optional)是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
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
输入)。
如果使用past_key_values
,用户可以选择仅输入形状为(batch_size, 1)
的最后一个decoder_input_ids
(那些没有将其过去的键值状态提供给此模型的)而不是形状为(batch_size, sequence_length)
的所有decoder_input_ids
。
inputs_embeds
(torch.FloatTensor
of shape (batch_size, sequence_length, hidden_size)
, optional) — 可选地,您可以选择直接传递嵌入表示而不是传递input_ids
。如果您想要更多控制如何将input_ids
索引转换为相关向量,而不是模型的内部嵌入查找矩阵,则这很有用。
decoder_inputs_embeds
(torch.FloatTensor
of shape (batch_size, target_sequence_length, hidden_size)
, 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
的值。
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 而不是普通元组。
返回
transformers.modeling_outputs.Seq2SeqLMOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.Seq2SeqLMOutput 或一个torch.FloatTensor
元组(如果传递return_dict=False
或config.return_dict=False
)包括根据配置(MusicgenConfig)和输入的各种元素。
loss
(torch.FloatTensor
of shape (1,)
, optional, 当提供labels
时返回) — 语言建模损失。
logits
(形状为(batch_size, sequence_length, config.vocab_size)
的torch.FloatTensor
)- 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。
past_key_values
(tuple(tuple(torch.FloatTensor))
,可选,当传递use_cache=True
或config.use_cache=True
时返回)- 长度为config.n_layers
的元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的张量。
包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码(参见past_key_values
输入)。
decoder_hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)- 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入输出的一个和每层输出的一个)。
每层解码器的隐藏状态加上初始嵌入输出。
decoder_attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。
解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
cross_attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。
解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。
encoder_last_hidden_state
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选)- 模型编码器最后一层的隐藏状态序列。
encoder_hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)- 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入输出的一个和每层输出的一个)。
每层编码器的隐藏状态加上初始嵌入输出。
encoder_attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。
编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
MusicgenForConditionalGeneration 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoProcessor, MusicgenForConditionalGeneration
>>> import torch
>>> processor = AutoProcessor.from_pretrained("facebook/musicgen-small")
>>> model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small")
>>> inputs = processor(
... text=["80s pop track with bassy drums and synth", "90s rock song with loud guitars and heavy drums"],
... padding=True,
... return_tensors="pt",
... )
>>> pad_token_id = model.generation_config.pad_token_id
>>> decoder_input_ids = (
... torch.ones((inputs.input_ids.shape[0] * model.decoder.num_codebooks, 1), dtype=torch.long)
... * pad_token_id
... )
>>> logits = model(**inputs, decoder_input_ids=decoder_input_ids).logits
>>> logits.shape # (bsz * num_codebooks, tgt_len, vocab_size)
torch.Size([8, 1, 2048])
原始文本:
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贡献。原始代码可以在此处找到。
pip install pretty-midi==0.2.9 essentia==2.1b6.dev1034 librosa scipy
请注意,您可能需要在安装后重新启动运行时。
Pop2PianoForConditionalGeneration.generate()
中选择不同的作曲家可以产生不同结果的多样性。
>>> 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")
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 的文档以获取更多信息。
class transformers.Pop2PianoFeatureExtractor
( *args **kwargs )
__call__
( *args **kwargs )
将自身作为函数调用。
class transformers.Pop2PianoForConditionalGeneration
( 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]
之间:
未屏蔽
的标记,
屏蔽
的标记。什么是注意力掩码?
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]
之间:
屏蔽
,
屏蔽
。
decoder_head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
,可选)— 用于使解码器中自注意力模块的选定头部失效的掩码。选择的掩码值在[0, 1]
之间:
屏蔽
,
屏蔽
。
cross_attn_head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.Tensor
,可选)— 用于使解码器中交叉注意力模块的选定头部失效的掩码。选择的掩码值在[0, 1]
之间:
屏蔽
,
屏蔽
。
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
有助于确定哪些区域被填充,哪些没有被填充。
未填充
的标记。
填充
的标记。
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 类型为:
为 MIDI 输出生成标记 ID。
大多数控制生成的参数都在 generation_config
中设置,如果未传递,则将设置为模型的默认生成配置。您可以通过传递相应的参数到 generate() 来覆盖任何 generation_config
,例如 .generate(inputs, num_beams=4, do_sample=True)
。有关生成策略和代码示例的概述,请查看以下指南。
class transformers.Pop2PianoTokenizer
( *args **kwargs )
__call__
( *args **kwargs )
将自身作为函数调用。
class transformers.Pop2PianoProcessor
( *args **kwargs )
__call__
( *args **kwargs )
将自身作为函数调用。
原文:
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 可以在不依赖于单独模型的情况下执行多个任务:
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)
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。
您可以使用 spkr_id
参数更改用于语音合成的说话者。对于某些语言,某些 spkr_id
的效果比其他的好!
您可以为语音和文本生成使用不同的 生成策略,例如 .generate(input_ids=input_ids, text_num_beams=4, speech_do_sample=True)
,这将在文本模型上连续执行波束搜索解码,并在语音模型上执行多项式采样。
使用 SeamlessM4TModel 的 return_intermediate_token_ids=True
来返回语音和文本!
SeamlessM4T 具有一个多功能架构,可以平滑处理文本和语音的顺序生成。此设置包括两个序列到序列 (seq2seq) 模型。第一个模型将输入模态转换为翻译文本,而第二个模型从翻译文本生成称为“单元标记”的语音标记。
每种模态都有自己专用的编码器,具有独特的架构。此外,对于语音输出,一个受 HiFi-GAN 架构启发的声码器被放置在第二个 seq2seq 模型的顶部。
以下是生成过程的工作原理:
此模型由 ylacombe 贡献。原始代码可以在 这里 找到。
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: Optional = None input_features: Optional = None return_intermediate_token_ids: Optional = None tgt_lang: Optional = None spkr_id: Optional = 0 generate_speech: Optional = True **kwargs ) → export const metadata = 'undefined';Union[SeamlessM4TGenerationOutput, Tuple[Tensor], ModelOutput]
参数
input_ids
(torch.LongTensor
of shape (batch_size, sequence_length)
, optional) — 词汇表中输入序列标记的索引。
可以使用 SeamlessM4TTokenizer 或 SeamlessM4TProcessor 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call
()。
什么是输入 ID?
input_features
(torch.FloatTensor
of shape (batch_size, sequence_length, num_banks)
, optional) — 输入音频特征。这应该由 SeamlessM4TFeatureExtractor 类或 SeamlessM4TProcessor 类返回。有关详细信息,请参阅 SeamlessM4TFeatureExtractor.call
()。
return_intermediate_token_ids
(bool
, optional) — 如果为True
,还会返回中间生成的文本和单元标记。如果您还想在音频旁边获取翻译文本,则设置为True
。请注意,如果generate_speech=True
,则此参数将被忽略。
tgt_lang
(str
, optional) — 用作翻译目标语言的语言。
spkr_id
(int
, optional, defaults to 0) — 用于语音合成的说话者 id。必须小于config.vocoder_num_spkrs
。
generate_speech
(bool
, optional, defaults to True
) — 如果为False
,将仅返回文本标记,不会生成语音。
kwargs
(optional) — 将传递给 GenerationMixin.generate()的剩余关键字参数字典。关键字参数有两种类型:
generate
方法的**kwargs
输入到每个子模型中,除了decoder_input_ids
只会通过文本组件传递。
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
。
生成翻译的标记 id 和/或翻译的音频波形。
此方法连续调用两个不同子模型的.generate
函数。您可以在两个不同级别指定关键字参数:将传递给两个模型的通用参数,或将传递给其中一个模型的前缀参数。
例如,调用.generate(input_ids=input_ids, num_beams=4, speech_do_sample=True)
将在文本模型上连续执行波束搜索解码,并在语音模型上执行多项式波束搜索采样。
有关生成策略和代码示例的概述,请查看以下指南。
class transformers.SeamlessM4TForTextToSpeech
( config: SeamlessM4TConfig )
参数
config
(~SeamlessM4TConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained()方法加载模型权重。用于 T2ST 的文本到语音 SeamlessM4T 模型变换器。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。
generate
( input_ids: Optional = None return_intermediate_token_ids: Optional = None tgt_lang: Optional = None spkr_id: Optional = 0 **kwargs ) → export const metadata = 'undefined';Union[SeamlessM4TGenerationOutput, Tuple[Tensor]]
参数
input_ids
(torch.LongTensor
,形状为(batch_size, sequence_length)
) — 词汇表中输入序列标记的索引。
可以使用 SeamlessM4TTokenizer 或 SeamlessM4TProcessor 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call
()获取详细信息。
什么是输入 ID?
return_intermediate_token_ids
(bool
,可选) — 如果为True
,还会返回中间生成的文本和单元标记。如果您还想在音频旁边获取翻译文本,请设置为True
。
tgt_lang
(str
,可选) — 用作翻译目标语言的语言。
spkr_id
(int
,可选,默认为 0) — 用于语音合成的说话者的 id。必须小于config.vocoder_num_spkrs
。
kwargs
(可选) — 将传递给 GenerationMixin.generate()的剩余关键字参数字典。关键字参数有两种类型:
**kwargs
输入到每个子模型的generate
方法中,除了decoder_input_ids
,它只会通过文本组件传递。
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)
将在文本模型上连续执行波束搜索解码,并在语音模型上执行多项式波束搜索采样。
有关生成策略和代码示例的概述,请查看以下指南。
class transformers.SeamlessM4TForSpeechToSpeech
( config )
参数
config
(~SeamlessM4TConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。可用于 S2ST 的语音到语音 SeamlessM4T 模型变换器。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有信息。
generate
( input_features: Optional = None return_intermediate_token_ids: Optional = None tgt_lang: Optional = None spkr_id: Optional = 0 **kwargs ) → export const metadata = 'undefined';Union[SeamlessM4TGenerationOutput, Tuple[Tensor]]
参数
input_features
(torch.FloatTensor
,形状为(batch_size, sequence_length, num_banks)
) — 输入音频特征。这应该由 SeamlessM4TFeatureExtractor 类或 SeamlessM4TProcessor 类返回。有关详细信息,请参阅 SeamlessM4TFeatureExtractor.call
()。
return_intermediate_token_ids
(bool
, 可选) — 如果为True
,还会返回中间生成的文本和单元标记。如果您还想在音频旁边获取翻译文本,请设置为True
。
tgt_lang
(str
, 可选) — 用作翻译目标语言的语言。
spkr_id
(int
, 可选,默认为 0) — 用于语音合成的说话者的 id。必须小于config.vocoder_num_spkrs
。
kwargs
(可选) — 将传递给 GenerationMixin.generate()的剩余关键字参数字典。关键字参数有两种类型:
**kwargs
输入到每个子模型的generate
方法中,除了decoder_input_ids
只会通过文本组件传递。
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)
将在文本模型上连续执行波束搜索解码,并在语音模型上执行多项式波束搜索采样。
有关生成策略和代码示例的概述,请查看以下指南。
class transformers.SeamlessM4TForTextToText
( config: SeamlessM4TConfig )
参数
config
(~SeamlessM4TConfig)- 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。文本到文本 SeamlessM4T 模型变压器可用于 T2TT。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
( input_ids: LongTensor = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None inputs_embeds: 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 **kwargs )
参数
input_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)- 词汇表中输入序列标记的索引。
可以使用 SeamlessM4TTokenizer 或 SeamlessM4TProcessor 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call
()。
什么是输入 ID?
attention_mask
(形状为(batch_size, sequence_length)
的torch.FloatTensor
,可选)- 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]
中:
masked
的标记,为 1。
masked
的标记,为 0。
什么是注意力掩码?
decoder_input_ids
(形状为(batch_size, target_sequence_length)
的torch.LongTensor
,可选)- 词汇表中解码器输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call
()。
什么是解码器输入 ID?
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
(形状为(batch_size, target_sequence_length)
的torch.LongTensor
,可选)- 默认行为:生成一个张量,忽略decoder_input_ids
中的填充标记。因果掩码也将默认使用。
如果要更改填充行为,您应该阅读modeling_bart._prepare_decoder_attention_mask
并根据您的需求进行修改。有关默认策略的更多信息,请参见论文中的图表 1。
encoder_outputs
(tuple(tuple(torch.FloatTensor)
, optional) — 元组包含(last_hidden_state
, optional: hidden_states
, optional: attentions
) last_hidden_state
的形状为(batch_size, sequence_length, hidden_size)
,optional)是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
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
输入)。
如果使用了past_key_values
,用户可以选择仅输入形状为(batch_size, 1)
的最后decoder_input_ids
(那些没有将它们的过去键值状态提供给此模型的输入),而不是形状为(batch_size, sequence_length)
的所有decoder_input_ids
。
inputs_embeds
(torch.FloatTensor
of shape(batch_size, sequence_length, hidden_size)
, optional) — 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids
。如果您希望更好地控制如何将input_ids
索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,这将非常有用。
decoder_inputs_embeds
(torch.FloatTensor
of shape (batch_size, target_sequence_length, hidden_size)
, 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
(torch.LongTensor
of shape (batch_size, sequence_length)
, optional) — 用于计算掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]
范围内(请参见input_ids
文档字符串)。索引设置为-100
的标记将被忽略(掩码),损失仅计算具有标签在[0, ..., config.vocab_size]
范围内的标记。
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 而不是普通的元组。
SeamlessM4TForTextToText 的前向方法重写了__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 ) → export const metadata = 'undefined';ModelOutput or torch.LongTensor
参数
input_ids
(根据模态性质的不同形状的torch.Tensor
,可选) — 词汇表中输入序列令牌的索引。
可以使用 SeamlessM4TTokenizer 或 SeamlessM4TProcessor 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call
()。
什么是输入 ID?
tgt_lang
(str
, 可选) — 用作翻译目标语言的语言。
generation_config
(~generation.GenerationConfig
, 可选) — 用作生成调用的基本参数化的生成配置。与generation_config
属性匹配的**kwargs
传递给 generate 将覆盖它们。如果未提供generation_config
,将使用默认值,其加载优先级如下:1)从generation_config.json
模型文件中获取,如果存在;2)从模型配置中获取。请注意,未指定的参数将继承 GenerationConfig 的默认值,应检查其文档以参数化生成。
logits_processor
(LogitsProcessorList
, 可选) — 自定义 logits 处理器,用于补充从参数和生成配置构建的默认 logits 处理器。如果传递了已经使用参数或生成配置创建的 logit 处理器,则会抛出错误。此功能适用于高级用户。
stopping_criteria
(StoppingCriteriaList
, 可选) — 自定义停止标准,用于补充从参数和生成配置构建的默认停止标准。如果传递了已经使用参数或生成配置创建的停止标准,则会抛出错误。此功能适用于高级用户。
prefix_allowed_tokens_fn
(Callable[[int, torch.Tensor], List[int]]
, 可选) — 如果提供,此函数将在每个步骤中将 beam 搜索限制为仅允许的令牌。如果未提供,则不应用约束。此函数接受 2 个参数:批次 IDbatch_id
和input_ids
。它必须返回一个列表,其中包含下一代步骤的允许令牌,条件是批次 IDbatch_id
和先前生成的令牌inputs_ids
。此参数对于基于前缀的受约束生成很有用,如自回归实体检索中所述。
synced_gpus
(bool
, 可选,默认为False
) — 是否继续运行 while 循环直到 max_length(需要 ZeRO 阶段 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 类型为:
生成标记 ID 序列。
大多数生成控制参数都在generation_config
中设置,如果未传递,则将设置为模型的默认生成配置。您可以通过传递相应的参数给 generate()来覆盖任何generation_config
,例如.generate(inputs, num_beams=4, do_sample=True)
。
有关生成策略和代码示例的概述,请查看以下指南。
class transformers.SeamlessM4TForSpeechToText
( config: SeamlessM4TConfig )
参数
config
(~SeamlessM4TConfig)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。语音到文本 SeamlessM4T 模型变压器,可用于 S2TT。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。
前进
( input_features: LongTensor = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None inputs_embeds: 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 **kwargs )
参数
input_features
(形状为(batch_size, sequence_length, num_banks)
的torch.FloatTensor
)— 输入音频特征。这应该由 SeamlessM4TFeatureExtractor 类或 SeamlessM4TProcessor 类返回。有关详细信息,请参阅 SeamlessM4TFeatureExtractor.call
()。
attention_mask
(形状为(batch_size, sequence_length)
的torch.FloatTensor
,可选)— 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]
中。
什么是注意力掩码?
decoder_input_ids
(形状为(batch_size, target_sequence_length)
的torch.LongTensor
,可选)— 词汇表中解码器输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call
()。
解码器输入 ID 是什么?
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
(形状为(batch_size, target_sequence_length)
的torch.LongTensor
,可选)— 默认行为:生成一个忽略decoder_input_ids
中填充标记的张量。因果掩码也将默认使用。
如果您想要更改填充行为,您应该阅读modeling_bart._prepare_decoder_attention_mask
并根据您的需求进行修改。有关默认策略的更多信息,请参阅论文中的图表 1。
encoder_outputs
(tuple(tuple(torch.FloatTensor)
, optional) — 元组包括(last_hidden_state
, optional: hidden_states
, optional: attentions
) last_hidden_state
的形状为(batch_size, sequence_length, hidden_size)
,optional)是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
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
输入)。
如果使用了past_key_values
,用户可以选择仅输入形状为(batch_size, 1)
的最后decoder_input_ids
(这些没有将其过去键值状态提供给此模型的)而不是所有形状为(batch_size, sequence_length)
的decoder_input_ids
。
inputs_embeds
(torch.FloatTensor
的形状为(batch_size, sequence_length, hidden_size)
,optional) — 可选地,您可以选择直接传递嵌入表示而不是传递input_ids
。如果您想要更多控制如何将input_ids
索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,则这很有用。
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_input_ids
和decoder_inputs_embeds
都未设置,则decoder_inputs_embeds
取inputs_embeds
的值。
labels
(torch.LongTensor
的形状为(batch_size, sequence_length)
,optional) — 用于计算掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]
内(请参阅input_ids
文档字符串)。索引设置为-100
的标记将被忽略(掩码),损失仅计算具有标签在[0, ..., config.vocab_size]
内的标记。
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 而不是普通元组。
SeamlessM4TForSpeechToText 的前向方法,覆盖了__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 ) → export const metadata = 'undefined';ModelOutput or torch.LongTensor
参数
input_features
(形状为(batch_size, sequence_length, num_banks)
的torch.FloatTensor
)— 输入音频特征。这应该由 SeamlessM4TFeatureExtractor 类或 SeamlessM4TProcessor 类返回。有关详细信息,请参阅 SeamlessM4TFeatureExtractor.call
()。
tgt_lang
(str
,可选)— 用作翻译目标语言的语言。
generation_config
(~generation.GenerationConfig
,可选)— 用作生成调用的基本参数化的生成配置。传递给生成匹配generation_config
属性的**kwargs
将覆盖它们。如果未提供generation_config
,将使用默认值,其加载优先级如下:1)来自generation_config.json
模型文件,如果存在;2)来自模型配置。请注意,未指定的参数将继承 GenerationConfig 的默认值,应检查其文档以参数化生成。
logits_processor
(LogitsProcessorList
,可选)— 自定义 logits 处理器,补充从参数和生成配置构建的默认 logits 处理器。如果传递的 logit 处理器已经使用参数或生成配置创建,则会引发错误。此功能适用于高级用户。
stopping_criteria
(StoppingCriteriaList
,可选)— 自定义停止标准,补充从参数和生成配置构建的默认停止标准。如果传递的停止标准已经使用参数或生成配置创建,则会引发错误。此功能适用于高级用户。
prefix_allowed_tokens_fn
(Callable[[int, torch.Tensor], List[int]]
,可选)— 如果提供,此函数将限制每一步的波束搜索仅允许特定的标记。如果未提供,则不应用任何约束。此函数接受 2 个参数:批次 ID batch_id
和 input_ids
。它必须返回一个列表,其中包含下一代步的允许标记,条件是批次 ID batch_id
和先前生成的标记 inputs_ids
。此参数对于基于前缀的受限生成很有用,如自回归实体检索中所述。
synced_gpus
(bool
,可选,默认为False
)— 是否继续运行 while 循环直到 max_length(对于 ZeRO 阶段 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 类型是:
生成标记 id 序列。
大多数控制生成的参数设置在generation_config
中,如果未传递,则将设置为模型的默认生成配置。您可以通过将相应参数传递给 generate()来覆盖任何generation_config
,例如.generate(inputs, num_beams=4, do_sample=True)
。
有关生成策略和代码示例的概述,请查看以下指南。
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 )
参数
vocab_size
(int
, optional, 默认为 256102) — SeamlessM4T 模型的词汇表大小。定义了在调用SeamlessM4TModel、SeamlessM4TForTextToSpeech 或~SeamlessM4TForTextToText 时可以表示的不同标记数量。
t2u_vocab_size
(int
, optional, 默认为 10082) — SeamlessM4T 模型的单元词汇表大小。定义了在调用SeamlessM4TModel、SeamlessM4TForSpeechToSpeech 或~SeamlessM4TForTextToSpeech 时可以表示的不同单元标记数量。
在子模型之间共享的参数
hidden_size
(int
, optional, 默认为 1024) — 架构中“中间”层的维度。
initializer_range
(float
, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
layer_norm_eps
(float
, optional, 默认为 1e-05) — 层归一化层使用的 epsilon。
use_cache
(bool
, optional, 默认为 True
) — 模型是否应返回最后一个键/值注意力(并非所有模型都使用)。
max_position_embeddings
(int
, optional, 默认为 1024) — 此模型文本编码器和解码器可能使用的最大序列长度。通常将其设置为较大的值以防万一(例如,512 或 1024 或 2048)。
is_encoder_decoder
(bool
, optional, 默认为 True
) — 模型是否用作编码器/解码器。
encoder_layerdrop
(float
, optional, 默认为 0.05) — 编码器的 LayerDrop 概率。更多细节请参阅LayerDrop 论文。
decoder_layerdrop
(float
, optional, 默认为 0.05) — 解码器的 LayerDrop 概率。更多细节请参阅LayerDrop 论文。
activation_function
(str
或 function
, optional, 默认为 "relu"
) — 解码器和前馈层中的非线性激活函数(函数或字符串)。如果是字符串,支持 "gelu"
, "relu"
, "selu"
, "swish"
和 "gelu_new"
。
dropout
(float
, optional, 默认为 0.1) — 嵌入层、编码器、解码器和池化器中所有全连接层的 dropout 概率。
attention_dropout
(float
, optional, 默认为 0.1) — 所有注意力层的 dropout 概率。
activation_dropout
(float
, optional, 默认为 0.0) — 模型中所有激活层的 dropout 概率。
scale_embedding
(bool
, optional, 默认为 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不同的标记开始解码,则该标记的 id。仅在文本解码器中应用。
max_new_tokens
(int
, optional, defaults to 256) — 生成的文本标记的最大数量,忽略提示中的标记数量。
pad_token_id
(int
, optional, defaults to 0) — 填充文本标记的 id。仅适用于文本解码器模型。
bos_token_id
(int
, optional, defaults to 2) — 流的开头文本标记的 id。仅适用于文本解码器模型。
eos_token_id
(int
, optional, defaults to 3) — 流的结尾文本标记的 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
or 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 论文。
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
为 True 时相关。
adaptor_stride
(int
, optional, defaults to 8) — 适配器网络中卷积层的步幅。仅在add_adapter
为 True 时相关。
adaptor_dropout
(float
, optional, defaults to 0.1) — 语音适配器中所有层的 dropout 概率。
num_adapter_layers
(int
, optional, defaults to 1) — 适配器网络中应使用的卷积层数。仅在add_adapter
为 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 层的内核大小。仅应用于语音编码器。
文本到单元组件(t2u)模型特定参数
t2u_bos_token_id
(int
, optional, defaults to 0) — beginning-of-stream单元标记的 id。仅应用于文本到单元 seq2seq 模型。
t2u_pad_token_id
(int
, optional, defaults to 1) — padding单元标记的 id。仅应用于文本到单元 seq2seq 模型。
t2u_eos_token_id
(int
, optional, defaults to 2) — end-of-stream单元标记的 id。仅应用于文本到单元 seq2seq 模型。
t2u_decoder_start_token_id
(int
, optional, defaults to 2) — 如果编码器-解码器模型以与bos不同的标记开始解码,则为该标记的 id。仅应用于文本到单元 seq2seq 模型。
t2u_max_new_tokens
(int
, optional, defaults to 1024) — 生成的单元标记的最大数量,忽略提示中的标记数量。仅应用于文本到单元 seq2seq 模型。
t2u_encoder_layers
(int
, optional, defaults to 6) — Transformer 文本到单元编码器中的隐藏层数量。
t2u_encoder_ffn_dim
(int
, optional, defaults to 8192) — Transformer 文本到单元编码器中“中间”(即前馈)层的维度。
t2u_encoder_attention_heads
(int
, optional, defaults to 16) — Transformer 文本到单元编码器中每个注意力层的注意力头数。
t2u_decoder_layers
(int
, optional, defaults to 6) — Transformer 文本到单元解码器中的隐藏层数量。
t2u_decoder_ffn_dim
(int
, optional, defaults to 8192) — Transformer 文本到单元解码器中“中间”(即前馈)层的维度。
t2u_decoder_attention_heads
(int
, optional, defaults to 16) — Transformer 文本到单元解码器中每个注意力层的注意力头数。
t2u_max_position_embeddings
(int
, optional, defaults to 2048) — 此模型文本到单元组件可能会使用的最大序列长度。通常将其设置为较大的值以防万一(例如 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]
或 List[int]
, optional, 默认为[11, 8, 8, 4, 4]
) — 一个整数元组,定义声码器上采样网络中每个 1D 卷积层的内核大小。upsample_kernel_sizes的长度定义了卷积层的数量,并且必须与upsample_rates的长度匹配。仅适用于声码器。
resblock_kernel_sizes
(Tuple[int]
或 List[int]
, optional, 默认为[3, 7, 11]
) — 一个整数元组,定义多接受域融合(MRF)模块中声码器 1D 卷积层的内核大小。仅适用于声码器。
resblock_dilation_sizes
(Tuple[Tuple[int]]
或 List[List[int]]
, optional, 默认为[[1, 3, 5], [1, 3, 5], [1, 3, 5]]
) — 一个嵌套的整数元组,定义多接受域融合(MRF)模块中声码器扩张的 1D 卷积层的扩张率。仅适用于声码器。
leaky_relu_slope
(float
, optional, 默认为 0.1) — 在声码器中使用的 leaky ReLU 激活的负斜率角度。仅适用于声码器。
unit_hifi_gan_vocab_size
(int
, optional, 默认为 10000) — SeamlessM4T 声码器的词汇大小。定义了在调用SeamlessM4TModel、SeamlessM4TForSpeechToSpeech 或~SeamlessM4TForTextToSpeech 时可以表示的不同单元标记数量。
unit_embed_dim
(int
, optional, 默认为 1280) — 提供给 hifi-gan 声码器的输入 id 的投影维度。仅适用于声码器。
lang_embed_dim
(int
, optional, 默认为 256) — 提供给 hifi-gan 声码器的目标语言的投影维度。仅适用于声码器。
spkr_embed_dim
(int
, optional, 默认为 256) — 提供给 hifi-gan 声码器的说话人 id 的投影维度。仅适用于声码器。
vocoder_num_langs
(int
, optional, 默认为 36) — 声码器支持的语言数量。可能与t2u_num_langs
不同。
vocoder_num_spkrs
(int
, optional, 默认为 200) — 声码器支持的说话人数量。
variance_predictor_kernel_size
(int
, optional, 默认为 3) — 持续预测器的内核大小。仅适用于声码器。
var_pred_dropout
(float
, optional, 默认为 0.5) — 持续预测器的 dropout 概率。仅适用于声码器。
vocoder_offset
(int
, optional, 默认为 4) — 将单元标记 id 偏移此数字以考虑符号标记。仅适用于声码器。
这是用于存储~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
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: Optional = None additional_special_tokens = None **kwargs )
参数
vocab_file
(str
) — 词汇文件的路径。
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>"
) — 用于序列分类时使用的分类器标记(对整个序列进行分类,而不是对每个标记进行分类)。当使用特殊标记构建序列时,它是序列的第一个标记。
unk_token
(str
, optional, defaults to "<unk>"
) — 未知标记。词汇表中不存在的标记无法转换为 ID,而是设置为此标记。
pad_token
(str
, optional, defaults to "<pad>"
) — 用于填充的标记,例如在批处理不同长度的序列时。
tokenizer_file
(str
, optional) — 要使用的分词器文件的路径,而不是词汇文件。
src_lang
(str
, optional, defaults to "eng"
) — 用作翻译源语言的语言。
tgt_lang
(str
, optional, defaults to "fra"
) — 用作翻译目标语言的语言。
sp_model_kwargs
(Dict[str, Any]
, optional) — 传递给模型初始化的额外关键字参数。
additional_special_tokens
(元组或str
或tokenizers.AddedToken
的列表,optional) — 附加特殊标记的元组或列表。可用于指定将由分词器支持的语言列表。
构建一个 SeamlessM4T 分词器。
改编自 RobertaTokenizer 和 XLNetTokenizer。基于SentencePiece。
源语言文档的标记方法为<language code> <tokens> <eos>
,目标语言文档的标记方法为<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: Union = None text_pair: Union = None text_target: Union = None text_pair_target: Union = None padding: Union = True pad_to_multiple_of: Optional = 2 src_lang: Optional = None tgt_lang: Optional = 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
或 PaddingStrategy,可选,默认为True
) — 选择一种策略来填充返回的序列(根据模型的填充方向和填充索引):
True
或 'longest'
:填充到批次中最长的序列(如果只提供了单个序列,则不填充)。
'max_length'
:填充到指定的最大长度(使用参数max_length
)或填充到模型的最大可接受输入长度(如果未提供该参数)。
False
或 'do_not_pad'
(默认):无填充(即可以输出长度不同的序列批次)。
pad_to_multiple_of
(int
,可选) — 如果设置,将填充序列到提供的值的倍数。
这对于启用 NVIDIA 硬件上的 Tensor Cores 特别有用,其计算能力为>= 7.5
(Volta)。
src_lang
(str
,可选) — 表示源语言的字符串。如果未指定,则将使用上次指定的src_lang
(在初始化时或调用此分词器时)。
tgt_lang
(str
,可选) — 表示目标语言的字符串。如果未指定,则将使用上次指定的tgt_lang
(在初始化时或调用此分词器时)。
kwargs
(可选) — 传递给 PreTrainedTokenizer.call
()的剩余关键字参数字典。
build_inputs_with_special_tokens
( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]
参数
token_ids_0
(List[int]
) — 将添加特殊标记的 ID 列表。
token_ids_1
(List[int]
, 可选) — 序列对的可选第二个 ID 列表。
返回
List[int]
带有适当特殊标记的 input IDs 列表。
通过连接和添加特殊标记从序列或序列对构建用于序列分类任务的模型输入。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: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → export const metadata = 'undefined';List[int]
参数
token_ids_0
(List[int]
) — ID 列表。
token_ids_1
(List[int]
, 可选) — 序列对的可选第二个 ID 列表。
already_has_special_tokens
(bool
,可选,默认为False
) — 标记列表是否已经为模型格式化了特殊标记。
返回
List[int]
一个整数列表,范围为[0, 1]:1 表示特殊标记,0 表示序列标记。
从没有添加特殊标记的标记列表中检索序列 ID。在使用分词器prepare_for_model
方法添加特殊标记时调用此方法。
create_token_type_ids_from_sequences
( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]
参数
token_ids_0
(List[int]
) — ID 列表。
token_ids_1
(List[int]
, 可选) — 序列对的可选第二个 ID 列表。
返回
List[int]
零的列表。
从传递的两个序列创建一个用于序列对分类任务的掩码。nllb 不使用标记类型 ID,因此返回一个零列表。
save_vocabulary
( save_directory: str filename_prefix: Optional = None )
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
, 可选) — 词汇表文件的路径。
tokenizer_file
(str
, 可选) — 要使用的分词器文件的路径,而不是词汇表文件。
bos_token
(str
, 可选, 默认为 "<s>"
) — 在预训练期间使用的序列开头标记。可以用作序列分类器标记。
在使用特殊标记构建序列时,这不是用于序列开头的标记。使用的标记是 cls_token
。
eos_token
(str
, 可选, 默认为 "</s>"
) — 序列结束标记。
在使用特殊标记构建序列时,这不是用于序列结尾的标记。使用的标记是 sep_token
。
sep_token
(str
, 可选, 默认为 "</s>"
) — 分隔符标记,在从多个序列构建序列时使用,例如用于序列分类的两个序列或用于文本和问题的问题回答。它还用作使用特殊标记构建的序列的最后一个标记。
cls_token
(str
, 可选, 默认为 "<s>"
) — 在进行序列分类(整个序列而不是每个标记的分类)时使用的分类器标记。当使用特殊标记构建序列时,它是序列的第一个标记。
unk_token
(str
, 可选, 默认为 "<unk>"
) — 未知标记。词汇表中不存在的标记无法转换为 ID,而是设置为此标记。
pad_token
(str
, 可选, 默认为 "<pad>"
) — 用于填充的标记,例如在批处理不同长度的序列时使用。
src_lang
(str
, 可选, 默认为 "eng"
) — 用作翻译源语言的语言。
tgt_lang
(str
, 可选, 默认为 "fra"
) — 用作翻译目标语言的语言。
additional_special_tokens
(str
或 tokenizers.AddedToken
的元组或列表,可选) — 附加特殊标记的元组或列表。
构建一个“快速” SeamlessM4T 分词器(由 HuggingFace 的 tokenizers 库支持)。基于BPE。
此分词器继承自 PreTrainedTokenizerFast,其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。
对于源语言文档,标记方法是 <语言代码> <标记> <eos>
,对于目标语言文档,标记方法是 <eos> <语言代码> <标记> <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: Union = None text_pair: Union = None text_target: Union = None text_pair_target: Union = None padding: Union = True pad_to_multiple_of: Optional = 2 src_lang: Optional = None tgt_lang: Optional = None **kwargs )
参数
text
(str
, List[str]
, List[List[str]]
, 可选) — 要编码的序列或序列批次。每个序列可以是字符串或字符串列表(预分词字符串)。如果提供的序列是字符串列表(预分词的),必须设置 is_split_into_words=True
(以消除与序列批次的歧义)。
text_pair
(str
,List[str]
,List[List[str]]
,可选)— 要编码的序列或批次。每个序列可以是字符串或字符串列表(预分词字符串)。如果将序列提供为字符串列表(预分词),则必须设置is_split_into_words=True
(以消除与批次序列的歧义)。
text_target
(str
,List[str]
,List[List[str]]
,可选)— 要编码为目标文本的序列或批次。每个序列可以是字符串或字符串列表(预分词字符串)。如果将序列提供为字符串列表(预分词),则必须设置is_split_into_words=True
(以消除与批次序列的歧义)。
text_pair_target
(str
,List[str]
,List[List[str]]
,可选)— 要编码为目标文本的序列或批次。每个序列可以是字符串或字符串列表(预分词字符串)。如果将序列提供为字符串列表(预分词),则必须设置is_split_into_words=True
(以消除与批次序列的歧义)。
padding
(bool
,str
或 PaddingStrategy,可选,默认为True
)— 选择一种策略来填充返回的序列(根据模型的填充方向和填充索引),包括:
True
或'longest'
:填充到批次中最长的序列(如果只提供单个序列,则不填充)。
'max_length'
: 使用参数max_length
指定的最大长度进行填充,或者如果未提供该参数,则填充到模型可接受的最大输入长度。
False
或'do_not_pad'
(默认):不填充(即,可以输出具有不同长度序列的批次)。
pad_to_multiple_of
(int
,可选)— 如果设置,将序列填充到提供的值的倍数。
这对于启用 NVIDIA 硬件上的 Tensor Cores 特别有用,其计算能力为>= 7.5
(Volta)。
src_lang
(str
,可选)— 表示源语言的字符串。如果未指定,则将使用上次指定的src_lang
(在初始化期间或在调用此分词器时)。
tgt_lang
(str
,可选)— 表示目标语言的字符串。如果未指定,则将使用上次指定的tgt_lang
(在初始化期间或在调用此分词器时)。
kwargs
(可选)— 将传递给 PreTrainedTokenizerFast.call
()的剩余关键字参数字典。
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)— 用于填充向量的值。
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: Union padding: Union = True pad_to_multiple_of: Optional = 2 max_length: Optional = None truncation: bool = False return_tensors: Union = None sampling_rate: Optional = None return_attention_mask: Optional = None do_normalize_per_mel_bins: Optional = 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
视为单声道、单样本声音。在所有其他情况下,无论是来自 np.ndarray
、torch.Tensor
还是 List[...]
的第一个维度,都对应于批次中的样本数,通道数(即单声道或立体声特征)从其他维度中派生(1D -> 单声道波形批次;2D -> 立体声波形批次)。
padding
(bool
, str
或 PaddingStrategy, optional, 默认为 True
) — 选择一种策略来填充返回的序列(根据模型的填充方向和填充索引):
True
或 'longest'
: 填充到批次中最长的序列(如果只提供了单个序列,则不进行填充)。
'max_length'
: 使用参数 max_length
指定的最大长度进行填充,或者如果未提供该参数,则填充到模型可接受的最大输入长度。
False
或 'do_not_pad'
(默认):无填充(即,可以输出长度不同的序列批次)。
pad_to_multiple_of
(int
, optional, 默认为 2) — 如果设置,将序列填充到提供的值的倍数。
这对于启用 NVIDIA 硬件上的 Tensor Cores 特别有用,其计算能力 >= 7.5
(Volta),或者对于受益于序列长度为 128 的倍数的 TPU。
max_length
(int
, optional) — 返回列表的最大长度和可选填充长度(见上文)。
truncation
(bool
) — 激活截断,将输入序列截断为长于 max_length 的部分至 max_length。
return_attention_mask
(bool
, optional) — 是否返回注意力掩码。如果保持默认设置,将根据特定 feature_extractor 的默认设置返回注意力掩码。
什么是注意力掩码?
对于 SeamlessM4T 模型,在批量推理时应始终传递 attention_mask
,以避免细微错误。
return_tensors
(str
或 TensorType, optional) — 如果设置,将返回张量而不是 Python 整数列表。可接受的值为:
'tf'
: 返回 TensorFlow tf.constant
对象。
'pt'
: 返回 PyTorch torch.Tensor
对象。
'np'
: 返回 Numpy np.ndarray
对象。
sampling_rate
(int
, optional) — raw_speech
输入的采样率。强烈建议在前向调用时传递 sampling_rate
,以防止潜在错误。
do_normalize_per_mel_bins
(bool
, optional, 默认为 True
) — 是否对每个 mel 通道的输入进行零均值单位方差归一化。
kwargs
(optional) — 将传递给分词器或特征提取器的剩余关键字参数字典。
对一个或多个序列进行特征化和准备模型的主要方法。
class transformers.SeamlessM4TProcessor
( feature_extractor tokenizer )
参数
feature_extractor
(SeamlessM4TFeatureExtractor) — 音频处理器是必需的输入。
tokenizer
(SeamlessM4TTokenizerFast) — 必需的输入是 tokenizer。
构建一个 SeamlessM4T 处理器,将 SeamlessM4T 特征提取器和 SeamlessM4T tokenizer 封装成一个单一处理器。
SeamlessM4TProcessor 提供了 SeamlessM4TFeatureExtractor 和 SeamlessM4TTokenizerFast 的所有功能。查看call()和decode()
获取更多信息。
__call__
( text = None audios = None src_lang = None tgt_lang = None **kwargs ) → export const metadata = 'undefined';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
, 可选) — 输入文本/音频的语言代码。如果未指定,将使用最后指定的src_lang
。
tgt_lang
(str
, 可选) — 目标语言的代码。如果未指定,将使用最后指定的tgt_lang
。
kwargs
(可选) — 将传递给特征提取器和/或 tokenizer 的剩余关键字参数字典。
返回
BatchEncoding
一个带有以下字段的 BatchEncoding:
input_ids
— 要输入模型的标记 id 列表。当text
不是None
时返回。
attention_mask
— 指定哪些标记应该被模型关注的索引列表(当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()。更多信息请参考上述两种方法的文档。
class transformers.SeamlessM4TCodeHifiGan
( config )
参数
config
(SeamlessM4TConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。根据此存储库中描述的 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)
) — 词汇表中输入序列标记的索引。
可以使用 SeamlessM4TTextToUnitForConditionalGeneration 获取索引。什么是输入 ID?
spkr_id
(int
, 可选) — 用于语音合成的说话者 ID。必须小于config.vocoder_num_spkrs
。
tgt_lang
(str
, 可选) — 用作翻译目标语言的语言 ID。
class transformers.SeamlessM4THifiGan
( config: SeamlessM4TConfig )
forward
( input_embeds: FloatTensor ) → export const metadata = 'undefined';torch.FloatTensor
参数
spectrogram
(torch.FloatTensor
) — 包含对数梅尔频谱图的张量。可以是批处理的,形状为(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,)
。
将对数梅尔频谱图转换为语音波形。传递一批对数梅尔频谱图将返回一批语音波形。传递单个、未经批处理的对数梅尔频谱图将返回单个、未经批处理的语音波形。
class transformers.SeamlessM4TTextToUnitModel
( config: SeamlessM4TConfig embed_tokens_decoder: Optional = None )
参数
config
(~SeamlessM4TConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。
embed_tokens_decoder
(nn.Embedding
, 可选) — 解码器的输入嵌入。
Transformer 裸文本到单元编码器-解码器。编码器是一个没有嵌入的SeamlessM4TEncoder
,解码器是一个SeamlessM4TDecoder
。这个模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。
class transformers.SeamlessM4TTextToUnitForConditionalGeneration
( config: SeamlessM4TConfig embed_tokens_decoder: Optional = None )
参数
config
(~SeamlessM4TConfig)- 模型配置类,包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。
embed_tokens_decoder
(nn.Embedding
,可选)- 解码器的输入嵌入。
带有语言模型头的文本到单元编码器-解码器。基本编码器-解码器模型是SeamlessM4TTextToUnit
。这个模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。
forward
( input_ids: LongTensor = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None inputs_embeds: 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 )
参数
input_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)- 输入序列标记的索引。
可以使用 SeamlessM4TTokenizer 或 SeamlessM4TProcessor 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call
()获取详细信息。
什么是输入 ID?
attention_mask
(形状为(batch_size, sequence_length)
的torch.FloatTensor
,可选)- 避免对填充标记索引执行注意力的掩码。掩码值选在[0, 1]
范围内:
masked
的标记,
masked
的标记。
什么是注意力掩码?
decoder_input_ids
(形状为(batch_size, target_sequence_length)
的torch.LongTensor
,可选)- 词汇表中解码器输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call
()获取详细信息。
什么是解码器输入 ID?
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
(形状为(batch_size, target_sequence_length)
的torch.LongTensor
,可选)— 默认行为:生成一个忽略decoder_input_ids
中填充标记的张量。因果掩码也将默认使用。
如果要更改填充行为,您应该阅读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
,用户可以选择仅输入最后的decoder_input_ids
(那些没有将其过去的键值状态提供给此模型的)的形状为(batch_size, 1)
的张量,而不是形状为(batch_size, sequence_length)
的所有decoder_input_ids
。
inputs_embeds
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选)— 可选择直接传递嵌入表示,而不是传递input_ids
。如果您想要更多控制权来将input_ids
索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,这将非常有用。
decoder_inputs_embeds
(形状为(batch_size, target_sequence_length, hidden_size)
的torch.FloatTensor
,可选)— 可选择直接传递嵌入表示,而不是传递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
,可选)— 用于计算掩码语言建模损失的标签。索引应在[-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 而不是普通元组。
SeamlessM4TTextToUnitForConditionalGeneration 的前向方法重写了__call__
特殊方法。
尽管前向传递的配方需要在此函数内定义,但应该在此之后调用Module
实例,而不是这个,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。
, target_sequence_length)的
torch.LongTensor`,可选)- 词汇表中解码器输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.`call`()获取详细信息。
什么是解码器输入 ID?
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
(形状为(batch_size, target_sequence_length)
的torch.LongTensor
,可选)— 默认行为:生成一个忽略decoder_input_ids
中填充标记的张量。因果掩码也将默认使用。
如果要更改填充行为,您应该阅读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
,用户可以选择仅输入最后的decoder_input_ids
(那些没有将其过去的键值状态提供给此模型的)的形状为(batch_size, 1)
的张量,而不是形状为(batch_size, sequence_length)
的所有decoder_input_ids
。
inputs_embeds
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选)— 可选择直接传递嵌入表示,而不是传递input_ids
。如果您想要更多控制权来将input_ids
索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,这将非常有用。
decoder_inputs_embeds
(形状为(batch_size, target_sequence_length, hidden_size)
的torch.FloatTensor
,可选)— 可选择直接传递嵌入表示,而不是传递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
,可选)— 用于计算掩码语言建模损失的标签。索引应在[-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 而不是普通元组。
SeamlessM4TTextToUnitForConditionalGeneration 的前向方法重写了__call__
特殊方法。
尽管前向传递的配方需要在此函数内定义,但应该在此之后调用Module
实例,而不是这个,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。