Function build_conv1d

src/models/ace_step/vae_decoder.cpp:400–437

}

core::TensorValue build_conv1d(
    core::ModuleBuildContext & ctx,
    const core::TensorValue & input,
    const WeightNormConv1dWeights & 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 = regular_conv_weight(weights.conv.weight, "ACE-Step VAE Conv1d");
    core::TensorValue bias_matrix;
    if (use_bias) {
        if (!weights.conv.bias.has_value()) {
            throw std::runtime_error("ACE-Step VAE Conv1d requires bias");
        }
        const auto bias = require_f32_weight(*weights.conv.bias, "ACE-Step VAE Conv1d 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 * batch_output = ggml_conv_1d(
            ctx.ggml,
            weight_contiguous.tensor,
            batch_input.tensor,
            weights.stride,
            weights.padding,
            weights.dilation);
        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_conv_transpose1d(
    core::ModuleBuildContext & ctx,