Function build_astral_projected

src/models/seed_vc/astral_quantizer.cpp:241–272

        out.blocks.push_back(item);
    }
    out.quantizer_project_in = engine::modules::LinearWeights{
        require_tensor(store, source, root + "quantizer.project_in.weight", storage_type),
        require_tensor(store, source, root + "quantizer.project_in.bias", storage_type)};
    engine::core::validate_shape(
        out.quantizer_project_in.weight,
        engine::core::TensorShape::from_dims({code_dim, channels}),
        "Seed-VC ASTRAL quantizer project_in weight");
    return out;
}

engine::core::TensorValue build_astral_projected(
    engine::core::ModuleBuildContext & ctx,
    const engine::core::TensorValue & hidden_btc,
    const AstralWeights & weights,
    int64_t input_channels,
    int64_t channels,
    int64_t intermediate_channels) {
    auto x = transpose_bct_btc(ctx, hidden_btc);
    x = engine::modules::Conv1dModule({input_channels, channels, 1, 1, 0, 1, true})
            .build(ctx, x, weights.input_projection);
    for (const auto & block : weights.blocks) {
        const auto residual = x;
        x = engine::modules::DepthwiseConv1dModule({channels, 7, 1, 3, 1, true})
                .build(ctx, x, block.dwconv);
        x = channel_layer_norm_bct(ctx, x, block.norm_weight, block.norm_bias, channels);
        x = contiguous(ctx, transpose_bct_btc(ctx, x));
        x = engine::modules::LinearModule({channels, intermediate_channels, true})
                .build(ctx, x, block.pwconv1);
        x = engine::modules::GeluModule({engine::modules::GeluApproximation::ExactErf}).build(ctx, x);
        x = grn_btc(ctx, x, block.grn_gamma, block.grn_beta, intermediate_channels);
        x = engine::modules::LinearModule({intermediate_channels, channels, true})
                .build(ctx, x, block.pwconv2);
        x = transpose_bct_btc(ctx, x);
        x = engine::core::wrap_tensor(
            ggml_add(ctx.ggml, contiguous(ctx, x).tensor, contiguous(ctx, residual).tensor),