Skip to content

vllm_omni.model_executor.models.qwen3_tts.qwen3_tts_talker

logger module-attribute 

logger = init_logger(__name__)

AttentiveStatisticsPooling

Bases: Module

Attentive statistic pooling layer: returns concatenated mean and std.

conv instance-attribute 

conv = Conv1d(
    attention_channels,
    channels,
    kernel_size=1,
    padding="same",
    padding_mode="reflect",
)

eps instance-attribute 

eps = 1e-12

tanh instance-attribute 

tanh = Tanh()

tdnn instance-attribute 

tdnn = TimeDelayNetBlock(
    channels * 3, attention_channels, 1, 1
)

forward 

forward(hidden_states)

Qwen3TTSSpeakerEncoder

Bases: Module

ECAPA-TDNN speaker encoder.

Reference: "ECAPA-TDNN: Emphasized Channel Attention, Propagation and Aggregation in TDNN Based Speaker Verification" (https://huggingface.co/papers/2005.07143).

asp instance-attribute 

asp = AttentiveStatisticsPooling(
    enc_channels[-1],
    attention_channels=enc_attention_channels,
)

blocks instance-attribute 

blocks = ModuleList()

channels instance-attribute 

channels = enc_channels

fc instance-attribute 

fc = Conv1d(
    enc_channels[-1] * 2,
    enc_dim,
    kernel_size=1,
    padding="same",
    padding_mode="reflect",
)

mfa instance-attribute 

mfa = TimeDelayNetBlock(
    enc_channels[-1],
    enc_channels[-1],
    enc_kernel_sizes[-1],
    enc_dilations[-1],
)

forward 

forward(hidden_states)

Qwen3TTSTalkerForConditionalGeneration

Bases: Module

vLLM-AR talker: step-wise layer-0 codec decoding. Predicts residual codebooks (1..Q-1) into audio_codes and streams text via tailing_text_hidden.

code_predictor instance-attribute 

code_predictor = (
    Qwen3TTSTalkerCodePredictorForConditionalGenerationVLLM(
        vllm_config=_code_predictor_vllm_config,
        config=code_predictor_config,
        talker_config=talker_config,
        prefix="code_predictor",
    )
)

config instance-attribute 

config: Qwen3TTSConfig = hf_config

deferred_prefix_cache_mm_keys instance-attribute 

deferred_prefix_cache_mm_keys = {'codes.audio'}

encoder instance-attribute 

encoder = _from_config(encoder_config)

gpu_resident_buffer_keys instance-attribute 

gpu_resident_buffer_keys: set[tuple[str, str]] = {
    ("codes", "audio"),
    ("hidden_states", "last"),
    ("hidden_states", "trailing_text"),
}

has_postprocess instance-attribute 

has_postprocess = True

has_preprocess instance-attribute 

has_preprocess = True

have_multimodal_outputs instance-attribute 

have_multimodal_outputs = True

hf_to_vllm_mapper class-attribute instance-attribute 

hf_to_vllm_mapper = WeightsMapper(
    orig_to_new_prefix={
        "talker.model.layers.": "model.layers.",
        "talker.model.norm.": "model.norm.",
        "talker.model.codec_embedding.": "model.embed_tokens.",
        "talker.codec_head.": "lm_head.",
        "talker.model.text_embedding.": "text_embedding.",
        "talker.text_projection.": "text_projection.",
        "talker.code_predictor.": "code_predictor.",
        "speaker_encoder.": "speaker_encoder.",
    }
)

lm_head instance-attribute 

lm_head = ParallelLMHead(
    vocab_size,
    hidden_size,
    quant_config=quant_config,
    prefix=maybe_prefix(prefix, "lm_head"),
)

logits_processor instance-attribute 

logits_processor = LogitsProcessor(vocab_size)

make_empty_intermediate_tensors instance-attribute 

make_empty_intermediate_tensors = (
    make_empty_intermediate_tensors
)

model instance-attribute 

model = Qwen3Model(
    vllm_config=vllm_config,
    prefix=maybe_prefix(prefix, "model"),
)

model_path instance-attribute 

model_path = model

mtp_hidden_size instance-attribute 

mtp_hidden_size = int(hidden_size)

requires_full_prefix_cached_hidden_states instance-attribute 

requires_full_prefix_cached_hidden_states = False

speaker_encoder instance-attribute 

speaker_encoder = Qwen3TTSSpeakerEncoder(
    speaker_encoder_config
)

talker_config instance-attribute 

talker_config: Qwen3TTSTalkerConfig = talker_config

talker_mtp_output_key instance-attribute 

talker_mtp_output_key = ('codes', 'audio')

text_embedding instance-attribute 

text_embedding = Embedding(
    text_vocab_size, text_hidden_size
)

text_projection instance-attribute 

text_projection = Qwen3TTSTalkerResizeMLP(
    text_hidden_size,
    text_hidden_size,
    hidden_size,
    hidden_act,
    bias=True,
)

vllm_config instance-attribute 

vllm_config = vllm_config

compute_logits 

compute_logits(
    hidden_states: Tensor | OmniOutput,
    sampling_metadata: Any = None,
) -> Tensor | None

embed_input_ids 

embed_input_ids(input_ids: Tensor, **_: Any) -> Tensor

forward 

forward(
    input_ids: Tensor,
    positions: Tensor,
    intermediate_tensors: IntermediateTensors | None = None,
    inputs_embeds: Tensor | None = None,
    **_: Any,
) -> Tensor | IntermediateTensors

load_weights 

load_weights(
    weights: Iterable[tuple[str, Tensor]],
) -> set[str]

make_omni_output 

make_omni_output(
    model_outputs: Tensor | OmniOutput, **kwargs: Any
) -> OmniOutput

postprocess 

postprocess(
    hidden_states: Tensor, **_: Any
) -> dict[str, Any]

preprocess 

preprocess(
    input_ids: Tensor,
    input_embeds: Tensor | None,
    **info_dict: Any,
) -> tuple[Tensor, Tensor, dict[str, Any]]

preprocess_batch 

preprocess_batch(
    *,
    req_ids: list[str],
    model_intermediate_buffer: dict[str, dict[str, Any]],
    device: device,
) -> None

Delegate batched preprocess to :class:Qwen3TTSPromptEmbedsBuilder.

preprocess_decode_batch 

preprocess_decode_batch(
    *, input_ids: Tensor, req_infos: list[dict[str, Any]]
) -> tuple[
    Tensor, Tensor, Tensor, Tensor, list[dict[str, Any]]
]

Batch the decode-only preprocess path for Qwen3-TTS.

This mirrors the scalar decode branch in preprocess(), but performs the token embedding lookup once for the whole decode batch.

talker_mtp 

talker_mtp(
    input_ids: Tensor,
    input_embeds: Tensor,
    last_talker_hidden: Tensor,
    text_step: Tensor,
    do_sample: bool | None = None,
    temperature: float | None = None,
    top_k: int | None = None,
    top_p: float | None = None,
    generator: Generator | None = None,
    **kwargs: Any,
) -> tuple[Tensor, Tensor]

GPU fast-path used by OmniGPUModelRunner to predict residual codebooks (1..Q-1). Returns (inputs_embeds, audio_codes) for the current step.

Qwen3TTSTalkerResizeMLP

Bases: Module

Two-layer MLP that maps between hidden sizes with an activation in between.

act_fn instance-attribute 

act_fn = ACT2FN[act]

linear_fc1 instance-attribute 

linear_fc1 = Linear(
    input_size, intermediate_size, bias=bias
)

linear_fc2 instance-attribute 

linear_fc2 = Linear(
    intermediate_size, output_size, bias=bias
)

forward 

forward(hidden_state)

Res2NetBlock

Bases: Module

blocks instance-attribute 

blocks = ModuleList(
    [
        (
            TimeDelayNetBlock(
                in_channel,
                hidden_channel,
                kernel_size=kernel_size,
                dilation=dilation,
            )
        )
        for _ in (range(scale - 1))
    ]
)

scale instance-attribute 

scale = scale

forward 

forward(hidden_states)

SqueezeExcitationBlock

Bases: Module

conv1 instance-attribute 

conv1 = Conv1d(
    in_channels,
    se_channels,
    kernel_size=1,
    padding="same",
    padding_mode="reflect",
)

conv2 instance-attribute 

conv2 = Conv1d(
    se_channels,
    out_channels,
    kernel_size=1,
    padding="same",
    padding_mode="reflect",
)

relu instance-attribute 

relu = ReLU(inplace=True)

sigmoid instance-attribute 

sigmoid = Sigmoid()

forward 

forward(hidden_states)

SqueezeExcitationRes2NetBlock

Bases: Module

TDNN-Res2Net-TDNN-SE building block used in ECAPA-TDNN.

out_channels instance-attribute 

out_channels = out_channels

res2net_block instance-attribute 

res2net_block = Res2NetBlock(
    out_channels,
    out_channels,
    res2net_scale,
    kernel_size,
    dilation,
)

se_block instance-attribute 

se_block = SqueezeExcitationBlock(
    out_channels, se_channels, out_channels
)

tdnn1 instance-attribute 

tdnn1 = TimeDelayNetBlock(
    in_channels, out_channels, kernel_size=1, dilation=1
)

tdnn2 instance-attribute 

tdnn2 = TimeDelayNetBlock(
    out_channels, out_channels, kernel_size=1, dilation=1
)

forward 

forward(hidden_state)

TimeDelayNetBlock

Bases: Module

activation instance-attribute 

activation = ReLU()

conv instance-attribute 

conv = Conv1d(
    in_channels=in_channels,
    out_channels=out_channels,
    kernel_size=kernel_size,
    dilation=dilation,
    padding="same",
    padding_mode="reflect",
)

forward 

forward(hidden_states: Tensor)