Skip to content

vllm_omni.model_executor.models.breeze_tts_2

Modules:

Name Description
code2wav
configuration_breeze

Configuration for the released Breeze-TTS-2 checkpoint.
depth_decoder

Breeze's within-frame transformer, with frame-local KV state.
first_code_sampler

Capture first-code sampling while preserving each request's RNG stream.
modeling_breeze

Breeze-TTS-2: T5Gemma2 prompt encoding, paged Qwen3, and RVQ decoding.
pipeline
prompt

Breeze's instruction and reference-audio templates for both public APIs.
reference_encoder

The bundled Qwen3 codec encoder used by Breeze voice cloning.
text_encoder_graph

Padded T5Gemma2 prefill graphs with explicit bidirectional masks.

BreezeCode2Wav

Bases: Qwen3TTSCode2Wav

Breeze bundles the same Qwen3 codec under audio_tokenizer/.

decoder_cudagraph_modes class-attribute instance-attribute 

decoder_cudagraph_modes = ('xvec',)

tokenizer_subfolder class-attribute instance-attribute 

tokenizer_subfolder = 'audio_tokenizer'

BreezeForConditionalGeneration

Bases: Module

codebook_size instance-attribute 

codebook_size = self.config.audio_vocab_size - 3

config instance-attribute 

config = cast(
    BreezeConfig, vllm_config.model_config.hf_config
)

depth_decoder instance-attribute 

depth_decoder = BreezeDepthDecoder(
    self.config.depth_decoder_config
)

gpu_resident_buffer_keys instance-attribute 

gpu_resident_buffer_keys = {
    ("breeze_state", "current"),
    ("breeze_state", "history"),
    ("breeze_prepared", "embeds"),
}

has_postprocess class-attribute instance-attribute 

has_postprocess = False

has_preprocess class-attribute instance-attribute 

has_preprocess = True

have_multimodal_outputs class-attribute instance-attribute 

have_multimodal_outputs = True

hidden_size instance-attribute 

hidden_size = self.config.backbone_config.hidden_size

lm_head instance-attribute 

lm_head = nn.Linear(
    self.hidden_size,
    self.config.vocab_size,
    bias=False,
    dtype=torch.float32,
)

model instance-attribute 

model = Qwen3Model(
    vllm_config=backbone_config,
    prefix=f"{prefix}.model".strip("."),
)

num_codebooks instance-attribute 

num_codebooks = self.config.num_codebooks

omni_pooler_payload_include_hidden class-attribute instance-attribute 

omni_pooler_payload_include_hidden = False

reference_encoder instance-attribute 

reference_encoder = BreezeReferenceEncoder(vllm_config)

requires_full_prefix_cached_hidden_states class-attribute instance-attribute 

requires_full_prefix_cached_hidden_states = False

text_encoder instance-attribute 

text_encoder = T5Gemma2TextEncoder(text_config)

text_encoder_proj instance-attribute 

text_encoder_proj = nn.Linear(
    text_config.hidden_size, self.hidden_size, bias=False
)

use_async_omni_output class-attribute instance-attribute 

use_async_omni_output = True

vllm_config instance-attribute 

vllm_config = vllm_config

compute_logits 

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

embed_input_ids 

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

forward 

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

load_weights 

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

make_omni_output 

make_omni_output(
    model_outputs: Tensor,
    *,
    model_intermediate_buffer: list[dict[str, object]]
    | None = None,
    request_token_spans: list[tuple[int, int]]
    | None = None,
    **_: object,
) -> OmniOutput

preprocess 

preprocess(
    input_ids: Tensor,
    input_embeds: Tensor | None,
    *,
    breeze_prompt: dict[str, Any],
    breeze_sampling: BreezeSampling,
    global_request_id: list[str],
    breeze_prepared: dict[str, Tensor] | None = None,
    breeze_state: BreezeState | None = None,
    _omni_is_prefill: bool,
    _omni_seed: int | None = None,
    **_: object,
) -> tuple[Tensor, Tensor, dict[str, object]]

preprocess_batch 

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

preprocess_decode_batch 

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

Embed one current RVQ frame per physical decode row, including CFG.