Function build_content_token_embedding_table

src/models/miocodec/weights.cpp:132–175

}

MioCodecContentTokenEmbeddingTable build_content_token_embedding_table(
    const engine::assets::TensorSource & source,
    const MioCodecConfig & config) {
    const int64_t quantizer_dim = static_cast<int64_t>(config.quantizer_levels.size());
    if (quantizer_dim <= 0 || config.quantizer_input_dim <= 0 || config.quantizer_output_dim <= 0) {
        throw std::runtime_error("MioCodec content token embedding dimensions are invalid");
    }
    if (config.quantizer_output_dim != config.wave_prenet_dim) {
        throw std::runtime_error("MioCodec content token embedding config is inconsistent with the wave prenet");
    }
    const int64_t codebook_size = product(config.quantizer_levels);
    const int64_t output_dim = config.quantizer_output_dim;
    const auto proj_out_weight = source.require_f32("local_quantizer.proj_out.weight", {output_dim, quantizer_dim});
    const auto proj_out_bias = source.require_f32("local_quantizer.proj_out.bias", {output_dim});
    const auto basis = quantizer_basis(config.quantizer_levels);

    MioCodecContentTokenEmbeddingTable table;
    table.codebook_size = codebook_size;
    table.dim = output_dim;
    table.values.resize(static_cast<size_t>(codebook_size * output_dim), 0.0F);
    std::vector<float> fsq_code(static_cast<size_t>(quantizer_dim), 0.0F);
    for (int64_t token = 0; token < codebook_size; ++token) {
        for (int64_t dim = 0; dim < quantizer_dim; ++dim) {
            const int64_t level = config.quantizer_levels[static_cast<size_t>(dim)];
            const int64_t half = level / 2;
            if (half <= 0) {
                throw std::runtime_error("MioCodec content token embedding level is invalid");
            }
            const int64_t component = (token / basis[static_cast<size_t>(dim)]) % level;
            fsq_code[static_cast<size_t>(dim)] =
                (static_cast<float>(component) - static_cast<float>(half)) / static_cast<float>(half);
        }
        float * dst = table.values.data() + static_cast<size_t>(token * output_dim);
        for (int64_t out = 0; out < output_dim; ++out) {
            const float * weight = proj_out_weight.data() + static_cast<size_t>(out * quantizer_dim);
            float value = proj_out_bias[static_cast<size_t>(out)];
            for (int64_t dim = 0; dim < quantizer_dim; ++dim) {
                value += fsq_code[static_cast<size_t>(dim)] * weight[dim];
            }
            dst[out] = value;
        }
    }
    return table;
}

MioCodecLinearWeights bind_linear(
    const MioCodecWeights & weights,