Class pyVisualizationSolver

include/bind.h:642–745

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

    template<class... Args>
    pyVisualizationSolver(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__") = "VisualizationSolver(dim, float_type=dtype.float32, index_type=dtype.uint32, "
                                              "device_ids=[], num_sampler_per_worker=auto, gpu_memory_limit=auto)"
        R"(
        Visualization 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", &VisualizationSolver::num_partition);
        def_readonly("num_negative", &VisualizationSolver::num_negative);
        def_readonly("sample_batch_size", &VisualizationSolver::sample_batch_size);
        def_readonly("optimizer", &VisualizationSolver::optimizer);
        def_readonly("negative_sample_exponent", &VisualizationSolver::negative_sample_exponent);
        def_readonly("negative_weight", &VisualizationSolver::negative_weight);
        def_readonly("model", &VisualizationSolver::model);
        def_readonly("num_epoch", &VisualizationSolver::num_epoch);
        def_readonly("resume", &VisualizationSolver::resume);
        def_readonly("episode_size", &VisualizationSolver::episode_size);
        def_readonly("batch_size", &VisualizationSolver::batch_size);
        def_readonly("positive_reuse", &VisualizationSolver::positive_reuse);
        def_readonly("log_frequency", &VisualizationSolver::log_frequency);
        def_readonly("num_worker", &VisualizationSolver::num_worker);
        def_readonly("num_sampler", &VisualizationSolver::num_sampler);
        def_readonly("gpu_memory_limit", &VisualizationSolver::gpu_memory_limit);
        def_readonly("gpu_memory_cost", &VisualizationSolver::gpu_memory_cost);

        // numpy views (mutable but unassignable)
        def_property_readonly("coordinates", numpy_view(&VisualizationSolver::coordinates),
                              "Low-dimensional coordinates (2D numpy view).");

        // member functions
        def(py::init<std::vector<int>, int, size_t> (), py::no_gil(),
            py::arg("device_ids") = std::vector<int>(), py::arg("num_sampler_per_worker") = graphvite::kAuto,
            py::arg("gpu_memory_limit") = graphvite::kAuto);