ml_based_method.hpp

Go to the documentation of this file.

/***************************************************************************
*                                                                          *
*   Copyright (C) 2018 by David B. Blumenthal                              *
*                                                                          *
*   This file is part of GEDLIB.                                           *
*                                                                          *
*   GEDLIB is free software: you can redistribute it and/or modify it      *
*   under the terms of the GNU Lesser General Public License as published  *
*   by the Free Software Foundation, either version 3 of the License, or   *
*   (at your option) any later version.                                    *
*                                                                          *
*   GEDLIB is distributed in the hope that it will be useful,              *
*   but WITHOUT ANY WARRANTY; without even the implied warranty of         *
*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the           *
*   GNU Lesser General Public License for more details.                    *
*                                                                          *
*   You should have received a copy of the GNU Lesser General Public       *
*   License along with GEDLIB. If not, see <http://www.gnu.org/licenses/>. *
*                                                                          *
***************************************************************************/

#ifndef SRC_METHODS_ML_BASED_METHOD_HPP_
#define SRC_METHODS_ML_BASED_METHOD_HPP_

namespace ged {

template<class UserNodeLabel, class UserEdgeLabel>
class MLBasedMethod : public LSAPEBasedMethod<UserNodeLabel, UserEdgeLabel> {

public:

    virtual ~MLBasedMethod() = 0;

    MLBasedMethod(const GEDData<UserNodeLabel, UserEdgeLabel> & ged_data);

    double predict(const GEDGraph & g, const GEDGraph & h, const NodeMap::Assignment & assignment);


protected:

    std::size_t num_features_;

private:

    enum MLMethod_ {DNN, SVM, ONE_CLASS_SVM};

    class Assignment_ {

    public:

        Assignment_(std::size_t row_in_master, std::size_t col_in_master, bool good_assignment, const std::vector<double> & feature_vector);

        Assignment_(const std::string & line, std::size_t num_features);

        Assignment_(const Assignment_ & assignment);

        std::size_t row_in_master() const;

        std::size_t col_in_master() const;

        std::string to_string() const;

        double * dnn_feature_vector();

        struct svm_node * svm_feature_vector();

        double * type();

        bool is_good_assignment() const;

        std::size_t num_features() const;

    private:

        std::size_t row_in_master_;

        std::size_t col_in_master_;

        double type_;

        std::vector<double> dnn_feature_vector_;

        std::vector<struct svm_node> svm_feature_vector_;
    };

    struct DNNParams_ {

        DNNParams_();

        std::vector<FANN::activation_function_enum> activation_candidates;

        unsigned int min_num_hidden_layers;

        unsigned int max_num_hidden_layers;

        unsigned int min_num_neurons_per_layer;

        unsigned int max_num_neurons_per_layer;
    };

    class DNN_ {

    public:

        DNN_();

        std::size_t load(const std::string & filename);

        void train(FANN::training_data & training_data, const MLBasedMethod::DNNParams_ & params, const std::string & filename, std::size_t num_threads);

        double decision_value(double * feature_vector);

    private:

        float cross_validate_(FANN::training_data & training_data, const MLBasedMethod::DNNParams_ & params, unsigned int num_hidden_layers, unsigned int num_neurons_per_layer, FANN::activation_function_enum hidden_activation);

        float train_and_validate_(FANN::neural_net & neural_net, FANN::training_data & training_data, FANN::training_data & validation_data, std::size_t max_num_epochs);

        FANN::neural_net neural_net_;
    };

    struct SVMParams_ {

        SVMParams_();

        int min_gamma_exp;

        int max_gamma_exp;

        int min_c_exp;

        int max_c_exp;

        double min_nu;

        double max_nu;
    };

    class SVM_ {

    public:

        ~SVM_();

        SVM_();

        std::size_t load(const std::string & filename);

        void train(struct svm_problem * training_data, const MLBasedMethod::SVMParams_ & params, std::size_t num_features, const std::string & filename, std::size_t num_threads);

