Function fsq_quantized

src/models/miocodec/graph_ops.cpp:530–563

    auto latent = engine::modules::LinearModule({768, 5, weights.input_projection.bias.has_value()}).build(
        ctx,
        input,
        weights.input_projection);
    constexpr float eps = 1.0e-3F;
    const float half_l_values[] = {3.5F * (1.0F - eps), 3.5F * (1.0F - eps), 3.5F * (1.0F - eps), 2.0F * (1.0F - eps), 2.0F * (1.0F - eps)};
    const float offset_values[] = {0.5F, 0.5F, 0.5F, 0.0F, 0.0F};
    const float shift_values[] = {
        std::tan(offset_values[0] / half_l_values[0]),
        std::tan(offset_values[1] / half_l_values[1]),
        std::tan(offset_values[2] / half_l_values[2]),
        0.0F,
        0.0F};
    const float half_width_values[] = {4.0F, 4.0F, 4.0F, 2.0F, 2.0F};
    const auto constant_shape = core::TensorShape::from_dims({1, 1, 5});
    const auto half_l = repeat_like(ctx, constants.make_f32(constant_shape, std::vector<float>(std::begin(half_l_values), std::end(half_l_values))), latent, constant_shape);
    const auto offset = repeat_like(ctx, constants.make_f32(constant_shape, std::vector<float>(std::begin(offset_values), std::end(offset_values))), latent, constant_shape);
    const auto shift = repeat_like(ctx, constants.make_f32(constant_shape, std::vector<float>(std::begin(shift_values), std::end(shift_values))), latent, constant_shape);
    const auto half_width = repeat_like(ctx, constants.make_f32(constant_shape, std::vector<float>(std::begin(half_width_values), std::end(half_width_values))), latent, constant_shape);
    auto shifted = core::wrap_tensor(ggml_add(ctx.ggml, latent.tensor, shift.tensor), latent.shape, GGML_TYPE_F32);
    auto bounded = core::wrap_tensor(ggml_tanh(ctx.ggml, shifted.tensor), latent.shape, GGML_TYPE_F32);
    auto scaled_bounded = engine::modules::MulModule{}.build(ctx, bounded, half_l);
    bounded = core::wrap_tensor(ggml_sub(ctx.ggml, scaled_bounded.tensor, offset.tensor), latent.shape, GGML_TYPE_F32);
    auto rounded = core::wrap_tensor(ggml_round(ctx.ggml, bounded.tensor), latent.shape, GGML_TYPE_F32);
    auto normalized = core::wrap_tensor(ggml_div(ctx.ggml, rounded.tensor, half_width.tensor), latent.shape, GGML_TYPE_F32);
    return engine::modules::LinearModule({5, 768, weights.output_projection.bias.has_value()}).build(
        ctx,
        normalized,
        weights.output_projection);
}

core::TensorValue convnext_block(
    core::ModuleBuildContext & ctx,
    const core::TensorValue & input_bct,
    const MioCodecConvNeXtBlockWeights & weights) {
    auto x = engine::modules::DepthwiseConv1dModule(weights.depthwise_conv_config).build(ctx, input_bct, weights.depthwise_conv);
    x = engine::modules::TransposeModule({{0, 2, 1, 3}, x.shape.rank}).build(ctx, x);
    x = engine::modules::LayerNormModule({384, 1.0e-6F, true, true}).build(ctx, x, weights.norm);
    x = engine::modules::LinearModule({384, 1152, weights.pointwise_conv1.bias.has_value()}).build(