Method build

include/core/solver.h:287–466

* @brief Determine and allocate all resources for the solver * @param _graph graph * @param _optimizer optimizer or learning rate * @param _num_partition number of partitions * @param _num_negative number of negative samples per positive sample * @param _batch_size batch size of samples in CPU-GPU transfer * @param _episode_size number of batches in a partition block

     * @param _episode_size number of batches in a partition block
     */
    void build(Graph &_graph, const Optimizer &_optimizer = kAuto, int _num_partition = kAuto, int _num_negative = 1,
               int _batch_size = 100000, int _episode_size = kAuto) {
        graph = &_graph;
        optimizer = _optimizer;
        if (optimizer.type == "Default") {
            Optimizer default_optimizer = get_default_optimizer();
            if (optimizer.init_lr > 0)
                default_optimizer.init_lr = optimizer.init_lr;
            optimizer = default_optimizer;
        }
        num_vertex = graph->num_vertex;
        num_edge = graph->num_edge;
        num_moment = optimizer.num_moment;
        num_partition = _num_partition;
        num_negative = _num_negative;
        batch_size = _batch_size;
        LOG_IF(WARNING, batch_size < kMinBatchSize)
                << "It is recommended to a minimum batch size of " << kMinBatchSize
                << ", but " << batch_size << " is specified";
        episode_size = _episode_size;
        available_models = get_available_models();
        batch_id = 0;

        // build embeddings & moments
        protocols = get_protocols();
        sampler_protocol = get_sampler_protocol();
        num_embedding = protocols.size();
        embeddings.resize(num_embedding);
        moments.resize(num_embedding);

        auto shapes = get_shapes();
        CHECK(shapes.size() == num_embedding) << "The number of shapes must equal to the number of embedding matrices";
        Protocol all = 0;
        tied_weights = false;
        for (int i = 0; i < num_embedding; i++) {
            Protocol protocol = protocols[i];
            CHECK(bool(protocol & kGlobal) + bool(protocol & kHeadPartition) + bool(protocol & kTailPartition) == 1)
                    << "The embedding matrix can be only binded to either global range, head partition "
                    << "or tail partition";
            if (protocol & (kHeadPartition | kTailPartition)) {
                if (shapes[i] == kAuto)
                    shapes[i] = num_vertex;
                else
                    CHECK(shapes[i] == num_vertex)
                            << "The shape for a partitioned embedding matrix must be `graph->num_vertex`";
            } else
                CHECK(!(protocol & kInPlace)) << "Global embedding matrix can't take in-place update";
            CHECK(shapes[i] != kAuto) << "Can't deduce shape for the " << i << "-th embedding matrix";

            if (protocol & kSharedWithPredecessor) {
                CHECK(i > 0) << "The first embedding matrix can't be shared";
                CHECK(shapes[i] == shapes[i - 1])
                        << "The " << i - 1 << "-th and the " << i << "-th matrices are shared, "
                        << "but different shapes are specified";
                tied_weights = tied_weights || ((protocols[i] | protocols[i - 1]) &
                                                (kHeadPartition | kTailPartition)) == (kHeadPartition | kTailPartition);
                embeddings[i] = embeddings[i - 1];
                moments[i] = moments[i - 1];