Function classify_embedding

src/framework/modules/ecapa_tdnn_runtime.cpp:746–779

}

std::vector<float> classify_embedding(
    const EcapaWeights & weights,
    const std::vector<float> & normalized_classifier_weight,
    std::vector<float> & centered,
    const std::vector<float> & embedding) {
    const auto start = Clock::now();
    if (weights.embedding_global_mean.size() != static_cast<size_t>(kEmbeddingDim)) {
        throw std::runtime_error("embedding global mean is missing from checkpoint");
    }
    if (normalized_classifier_weight.empty() || normalized_classifier_weight.size() % static_cast<size_t>(kEmbeddingDim) != 0) {
        throw std::runtime_error("normalized classifier weights are missing");
    }
    const int64_t class_count = static_cast<int64_t>(normalized_classifier_weight.size() / static_cast<size_t>(kEmbeddingDim));
    if (centered.size() != static_cast<size_t>(kEmbeddingDim)) {
        centered.resize(static_cast<size_t>(kEmbeddingDim));
    }
    float emb_norm_sq = 0.0f;
    for (int64_t i = 0; i < kEmbeddingDim; ++i) {
        centered[static_cast<size_t>(i)] = embedding[static_cast<size_t>(i)] - weights.embedding_global_mean[static_cast<size_t>(i)];
        emb_norm_sq += centered[static_cast<size_t>(i)] * centered[static_cast<size_t>(i)];
    }
    const float inv_emb_norm = 1.0f / std::sqrt(std::max(emb_norm_sq, kStatsEps));
    std::vector<float> logits(static_cast<size_t>(class_count), 0.0f);
    for (int64_t cls = 0; cls < class_count; ++cls) {
        const float * row = normalized_classifier_weight.data() + static_cast<size_t>(cls * kEmbeddingDim);
        float dot = 0.0f;
        for (int64_t i = 0; i < kEmbeddingDim; ++i) {
            dot += centered[static_cast<size_t>(i)] * row[static_cast<size_t>(i)];
        }
        logits[static_cast<size_t>(cls)] = dot * inv_emb_norm;
    }
    debug::timing_log_scalar("ecapa.classifier_ms", engine::debug::elapsed_ms(start, Clock::now()));
    return logits;
}

}  // namespace