Semspear_tree.h

Go to the documentation of this file.

#ifndef SEMSPEAR_TREE_H_
#define SEMSPEAR_TREE_H_

#include "m_cpp/m_vector.h"
#include "semantics/Syntactic_event.h"
#include "semantics/Semantic_step_event.h"
#include "semantics/Elaboration_tree.h"
#include "semantics/SemanticIO.h"
#include "semantics/Event_parser.h"
#include <boost/make_shared.hpp>
#include <list>
#include <map>


namespace semantics
{

    class Semantic_step_proposal;
    
    void initialize_special_symbols();
    
    class Semspear_tree
    {
    public:
        /*------------------------------------------------------------
         * TYPEDEFS
         *------------------------------------------------------------*/
        typedef boost::shared_ptr<Semspear_tree> Self_ptr;
        typedef Syntactic_event::Word_type Word;
        typedef boost::shared_ptr<Word> Word_ptr;
        typedef Syntactic_event::Label_type Label;
        typedef boost::shared_ptr<Label> Label_ptr;
        typedef std::list<Self_ptr> Child_list;
        typedef Syntactic_event::Event_ptr Syn_event_ptr;
        typedef Semantic_step_event::Event_ptr Sem_event_ptr;
        typedef Syntactic_event::Node_data Node_data;
        typedef boost::shared_ptr<Elaboration_tree> Sem_tree_ptr;
        typedef Elaboration_tree::Elab_ptr Elab_ptr;
        typedef Elaboration_tree::Elab_ptr_const Elab_ptr_const;
        typedef Elaboration_tree::Hash_pair Hash_pair;
        typedef std::map<Lexicon_db::Val_type, bool> LF_map_t;
        typedef std::map<Word, size_t> Freq_map;
        typedef std::list<Token_map::Key_type> Symbol_list;
        
        enum Role {TOP, ROOT, UNARY, DEPENDENCY, PUNCTUATION, COORD, NUM_ROLES};

        static bool VERBOSE;

    public:
        
        /*------------------------------------------------------------
         * CONSTRUCTORS/DESTRUCTOR
         *------------------------------------------------------------*/
        
        Semspear_tree(
            const Role& role,
            const bool& learn = true,
            const bool& collins = false
            );
        
        Semspear_tree(
            const Word&   word,
            const Label&  label,
            const Role&   role,
            const bool&   learn = true,
            const bool&   collins = false
            );

        Semspear_tree(
            const Label& label,
            const Role&  role,
            const bool&  learn = true,
            const bool&  collins = false
            );

        Semspear_tree(
            const Self_ptr other,
            const bool&    learn = false
            );

        ~Semspear_tree();
        

        /*------------------------------------------------------------
         * ACCESSORS
         *------------------------------------------------------------*/
        
        Word word() const {if(word_ != NULL) return *word_; else return Word();}

        Label label() const
        {
            if(label_ != NULL) return *label_;
            else return Label();
        }

        const Self_ptr head() const
        {
            if(head_ == children_.end()) return Self_ptr();
            else return *head_;
        }

        const Child_list& children() const { return children_; }

        Word head_word() const;

        Label head_tag() const;

        Elab_ptr_const semantic_root() const;

        const Hash_pair& semantic_codes() const { return semantic_codes_; }

        const Syn_event_ptr syntactic_event() const { return event_; }
                
        /*------------------------------------------------------------
         * QUERIES
         *------------------------------------------------------------*/
        
        bool is_terminal() const {return children_.empty() && word_ != NULL;}

        bool is_punctuation() const {return is_punc_;}

        bool is_coordination() const {return is_coord_;}

        /*------------------------------------------------------------
         * CALCULATION
         *------------------------------------------------------------*/
        
        double node_log_probability() const;

#ifdef USE_SEMANTICS
        double subtree_log_probability(
            const Elab_ptr_const semantic_parent
            ) const;
#else
        double subtree_log_probability() const;
#endif

        /*------------------------------------------------------------
         * MEMBER ASSIGNMENT
         *------------------------------------------------------------*/
        
        void set_word(const Word& word);

        void set_label(const Label& label);

        void set_head(const Child_list::const_iterator head);

        void set_role(const Role& role) { role_ = role; }

        void set_coord(const bool new_value)
        {
            is_coord_ = new_value;
            if(is_coord_ && !is_base_np_) set_role(COORD);
        }
        
        void set_semantic_tree(const Sem_tree_ptr new_tree);

        void set_semantic_data(
            const Elab_ptr_const semantic_parent,
            const Step_code_t&   step_code
            );
        

        /*------------------------------------------------------------
         * MANIPULATION
         *------------------------------------------------------------*/
        
