rules.cpp

Go to the documentation of this file.

#include "rules.h"
#include "symbols.h"
// #include "symbols.cpp"


std::ostream& operator<<(std::ostream &out, const Rule& r)
{
        out << "ACTION:\n";
        out << *static_cast<const Symbol*>(&r);
        out << "\n";
        out << "CONTEXT:\n";
        out << r.preconditions_;
        out << "\n";
        out << "OUTCOMES:\n";
//      for ( OutcomeList::iterator it=r.outcomes_.begin() ; it != r.outcomes_.end(); it++ )
        for ( size_t i = 0; i < r.outcomes_.size(); i++)
                out << r.outcomes_[i] << "\n";
        out << "\n";
        
        return out;
}

std::ostream& operator<<(std::ostream &out, const RuleSet& r)
{
//      for ( RuleList::iterator it=r.rules_.begin() ; it != r.rules_.end(); it++ )
//              out << *it << "\n";
        for ( size_t i = 0; i < r.rules_.size(); i++)
                out << (*r.rules_[i]);
        
        return out;
}

Rule::Rule(const Rule& rule) :
        Symbol(rule),
        preconditions_(rule.preconditions_),
        outcomes_(rule.outcomes_),
        m_(rule.m_)
{ 
        total_executions_ = 0;
        for ( OutcomeList::const_iterator it = rule.outcomes_.begin(); it != rule.outcomes_.end(); it++) {
                total_executions_ += it->num_executions_;
        }
}

Rule::Rule(Symbol symbol, PredicateList preconditions, uint m) :
        Symbol(symbol),
        preconditions_(preconditions),
        m_(m),
        total_executions_(0)
{ }

void Rule::add_outcome(PredicateList predicates, float init_probability)
{
        outcomes_.push_back(Outcome(predicates, init_probability));
}

void Rule::add_outcome(Outcome outcome)
{
        outcomes_.push_back(outcome);
}

bool Rule::satisfiesPreconditions(PredicateList predicates)
{
        if (preconditions_.is_satisfied(predicates))
                return true;
        else
                return false;
}

bool Rule::has_enough_experiences()
{
        if (total_executions_ > m_)
                return true;
        else
                return false;
}

void Rule::sanitize_probabities()
{
        float sum_probs = 0.0;
        for ( OutcomeList::iterator it = this->outcomes_.begin(); it != this->outcomes_.end(); it++) {
                sum_probs += it->init_probability_;
        }
        if (sum_probs != 1.0) {
                this->outcomes_[0].init_probability_ -= (sum_probs - 1.0);
                update_probabilities();
        }
}

RuleSet::RuleSet() :
        m_(0)
{ }

RuleSet::RuleSet(uint m) :
        m_(m)
{ }

RuleSet::RuleSet(uint m, RuleList rules) :
        m_(m)
{
        add(rules);
}

RuleSet::RuleSet(std::string file_path, uint m) :
        m_(m)
{ 
        read_rules_from_file(file_path);
}

void RuleSet::read_rules_from_file(std::string file_path)
{
        std::string line;
        std::ifstream rules_file(file_path.c_str());
        
        // Clear previous rules
        rules_.clear();
        
        if (rules_file.is_open())
        {
                std::string line1;
                std::string line2;
                std::string line_aux;
                
                getline (rules_file,line_aux);
                while ( rules_file.good() )
                {
                        // ACTION:
                        // read until ACTION: found
                        while (line_aux.compare("ACTION:") != 0) {
                                getline (rules_file,line_aux);
                        }
                        
                        // Action name
                        getline (rules_file,line1);
                        
                        // CONTEXT:
                        getline (rules_file,line_aux);
                        
                        // Preconditions
                        getline (rules_file,line2);
                        
                        MRule rule(get_symbol_from_string(line1), 
                                get_predicates_from_string(line2), 
                                m_);
                        
                        // OUTCOMES:
                        getline (rules_file,line_aux);
                        
                        // Outcome i
                        getline (rules_file,line1);
                        while (line1.compare("") != 0) {
                                rule.add_outcome(get_outcome_from_string(line1));
                                getline (rules_file,line1);
                        }
                        
                        if ( (!rule.has_name(DUMMY_ACTION_NAME)) && (!rule.has_name(DEFAULT_ACTION_NAME))) {
                                rules_.push_back(boost::make_shared<MRule>(rule));
                        }
                        
                        // read lines until not empty line
                        getline (rules_file,line_aux);
                        line_aux.erase(remove_if(line_aux.begin(), line_aux.end(), isspace), line_aux.end());
                        while ((not rules_file.eof()) && rules_file.good() && (line_aux.compare("") == 0)) {
                                getline (rules_file,line_aux);
                        }
                }
        }
        
        sanitize_probabities();
        
        ROS_DEBUG_STREAM("Read rules are " << *this);
        rules_file.close();
}

void RuleSet::write_rules_to_file(std::string file_path)
{
        std::ofstream rules_file(file_path.c_str());
        ROS_DEBUG_STREAM("Writting rules to file" << file_path);
        if (rules_file.is_open())
        {
                rules_file << *this;
        }
        else
                ROS_ERROR_STREAM("Couldn't write rules to " << file_path);
        rules_file.close();
}

