rules.h

Go to the documentation of this file.

#ifndef IRI_RULE_LEARNER_RULES_H
#define IRI_RULE_LEARNER_RULES_H 1

#include <iri_rule_learner/RuleLearnerConfig.h>
#include <fstream>
#include <symbols.h>
#include <predicates.h>
#include <transitions.h>


class Rule : public Symbol
{
public:
        PredicateGroup preconditions_;
        OutcomeList outcomes_;
        uint m_;
        uint total_executions_;
        
        Rule(const Rule& rule);
        
        Rule(Symbol symbol, PredicateList preconditions, uint m);
        
        void add_outcome(PredicateList predicates, float init_probability);
        
        void add_outcome(Outcome outcome);
        
        bool satisfiesPreconditions(PredicateList predicates);
        
        void sanitize_probabities();
        
        bool has_enough_experiences();
        
        virtual bool needs_learning() =0;
        virtual bool needs_pasula_learning() =0;
        virtual void add_old_execution(PredicateList outcome_predicates) =0;
        virtual void add_execution(PredicateList outcome_predicates) =0;
        virtual void update_probabilities() =0;
        
        friend std::ostream& operator<<(std::ostream &out, const Rule& r);
};

typedef std::vector< boost::shared_ptr<Rule> > RuleList;


class MRule : public Rule
{
public:
        MRule(const Rule& rule) :
                Rule(rule)
        { }
        
        MRule(Symbol symbol, PredicateList preconditions, uint m) :
                Rule(symbol, preconditions, m)
        { }
        
        bool needs_learning()
        {
                if (total_executions_ < m_)
                        return true;
                else 
                        return false;
        }
        bool needs_pasula_learning() {
                return has_enough_experiences();
        }
        
        void add_old_execution(PredicateList outcome_predicates) { add_execution(outcome_predicates); }
        
        void add_execution(PredicateList outcome_predicates)
        {
                OutcomeList::iterator winner_it;
                
                ROS_DEBUG_STREAM("Adding execution. Search outcome for " << PredicateGroup(outcome_predicates));
                
                int max = -1;
                for ( OutcomeList::iterator it=outcomes_.begin() ; it < outcomes_.end(); it++ ) {
                        if ( it->is_satisfied(outcome_predicates) ) {
                                int n_satisfied = it->count_satisfied(outcome_predicates);
                                if (n_satisfied > max) {
                                        max = n_satisfied;
                                        winner_it = it;
                                        ROS_DEBUG_STREAM("New winner is " << *it);
                                }
                        }
                }
                
                ROS_DEBUG_STREAM("Updated winner is " << *winner_it);
                
                ROS_INFO_STREAM("Rule before learning " << *this);
                winner_it->add_execution();
                total_executions_++;
                update_probabilities();
                ROS_INFO_STREAM("Rule after learning " << *this);
        }
        
        void update_probabilities() 
        {
                double learn_param;
                
                // option 1
                //learn_param = m_;
                
                // option 2
                if (total_executions_ > 0)
                        learn_param = m_ / sqrt(total_executions_);
                else
                        learn_param = m_;
                
                // option 3
                //if (total_executions_ > 0)
                        //learn_param = m_ / total_executions_;
                //else
                        //learn_param = m_;
                
                for ( OutcomeList::iterator it=outcomes_.begin() ; it < outcomes_.end(); it++ )
                        it->update_probability(total_executions_, learn_param);
                
                sanitize_probabities();
        }
};


class PasulaRule : public Rule
{
public:
        uint new_executions_;
        
        PasulaRule(const Rule& rule) :
                Rule(rule),
                new_executions_(0)
        { }
        
        bool needs_learning()
        {
                return true;
        }
        bool needs_pasula_learning(){
                return true;
        }
        void add_old_execution(PredicateList outcome_predicates)
        {
                ++total_executions_;
        }
        void add_execution(PredicateList outcome_predicates)
        {
                ++total_executions_;
                ++new_executions_;
        }
        void update_probabilities()
        { }
};


class RuleSet
{
public:
        RuleList rules_;
        uint m_;
        
        // constructors
        RuleSet();
        RuleSet(uint m);
        RuleSet(uint m, RuleList rules);
        RuleSet(std::string file_path, uint m);
        
        // i/o with files
        void read_rules_from_file(std::string file_path);
        void write_rules_to_file(std::string file_path);
        void write_debugging_rules_to_file(std::string file_path);
        void sanitize_probabities();
        
        // general learning
        bool needs_learning(std::string name, std::string preconditions);
        bool needs_learning(std::string name, PredicateList preconditions);
        void add_execution(Transition transition, bool is_new = true);
        
        // pasula stuff
        std::vector<std::string> actions_needing_pasula_learning();
        RuleList extract_pasula_not_learned_rules();
        void transform_rules_to_pasula();
        
        // m_estimate stuff
        void set_learning_m(uint m);
        void update_probabilities();
        
        // add and remove rules
        void add(RuleList rules);
        void remove_action_rules(std::string action);
        
        // operators
        friend std::ostream& operator<<(std::ostream &out, const RuleSet& r);
};

// typedef boost::shared_ptr<GraspPhase> GraspPhasePtr;

// typedef std::vector<GraspPhasePtr> GraspPhaseSequence;

#endif