Class pyKnowledgeGraphSolver

include/bind.h:516–639

template<size_t dim, class Float = float, class Index = size_t>
class pyKnowledgeGraphSolver : public py::class_<graphvite::KnowledgeGraphSolver<dim, Float, Index>> {
public:
    typedef graphvite::KnowledgeGraphSolver<dim, Float, Index> KnowledgeGraphSolver;
    typedef py::class_<KnowledgeGraphSolver> Base;
    using Base::attr;
    using Base::def;
    using Base::def_readonly;
    using Base::def_property_readonly;

    template<class... Args>
    pyKnowledgeGraphSolver(py::handle scope, const char *name, const Args &...args) :
            Base(scope, signature(name, dim, typeid(Float).name(), typeid(Index).name()).c_str(), args...) {
        attr("__doc__") = "KnowledgeGraphSolver(dim, float_type=dtype.float32, index_type=dtype.uint32, "
                                               "device_ids=[], num_sampler_per_worker=auto, gpu_memory_limit=auto)"
        R"(
        Knowledge graph embedding solver.

        Parameters:
            dim (int): dimension of embeddings
            float_type (dtype): type of parameters
            index_type (dtype): type of node indexes
            device_ids (list of int, optional): GPU ids, [] for auto
            num_sampler_per_worker (int, optional): number of sampler thread per GPU
            gpu_memory_limit (int, optional): memory limit for each GPU in bytes
        )";

        // override instance name with template name
        attr("__name__") = py::internal_str(name);
        attr("__qualname__") = py::internal_str(name);

        // data members
        def_readonly("num_partition", &KnowledgeGraphSolver::num_partition);
        def_readonly("num_negative", &KnowledgeGraphSolver::num_negative);
        def_readonly("sample_batch_size", &KnowledgeGraphSolver::sample_batch_size);
        def_readonly("optimizer", &KnowledgeGraphSolver::optimizer);
        def_readonly("negative_sample_exponent", &KnowledgeGraphSolver::negative_sample_exponent);
        def_readonly("model", &KnowledgeGraphSolver::model);
        def_readonly("num_epoch", &KnowledgeGraphSolver::num_epoch);
        def_readonly("resume", &KnowledgeGraphSolver::resume);
        def_readonly("relation_lr_multiplier", &KnowledgeGraphSolver::relation_lr_multiplier);
        def_readonly("episode_size", &KnowledgeGraphSolver::episode_size);
        def_readonly("batch_size", &KnowledgeGraphSolver::batch_size);
        def_readonly("margin", &KnowledgeGraphSolver::margin);
        def_readonly("l3_regularization", &KnowledgeGraphSolver::l3_regularization);
        def_readonly("adversarial_temperature", &KnowledgeGraphSolver::adversarial_temperature);
        def_readonly("positive_reuse", &KnowledgeGraphSolver::positive_reuse);
        def_readonly("log_frequency", &KnowledgeGraphSolver::log_frequency);
        def_readonly("num_worker", &KnowledgeGraphSolver::num_worker);
        def_readonly("num_sampler", &KnowledgeGraphSolver::num_sampler);
        def_readonly("gpu_memory_limit", &KnowledgeGraphSolver::gpu_memory_limit);
        def_readonly("gpu_memory_cost", &KnowledgeGraphSolver::gpu_memory_cost);

        // numpy views (mutable but unassignable)
        def_property_readonly("entity_embeddings", numpy_view(&KnowledgeGraphSolver::entity_embeddings),
                              "Entity embeddings (2D numpy view).");
        def_property_readonly("relation_embeddings", numpy_view(&KnowledgeGraphSolver::relation_embeddings),
                              "Relation embeddings (2D numpy view).");