Method train

include/core/solver.h:588–654

* @brief Train embeddings * @param _model model * @param _num_epoch number of epochs, i.e. #positive edges / |E| * @param _resume resume training from learned embeddings or not * @param _sample_batch_size batch size of samples in samplers * @param _positive_reuse times of reusing positive samples * @param _negative_sample_exponent exponent of degrees in negative sampl

     * @param _log_frequency log every log_frequency batches
     */
    void train(const std::string &_model, int _num_epoch = 2000, bool _resume = false, int _sample_batch_size = 2000,
               int _positive_reuse = 1, float _negative_sample_exponent = 0.75, float _negative_weight = 5,
               int _log_frequency = 1000) {
        CHECK(graph) << "The model must be built on a graph first";
        model = _model;
        CHECK(available_models.find(model) != available_models.end()) << "Invalid model `" << model << "`";
        num_epoch = _num_epoch;
        resume = _resume;
        sample_batch_size = _sample_batch_size;
        positive_reuse = _positive_reuse;
        negative_sample_exponent = _negative_sample_exponent;
        negative_weight = _negative_weight;
        LOG_IF(WARNING, negative_weight > kMaxNegativeWeight)
                << "It is recommended to a maximum negative weight of " << kMaxNegativeWeight
                << ", but " << negative_weight << " is specified";
        log_frequency = _log_frequency;

        LOG(WARNING) << pretty::block(info());
        if (!resume) {
            init_embeddings();
            init_moments();
            batch_id = 0;
        }
        num_batch = batch_id + num_epoch * num_edge / batch_size;
        is_train = true;

        std::vector<std::thread> sample_threads(num_sampler);
        std::vector<std::thread> worker_threads(num_worker);
        int num_sample = episode_size * batch_size;
        int work_load = (num_sample + num_sampler - 1) / num_sampler;
        auto schedule = get_schedule();

        SampleFunction sample_function = get_sample_function();
        {
            Timer timer("Sample threads");
            for (int i = 0; i < num_sampler; i++)
                sample_threads[i] = std::thread(sample_function, samplers[i], work_load * i,
                                                std::min(work_load * (i + 1), num_sample));
            for (auto &&thread : sample_threads)
                thread.join();
        }
        while (batch_id < num_batch) {
            pool_id ^= 1;
            if (shuffle_partition)
                assignment_offset = (assignment_offset + 1) % num_partition;
            for (int i = 0; i < num_sampler; i++)
                sample_threads[i] = std::thread(sample_function, samplers[i], work_load * i,
                                                std::min(work_load * (i + 1), num_sample));
            for (auto &&assignment : schedule) {
                for (int i = 0; i < assignment.size(); i++)
                    worker_threads[i] = std::thread(&Worker::train, workers[i],
                                                    assignment[i].first,
                                                    (assignment[i].second + assignment_offset) % num_partition);
                for (int i = 0; i < assignment.size(); i++)
                    worker_threads[i].join();
            }
            {
                Timer timer("Wait for sample threads");