Qwen2Audio

概述

Qwen2-Audio 是 Qwen 团队新推出的大型音频语言模型系列。Qwen2-Audio 能够接收各种音频信号输入，并针对语音指令执行音频分析或直接文本响应。我们介绍了两种不同的音频交互模式

语音聊天：用户可以自由地与 Qwen2-Audio 进行语音互动，无需文本输入
音频分析：用户可以在互动期间提供音频和文本指令进行分析

它在 Qwen2-Audio 技术报告中被提出，作者为 Yunfei Chu, Jin Xu, Qian Yang, Haojie Wei, Xipin Wei, Zhifang Guo, Yichong Leng, Yuanjun Lv, Jinzheng He, Junyang Lin, Chang Zhou, Jingren Zhou。

该论文的摘要如下

我们介绍了 Qwen-Audio 的最新进展，这是一个名为 Qwen2-Audio 的大规模音频语言模型，它能够接收各种音频信号输入，并针对语音指令执行音频分析或直接文本响应。与复杂的层级标签相比，我们通过为不同的数据和任务使用自然语言提示简化了预训练过程，并进一步扩大了数据量。我们提升了 Qwen2-Audio 的指令遵循能力，并为语音聊天和音频分析实现了两种不同的音频交互模式。在语音聊天模式下，用户可以自由地与 Qwen2-Audio 进行语音互动，无需文本输入。在音频分析模式下，用户可以在互动期间提供音频和文本指令进行分析。请注意，我们不使用任何系统提示来切换语音聊天和音频分析模式。Qwen2-Audio 能够智能地理解音频中的内容，并遵循语音命令做出适当的响应。例如，在一个同时包含声音、多说话人对话和语音命令的音频片段中，Qwen2-Audio 可以直接理解命令，并提供对音频的解释和响应。此外，DPO 优化了模型在事实性和符合期望行为方面的性能。根据 AIR-Bench 的评估结果，在以音频为中心的指令遵循能力测试中，Qwen2-Audio 的性能优于之前的 SOTA 模型，如 Gemini-1.5-pro。Qwen2-Audio 已开源，旨在促进多模态语言社区的发展。

使用技巧

Qwen2-Audio-7B 和 Qwen2-Audio-7B-Instruct 可以在 Huggingface Hub 上找到

推理

from io import BytesIO
from urllib.request import urlopen
import librosa
from transformers import AutoProcessor, Qwen2AudioForConditionalGeneration

model = Qwen2AudioForConditionalGeneration.from_pretrained("Qwen/Qwen2-Audio-7B", trust_remote_code=True, device_map="auto")
processor = AutoProcessor.from_pretrained("Qwen/Qwen2-Audio-7B", trust_remote_code=True)

prompt = "<|audio_bos|><|AUDIO|><|audio_eos|>Generate the caption in English:"
url = "https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen-Audio/glass-breaking-151256.mp3"
audio, sr = librosa.load(BytesIO(urlopen(url).read()), sr=processor.feature_extractor.sampling_rate)
inputs = processor(text=prompt, audios=audio, return_tensors="pt").to(model.device)

generate_ids = model.generate(**inputs, max_length=256)
generate_ids = generate_ids[:, inputs.input_ids.size(1):]

response = processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]

# We can also omit the audio_bos and audio_eos tokens
prompt = "<|AUDIO|>Generate the caption in English:"
inputs = processor(text=prompt, audios=audio, return_tensors="pt").to(model.device)

generate_ids = model.generate(**inputs, max_length=256)
generate_ids = generate_ids[:, inputs.input_ids.size(1):]

response = processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]

在下面，我们将演示如何使用 Qwen2-Audio-7B-Instruct 进行推理，支持语音聊天和音频分析模式。请注意，我们使用了 ChatML 格式进行对话，在这个演示中，我们将展示如何利用 apply_chat_template 来实现此目的。

语音聊天推理

