Method build_convolution_module

cactus/models/model_parakeet.cpp:447–488

}

size_t ParakeetModel::build_convolution_module(CactusGraph* gb, size_t hidden, uint32_t layer_idx, ComputeBackend backend) {
    (void)backend;
    const auto& layer = weight_nodes_.layers[layer_idx];
    const auto& hidden_shape = gb->get_output_buffer(hidden).shape;
    if (hidden_shape.size() != 2) {
        throw std::runtime_error("Parakeet convolution module expects [T, D]");
    }

    const size_t T = hidden_shape[0];
    const size_t D = hidden_shape[1];

    size_t x = gb->reshape(hidden, {1, T, D});
    x = gb->conv1d_pointwise(x, layer.conv_pointwise1_weight, layer.conv_pointwise1_bias);
    x = gb->glu(x, -1);

    x = gb->conv1d_same_depthwise_k9(x, layer.conv_depthwise_weight, layer.conv_depthwise_bias);

    x = gb->batchnorm(
        x,
        layer.conv_batchnorm_weight,
        layer.conv_batchnorm_bias,
        layer.conv_batchnorm_running_mean,
        layer.conv_batchnorm_running_var,
        2,
        1e-5f
    );

    std::string act = config_.encoder_hidden_act;
    std::transform(act.begin(), act.end(), act.begin(), ::tolower);
    if (act.find("gelu") != std::string::npos) {
        x = gb->gelu(x);
    } else if (act == "relu") {
        x = gb->relu(x);
    } else {
        x = gb->silu(x);
    }

    x = gb->conv1d_pointwise(x, layer.conv_pointwise2_weight, layer.conv_pointwise2_bias);

    x = gb->reshape(x, {T, D});
    return x;
}

size_t ParakeetModel::build_encoder_block(CactusGraph* gb, size_t hidden, size_t position_embeddings,
                                          uint32_t layer_idx, ComputeBackend backend) {