        double decision_value(struct svm_node * feature_vector) const;

    private:

        struct svm_model * svm_model_;

    };

    class OneClassSVM_ {

    public:

        ~OneClassSVM_();

        OneClassSVM_();

        std::size_t load(const std::string & filename, bool use_likelihood);

        void train(struct svm_problem * training_data, bool use_likelihood, std::size_t num_features, const std::string & filename);

        double decision_value(struct svm_node * feature_vector) const;

    private:

        struct svm_model * svm_model_;

        double rho_;

        double sum_alpha_;

        double scale_factor_;

        bool use_likelihood_;

        void compute_rho_and_scale_factor_(std::size_t num_features);
    };

    std::pair<GEDGraph::GraphID, GEDGraph::GraphID> prediction_initialized_;

    std::vector<Assignment_> assignments_;

    MLMethod_ ml_method_;

    GEDMethod<UserNodeLabel, UserEdgeLabel> * ground_truth_method_;

    std::string ground_truth_options_;

    DNNParams_ dnn_params_;

    DNN_ dnn_;

    FANN::training_data dnn_training_data_;

    std::vector<double *> dnn_feature_vectors_;

    std::vector<double *> dnn_types_;

    SVMParams_ svm_params_;

    SVM_ svm_;

    struct svm_problem svm_training_data_;

    std::vector<struct svm_node *> svm_feature_vectors_;

    std::vector<double> svm_types_;

    bool one_class_svm_use_likelihood_;

    OneClassSVM_ one_class_svm_;

    std::string infile_;

    std::string outfile_;

    std::string logfile_;

    std::string training_infile_;

    std::string training_outfile_;

    std::string ground_truth_infile_;

    std::string ground_truth_outfile_;

    // Member functions inherited from LSAPEBasedMethod.

    virtual void lsape_init_() final;

    virtual void lsape_pre_graph_init_(bool called_at_runtime) final;

    virtual void lsape_populate_instance_(const GEDGraph & g, const GEDGraph & h, DMatrix & master_problem) final;

    virtual std::string lsape_valid_options_string_() const final;

    virtual void lsape_set_default_options_() final;

    virtual bool lsape_parse_option_(const std::string & option, const std::string & value) final;

    virtual void lsape_init_graph_(const GEDGraph & graph) final;

    virtual void lsape_default_post_graph_init_() final;

    // Private helper functions.

    bool initialized_for_prediction_(const GEDGraph & g, const GEDGraph & h) const;

    void generate_assignments_(const GEDGraph & g, const GEDGraph & h);

    void load_or_generate_training_data_();

    void save_training_data_();

    bool load_config_file_() const;

    bool log_prediction_ratios_() const;

    bool compute_or_load_ground_truth_() const;

    double decision_value_(Assignment_ & assignmment);

    void train_();

    // Virtual functions to be overridden by derived classes.

    virtual void ml_init_feature_variables_(const GEDGraph & g, const GEDGraph & h, std::size_t num_threads);

    virtual std::string ml_valid_options_string_() const;

    virtual bool ml_parse_option_(const std::string & option, const std::string & arg);

    virtual void ml_set_default_options_();

    virtual void ml_init_();

    virtual void ml_init_graph_(const GEDGraph & graph);

    virtual std::size_t ml_get_num_features_();

    virtual void ml_init_for_num_features_();

    virtual void ml_populate_substitution_feature_vector_(const GEDGraph & g, const GEDGraph & h, GEDGraph::NodeID i, GEDGraph::NodeID k, std::vector<double> & feature_vector);

    virtual void ml_populate_deletion_feature_vector_(const GEDGraph & g, GEDGraph::NodeID i, std::vector<double> & feature_vector);

    virtual void ml_populate_insertion_feature_vector_(const GEDGraph & h, GEDGraph::NodeID k, std::vector<double> & feature_vector);

};

}

#endif /* SRC_METHODS_ML_BASED_METHOD_HPP_ */