Method construct

include/rabitqlib/index/ivf/ivf.hpp:170–214

* @brief Construct clusters in IVF * * @param data Data objects (N*DIM) * @param centroids Centroid vectors (K*DIM) * @param clustter_ids Cluster ID for each data objects */

 */
inline void IVF::construct(
    const float* data, const float* centroids, const PID* cluster_ids, bool faster = false,
    size_t num_threads = std::numeric_limits<size_t>::max()
) {
    std::cout << "Start IVF construction...\n";

    // get id list for each cluster
    std::cout << "\tLoading clustering information...\n";
    std::vector<size_t> counts(num_cluster_, 0);
    std::vector<std::vector<PID>> id_lists(num_cluster_);
    for (size_t i = 0; i < num_; ++i) {
        PID cid = cluster_ids[i];
        if (cid > num_cluster_) {
            std::cerr << "Bad cluster id\n";
            exit(1);
        }
        id_lists[cid].push_back(static_cast<PID>(i));
        counts[cid] += 1;
    }

    allocate_memory(counts);

    // init the cluster list
    init_clusters(counts);

    // all rotated centroids
    std::vector<float> rotated_centroids(num_cluster_ * padded_dim_);

    quant::RabitqConfig config;
    if (faster) {
        config = quant::faster_config(padded_dim_, ex_bits_ + 1);
    }

    num_threads = std::min(num_threads, rabitqlib::total_threads());
    /* Quantize each cluster */
#pragma omp parallel for schedule(dynamic) num_threads(num_threads)
    for (size_t i = 0; i < num_cluster_; ++i) {
        const float* cur_centroid = centroids + (i * dim_);
        float* cur_rotated_c = &rotated_centroids[i * padded_dim_];
        Cluster& cp = cluster_lst_[i];
        quantize_cluster(cp, id_lists[i], data, cur_centroid, cur_rotated_c, config);
    }

    this->initer_->add_vectors(rotated_centroids.data(), num_threads);
}

inline void IVF::allocate_memory(const std::vector<size_t>& cluster_sizes) {
    std::cout << "Allocating memory for IVF...\n";
    if (num_cluster_ < 20000UL) {