void RuleSet::write_debugging_rules_to_file(std::string file_path)
{
        std::ofstream rules_file(file_path.c_str());
        if (rules_file.is_open())
        {
                for ( size_t i = 0; i < this->rules_.size(); i++) {
                        rules_file << *this->rules_[i];
                        rules_file << "Total " << this->rules_[i]->total_executions_ << std::endl;
                        for ( size_t j = 0; j < this->rules_[i]->outcomes_.size(); j++)
                                rules_file << "Out" << i << " " <<  this->rules_[i]->outcomes_[j].num_executions_ << " - " << this->rules_[i]->outcomes_[j].init_probability_ << "\n";
                        rules_file << std::endl;
                        rules_file << std::endl;
                }
        }
        else {
                ROS_ERROR_STREAM("Couldn't write debugging rules to " << file_path);
        }
        rules_file.close();
}


void RuleSet::sanitize_probabities()
{
        for ( RuleList::iterator it=rules_.begin() ; it != rules_.end(); ++it ) {
                (*it)->sanitize_probabities();
        }
}


// void RuleSet::add_execution(Symbol action, PredicateList preconditions, PredicateList outcome_predicates)
void RuleSet::add_execution(Transition transition, bool is_new)
{
        PredicateGroup prec_group(transition.prev_state_);
        PredicateGroup out_group(transition.next_state_);
        
        // grounded predicates
        // 1 -> X, etc...
        std::string DEFAULT_VARIABLES[] = {"X", "Y", "Z"};
        for (size_t i = 0; i < transition.action_.param_names_.size(); i++) {
                prec_group.change_variable(transition.action_.param_names_[i], DEFAULT_VARIABLES[i]);
                out_group.change_variable(transition.action_.param_names_[i], DEFAULT_VARIABLES[i]);
                transition.action_.param_names_[i] = DEFAULT_VARIABLES[i];
        }
        
        // get preconditions?
        PredicateGroup important_prec = prec_group.get_predicates_with_vars(transition.action_.param_names_);
        
        // get differences
        PredicateGroup important_out = out_group.get_predicates_with_vars(transition.action_.param_names_);
        PredicateGroup differences = important_prec.get_differences(important_out);
        
        if (is_new) {
                ROS_INFO_STREAM("Adding execution " << transition.action_ << "\nPreconditions " << PredicateGroup(important_prec) << "\nOutcome " << PredicateGroup(differences));
        }
        for ( RuleList::iterator it=rules_.begin() ; it != rules_.end(); it++ ) {
                if ( ((*it)->has_name(transition.action_.name_)) && ((*it)->satisfiesPreconditions(important_prec.predicates_)) ) {
                        if (is_new)
                                (*it)->add_execution(differences.predicates_);
                        else
                                (*it)->add_old_execution(differences.predicates_);
                }
        }
}


std::vector<std::string> RuleSet::actions_needing_pasula_learning()
{
        std::vector<std::string> result;
        for ( RuleList::iterator it=rules_.begin() ; it != rules_.end(); ++it ) {
                if ((*it)->needs_pasula_learning()) {
                        result.push_back((*it)->name_);
                }
        }
        return result;
}

RuleList RuleSet::extract_pasula_not_learned_rules()
{
        RuleList unlearned_rules;
        
        for ( RuleList::iterator rule=rules_.begin() ; rule != rules_.end(); ) {
                if (!(*rule)->has_enough_experiences()) {
                        (*rule)->total_executions_=0;
                        unlearned_rules.push_back(boost::make_shared<MRule>(MRule(**rule)));
                        rule = rules_.erase(rule);
                }
                else {
                        ++rule;
                }
        }
        
        return unlearned_rules;
}


void RuleSet::add(RuleList rules)
{
        for ( RuleList::iterator rule=rules.begin() ; rule != rules.end(); rule++ ) {
                rules_.push_back(*rule);
        }
}


void RuleSet::remove_action_rules(std::string action)
{
        for ( RuleList::iterator rule=rules_.begin() ; rule != rules_.end();  ) {
                if ((*rule)->name_.compare(action) == 0) {
                        rule = rules_.erase(rule);
                }
                else {
                        ++rule;
                }
        }
}

bool RuleSet::needs_learning(std::string name, PredicateList preconditions)
{
        bool result = false;
        
        for ( RuleList::iterator it=rules_.begin() ; it != rules_.end(); it++ ) {
                if ( ((*it)->has_name(name)) && ((*it)->satisfiesPreconditions(preconditions)) )
                        if ((*it)->needs_learning())
                                result = true;
        }
        
        return result;
}


void RuleSet::transform_rules_to_pasula()
{
        RuleList new_rules;
        for ( RuleList::iterator rule=rules_.begin() ; rule != rules_.end();  ) {
                new_rules.push_back(boost::make_shared<PasulaRule>(PasulaRule(**rule)));
                rule = rules_.erase(rule);
        }
        rules_ = new_rules;
}


void RuleSet::set_learning_m(uint m)
{
        this->m_ = m;
        update_probabilities();
}

void RuleSet::update_probabilities()
{
        for ( RuleList::iterator it=rules_.begin() ; it != rules_.end(); it++ ) {
                (*it)->update_probabilities();
        }
}

bool RuleSet::needs_learning(std::string name, std::string preconditions)
{
        return needs_learning(name, get_predicates_from_string(preconditions));
}