gum::prm::GSpan< GUM_SCALAR > Class Template Reference

This class discovers pattern in a PRM<GUM_SCALAR>'s PRMSystem<GUM_SCALAR> to speed up structured inference. More...

#include <agrum/PRM/gspan.h>

Collaboration diagram for gum::prm::GSpan< GUM_SCALAR >:

Public Member Functions
Constructors & destructor.
	GSpan (const PRM< GUM_SCALAR > &prm, const PRMSystem< GUM_SCALAR > &sys, gspan::SearchStrategy< GUM_SCALAR > *strategy=0)
	Default constructor. More...
	~GSpan ()
	Destructor. More...
Getters and setters.
Size	getMaxDFSDepth () const
	Returns the maximal depth of the DFSTree used to discover new patterns. More...
void	setMaxDFSDepth (Size depth)
	Defines the maximal depth of the DFSTree used by this class to discover new patterns. More...
gspan::DFSTree< GUM_SCALAR > &	tree ()
	Returns the DFSTree used to discover new patters. More...
const gspan::DFSTree< GUM_SCALAR > &	tree () const
	Returns the DFSTree used to discover new patters. More...
gspan::InterfaceGraph< GUM_SCALAR > &	interfaceGraph ()
	Returns the InterfaceGraph used by this. More...
const gspan::InterfaceGraph< GUM_SCALAR > &	interfaceGraph () const
	Returns the InterfaceGraph used by this. More...

Classes
class	LabelSort
	Private class used to sort LabelData using STL sort algorithms. More...
class	PatternSort
	Private class used to sort Pattern using STL sort algorithms. More...

Pattern discovery methods.
typedef Set< Sequence< PRMInstance< GUM_SCALAR > *> *>	MatchedInstances
	Code alias. More...
void	discoverPatterns ()
	This will methods will discover repeated patterns in the PRMSystem<GUM_SCALAR> assigned to this class. More...
std::vector< gspan::Pattern *> &	patterns ()
	Returns the Pattern mined by this class in a decreasing order of interest. More...
const std::vector< gspan::Pattern *> &	patterns () const
	Returns the Pattern mined by this class in a decreasing order of interest. More...
MatchedInstances &	matches (const gspan::Pattern &p)
	Returns a mapping between patterns and the sequence of instance in the interface graph matching them. More...
const MatchedInstances &	matches (const gspan::Pattern &p) const
	Returns a mapping between patterns and the sequence of instance in the interface graph matching them. More...

Detailed Description

template<typename GUM_SCALAR>
class gum::prm::GSpan< GUM_SCALAR >

This class discovers pattern in a PRM<GUM_SCALAR>'s PRMSystem<GUM_SCALAR> to speed up structured inference.

This class is not an inference algorithm for PRM<GUM_SCALAR>, however it can be used to speed up structured inference as it will discover repeated patterns including more than one PRMInstance<GUM_SCALAR>.

This algorithm proceeds in three main steps represented by the private methods GSpan::sortNodesAndEdges__(), GSpan::subgraph_mining__() and GSpan::sortPatterns__().

Definition at line 56 of file DFSTree.h.

Member Typedef Documentation

MatchedInstances

template<typename GUM_SCALAR >

typedef Set< Sequence< PRMInstance< GUM_SCALAR >* >* > gum::prm::GSpan< GUM_SCALAR >::MatchedInstances

Code alias.

Definition at line 169 of file gspan.h.

Constructor & Destructor Documentation

GSpan()

template<typename GUM_SCALAR >

INLINE gum::prm::GSpan< GUM_SCALAR >::GSpan	(	const PRM< GUM_SCALAR > &	prm,
		const PRMSystem< GUM_SCALAR > &	sys,
		gspan::SearchStrategy< GUM_SCALAR > *	strategy = 0
	)

Default constructor.

Parameters

prm	The PRM<GUM_SCALAR> used by this class.
sys	The PRMSystem<GUM_SCALAR> on which this class searches for patterns.
strategy	The search strategy used for pattern mining, the default strategy is gspan::FrequenceSearch.

Definition at line 360 of file gspan_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                                               :
        graph__(new gspan::InterfaceGraph< GUM_SCALAR >(sys)),
        tree__(*graph__, strategy), depth_stop__(INT_MAX) {
      GUM_CONSTRUCTOR(GSpan);
    }

