Method predict

include/core/solver.h:660–723

* @brief Predict logits for samples * @param _samples edge samples */

     * @param _samples edge samples
     */
    std::vector<Float> predict(const std::vector<EdgeSample> &_samples) {
        samples = &_samples;
        is_train = false;

        pool_offsets.resize(num_sampler + 1);
        for (auto &&sampler_offsets : pool_offsets) {
            sampler_offsets.resize(num_partition);
            for (auto &&partition_offsets : sampler_offsets)
                partition_offsets.resize(num_partition);
        }
        predict_pool.resize(num_partition);
        for (auto &&partition_pool : predict_pool)
            partition_pool.resize(num_partition);
        sample_indexes.resize(num_partition);
        for (auto &&partition_indexes : sample_indexes)
            partition_indexes.resize(num_partition);

        std::vector<std::thread> sample_threads(num_sampler + num_worker);
        size_t num_sample = samples->size();
        size_t work_load = (num_sample + num_sampler - 1) / num_sampler;
        for (int i = 0; i < num_sampler + num_worker; i++)
            sample_threads[i] = std::thread(&Sampler::count, samplers[0], work_load * i,
                                             std::min(work_load * (i + 1), num_sample), i);
        for (auto &&thread : sample_threads)
            thread.join();

        for (int i = 0; i < num_sampler; i++)
            for (int j = 0; j < num_partition; j++)
                for (int k = 0; k < num_partition; k++)
                    pool_offsets[i + 1][j][k] += pool_offsets[i][j][k];
        predict_batch_id = 0;
        num_predict_batch = 0;
        size_t all_pool = 0;
        for (int i = 0; i < num_partition; i++)
            for (int j = 0; j < num_partition; j++) {
                size_t this_pool_size = pool_offsets[num_sampler][i][j];
                all_pool += this_pool_size;
                predict_pool[i][j].resize(this_pool_size);
                sample_indexes[i][j].resize(this_pool_size);
                num_predict_batch += (this_pool_size + batch_size - 1) / batch_size;
            }

        for (int i = 0; i < num_sampler + num_worker; i++)
            sample_threads[i] = std::thread(&Sampler::distribute, samplers[0], work_load * i,
                                             std::min(work_load * (i + 1), num_sample), i);
        for (auto &&thread : sample_threads)
            thread.join();

        results.resize(num_sample);
        std::vector<std::thread> worker_threads(num_worker);
        auto schedule = get_schedule();
        for (auto &&assignment : schedule) {
            for (int i = 0; i < assignment.size(); i++)
                worker_threads[i] = std::thread(&Worker::predict, workers[i], assignment[i].first, assignment[i].second);
            for (int i = 0; i < assignment.size(); i++)
                worker_threads[i].join();
        }