rule_learner_alg.cpp

Go to the documentation of this file.

#include "rule_learner_alg.h"

RuleLearnerAlgorithm::RuleLearnerAlgorithm(void)
{
        this->needs_learning_ = false;
}

RuleLearnerAlgorithm::~RuleLearnerAlgorithm(void)
{
}

void RuleLearnerAlgorithm::config_update(Config& new_cfg, uint32_t level)
{
        this->lock();
        
        if (this->learning_m_ != new_cfg.learning_m) {
                this->learning_m_ = new_cfg.learning_m;
                this->rules_.set_learning_m(this->learning_m_);
        }
        
        if (this->rules_path_.compare(new_cfg.rules_path) != 0){
                this->rules_path_ = new_cfg.rules_path;
                // reload rules
                this->rules_.read_rules_from_file(this->rules_path_);
        }
        
        if (this->restore_transitions_path_ != new_cfg.restore_transitions_path) {
                this->restore_transitions_path_ = new_cfg.restore_transitions_path;
                this->transitions_ = read_transitions_from_file(this->restore_transitions_path_);
                for ( TransitionList::iterator transition=this->transitions_.begin() ; transition != this->transitions_.end(); ++transition ) {
                        this->rules_.add_execution(*transition, true);
                }
                ROS_INFO_STREAM("transitions\n " << this->transitions_);
        }
        
        this->pasula_rules_path_ = new_cfg.pasula_rules_path;
        this->updated_rules_path_ = new_cfg.updated_rules_path;
        this->debugging_rules_path_ = new_cfg.debugging_rules_path;
        this->transitions_path_ = new_cfg.transitions_path;
        this->backup_transitions_path_ = new_cfg.backup_transitions_path;
        
        // save the current configuration
        this->config_=new_cfg;
        
        this->unlock();
}

bool RuleLearnerAlgorithm::add_state(std::string state)
{
        bool rules_updated;
        
        if (this->needs_learning_) {
                this->add_execution(state);
                
                this->needs_learning_ = false;
                rules_updated = true;
                
                // debugging
                this->rules_.write_debugging_rules_to_file(debugging_rules_path_);
        }
        else {
                rules_updated = false;
        }
        
        this->last_state_ = state;
        
        return rules_updated;
}

bool RuleLearnerAlgorithm::add_action(std::string action_name, std::vector<uint> params)
{
        std::stringstream ss;
        ss << action_name << "(";
        for (size_t i = 0; i < params.size(); i++) {
                ss << (params[i] + 60);
                if ( (i + 1) < params.size() ) {
                        ss << ",";
                }
        }
        ss << ")";
        this->last_action_ = get_symbol_from_string(ss.str());
        
        if (this->last_action_.exists()) { // (req.action_movements_successful && this->alg_.rules_.needs_learning(req.action, representation_to_string_srv_.response.state_string)) { // needs learning
                this->needs_learning_ = true;
                ROS_DEBUG_STREAM("Needs learning");
        }
        else {
                this->needs_learning_ = false;
                ROS_DEBUG_STREAM("Doesn't need learning");
        }
        
        return this->needs_learning_;
}

// RuleLearnerAlgorithm Public API
void RuleLearnerAlgorithm::add_execution(std::string state)
{
        ROS_INFO_STREAM("Learning\nAction " << this->last_action_ << "\nPrevious state is " << this->last_state_ << "\nCurrent state is " << state);

        // add execution
        this->lock();
        ROS_INFO_STREAM("transitions\n " << transitions_);
        Transition transition(this->last_state_, this->last_action_, state);
        transitions_.push_back(transition);
        write_transitions_to_file(transitions_, this->backup_transitions_path_);
        new_transitions_.push_back(transition);
        rules_.add_execution(transition);
        this->unlock();

        // write results
        ROS_DEBUG_STREAM("New rules are " << rules_);
        rules_.write_rules_to_file(this->updated_rules_path_);
}


std::vector<int> RuleLearnerAlgorithm::update_with_pasula_rules(std::vector<std::string> actions, TransitionList transitions)
{       
        std::vector<int> res; // contains number of pasula rules, number of learned rules, total number of rules
        ROS_INFO_STREAM("Updating with pasula rules");
        
        // read pasula rules
        RuleSet pasula_rules(this->pasula_rules_path_, this->learning_m_);
        pasula_rules.transform_rules_to_pasula();
        res.push_back(pasula_rules.rules_.size()); // number of pasula rules
        
        // remove learned rules from standard rules
        for ( RuleList::iterator rule=pasula_rules.rules_.begin() ; rule != pasula_rules.rules_.end(); ++rule ) {
                rules_.remove_action_rules((*rule)->name_);
        }
        
        // add transitions_
        for ( TransitionList::iterator transition=transitions.begin() ; transition != transitions.end(); ++transition ) {
                pasula_rules.add_execution(*transition, false);
        }
        
        // remove not pasula and add to rules
//         RuleSet not_learned_rules = RuleSet(rules_.m_);
//         not_learned_rules.add(pasula_rules.extract_pasula_not_learned_rules());
        res.push_back(pasula_rules.rules_.size()); // number of learned rules
        
        // add new transitions obtained while learning
        for ( TransitionList::iterator transition=new_transitions_.begin() ; transition != new_transitions_.end(); ++transition ) {
                pasula_rules.add_execution(*transition);
        }
        
//         for ( TransitionList::iterator transition=this->transitions_.begin() ; transition != this->transitions_.end(); ++transition ) {
//                 not_learned_rules.add_execution(*transition);
//         }
        
//         rules_.add(not_learned_rules.rules_);
        rules_.add(pasula_rules.rules_);
        rules_.update_probabilities();
        
        ROS_INFO_STREAM("Updated rules with Pasula are " << rules_);
        rules_.write_rules_to_file(this->updated_rules_path_);
        res.push_back(rules_.rules_.size()); // number of total rules
        return res;
}

std::vector<std::string> RuleLearnerAlgorithm::actions_needing_pasula_learning() {
        std::vector<std::string> result;
        
        result = rules_.actions_needing_pasula_learning();
        
        // remove duplicated
        remove_duplicates(result);
        
        return result;
}

TransitionList RuleLearnerAlgorithm::get_transitions_with_actions(std::vector<std::string> actions) {
        TransitionList important_transitions;
        for ( TransitionList::iterator transition=transitions_.begin() ; transition != transitions_.end(); ++transition ) {
                bool transition_added = false;
                std::vector<std::string>::iterator action=actions.begin();
                while ((action != actions.end()) && !transition_added) {
                        if (transition->action_.has_name(*action)) {
                                important_transitions.push_back(Transition(*transition));
                                transition_added=true;
                        }
                        ++action;
                }
        }
        
        return important_transitions;
}

void RuleLearnerAlgorithm::write_transitions(TransitionList transitions) {
        write_transitions_to_file(transitions, this->transitions_path_);
}

void RuleLearnerAlgorithm::reset_new_transitions() {
        new_transitions_.clear();
}