Here is the call graph for this function:

~GSpan()

template<typename GUM_SCALAR >

INLINE gum::prm::GSpan< GUM_SCALAR >::~GSpan

(

)

Destructor.

Definition at line 369 of file gspan_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                       {
      GUM_DESTRUCTOR(GSpan);

      for (const auto& elt: matched_instances__)
        delete elt.second;

      delete graph__;
    }

Here is the call graph for this function:

Member Function Documentation

cost_func__()

template<typename GUM_SCALAR >

INLINE Idx gum::prm::GSpan< GUM_SCALAR >::cost_func__ ( Size  interface_size, Size  frequency  )

private

Returns the cost with respect to an interface size and its frequency.

Parameters

interface_size	The size of all output nodes of a pattern.
frequency	The frequency of the pattern in the current interface graph.

Returns

the cost with respect to an interface size and its frequency.

Definition at line 399 of file gspan_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                                {
      return Idx(interface_size * frequency);
    }

Here is the call graph for this function:

discoverPatterns()

template<typename GUM_SCALAR >

void gum::prm::GSpan< GUM_SCALAR >::discoverPatterns

(

)

This will methods will discover repeated patterns in the PRMSystem<GUM_SCALAR> assigned to this class.

The results are saved in a vector of Patterns which can be obtained by calling GSpan::patterns().

Definition at line 35 of file gspan_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                               {
      Timer t;
      sortNodesAndEdges__();
      gspan::InterfaceGraph< GUM_SCALAR > graph(*graph__);

      for (auto root = tree__.roots().begin(); root != tree__.roots().end();
           ++root) {
        if (tree__.strategy().accept_root(&(tree__.pattern(*root)))) {
          gspan::Pattern& p = tree__.pattern(*root);
          subgraph_mining__(graph, p);

          for (const auto node: tree__.iso_graph(p).nodes()) {
            PRMInstance< GUM_SCALAR >* u = tree__.iso_map(p, node).atPos(0);
            PRMInstance< GUM_SCALAR >* v = tree__.iso_map(p, node).atPos(1);
            graph.graph().eraseEdge(Edge(graph.id(u), graph.id(v)));
          }
        }
      }

      sortPatterns__();
    }

Here is the call graph for this function:

getMaxDFSDepth()

template<typename GUM_SCALAR >

INLINE Size gum::prm::GSpan< GUM_SCALAR >::getMaxDFSDepth

(

)

const

Returns the maximal depth of the DFSTree used to discover new patterns.

Returns

the maximal depth of the DFSTree used to discover new patterns.

Definition at line 379 of file gspan_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                          {
      return depth_stop__;
    }

Here is the call graph for this function:

interfaceGraph() [1/2]

template<typename GUM_SCALAR >

INLINE gspan::InterfaceGraph< GUM_SCALAR > & gum::prm::GSpan< GUM_SCALAR >::interfaceGraph

(

)

Returns the InterfaceGraph used by this.

Returns

the InterfaceGraph used by this.

Definition at line 429 of file gspan_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                               {
      return *graph__;
    }

Here is the call graph for this function:

interfaceGraph() [2/2]

template<typename GUM_SCALAR >

INLINE const gspan::InterfaceGraph< GUM_SCALAR > & gum::prm::GSpan< GUM_SCALAR >::interfaceGraph

(

)

const

Returns the InterfaceGraph used by this.

Returns

the InterfaceGraph used by this.

Definition at line 435 of file gspan_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                           {
      return *graph__;
    }

Here is the call graph for this function:

isEdgeEligible__()

template<typename GUM_SCALAR >

INLINE bool gum::prm::GSpan< GUM_SCALAR >::isEdgeEligible__ ( typename gspan::EdgeData< GUM_SCALAR > *  e )

private

Returns true if e is an eligible root edge.

Parameters

e	An EdgeData<GUM_SCALAR>.

Returns

true if e is an eligible root edge.

Definition at line 441 of file gspan_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                                           {
      return (graph__->edges(e->l).size() >= 2)
          && (graph__->nodes(e->l_u).size() >= 2)
          && (graph__->nodes(e->l_v).size() >= 2);
    }