        void add_child(const Self_ptr& new_child, bool on_left = false);
        
        void preprocess_tree();

        void complete_tree()
        {
            add_stops();
            rebuild_events_recursively(NULL, this);
        }

        void release_event_counts()
        {
            if(event_ != NULL) event_ -> release_view_counts();
            if(sem_event_ != NULL) sem_event_ -> release_view_counts();
            learn_ = false;
            std::for_each(
                children_.begin(), children_.end(),
                boost::bind(&Semspear_tree::release_event_counts, _1)
                );
        }

        void reacquire_event_counts()
        {
            if(event_ != NULL) event_->reacquire_view_counts();
            if(sem_event_ != NULL) sem_event_->reacquire_view_counts();
            learn_ = true;
        }

        void reacquire_event_counts_recursively()
        {
            reacquire_event_counts();
            std::for_each(
                children_.begin(), children_.end(),
                boost::bind(
                    &Semspear_tree::reacquire_event_counts_recursively,
                    _1)
                );
        }

        void update_event_views_recursively();

        /*------------------------------------------------------------
         * DISPLAY
         *------------------------------------------------------------*/
        
        void print_constituency_tree(
            std::ostream& os,
            bool          is_head = false,
            int           indent_level = 0
            ) const;

        void print_dependency_tree(
            std::ostream& os,
            bool          is_head = false,
            int           indent_level = 0
            ) const;

        void print_events_with_probabilities(std::ostream& os) const;

        void print_subtree_view_counts(std::ostream& os) const;


        /*------------------------------------------------------------
         * FRIEND FUNCTIONS
         *------------------------------------------------------------*/
        
        friend void initialize_special_symbols();

        friend boost::tuple<Self_ptr, kjb::Vector> propose_new_tree(
            const Self_ptr source
            );

        friend void resample_event_tables(Self_ptr& source);
        
    public:
        /*------------------------------------------------------------
         * STATIC ACCESSORS
         *------------------------------------------------------------*/

        static Lexicon_db& lexicon() {return Syntactic_event::lexicon();}

        static Nonterminal_db& nt_lexicon();

        static LF_map_t& lf_word_map() {return Event_db::lf_word_map();}

        static Freq_map& word_freq_map()
        {
            static boost::shared_ptr<Freq_map> wfm(new Freq_map());
            return *wfm;
        };

    private:


        Child_list::iterator head_iterator()
        {
            return head_;
        }

        Child_list::reverse_iterator head_riterator()
        {
            return std::reverse_iterator<Child_list::iterator>(head_);
        }

        void add_stops();

        double resample_semantic_move(
            const Elab_ptr_const& semantic_parent,
            bool&                 altered
            );

        double evaluate_reverse_move(
            const Elab_ptr_const&  semantic_parent,
            const bool             tree_is_altered
            ) const;

    private:

        /*------------------------------------------------------------
         * UPDATE-RELATED HELPERS
         *------------------------------------------------------------*/
        
        void update_local_event(
            Semspear_tree*   parent,
            Semspear_tree*   sister_head,
            const int&       dist_code,
            bool             punc_flag,
            const Node_data& punc_data,
            bool             coord_flag,
            const Node_data& coord_data,
            const int&       depth
            );

        void update_semantic_context(
            const Hash_pair& parent_semantics,
            const Hash_pair& head_semantics
            );

        void update_semantic_association
        (
            Elab_ptr_const semantic_parent,
            bool           resample_step_codes = true   
        );
        
        void rebuild_events_recursively(
            Semspear_tree* const  parent       = NULL,
            Semspear_tree* const  sister_head  = NULL,
            const int&            dist_code    = 0,
            bool                  punc_flag    = false,
            const Node_data&      punc_data    = Node_data(0, 0, 0),
            bool                  coord_flag   = false,
            const Node_data&      coord_data   = Node_data(0, 0, 0),
            const int&            depth        = 0
            );
        
        template<typename Iter>
        void update_events_in_child_range(
            const Iter& start,
            const Iter& end,
            const int&  dist_base,
            const int&  depth
            );

        /*------------------------------------------------------------
         * PROPOSAL HELPERS
         *------------------------------------------------------------*/

        template<typename Iter>
        static kjb::Vector propose_associations_in_child_range(
            const Self_ptr    source,
            Self_ptr&         dest,
            Iter              source_start,
            Iter              source_end,
            Iter              dest_start,
            Iter              dest_end,
            bool              tree_is_altered
            );

        static kjb::Vector propose_new_associations(
            const Self_ptr        source,
            Self_ptr&             dest,
            const Elab_ptr_const  source_semantic_parent,
            const Elab_ptr_const  dest_semantic_parent,
            const bool            tree_is_altered
            );
        