在语音聊天模式下，用户可以自由地与 Qwen2-Audio 进行语音互动，无需文本输入

from io import BytesIO
from urllib.request import urlopen
import librosa
from transformers import Qwen2AudioForConditionalGeneration, AutoProcessor

processor = AutoProcessor.from_pretrained("Qwen/Qwen2-Audio-7B-Instruct")
model = Qwen2AudioForConditionalGeneration.from_pretrained("Qwen/Qwen2-Audio-7B-Instruct", device_map="auto")

conversation = [
    {"role": "user", "content": [
        {"type": "audio", "audio_url": "https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen2-Audio/audio/guess_age_gender.wav"},
    ]},
    {"role": "assistant", "content": "Yes, the speaker is female and in her twenties."},
    {"role": "user", "content": [
        {"type": "audio", "audio_url": "https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen2-Audio/audio/translate_to_chinese.wav"},
    ]},
]
text = processor.apply_chat_template(conversation, add_generation_prompt=True, tokenize=False)
audios = []
for message in conversation:
    if isinstance(message["content"], list):
        for ele in message["content"]:
            if ele["type"] == "audio":
                audios.append(librosa.load(
                    BytesIO(urlopen(ele['audio_url']).read()),
                    sr=processor.feature_extractor.sampling_rate)[0]
                )

inputs = processor(text=text, audios=audios, return_tensors="pt", padding=True)
inputs.input_ids = inputs.input_ids.to("cuda")

generate_ids = model.generate(**inputs, max_length=256)
generate_ids = generate_ids[:, inputs.input_ids.size(1):]

response = processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]

音频分析推理

在音频分析中，用户可以提供音频和文本指令进行分析

from io import BytesIO
from urllib.request import urlopen
import librosa
from transformers import Qwen2AudioForConditionalGeneration, AutoProcessor

processor = AutoProcessor.from_pretrained("Qwen/Qwen2-Audio-7B-Instruct")
model = Qwen2AudioForConditionalGeneration.from_pretrained("Qwen/Qwen2-Audio-7B-Instruct", device_map="auto")

conversation = [
    {'role': 'system', 'content': 'You are a helpful assistant.'},
    {"role": "user", "content": [
        {"type": "audio", "audio_url": "https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen2-Audio/audio/glass-breaking-151256.mp3"},
        {"type": "text", "text": "What's that sound?"},
    ]},
    {"role": "assistant", "content": "It is the sound of glass shattering."},
    {"role": "user", "content": [
        {"type": "text", "text": "What can you do when you hear that?"},
    ]},
    {"role": "assistant", "content": "Stay alert and cautious, and check if anyone is hurt or if there is any damage to property."},
    {"role": "user", "content": [
        {"type": "audio", "audio_url": "https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen2-Audio/audio/1272-128104-0000.flac"},
        {"type": "text", "text": "What does the person say?"},
    ]},
]
text = processor.apply_chat_template(conversation, add_generation_prompt=True, tokenize=False)
audios = []
for message in conversation:
    if isinstance(message["content"], list):
        for ele in message["content"]:
            if ele["type"] == "audio":
                audios.append(
                    librosa.load(
                        BytesIO(urlopen(ele['audio_url']).read()),
                        sr=processor.feature_extractor.sampling_rate)[0]
                )

inputs = processor(text=text, audios=audios, return_tensors="pt", padding=True)
inputs.input_ids = inputs.input_ids.to("cuda")

generate_ids = model.generate(**inputs, max_length=256)
generate_ids = generate_ids[:, inputs.input_ids.size(1):]

response = processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]

批量推理

我们也支持批量推理

from io import BytesIO
from urllib.request import urlopen
import librosa
from transformers import Qwen2AudioForConditionalGeneration, AutoProcessor

processor = AutoProcessor.from_pretrained("Qwen/Qwen2-Audio-7B-Instruct")
model = Qwen2AudioForConditionalGeneration.from_pretrained("Qwen/Qwen2-Audio-7B-Instruct", device_map="auto")