Here is the call graph for this function:

matches() [1/2]

template<typename GUM_SCALAR >

INLINE GSpan< GUM_SCALAR >::MatchedInstances & gum::prm::GSpan< GUM_SCALAR >::matches

(

const gspan::Pattern &

p

)

Returns a mapping between patterns and the sequence of instance in the interface graph matching them.

Returns

a mapping between patterns and the sequence of instance in the interface graph matching them.

Definition at line 417 of file gspan_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                         {
      return *(matched_instances__[const_cast< gspan::Pattern* >(&p)]);
    }

Here is the call graph for this function:

matches() [2/2]

template<typename GUM_SCALAR >

INLINE const GSpan< GUM_SCALAR >::MatchedInstances & gum::prm::GSpan< GUM_SCALAR >::matches

(

const gspan::Pattern &

p

)

const

Returns a mapping between patterns and the sequence of instance in the interface graph matching them.

Returns

a mapping between patterns and the sequence of instance in the interface graph matching them.

Definition at line 423 of file gspan_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                               {
      return *(matched_instances__[const_cast< gspan::Pattern* >(&p)]);
    }

Here is the call graph for this function:

patterns() [1/2]

template<typename GUM_SCALAR >

INLINE std::vector< gspan::Pattern *> & gum::prm::GSpan< GUM_SCALAR >::patterns

(

)

Returns the Pattern mined by this class in a decreasing order of interest.

Returns

the Pattern mined by this class in a decreasing order of interest.

Definition at line 405 of file gspan_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                                     {
      return patterns__;
    }

Here is the call graph for this function:

patterns() [2/2]

template<typename GUM_SCALAR >

INLINE const std::vector< gspan::Pattern *> & gum::prm::GSpan< GUM_SCALAR >::patterns

(

)

const

Returns the Pattern mined by this class in a decreasing order of interest.

Returns

the Pattern mined by this class in a decreasing order of interest.

Definition at line 411 of file gspan_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                     {
      return patterns__;
    }

Here is the call graph for this function:

setMaxDFSDepth()

template<typename GUM_SCALAR >

INLINE void gum::prm::GSpan< GUM_SCALAR >::setMaxDFSDepth

(

Size

depth

)

Defines the maximal depth of the DFSTree used by this class to discover new patterns.

Parameters

depth

The new maximal DFSTree depth.

Definition at line 384 of file gspan_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                              {
      depth_stop__ = depth;
    }

Here is the call graph for this function:

sortNodesAndEdges__()

template<typename GUM_SCALAR >

void gum::prm::GSpan< GUM_SCALAR >::sortNodesAndEdges__ ( )

private

Sort the nodes and edges of graph__.

Definition at line 58 of file gspan_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                  {
      for (auto iter = graph__->labels().begin(); iter != graph__->labels().end();
           ++iter) {
        try {
          if (graph__->nodes(iter.second()).size() >= 2) {
            cost__.insert(iter.second(),
                          cost_func__(iter.second()->tree_width,
                                      graph__->nodes(iter.second()).size()));
            nodes__.push_back(const_cast< gspan::LabelData* >(iter.second()));
          }
        } catch (NotFound&) {
          // It's a label over edges
          if (isEdgeEligible__(*(graph__->edges(iter.second()).begin()))) {
            cost__.insert(iter.second(),
                          cost_func__(iter.second()->tree_width,
                                      graph__->edges(iter.second()).size()));
            edges__.push_back(iter.second());
          }
        }
      }

      Bijection< Idx, gspan::LabelData* >* new_labels
         = new Bijection< Idx, gspan::LabelData* >();
      GSpan< GUM_SCALAR >::LabelSort my_sort(this);
      std::sort(nodes__.begin(), nodes__.end(), my_sort);
      std::sort(edges__.begin(), edges__.end(), my_sort);
      Size idx = 0;

      for (auto iter = nodes__.begin(); iter != nodes__.end(); ++iter) {
        (*iter)->id = ++idx;
        new_labels->insert(idx, *iter);
      }

      for (auto iter = edges__.begin(); iter != edges__.end(); ++iter) {
        (*iter)->id = ++idx;
        new_labels->insert(idx, *iter);
        tree__.addRoot(**iter);
      }

      delete graph__->labels__;
      graph__->labels__ = new_labels;
    }

