vllm_omni.diffusion.models.soulx_singer.modules.note_transcription ¶

hidden_size = hparams['hidden_size']

net = Unet(
    hidden_size,
    down_layers=len(updown_rates),
    mid_layers=hparams.get("bkb_layers", 12),
    up_layers=len(updown_rates),
    kernel_size=3,
    updown_rates=updown_rates,
    channel_multiples=channel_multiples,
    is_btc=True,
    constant_channels=False,
    mid_net=None,
    use_skip_layer=hparams.get("unet_skip_layer", False),
)

encoder_layers = nn.ModuleList(
    [
        (
            EncoderLayer(
                hidden_size,
                RelPositionMultiHeadedAttention(
                    num_heads, hidden_size, 0.0
                ),
                positionwise_layer(
                    *positionwise_layer_args
                ),
                positionwise_layer(
                    *positionwise_layer_args
                ),
                ConvolutionModule(
                    hidden_size, kernel_size, Swish()
                ),
            )
        )
        for _ in (range(num_layers))
    ]
)

hiddens = []

layer_norm = nn.LayerNorm(hidden_size)

layers = nn.ModuleList()

pos_embed = RelPositionalEncoding(hidden_size)

save_hidden = save_hidden

use_last_norm = use_last_norm

is_btc = is_btc

last_norm = LayerNorm(hidden_size, dim=1, eps=ln_eps)

post_net1 = nn.Conv1d(
    hidden_size,
    out_dims,
    kernel_size=post_net_kernel,
    padding=post_net_kernel // 2,
)

res_blocks = nn.Sequential(*res_blocks)

activation = activation

depthwise_conv = nn.Conv1d(
    channels,
    channels,
    kernel_size=kernel_size,
    padding=(kernel_size - 1) // 2,
    groups=channels,
    bias=bias,
)

norm = nn.BatchNorm1d(channels)

pointwise_conv1 = nn.Conv1d(
    channels, 2 * channels, kernel_size=1, bias=bias
)

pointwise_conv2 = nn.Conv1d(
    channels, channels, kernel_size=1, bias=bias
)

concat_after = concat_after

concat_linear = nn.Linear(2 * size, size)

conv_module = conv_module

feed_forward = feed_forward

feed_forward_macaron = feed_forward_macaron

ff_scale = 0.5 if feed_forward_macaron is not None else 1.0

norm_conv = LayerNorm(size)

norm_ff = LayerNorm(size)

norm_ff_macaron = (
    LayerNorm(size)
    if feed_forward_macaron is not None
    else None
)

norm_final = LayerNorm(size)

norm_mha = LayerNorm(size)

normalize_before = normalize_before

self_attn = self_attn

size = size

lambd = lambd

dim = dim

attn = None

d_k = n_feat // n_head

dropout = nn.Dropout(p=dropout_rate)

dropout_rate = dropout_rate

flash = flash

h = n_head

linear_k = nn.Linear(n_feat, n_feat)

linear_out = nn.Linear(n_feat, n_feat)

linear_q = nn.Linear(n_feat, n_feat)

linear_v = nn.Linear(n_feat, n_feat)

w_1 = nn.Conv1d(
    in_chans, hidden_chans, kernel_size, padding=padding
)

w_2 = nn.Conv1d(
    hidden_chans, in_chans, kernel_size, padding=padding
)

args = args

d_model = d_model

pe = None

reverse = reverse

xscale = math.sqrt(self.d_model)

linear_pos = nn.Linear(n_feat, n_feat, bias=False)

pos_bias_u = nn.Parameter(torch.Tensor(self.h, self.d_k))

pos_bias_v = nn.Parameter(torch.Tensor(self.h, self.d_k))

shape = args

blocks = nn.ModuleList(
    [
        (
            nn.Sequential(
                LayerNorm(channels, dim=1, eps=ln_eps),
                nn.Conv1d(
                    channels,
                    c_multiple * channels,
                    kernel_size,
                    dilation=dilation,
                    padding=dilation
                    * (kernel_size - 1)
                    // 2,
                ),
                LambdaLayer(
                    lambda x: x * kernel_size**-0.5
                ),
                nn.LeakyReLU(),
                nn.Conv1d(
                    c_multiple * channels,
                    channels,
                    kernel_size=1,
                    dilation=dilation,
                ),
            )
        )
        for _ in (range(n))
    ]
)

down = UnetDown(
    hidden_size,
    down_layers,
    kernel_size,
    updown_rates,
    channel_multiples,
    is_btc,
    constant_channels,
)

mid = UnetMid(
    hidden_size,
    kernel_size,
    mid_layers,
    in_dims=down_out_dims,
    out_dims=down_out_dims,
    is_btc=is_btc,
    net=mid_net,
)

up = UnetUp(
    hidden_size,
    up_layers,
    kernel_size,
    updown_rates,
    channel_multiples,
    is_btc,
    constant_channels,
    use_skip_layer,
    skip_scale,
)

downs = nn.ModuleList()

hidden_size = hidden_size

is_btc = is_btc

last_norm = LayerNorm(out_channels, dim=1, eps=1e-06)

layers = nn.ModuleList()

n_layers = n_layers

post_net = nn.Conv1d(
    out_channels,
    out_channels,
    kernel_size=kernel_size,
    padding=kernel_size // 2,
)

is_btc = is_btc

net = net

post = nn.Conv1d(
    hidden_size,
    out_dims,
    kernel_size,
    padding=kernel_size // 2,
)

pre = nn.Conv1d(
    in_dims,
    hidden_size,
    kernel_size,
    padding=kernel_size // 2,
)

hidden_size = hidden_size

in_channels_lst = (
    (
        np.cumprod([1] + channel_multiples) * hidden_size
    ).astype(int)
    if not constant_channels
    else [hidden_size for _ in (range(self.n_layers + 1))]
)

is_btc = is_btc

last_norm = LayerNorm(out_channels, dim=1, eps=1e-06)

layers = nn.ModuleList()

n_layers = n_layers

out_channels = out_channels

post_net = nn.Conv1d(
    out_channels,
    out_channels,
    kernel_size=kernel_size,
    padding=kernel_size // 2,
)

skip_layers = nn.ModuleList()

skip_scale = skip_scale

ups = nn.ModuleList()