        /*------------------------------------------------------------
         * PREPROCESSING HELPER FUNCTIONS
         *------------------------------------------------------------*/
        
        bool contains_verb() const;
        
        bool should_be_npb() const;

        void prune_unnecessary_nodes();
        
        void process_npbs();

        void insert_npb_parents();

        void raise_punctuation(
            Child_list&           siblings,
            Child_list::iterator  begin,
            Child_list::iterator  end
            );

        void mark_coordinated_phrase_children();

    private:
        Role role_; 
        Word_ptr word_; 
        Label_ptr label_; 
        Child_list children_; 
        Child_list::iterator head_; 
        Sem_tree_ptr semantic_tree_; 
        Elab_ptr_const semantic_node_; 
        Hash_pair semantic_codes_; 
        Step_code_t step_code_; 
        Syn_event_ptr event_; 
        Sem_event_ptr sem_event_; 
        bool is_punc_; 
        bool is_coord_; 
        bool is_base_np_; 
        bool learn_; 
        bool collins_; 
    };

    /*------------------------------------------------------------
     * FREE FUNCTIONS
     *------------------------------------------------------------*/
    
    boost::tuple<Semspear_tree::Self_ptr, kjb::Vector>
    propose_new_tree(const Semspear_tree::Self_ptr source);

    void resample_event_tables(Semspear_tree::Self_ptr& source);

    /*------------------------------------------------------------
     * TEMPLATE MEMBER DEFINITIONS
     *------------------------------------------------------------*/
    
    template<typename Iter>
    void Semspear_tree::update_events_in_child_range(
        const Iter& start,
        const Iter& end,
        const int&  dist_base,
        const int&  depth
        )
    {
        Semspear_tree* hh = head().get();
        bool adjacent_to_head = true;
        bool has_intervening_verb = false;
        bool next_punc_flag = false;
        Node_data next_punc_data = Node_data(0, 0, 0);
        bool next_coord_flag = false;
        Node_data next_coord_data = Node_data(0, 0, 0);
        int dist = dist_base + 10*adjacent_to_head + 1*has_intervening_verb;
        for(Iter it = start; it != end; it++)
        {
            if(*it == head()) continue;
            (*it) ->
                rebuild_events_recursively(
                    this,
                    hh,
                    dist,
                    next_punc_flag,
                    next_punc_data,
                    next_coord_flag,
                    next_coord_data,
                    depth + 1
                    );
            if(!((*it) -> is_punctuation())
               && (!(*it) -> is_coordination() || is_base_np_))
            {
                adjacent_to_head = false;
                next_punc_flag = false;
                next_punc_data = Node_data(0, 0, 0);
                next_coord_flag = false;
                next_coord_data = Node_data(0, 0, 0);
                if(is_base_np_)
                {
                    hh = (*it).get();
                    adjacent_to_head = true;
                    has_intervening_verb = false;
                } else if((*it) -> contains_verb())
                {
                    has_intervening_verb = true;
                }
            } else if((*it) -> is_punctuation() && !next_punc_flag) {
                assert((*it) -> word() != 0);
                assert((*it) -> label() != 0);
                next_punc_flag = true;
                next_punc_data =
                    Node_data((*it) -> word(), (*it) -> label(), 0);
            } else if((*it) -> is_coordination() && !next_coord_flag) {
                next_coord_flag = true;
                next_coord_data =
                    Node_data((*it) -> word(), (*it) -> label(), 0);
            }
            dist = dist_base + 10*adjacent_to_head + 1*has_intervening_verb;
        }
    }

/* /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ */ 

    template<typename Iter>
    kjb::Vector Semspear_tree::propose_associations_in_child_range(
        const Self_ptr source,
        Self_ptr&      dest,
        Iter           source_child_start,
        Iter           source_child_end,
        Iter           dest_child_start,
        Iter           dest_child_end,
        const bool     tree_is_altered
        )
    {
        typedef kjb::Vector Result;
        Result result(0.0, 0.0);
        Semspear_tree* hh = dest->head().get();
        Iter s_it = source_child_start, d_it = dest_child_start;
        for( ;
            s_it != source_child_end && d_it != dest_child_end;
            ++s_it, ++d_it)
        {
            if((*s_it) == source->head() || (*s_it)->is_punctuation()) continue;
            (*d_it)->update_semantic_context(
                dest->semantic_codes(),
                hh->semantic_codes()
                );
            result +=
                Semspear_tree::propose_new_associations(
                    *s_it, *d_it,
                    source->semantic_node_,
                    dest->semantic_node_,
                    tree_is_altered
                    );
            if(dest->is_base_np_)
            {
                hh = (*d_it).get();
            }
        }
        return result;
    }
};

#endif