Here is the call graph for this function:

sortPatterns__()

template<typename GUM_SCALAR >

void gum::prm::GSpan< GUM_SCALAR >::sortPatterns__ ( )

private

Sort the patterns and compute their respective costs.

Definition at line 230 of file gspan_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                             {
      // First we put all the patterns in patterns__.
      std::vector< NodeId > stack;

      for (std::list< NodeId >::reverse_iterator root = tree().roots().rbegin();
           root != tree().roots().rend();
           ++root)
        stack.push_back(*root);

      NodeId               id       = 0;
      std::list< NodeId >* children = nullptr;

      while (!stack.empty()) {
        id = stack.back();
        stack.pop_back();
        patterns__.push_back(&(tree().pattern(id)));
        children = &(tree().children(tree().pattern(id)));

        for (std::list< NodeId >::reverse_iterator child = children->rbegin();
             child != children->rend();
             ++child)
          stack.push_back(*child);
      }

      if (!patterns__.empty()) {
        // We sort patterns__.
        GSpan< GUM_SCALAR >::PatternSort my_sort(this);
        std::sort(patterns__.begin(), patterns__.end(), my_sort);
        // Now we need to find all the matches we can, using patterns__.
        // We start by the best Pattern and add it's maximal independent set to
        // chosen__
        GSpan< GUM_SCALAR >::MatchedInstances* matches
           = new GSpan< GUM_SCALAR >::MatchedInstances();
        Sequence< PRMInstance< GUM_SCALAR >* >* match = nullptr;

        for (const auto node: tree().max_indep_set(*(patterns__.front()))) {
          match = &(tree().iso_map(*(patterns__.front()), node));

          for (const auto i: *match)
            chosen__.insert(i);

          matches->insert(match);
        }

        matched_instances__.insert(patterns__.front(), matches);
        // Now we see what kind of pattern we can still use
        bool       found;
        UndiGraph* iso_graph = nullptr;

        for (auto patt = patterns__.begin() + 1; patt != patterns__.end();
             ++patt) {
          UndiGraph             reduced_iso_graph;
          std::vector< NodeId > degree_list;
          iso_graph = &(tree().iso_graph(**patt));

          for (const auto node: iso_graph->nodes()) {
            found = false;
            match = &(tree().iso_map(**patt, node));

            for (const auto i: *match)
              if (chosen__.exists(i)) {
                found = true;
                break;
              }

            if (!found) {
              // We add the pattern to the reduced isomorphism graph to compute
              // the
              // max independent set
              // over the remaining matches
              reduced_iso_graph.addNodeWithId(node);

              for (const auto iso: reduced_iso_graph.nodes())
                if (iso_graph->existsEdge(node, iso))
                  reduced_iso_graph.addEdge(node, iso);

              degree_list.push_back(node);
            }
          }

          // We create a new set to hold all the chosen matches of patt
          matches = new GSpan< GUM_SCALAR >::MatchedInstances();
          // We can compute the max independent set and the matches belonging to
          // it
          typename gspan::DFSTree< GUM_SCALAR >::NeighborDegreeSort my_sort(
             reduced_iso_graph);
          std::sort(degree_list.begin(), degree_list.end(), my_sort);
          Set< NodeId > removed;

          for (const auto node: degree_list)
            if (!removed.exists(node)) {
              // First we update removed to follow the max independent set
              // algorithm
              removed.insert(node);

              for (const auto neighbor: reduced_iso_graph.neighbours(node))
                removed.insert(neighbor);

              // Second we update match and matches to keep track of the current
              // match
              match = &(tree().iso_map(**patt, node));
              matches->insert(match);

              for (const auto elt: *match)
                chosen__.insert(elt);
            }

          matched_instances__.insert(*patt, matches);
        }

        // // We remove patterns with 0 matches
        std::vector< size_t > trash;

        for (size_t idx = 0; idx < patterns__.size(); ++idx)
          if (matched_instances__[patterns__[idx]]->size() < 2)
            trash.push_back(idx);

        while (trash.size()) {
          delete matched_instances__[patterns__[trash.back()]];
          matched_instances__.erase(patterns__[trash.back()]);
          // delete patterns__[trash.back()];
          patterns__[trash.back()] = patterns__.back();
          patterns__.pop_back();
          trash.pop_back();
        }
      }
    }

