Function scalar_decoder

src/models/heartmula/codec.cpp:650–707

                config.res_kernel_size,
                dilations[residual]);
        }
        channels = out_channels;
    }
    if (config.num_samples > 1) {
        x = adjacent_repeat_frames_bct(ctx, x, config.num_samples);
        x = causal_conv1d(
            ctx,
            x,
            weights.post_processor.conv,
            config.init_channel,
            config.init_channel,
            config.default_kernel_size);
        x = prelu(ctx, x, weights.post_processor.activation);
    }
    return causal_conv1d(
        ctx,
        x,
        weights.output_conv,
        config.init_channel,
        config.num_bands,
        config.default_kernel_size);
}

core::TensorValue expand_batch_token(
    core::ModuleBuildContext & ctx,
    const core::TensorValue & input_bd,
    int64_t tokens,
    int64_t dim) {
    const int64_t batch = input_bd.shape.dims[0];
    const auto view = core::reshape_tensor(ctx, core::ensure_backend_addressable_layout(ctx, input_bd), core::TensorShape::from_dims({batch, 1, dim}));
    return modules::RepeatModule({core::TensorShape::from_dims({batch, tokens, dim})}).build(ctx, view);
}

core::TensorValue project_layer(
    core::ModuleBuildContext & ctx,
    const core::TensorValue & input_btc,
    const HeartCodecProjectLayerWeights & weights,
    int64_t in_channels,
    int64_t out_channels) {
    auto x = modules::TransposeModule({{0, 2, 1}, 3}).build(ctx, input_btc);
    x = modules::Conv1dModule({in_channels, out_channels, 3, 1, 1, 1, true}).build(ctx, x, weights.ffn_1);
    x = scale(ctx, x, kProjectLayerScale);
    x = modules::TransposeModule({{0, 2, 1}, 3}).build(ctx, x);
    return modules::LinearModule({out_channels, out_channels, true, GGML_PREC_F32}).build(ctx, x, weights.ffn_2);
}

core::TensorValue timestep_embedding(
    core::ModuleBuildContext & ctx,
    const core::TensorValue & timesteps,
    const core::TensorValue & freqs) {
    const int64_t batch = timesteps.shape.dims[0];
    auto t = core::reshape_tensor(ctx, timesteps, core::TensorShape::from_dims({batch, 1}));
    t = modules::RepeatModule({core::TensorShape::from_dims({batch, 256})}).build(ctx, t);
    auto f = modules::RepeatModule({core::TensorShape::from_dims({batch, 256})}).build(ctx, freqs);
    auto args = scale(ctx, modules::MulModule{}.build(ctx, t, f), kFlowTimestepScale);
    auto cos_part = core::wrap_tensor(ggml_cos(ctx.ggml, core::ensure_backend_addressable_layout(ctx, args).tensor), args.shape, GGML_TYPE_F32);
    auto sin_part = core::wrap_tensor(ggml_sin(ctx.ggml, args.tensor), args.shape, GGML_TYPE_F32);
    return modules::ConcatModule({1}).build(ctx, cos_part, sin_part);