vllm_omni.model_executor.models.covo_audio.token2wav ¶

activations = ModuleList(
    [
        (
            AliasFreeActivation1d(
                activation=SnakeBeta(
                    channels, alpha_logscale=snake_logscale
                )
            )
        )
        for _ in (range(num_layers))
    ]
)

convs1 = ModuleList(
    [
        weight_norm(
            Conv1d(
                channels,
                channels,
                kernel_size,
                1,
                dilation=dilation[0],
                causal=causal,
            )
        ),
        weight_norm(
            Conv1d(
                channels,
                channels,
                kernel_size,
                1,
                dilation=dilation[1],
                causal=causal,
            )
        ),
        weight_norm(
            Conv1d(
                channels,
                channels,
                kernel_size,
                1,
                dilation=dilation[2],
                causal=causal,
            )
        ),
    ]
)

convs2 = ModuleList(
    [
        weight_norm(
            Conv1d(
                channels,
                channels,
                kernel_size,
                1,
                dilation=1,
                causal=causal,
            )
        ),
        weight_norm(
            Conv1d(
                channels,
                channels,
                kernel_size,
                1,
                dilation=1,
                causal=causal,
            )
        ),
        weight_norm(
            Conv1d(
                channels,
                channels,
                kernel_size,
                1,
                dilation=1,
                causal=causal,
            )
        ),
    ]
)

h = h

num_layers = len(convs1) + len(convs2)

activation_post = AliasFreeActivation1d(
    activation=activation_post
)

config = h

conv_post = weight_norm(Conv1d(ch, 1, 7, 1, causal=causal))

conv_pre = weight_norm(
    Conv1d(
        latent_dim,
        upsample_initial_channel,
        7,
        1,
        causal=False,
    )
)

h = h

hop_size = prod(downsample_rates)

num_kernels = len(resblock_kernel_sizes)

num_upsamples = len(upsample_rates)

resblocks = ModuleList()

ups = ModuleList()

activation = (
    activation if activation is not None else Identity()
)

bn = BatchNorm1d(out_channels) if bn else Identity()

causal = causal

in_channels = in_channels

left_padding = dilation * (kernel_size - 1)

transpose = input_transpose

conv = Conv1d(
    hidden_size,
    hidden_size,
    kernel_size,
    groups=groups,
    input_transpose=True,
    activation=GELU(),
)

causal = causal

stride = stride

transpose = input_transpose

force_drop = force_drop

inplace = inplace

p = p

output_dim = embedding_dim

pad_id = pad_id

adaLN_modulation = Sequential(
    SiLU(), Linear(hidden_size, 2 * hidden_size, bias=True)
)

linear = Linear(hidden_size, output_size, bias=True)

norm = LayerNorm(
    hidden_size, elementwise_affine=False, eps=1e-06
)

activation = (
    activation if activation is not None else Identity()
)

output_dim = out_channels

act = act_layer()

drop = Dropout(dropout)

fc1 = Linear(hidden_size, ffn_hidden_size)

fc2 = Linear(ffn_hidden_size, hidden_size)

attn_drop = Dropout(attn_drop)

cpu_config = AttentionConfig(True, True, True)

cuda_config = AttentionConfig(True, True, True)

head_dim = hidden_size // num_heads

k_norm = norm_layer(head_dim) if qk_norm else Identity()

k_proj = Linear(hidden_size, hidden_size, bias=qkv_bias)

max_position_embeddings = max_position_embeddings

num_heads = num_heads

o_dropout = Dropout(dropout)

o_proj = Linear(hidden_size, hidden_size)

q_norm = norm_layer(head_dim) if qk_norm else Identity()

q_proj = Linear(hidden_size, hidden_size, bias=qkv_bias)

rotary = RotaryEmbedding(head_dim)

rotary_bias = rotary_bias

scale = head_dim ** -0.5

v_proj = Linear(hidden_size, hidden_size, bias=qkv_bias)

device

frequency_embedding_size = frequency_embedding_size

mlp = Sequential(
    Linear(
        frequency_embedding_size, hidden_size, bias=True
    ),
    SiLU(),
    Linear(hidden_size, hidden_size, bias=True),
)

config = config

global_mean_var = getattr(config, 'global_mean_var', None)

token2latent = Token2latentFlowMatchingWithEmbed(
    token2latent
)

trainable_module = ['wavegan', 'token2latent']

upsample_factor = get('upsample_factor', 1)

wav_input_sr = get('wav_input_sr', 24000)

wavegan = BigVGANFlowVAE(wavegan)

wavegan_hop_size = prod(downsample_rates)

blocks = ModuleList()

cond_proj = Linear(model_dim + spkr_embed_dim, model_dim)

config = config

conv_embed = ConvPositionEmbed(
    hidden_size=model_dim, kernel_size=31, groups=16
)

model_dim = hidden_size

output_layer = FinalLayer(hidden_size, target_dim)

spkr_embed_dim = get('spkr_embed_dim', 512)

target_dim = z_dim

time_embedder = TimestepEmbedder(model_dim)

token_input_dim = get('token_input_dim', model_dim)

token_pad_id = -1

token_proj = Sequential(
    Linear(token_input_dim, model_dim, bias=True),
    ConvTranspose1d(
        model_dim,
        model_dim,
        stride=upsample_factor,
        kernel_size=upsample_factor * 2,
    ),
)

transformer_input_proj = Linear(
    model_dim + target_dim * 2, model_dim
)

token_embedding = EmbeddingTable(
    num_embeddings=vocab_size,
    embedding_dim=token_input_dim,
    pad_id=token_pad_id,
)

vocab_size = token_vocab_size

attn = attention

ffn = ffn

modulation = modulation

modulation_layer = Sequential(
    SiLU(), Linear(hidden_size, 6 * hidden_size, bias=True)
)

norm1 = LayerNorm(
    hidden_size, elementwise_affine=not modulation, eps=eps
)

norm2 = LayerNorm(
    hidden_size, elementwise_affine=not modulation, eps=eps
)