Added find_max_parse_cky() and its supporting tools.

dlib/optimization.h

@@ -15,6 +15,7 @@
 #include "optimization/max_sum_submatrix.h"
 #include "optimization/find_max_factor_graph_nmplp.h"
 #include "optimization/find_max_factor_graph_viterbi.h"
+#include "optimization/find_max_parse_cky.h"
 
 #endif // DLIB_OPTIMIZATIOn_HEADER
 

dlib/optimization/find_max_parse_cky.h

+// Copyright (C) 2012  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_FIND_MAX_PaRSE_CKY_H__
+#define DLIB_FIND_MAX_PaRSE_CKY_H__
+
+#include "find_max_parse_cky_abstract.h"
+#include <vector>
+#include <string>
+#include <sstream>
+#include "../array2d.h"
+
+namespace dlib
+{
+
+// -----------------------------------------------------------------------------------------
+
+    template <typename T>
+    struct constituent 
+    {
+        unsigned long begin, end, k;
+        T left_tag; 
+        T right_tag;
+    };
+
+    const unsigned long END_OF_TREE = 0xFFFFFFFF;
+
+    template <typename T>
+    struct parse_tree_element
+    {
+        constituent<T> c;
+        T tag; // id for the constituent corresponding to this level of the tree
+
+        unsigned long left;
+        unsigned long right; 
+        double score; 
+    };
+
+
+    namespace impl
+    {
+        template <typename T>
+        unsigned long fill_parse_tree(
+            std::vector<parse_tree_element<T> >& parse_tree, 
+            const T& tag,
+            const array2d<std::map<T, parse_tree_element<T> > >& back, 
+            long r, long c
+        )
+        /*!
+            requires
+                - back[r][c].size() == 0 || back[r][c].count(tag) != 0
+        !*/
+        {
+            // base case of the recursion 
+            if (back[r][c].size() == 0)
+            {
+                return END_OF_TREE;
+            }
+
+            const unsigned long idx = parse_tree.size();
+            const parse_tree_element<T>& item = back[r][c].find(tag)->second;
+            parse_tree.push_back(item);
+
+            const long k = item.c.k;
+            const unsigned long idx_left  = fill_parse_tree(parse_tree, item.c.left_tag, back, r, k-1); 
+            const unsigned long idx_right = fill_parse_tree(parse_tree, item.c.right_tag, back, k, c); 
+            parse_tree[idx].left = idx_left;
+            parse_tree[idx].right = idx_right;
+            return idx;
+        }
+    }
+
+    template <typename T, typename production_rule_function>
+    void find_max_parse_cky (
+        const std::vector<T>& sequence,
+        const production_rule_function& production_rules,
+        std::vector<std::vector<parse_tree_element<T> > >& parse_trees
+    )
+    {
+        parse_trees.clear();
+        array2d<std::map<T,double> > table(sequence.size(), sequence.size());
+        array2d<std::map<T,parse_tree_element<T> > > back(sequence.size(), sequence.size());
+        typedef typename std::map<T,double>::iterator itr;
+        typedef typename std::map<T,parse_tree_element<T> >::iterator itr_b;
+
+        for (long r = 0; r < table.nr(); ++r)
+            table[r][r][sequence[r]] = 0;
+
+        std::vector<std::pair<T,double> > possible_tags;
+
+        for (long r = table.nr()-2; r >= 0; --r)
+        {
+            for (long c = r+1; c < table.nc(); ++c)
+            {
+                for (long k = r; k < c; ++k)
+                {
+                    for (itr i = table[k+1][c].begin(); i != table[k+1][c].end(); ++i)
+                    {
+                        for (itr j = table[r][k].begin(); j != table[r][k].end(); ++j)
+                        {
+                            constituent<T> con;
+                            con.begin = r;
+                            con.end = c+1;
+                            con.k = k+1;
+                            con.left_tag = j->first;
+                            con.right_tag = i->first;
+                            possible_tags.clear();
+                            production_rules(sequence, con, possible_tags);
+                            for (unsigned long m = 0; m < possible_tags.size(); ++m)
+                            {
+                                const double score = possible_tags[m].second + i->second + j->second;
+                                itr match = table[r][c].find(possible_tags[m].first);
+                                if (match == table[r][c].end() || score > match->second)
+                                {
+                                    table[r][c][possible_tags[m].first] = score;
+                                    parse_tree_element<T> item;
+                                    item.c = con;
+                                    item.score = score;
+                                    item.tag = possible_tags[m].first;
+                                    back[r][c][possible_tags[m].first] = item;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+
+        // now use back pointers to build the parse trees
+        for (long r = 0; r < back.nr(); ++r)
+        {
+            for (long c = back.nc()-1; c > r; --c)
+            {
+                if (back[r][c].size() != 0)
+                {
+
+                    // find the max scoring element in back[r][c]
+                    itr_b max_i = back[r][c].begin();
+                    itr_b i = max_i;
+                    ++i;
+                    for (; i != back[r][c].end(); ++i)
+                    {
+                        if (i->second.score > max_i->second.score)
+                            max_i = i;
+                    }
+
+                    parse_trees.resize(parse_trees.size()+1);
+                    parse_trees.back().reserve(c);
+                    impl::fill_parse_tree(parse_trees.back(), max_i->second.tag, back, r, c);
+
+                    r = c;
+                    break;
+                }
+            }
+        }
+    }
+
+// -----------------------------------------------------------------------------------------
+
+    class parse_tree_to_string_error : public error
+    {
+    public:
+        parse_tree_to_string_error(const std::string& str): error(str) {}
+    };
+
+    namespace impl
+    {
+        template <bool enabled, typename T>
+        typename enable_if_c<enabled>::type conditional_print(
+            const T& item,
+            std::ostream& out
+        ) { out << item << " "; }
+
+        template <bool enabled, typename T>
+        typename disable_if_c<enabled>::type conditional_print(
+            const T& ,
+            std::ostream& 
+        ) {  }
+
+        template <bool print_tag, typename T, typename U >
+        void print_parse_tree_helper (
+            const std::vector<parse_tree_element<T> >& tree,
+            const std::vector<U>& items,
+            unsigned long i,
+            std::ostream& out
+        )
+        {
+            out << "[";
+            bool left_recurse = false;
+
+            // Only print if we are supposed to.  Doing it this funny way avoids compiler
+            // errors in parse_tree_to_string() for the case where tag isn't
+            // printable.
+            conditional_print<print_tag>(tree[i].tag, out);
+
+            if (tree[i].left < tree.size())
+            {
+                left_recurse = true;
+                print_parse_tree_helper<print_tag>(tree, items, tree[i].left, out);
+            }
+            else
+            {
+                if (tree[i].c.begin < items.size())
+                {
+                    out << items[tree[i].c.begin] << " ";
+                }
+                else
+                {
+                    std::ostringstream sout;
+                    sout << "Parse tree refers to element " << tree[i].c.begin 
+                         << " of sequence which is only of size " << items.size() << ".";
+                    throw parse_tree_to_string_error(sout.str());
+                }
+            }
+
+            if (tree[i].right < tree.size())
+            {
+                if (left_recurse == true)
+                    out << " ";
+
+                print_parse_tree_helper<print_tag>(tree, items, tree[i].right, out);
+            }
+            else
+            {
+                if (tree[i].c.k < items.size())
+                {
+                    out << items[tree[i].c.k];
+                }
+                else
+                {
+                    std::ostringstream sout;
+                    sout << "Parse tree refers to element " << tree[i].c.k 
+                         << " of sequence which is only of size " << items.size() << ".";
+                    throw parse_tree_to_string_error(sout.str());
+                }
+            }
+
+
+            out << "]";
+        }
+    }
+
+// -----------------------------------------------------------------------------------------
+
+    template <typename T, typename U>
+    std::string parse_tree_to_string (
+        const std::vector<parse_tree_element<T> >& tree,
+        const std::vector<U>& items
+    )
+    {
+        if (tree.size() == 0)
+            return "";
+
+        std::ostringstream sout;
+        impl::print_parse_tree_helper<false>(tree, items, 0, sout);
+        return sout.str();
+    }
+
+// -----------------------------------------------------------------------------------------
+
+    template <typename T, typename U>
+    std::string parse_tree_to_string_tagged (
+        const std::vector<parse_tree_element<T> >& tree,
+        const std::vector<U>& items
+    )
+    {
+        if (tree.size() == 0)
+            return "";
+
+        std::ostringstream sout;
+        impl::print_parse_tree_helper<true>(tree, items, 0, sout);
+        return sout.str();
+    }
+
+// -----------------------------------------------------------------------------------------
+
+}
+
+#endif // DLIB_FIND_MAX_PaRSE_CKY_H__
+

dlib/optimization/find_max_parse_cky_abstract.h

+// Copyright (C) 2012  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#undef DLIB_FIND_MAX_PARsE_CKY_ABSTRACT_H__
+#ifdef DLIB_FIND_MAX_PARsE_CKY_ABSTRACT_H__
+
+#include <vector>
+#include <string>
+
+namespace dlib
+{
+
+// -----------------------------------------------------------------------------------------
+
+    template <typename T>
+    struct constituent 
+    {
+        /*!
+            WHAT THIS OBJECT REPRESENTS
+        !*/
+
+        unsigned long begin, end, k;
+        T left_tag; 
+        T right_tag;
+    };
+
+    const unsigned long END_OF_TREE = 0xFFFFFFFF;
+
+    template <typename T>
+    struct parse_tree_element
+    {
+        /*!
+            WHAT THIS OBJECT REPRESENTS
+        !*/
+
+        constituent<T> c;
+        T tag; // id for the constituent corresponding to this level of the tree
+
+        // subtrees.  These are the index values into the std::vector that contains all the parse_tree_elements.
+        unsigned long left;
+        unsigned long right; 
+
+        double score; // score for this tree
+    };
+
+// -----------------------------------------------------------------------------------------
+// -----------------------------------------------------------------------------------------
+
+    void example_production_rule_function (
+        const std::vector<T>& sequence,
+        const constituent<T>& c,
+        std::vector<std::pair<T,double> >& possible_tags
+    )
+    /*!
+        requires
+            - 0 <= c.begin < c.k < c.end <= sequence.size()
+            - possible_tags.size() == 0 
+        ensures
+            - finds all the production rules that can turn c into a single non-terminal.
+              Puts the IDs of these rules and their scores into possible_tags.
+            - Note that example_production_rule_function() is not a real function.  It is
+              here just to show you how to define production rule producing functions
+              for use with the find_max_parse_cky() routine defined below.
+    !*/
+
+    template <
+        typename T, 
+        typename production_rule_function
+        >
+    void find_max_parse_cky (
+        const std::vector<T>& sequence,
+        const production_rule_function& production_rules,
+        std::vector<std::vector<parse_tree_element<T> > >& parse_trees
+    );
+    /*!
+        requires
+            - production_rule_function == a function or function object with the same
+              interface as example_production_rule_function defined above.
+    !*/
+
+// -----------------------------------------------------------------------------------------
+// -----------------------------------------------------------------------------------------
+
+    class parse_tree_to_string_error : public error
+    {
+        /*!
+            WHAT THIS OBJECT REPRESENTS
+        !*/
+    };
+
+// -----------------------------------------------------------------------------------------
+
+    template <typename T, typename U>
+    std::string parse_tree_to_string (
+        const std::vector<parse_tree_element<T> >& tree,
+        const std::vector<U>& items
+    );
+    /*!
+        ensures
+            - 
+    !*/
+
+// -----------------------------------------------------------------------------------------
+
+    template <typename T, typename U>
+    std::string parse_tree_to_string_tagged (
+        const std::vector<parse_tree_element<T> >& tree,
+        const std::vector<U>& items
+    );
+    /*!
+        ensures
+            - 
+    !*/
+
+// -----------------------------------------------------------------------------------------
+
+}
+
+#endif // DLIB_FIND_MAX_PARsE_CKY_ABSTRACT_H__
+