Function build_conv_transpose1d_col2im

src/models/ace_step/vae_decoder.cpp:494–536

}

core::TensorValue build_conv_transpose1d_col2im(
    core::ModuleBuildContext & ctx,
    const core::TensorValue & input,
    const WeightNormConvTranspose1dWeights & weights,
    int64_t in_channels,
    int64_t out_channels,
    bool use_bias) {
    const auto input_contiguous = ensure_f32(ctx, ensure_contiguous_nontransposed(ctx, input));
    const auto weight_contiguous =
        require_contiguous_nontransposed_weight(weights.col_weight, "ACE-Step VAE ConvTranspose1d col2im weight");
    if (weight_contiguous.type != GGML_TYPE_F32) {
        throw std::runtime_error("ACE-Step VAE ConvTranspose1d col2im requires uploaded F32 weights");
    }
    core::TensorValue bias_matrix;
    if (use_bias) {
        if (!weights.conv.bias.has_value()) {
            throw std::runtime_error("ACE-Step VAE ConvTranspose1d requires bias");
        }
        const auto bias = require_f32_weight(*weights.conv.bias, "ACE-Step VAE ConvTranspose1d bias");
        bias_matrix = core::reshape_tensor(ctx, bias, core::TensorShape::from_dims({out_channels, 1}));
    }
    core::TensorValue output;
    for (int64_t batch_index = 0; batch_index < input.shape.dims[0]; ++batch_index) {
        const auto batch_input = view_batch_matrix(ctx, input_contiguous, batch_index, in_channels, input.shape.dims[2]);
        auto * transposed_input = ggml_cont(ctx.ggml, ggml_transpose(ctx.ggml, batch_input.tensor));
        auto * columns = ggml_mul_mat(ctx.ggml, weight_contiguous.tensor, transposed_input);
        auto * batch_output = ggml_col2im_1d(
            ctx.ggml,
            columns,
            weights.stride,
            static_cast<int>(out_channels),
            weights.padding);
        if (use_bias) {
            batch_output = ggml_add(ctx.ggml, batch_output, bias_matrix.tensor);
        }
        auto batch_value = core::wrap_tensor(
            ggml_reshape_3d(ctx.ggml, batch_output, batch_output->ne[0], batch_output->ne[1], 1),
            core::TensorShape::from_dims({1, out_channels, batch_output->ne[0]}),
            GGML_TYPE_F32);
        output = output.valid() ? modules::ConcatModule({0}).build(ctx, output, batch_value) : batch_value;
    }
    return output;
}

core::TensorValue build_residual_unit(
    core::ModuleBuildContext & ctx,