conversation1 = [
    {"role": "user", "content": [
        {"type": "audio", "audio_url": "https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen2-Audio/audio/glass-breaking-151256.mp3"},
        {"type": "text", "text": "What's that sound?"},
    ]},
    {"role": "assistant", "content": "It is the sound of glass shattering."},
    {"role": "user", "content": [
        {"type": "audio", "audio_url": "https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen2-Audio/audio/f2641_0_throatclearing.wav"},
        {"type": "text", "text": "What can you hear?"},
    ]}
]

conversation2 = [
    {"role": "user", "content": [
        {"type": "audio", "audio_url": "https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen2-Audio/audio/1272-128104-0000.flac"},
        {"type": "text", "text": "What does the person say?"},
    ]},
]

conversations = [conversation1, conversation2]

text = [processor.apply_chat_template(conversation, add_generation_prompt=True, tokenize=False) for conversation in conversations]

audios = []
for conversation in conversations:
    for message in conversation:
        if isinstance(message["content"], list):
            for ele in message["content"]:
                if ele["type"] == "audio":
                    audios.append(
                        librosa.load(
                            BytesIO(urlopen(ele['audio_url']).read()),
                            sr=processor.feature_extractor.sampling_rate)[0]
                    )

inputs = processor(text=text, audios=audios, return_tensors="pt", padding=True)
inputs['input_ids'] = inputs['input_ids'].to("cuda")
inputs.input_ids = inputs.input_ids.to("cuda")

generate_ids = model.generate(**inputs, max_length=256)
generate_ids = generate_ids[:, inputs.input_ids.size(1):]

response = processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)

Qwen2AudioConfig

class transformers.Qwen2AudioConfig

< source >

( audio_config = None text_config = None audio_token_index = 151646 **kwargs )

参数

audio_config (Union[AutoConfig, dict], 可选, 默认为 CLIPVisionConfig) — 音频骨干网络的配置对象或字典。
text_config (Union[AutoConfig, dict], 可选, 默认为 LlamaConfig) — 文本骨干网络的配置对象或字典。
audio_token_index (int, 可选, 默认为 151646) — 用于编码图像提示的图像 token 索引。

这是用于存储 Qwen2AudioForConditionalGeneration 配置的配置类。它用于根据指定的参数实例化 Qwen2-Audio 模型，定义模型架构。使用默认值实例化配置将产生与 Qwen2-Audio 类似的配置。

例如：Qwen/Qwen2-Audio-7B

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

示例

>>> from transformers import Qwen2AudioForConditionalGeneration, Qwen2AudioConfig, Qwen2AudioEncoderConfig, Qwen2Config

>>> # Initializing a Qwen2AudioEncoder config
>>> audio_config = Qwen2AudioEncoderConfig()

>>> # Initializing a Qwen2 config
>>> text_config = Qwen2Config()

>>> # Initializing a Qwen2Audio configuration
>>> configuration = Qwen2AudioConfig(audio_config, text_config)

>>> # Initializing a model from the qwen2-audio style configuration
>>> model = Qwen2AudioForConditionalGeneration(configuration)

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

Qwen2AudioEncoderConfig

class transformers.Qwen2AudioEncoderConfig

< source >

( num_mel_bins = 128 encoder_layers = 32 encoder_attention_heads = 20 encoder_ffn_dim = 5120 encoder_layerdrop = 0.0 d_model = 1280 dropout = 0.0 attention_dropout = 0.0 activation_function = 'gelu' activation_dropout = 0.0 scale_embedding = False init_std = 0.02 max_source_positions = 1500 **kwargs )

参数