Here is the call graph for this function:

subgraph_mining__()

template<typename GUM_SCALAR >

void gum::prm::GSpan< GUM_SCALAR >::subgraph_mining__ ( gspan::InterfaceGraph< GUM_SCALAR > &  graph, gspan::Pattern &  p  )

private

Discovers new patterns by developing p.

Parameters

graph	The interface graph used in this discovery process.
p	The pattern used as a base for discovery.

Definition at line 102 of file gspan_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                               {
      std::vector< gspan::Pattern* > stack;
      stack.push_back(&pat);
      // Pointers used in the following while
      gspan::Pattern*                                             p = nullptr;
      HashTable< std::string, gspan::EdgeGrowth< GUM_SCALAR >* >* edge_count
         = nullptr;
      gspan::EdgeGrowth< GUM_SCALAR >*        edge_growth = nullptr;
      Sequence< PRMInstance< GUM_SCALAR >* >* seq         = nullptr;
      PRMInstance< GUM_SCALAR >*              current     = nullptr;
      PRMInstance< GUM_SCALAR >*              neighbor    = nullptr;

      // Neighbor_id is the neighbor's id in the interface graph and
      // neighbor_node
      // is its id in the rightmost path in the case of a backward edge growth
      NodeId            current_id     = 0;
      NodeId            neighbor_node  = 0;
      gspan::LabelData* neighbor_label = 0;

      typename gspan::EdgeData< GUM_SCALAR >* edge_data = nullptr;

      size_t                     idx;
      const std::list< NodeId >* children = 0;

      while (!stack.empty()) {
        // Getting next pattern
        p = stack.back();
        stack.pop_back();

        if (p->code().codes.size() < depth_stop__) {
          // We need the rightmost path of p
          std::list< NodeId > r_path;
          p->rightmostPath(r_path);
          // Mapping used to count each possible child of p, the position in the
          // vector
          // matches the one in the rightmost path
          std::vector<
             HashTable< std::string, gspan::EdgeGrowth< GUM_SCALAR >* >* >
             count_vector;

          for (size_t i = 0; i < r_path.size(); ++i)
            count_vector.push_back(
               new HashTable< std::string, gspan::EdgeGrowth< GUM_SCALAR >* >());

          // For each subgraph represented by p, we look for a valid edge growth
          // for
          // each instance match of p in its isomorphism graph.
          for (const auto iso_node: tree__.iso_graph(*p).nodes()) {
            seq = &(tree__.iso_map(*p, iso_node));
            idx = 0;

            for (const auto node: r_path) {
              edge_count = count_vector[idx];
              // Retrieving the equivalent instance in the current match
              current    = seq->atPos((Idx)(node - 1));
              current_id = ig.id(current);
              // Checking for edges not in p

              for (const auto neighbor_id: ig.graph().neighbours(current_id)) {
                neighbor = ig.node(neighbor_id).n;

                // We want a forward edge in any case or a backward edge if
                // current
                // is the rightmost vertex
                if ((!seq->exists(neighbor)) || (node == r_path.back())) {
                  // Things we need to know: the LabelData data of the neighbour
                  // and,
                  // if it's a backward edge, its node id in the rightmost path
                  edge_data      = &(ig.edge(current_id, neighbor_id));
                  neighbor_label = (neighbor == edge_data->u) ? edge_data->l_u
                                                              : edge_data->l_v;
                  neighbor_node
                     = (seq->exists(neighbor)) ? seq->pos(neighbor) + 1 : 0;
                  // Adding the edge growth to the edge_growth hashtable
                  gspan::EdgeGrowth< GUM_SCALAR > temp_growth(node,
                                                              edge_data->l,
                                                              neighbor_label,
                                                              neighbor_node);

                  try {
                    edge_growth = (*edge_count)[temp_growth.toString()];
                    edge_growth->insert(current, neighbor);
                  } catch (NotFound&) {
                    edge_growth
                       = new gspan::EdgeGrowth< GUM_SCALAR >(node,
                                                             edge_data->l,
                                                             neighbor_label,
                                                             neighbor_node);
                    edge_growth->insert(current, neighbor);
                    edge_count->insert(edge_growth->toString(), edge_growth);
                  }
                }
              }
            }
          }

          // Removing any infrequent child
          for (size_t node = 0; node < count_vector.size(); ++node) {
            edge_count = count_vector[node];

            for (const auto& elt: *edge_count) {
              try {
                tree__.growPattern(*p, *elt.second, 2);
              } catch (OperationNotAllowed&) {
                // The child was not minimal or was not worth considering
              }

              delete elt.second;
            }

            delete edge_count;
          }

          // Calling subgraph_mining__ over children of p
          children = &(tree__.children(*p));

          for (std::list< NodeId >::const_reverse_iterator child
               = children->rbegin();
               child != children->rend();
               ++child)
            stack.push_back(&(tree__.pattern(*child)));
        }
      }
    }

