Function build_mask_output

src/models/roformer/runtime.cpp:376–421

    x = fc1.build(ctx, x, binding::linear_data(ctx, weights.fc1.weight, weights.fc1.bias));
    x = modules::GeluModule({modules::GeluApproximation::ExactErf}).build(ctx, x);
    x = fc2.build(ctx, x, binding::linear_data(ctx, weights.fc2.weight, weights.fc2.bias));
    return x;
}

core::TensorValue build_transformer_branch(
    core::ModuleBuildContext & ctx,
    const core::TensorValue & input,
    const core::TensorValue & positions,
    const TransformerBranchWeights & weights,
    const RoformerArchitectureConfig & config) {
    auto x = input;
    for (const auto & layer : weights.layers) {
        x = modules::AddModule{}.build(ctx, x, build_attention(ctx, x, positions, layer.attention, config));
        x = modules::AddModule{}.build(ctx, x, build_feed_forward(ctx, x, layer.feed_forward, config));
    }
    if (config.transformer_output_norm) {
        return build_reference_rms_norm(ctx, x, config.dim, weights.norm);
    }
    return x;
}

core::TensorValue build_band_split(
    core::ModuleBuildContext & ctx,
    const core::TensorValue & input,
    const MelBandWeights & weights,
    const RoformerArchitectureConfig & config) {
    std::vector<core::TensorValue> outputs;
    outputs.reserve(weights.band_split.size());
    int64_t offset = 0;
    for (size_t band = 0; band < weights.band_split.size(); ++band) {
        const int64_t dim_in = config.band_input_dims[band];
        auto band_input = modules::SliceModule({2, offset, dim_in}).build(ctx, input);
        band_input = build_reference_rms_norm(ctx, band_input, dim_in, weights.band_split[band].norm);
        band_input = modules::LinearModule(binding::linear_config(dim_in, config.dim, true))
                         .build(ctx, band_input, binding::linear_data(ctx, weights.band_split[band].proj.weight, weights.band_split[band].proj.bias));
        band_input = core::reshape_tensor(
            ctx,
            ensure_contiguous(ctx, band_input),
            core::TensorShape::from_dims({input.shape.dims[0], input.shape.dims[1], 1, config.dim}));
        outputs.push_back(band_input);
        offset += dim_in;
    }

    while (outputs.size() > 1) {
        std::vector<core::TensorValue> next;
        next.reserve((outputs.size() + 1) / 2);
        for (size_t i = 0; i < outputs.size(); i += 2) {
            if (i + 1 < outputs.size()) {
                next.push_back(modules::ConcatModule({2}).build(ctx, outputs[i], outputs[i + 1]));