num_mel_bins (int, 可选, 默认为 128) — 每个输入特征使用的梅尔特征数量。应与 Qwen2AudioProcessor 类中使用的值相对应。
encoder_layers (int, 可选, 默认为 32) — 编码器层数。
encoder_attention_heads (int, 可选, 默认为 20) — Transformer 编码器中每个注意力层的注意力头数。
encoder_ffn_dim (int, 可选, 默认为 5120) — 编码器中“中间”（通常称为前馈）层的维度。
encoder_layerdrop (float, 可选, 默认为 0.0) — 编码器的 LayerDrop 概率。有关更多详细信息，请参阅 [LayerDrop 论文](see https://arxiv.org/abs/1909.11556)。
d_model (int, 可选, 默认为 1280) — 层的维度。
dropout (float, 可选, 默认为 0.0) — 嵌入层、编码器和池化层中所有全连接层的 dropout 概率。
attention_dropout (float, 可选, 默认为 0.0) — 注意力概率的 dropout 比率。
activation_function (str, 可选, 默认为 "gelu") — 编码器和池化层中的非线性激活函数（函数或字符串）。如果为字符串，则支持 "gelu"、"relu"、"silu" 和 "gelu_new"。
activation_dropout (float, 可选, 默认为 0.0) — 全连接层内部激活的 dropout 比率。
scale_embedding (bool, 可选, 默认为 False) — 通过除以 sqrt(d_model) 来缩放嵌入。
init_std (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
max_source_positions (int, 可选, 默认为 1500) — 此模型可能使用的 log-mel 滤波器组特征的最大序列长度。

这是用于存储 Qwen2AudioEncoder 配置的配置类。它用于根据指定的参数实例化 Qwen2-Audio 音频编码器，定义模型架构。使用默认值实例化配置将产生与 Qwen2-Audio 架构的音频编码器类似的配置。

例如：Qwen/Qwen2-Audio-7B

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

示例

>>> from transformers import Qwen2AudioEncoderConfig, Qwen2AudioEncoder

>>> # Initializing a Qwen2AudioEncoderConfig
>>> configuration = Qwen2AudioEncoderConfig()

>>> # Initializing a Qwen2AudioEncoder (with random weights)
>>> model = Qwen2AudioEncoder(configuration)

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

Qwen2AudioProcessor

class transformers.Qwen2AudioProcessor

< source >

参数

feature_extractor (WhisperFeatureExtractor, 可选) — 特征提取器是必需的输入。
tokenizer (Qwen2TokenizerFast, 可选) — 分词器是必需的输入。
chat_template (Optional[str], 可选) — 用于格式化对话的 Jinja 模板。如果未提供，则使用默认的聊天模板。
audio_token (str, 可选, 默认为 "<|AUDIO|>") — 用于音频 tokens 的 token。
audio_bos_token (str, 可选, 默认为 "<|audio_bos|>") — 用于音频 bos tokens 的 token。
audio_eos_token (str, 可选, 默认为 "<|audio_eos|>") — 用于音频 eos tokens 的 token。

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

Qwen2AudioProcessor 提供了 WhisperFeatureExtractor 和 Qwen2TokenizerFast 的所有功能。有关更多信息，请参阅 __call__() 和 decode()。

batch_decode

< source >

( *args **kwargs )

此方法将其所有参数转发到 Qwen2TokenizerFast 的 batch_decode()。有关更多信息，请参阅此方法的文档字符串。

解码

< source >

( *args **kwargs )

此方法将其所有参数转发到 Qwen2TokenizerFast 的 decode()。有关更多信息，请参阅此方法的文档字符串。

Qwen2AudioEncoder

class transformers.Qwen2AudioEncoder

< source >

( config: Qwen2AudioEncoderConfig )

参数

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

来自 Qwen2Audio 的音频模型，顶部没有任何 head 或 projection。此模型继承自 PreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝 head 等）。

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

Transformer 编码器，由 config.encoder_layers 自注意力层组成。每层都是一个 Qwen2AudioEncoderLayer。

前向传播

< source >

( input_features attention_mask = None head_mask = None output_attentions = None output_hidden_states = None return_dict = None )

参数

input_features (torch.LongTensor，形状为 (batch_size, feature_size, sequence_length)) — 从原始语音波形中提取的 mel 特征的浮点值。原始语音波形可以通过将 .flac 或 .wav 音频文件加载到 List[float] 类型的数组或 numpy.ndarray 中来获得，例如通过 soundfile 库 (pip install soundfile)。要将数组准备为 input_features，应使用 AutoFeatureExtractor 来提取 mel 特征、填充并转换为 torch.FloatTensor 类型的张量。请参阅 call()
attention_mask (torch.Tensor), *optional*) -- Qwen2Audio 不支持对 input_features` 进行掩码，此参数保留用于兼容性，但未使用。默认情况下，输入 log mel 频谱图中的静音将被忽略。
head_mask (torch.Tensor，形状为 (encoder_layers, encoder_attention_heads)，可选) — 用于置空注意力模块的选定 head 的掩码。在 [0, 1] 中选择的掩码值：
- 1 表示 head 未被掩码，
- 0 表示 head 被掩码。
output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。

Qwen2AudioForConditionalGeneration

class transformers.Qwen2AudioForConditionalGeneration

< source >

( config: Qwen2AudioConfig )

参数

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

QWEN2AUDIO 模型，它由音频骨干网络和语言模型组成。此模型继承自 PreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝 head 等）。

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

前向传播

< source >

( input_ids: LongTensor = None input_features: FloatTensor = None attention_mask: typing.Optional[torch.Tensor] = None feature_attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[transformers.cache_utils.Cache] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.qwen2_audio.modeling_qwen2_audio.Qwen2AudioCausalLMOutputWithPast 或 tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。默认情况下，如果您提供填充，则会忽略填充。

索引可以使用 AutoTokenizer 获得。请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 了解详细信息。

什么是输入 ID？
input_features (torch.FloatTensor，形状为 (batch_size, feature_size, feature_sequence_length)) — 从原始语音波形中提取的 mel 特征的浮点值。原始语音波形可以通过将 .flac 或 .wav 音频文件加载到 List[float] 类型的数组或 numpy.ndarray 中来获得，例如通过 soundfile 库 (pip install soundfile)。要将数组准备为 input_features，应使用 AutoFeatureExtractor 来提取 mel 特征、填充并转换为 torch.FloatTensor 类型的张量。请参阅 call()
attention_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 掩码，用于避免在填充 token 索引上执行注意力机制。在 [0, 1] 中选择的掩码值：
- 1 表示 token 未被掩码，
- 0 表示 token 被掩码。
什么是注意力掩码？

索引可以使用 AutoTokenizer 获得。请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 了解详细信息。

如果使用 past_key_values，则可以选择仅输入最后的 decoder_input_ids（请参阅 past_key_values）。

如果您想更改填充行为，您应该阅读 modeling_opt._prepare_decoder_attention_mask 并根据您的需要进行修改。有关默认策略的更多信息，请参阅论文中的图 1。
- 1 表示 head 未被掩码，
- 0 表示 head 被掩码。
feature_attention_mask (torch.Tensor，形状为 (batch_size, feature_sequence_length)) — 掩码，用于避免在填充特征索引上执行注意力机制。在 [0, 1] 中选择的掩码值：
- 1 表示 token 未被掩码，
- 0 表示 token 被掩码。
position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列 token 的位置索引。在 [0, config.n_positions - 1] 范围内选择。什么是位置 ID？
past_key_values (Cache，可选，当传递 use_cache=True 或当 config.use_cache=True 时返回) — 预先计算的隐藏状态，可用于加速自回归（顺序）解码。有两组预先计算的隐藏状态：自注意力模块中的键和值状态。当传递 use_cache=True 或当 config.use_cache=True 时，将返回 past_key_values。它是 Cache 实例。

如果使用 past_key_values，则用户可以选择仅输入最后的 input_ids（那些没有将其过去的键值状态提供给此模型的）形状为 (batch_size, 1)，而不是所有形状为 (batch_size, sequence_length) 的 input_ids。形状为 (batch_size, 1)，而不是所有形状为 (batch_size, sequence_length) 的 decoder_input_ids。
inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联向量，这将非常有用。
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, sequence_length), optional) — 用于计算掩码语言建模损失的标签。索引应为 [0, ..., config.vocab_size] 或 -100（参见 input_ids 文档字符串）。索引设置为 -100 的 token 将被忽略（掩码），损失仅针对标签在 [0, ..., config.vocab_size] 中的 token 计算。

transformers.models.qwen2_audio.modeling_qwen2_audio.Qwen2AudioCausalLMOutputWithPast 或 tuple(torch.FloatTensor)

一个 transformers.models.qwen2_audio.modeling_qwen2_audio.Qwen2AudioCausalLMOutputWithPast 或 torch.FloatTensor 的元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时)，包含各种元素，具体取决于配置 (Qwen2AudioConfig) 和输入。

loss (torch.FloatTensor, 形状为 (1,), optional, 当提供 labels 时返回) — 语言建模损失（用于预测下一个 token）。
logits (torch.FloatTensor, 形状为 (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测得分（SoftMax 之前每个词汇 token 的得分）。
past_key_values (Cache, optional, 当传递了 use_cache=True 或当 config.use_cache=True 时返回) — 可用于加速自回归（顺序）解码的预计算隐藏状态。有两组预计算的隐藏状态：自注意力模块中的键和值状态。当传递了 use_cache=True 或当 config.use_cache=True 时，将返回 past_key_values。它是 Cache 实例。

如果使用 past_key_values，用户可以选择仅输入最后一次的 input_ids（那些没有将其过去的键值状态提供给此模型的），形状为 (batch_size, 1)，而不是所有形状为 (batch_size, sequence_length) 的 input_ids。
hidden_states (tuple(torch.FloatTensor), optional, 当传递了 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（如果模型具有嵌入层，则为嵌入输出，加上每层输出一个），形状为 (batch_size, sequence_length, hidden_size)。

模型在每一层输出的隐藏状态，加上可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传递了 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
attention_mask (torch.FloatTensor, optional) — 注意力掩码，用于更新注意力掩码和 position_ids。

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

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

示例

>>> from io import BytesIO
>>> from urllib.request import urlopen
>>> import librosa
>>> from transformers import AutoProcessor, Qwen2AudioForConditionalGeneration

>>> model = Qwen2AudioForConditionalGeneration.from_pretrained("Qwen/Qwen2-Audio-7B")
>>> processor = AutoProcessor.from_pretrained("Qwen/Qwen2-Audio-7B")

>>> prompt = "<|audio_bos|><|AUDIO|><|audio_eos|>Generate the caption in English:"
>>> url = "https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen2-Audio/audio/glass-breaking-151256.mp3"
>>> audio, _ = librosa.load(BytesIO(urlopen(url).read()), sr=self.processor.feature_extractor.sampling_rate)

>>> inputs = processor(text=prompt, audios=audio, return_tensors="pt")

>>> # Generate
>>> generate_ids = model.generate(**inputs, max_length=30)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"Generate the caption in English: Glass is breaking."

< > 在 GitHub 上更新

Transformers

Qwen2Audio

概述

使用技巧

推理

语音聊天推理

音频分析推理

批量推理

Qwen2AudioConfig

class transformers.Qwen2AudioConfig

Qwen2AudioEncoderConfig

class transformers.Qwen2AudioEncoderConfig

Qwen2AudioProcessor

class transformers.Qwen2AudioProcessor

batch_decode

解码

Qwen2AudioEncoder

class transformers.Qwen2AudioEncoder

前向传播

Qwen2AudioForConditionalGeneration

class transformers.Qwen2AudioForConditionalGeneration

前向传播