Here is the call graph for this function:

tree() [1/2]

template<typename GUM_SCALAR >

INLINE gspan::DFSTree< GUM_SCALAR > & gum::prm::GSpan< GUM_SCALAR >::tree

(

)

Returns the DFSTree used to discover new patters.

Returns

the DFSTree used to discover new patters.

Definition at line 389 of file gspan_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                                 {
      return tree__;
    }

Here is the call graph for this function:

tree() [2/2]

template<typename GUM_SCALAR >

INLINE const gspan::DFSTree< GUM_SCALAR > & gum::prm::GSpan< GUM_SCALAR >::tree

(

)

const

Returns the DFSTree used to discover new patters.

Returns

the DFSTree used to discover new patters.

Definition at line 394 of file gspan_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                                             {
      return tree__;
    }

Here is the call graph for this function:

Member Data Documentation

chosen__

template<typename GUM_SCALAR >

Set< PRMInstance< GUM_SCALAR >* > gum::prm::GSpan< GUM_SCALAR >::chosen__

private

Contains all instance which belongs to a discovered and used pattern.

Definition at line 240 of file gspan.h.

cost__

template<typename GUM_SCALAR >

HashTable< gspan::LabelData*, Idx > gum::prm::GSpan< GUM_SCALAR >::cost__

private

Mapping between labels and their cost.

Definition at line 233 of file gspan.h.

depth_stop__

template<typename GUM_SCALAR >

Size gum::prm::GSpan< GUM_SCALAR >::depth_stop__

private

The max depth allowed for the DSF tree.

Definition at line 221 of file gspan.h.

edges__

template<typename GUM_SCALAR >

std::vector< gspan::LabelData* > gum::prm::GSpan< GUM_SCALAR >::edges__

private

The vector of edges in graph__, in decreasing order of interest.

Definition at line 230 of file gspan.h.

graph__

template<typename GUM_SCALAR >

gspan::InterfaceGraph< GUM_SCALAR >* gum::prm::GSpan< GUM_SCALAR >::graph__

private

The interface graph used by this class.

Definition at line 215 of file gspan.h.

matched_instances__

template<typename GUM_SCALAR >

HashTable< gspan::Pattern*, MatchedInstances* > gum::prm::GSpan< GUM_SCALAR >::matched_instances__

private

Mapping between a pattern and the multiset of instances matched to it.

Definition at line 237 of file gspan.h.

nodes__

template<typename GUM_SCALAR >

std::vector< gspan::LabelData* > gum::prm::GSpan< GUM_SCALAR >::nodes__

private

The vector of nodes in graph__, in decreasing order of interest.

Definition at line 227 of file gspan.h.

patterns__

template<typename GUM_SCALAR >

std::vector< gspan::Pattern* > gum::prm::GSpan< GUM_SCALAR >::patterns__

private

The vector of discovered patters, in decreasing order of interest.

Definition at line 224 of file gspan.h.

tree__

template<typename GUM_SCALAR >

gspan::DFSTree< GUM_SCALAR > gum::prm::GSpan< GUM_SCALAR >::tree__

private

The DFSTree used to discover new patters.

Definition at line 218 of file gspan.h.

---

The documentation for this class was generated from the following files:

• agrum/PRM/gspan/DFSTree.h
• agrum/PRM/inference/gspan.h
• agrum/PRM/inference/gspan_tpl.h