lwtDev::Graph Class Reference

#include <Graph.h>

Collaboration diagram for lwtDev::Graph:

Public Member Functions
	Graph ()
	Graph (const std::vector< NodeConfig > &nodes, const std::vector< LayerConfig > &layers)
	Graph (Graph &)=delete
Graph &	operator= (Graph &)=delete
	~Graph ()
VectorXd	compute (const ISource &, size_t node_number) const
VectorXd	compute (const ISource &) const
MatrixXd	scan (const ISource &, size_t node_number) const
MatrixXd	scan (const ISource &) const

Private Member Functions
void	build_node (const size_t, const std::vector< NodeConfig > &nodes, const std::vector< LayerConfig > &layers, std::set< size_t > cycle_check={})

Private Attributes
std::unordered_map< size_t, INode * >	m_nodes
size_t	m_last_node
std::unordered_map< size_t, Stack * >	m_stacks
std::unordered_map< size_t, ISequenceNode * >	m_seq_nodes
std::unordered_map< size_t, RecurrentStack * >	m_seq_stacks

Detailed Description

Definition at line 119 of file Graph.h.

Constructor & Destructor Documentation

Graph() [1/3]

lwtDev::Graph::Graph

(

)

Definition at line 276 of file Graph.cxx.

               {
    m_stacks[0] = new Stack;
 
    m_nodes[0] = new InputNode(0, 2);
    m_nodes[1] = new InputNode(1, 2);
    m_nodes[2] = new ConcatenateNode({m_nodes.at(0), m_nodes.at(1)});
    m_nodes[3] = new FeedForwardNode(m_stacks.at(0), m_nodes.at(2));
    m_last_node = 3;
  }

Graph() [2/3]

lwtDev::Graph::Graph	(	const std::vector< NodeConfig > &	nodes,
		const std::vector< LayerConfig > &	layers )

Definition at line 285 of file Graph.cxx.

                                                    :
    m_last_node(0)
  {
    for (size_t iii = 0; iii < nodes.size(); iii++) {
      build_node(iii, nodes, layers);
    }
    // assert(maps.node.size() + maps.seq_node.size() == nodes.size());
  }

Graph() [3/3]

lwtDev::Graph::Graph ( Graph & )

delete

~Graph()

lwtDev::Graph::~Graph

(

)

Definition at line 294 of file Graph.cxx.

                {
    for (auto node: m_nodes) {
      delete node.second;
      node.second = nullptr;
    }
    for (auto node: m_seq_nodes) {
      // The m_nodes collection is the owner of anything that inherits
      // from both INode and ISequenceNode. So we try not to delete
      // anything that the m_nodes would already take care of.
      if (!m_nodes.count(node.first)) delete node.second;
      node.second = nullptr;
    }
    for (auto stack: m_stacks) {
      delete stack.second;
      stack.second = nullptr;
    }
    for (auto stack: m_seq_stacks) {
      delete stack.second;
      stack.second = nullptr;
    }
  }

Member Function Documentation

build_node()

void lwtDev::Graph::build_node ( const size_t iii, const std::vector< NodeConfig > & nodes, const std::vector< LayerConfig > & layers, std::set< size_t > cycle_check = {} )

private

Definition at line 353 of file Graph.cxx.

                                                     {
    if (m_nodes.count(iii) || m_seq_nodes.count(iii)) return;
 
    // we insist that the upstream nodes are built before the
    // downstream ones, so the last node built should be some kind of
    // sink for graphs with only one output this will be it.
    m_last_node = iii;
 
    if (iii >= nodes.size()) throw_cfg("no node index", iii);
 
    const NodeConfig& node = nodes.at(iii);
 
    // if it's an input, build and return
    if (node.type == NodeConfig::Type::INPUT) {
      check_compute_node(node);
      size_t input_number = node.sources.at(0);
      m_nodes[iii] = new InputNode(input_number, node.index);
      return;
    } else if (node.type == NodeConfig::Type::INPUT_SEQUENCE) {
      check_compute_node(node);
      size_t input_number = node.sources.at(0);
      m_seq_nodes[iii] = new InputSequenceNode(input_number, node.index);
      return;
    }
 
    // otherwise build all the inputs first
    if (cycle_check.count(iii)) {
      throw NNConfigurationException("found cycle in graph");
    }
    cycle_check.insert(iii);
    for (size_t source_node: node.sources) {
      build_node(source_node, nodes, layers, cycle_check);
    }
 
    // check node types
    if (node.type == NodeConfig::Type::FEED_FORWARD) {
      m_nodes[iii] = get_feedforward_node(node, layers,
                                          m_nodes, m_stacks);
    } else if (node.type == NodeConfig::Type::TIME_DISTRIBUTED) {
      m_seq_nodes[iii] = get_time_distributed_node(node, layers,
                                                   m_seq_nodes, m_stacks);
    } else if (node.type == NodeConfig::Type::SEQUENCE) {
      SequenceNode* seq_node =
        get_sequence_node(node, layers, m_seq_nodes, m_seq_stacks);
      // entering in m_nodes means that m_nodes will delete this one
      m_nodes[iii] = seq_node;
      m_seq_nodes[iii] = seq_node;
    } else if (node.type == NodeConfig::Type::CONCATENATE) {
      // build concatenate layer
      std::vector<const INode*> in_nodes;
      for (size_t source_node: node.sources) {
        in_nodes.push_back(m_nodes.at(source_node));
      }
      m_nodes[iii] = new ConcatenateNode(in_nodes);
    } else if (node.type == NodeConfig::Type::SUM) {
      if (node.sources.size() != 1) {
        throw NNConfigurationException("Sum node needs exactly 1 source");
      }
      m_nodes[iii] = new SumNode(m_seq_nodes.at(node.sources.at(0)));
    } else {
      throw NNConfigurationException("unknown node type");
    }
  }

compute() [1/2]

VectorXd lwtDev::Graph::compute

(

const ISource &

source

)

const

Definition at line 326 of file Graph.cxx.

                                                     {
    if (!m_nodes.count(m_last_node)) {
      throw OutputRankException("Graph: output is not a feed forward node");
    }
    return m_nodes.at(m_last_node)->compute(source);
  }

compute() [2/2]

VectorXd lwtDev::Graph::compute	(	const ISource &	source,
		size_t	node_number ) const

Definition at line 315 of file Graph.cxx.

                                                                         {
    if (!m_nodes.count(node_number)) {
      auto num = std::to_string(node_number);
      if (m_seq_nodes.count(node_number)) {
        throw OutputRankException(
          "Graph: output at " + num + " not feed forward");
      }
      throw NNEvaluationException("Graph: no output at " + num);
    }
    return m_nodes.at(node_number)->compute(source);
  }

operator=()

Graph & lwtDev::Graph::operator= ( Graph & )

delete

scan() [1/2]

MatrixXd lwtDev::Graph::scan

(

const ISource &

source

)

const

Definition at line 343 of file Graph.cxx.

                                                  {
    if (!m_seq_nodes.count(m_last_node)) {
      throw OutputRankException("Graph: output is not a sequence node");
    }
    return m_seq_nodes.at(m_last_node)->scan(source);
  }

scan() [2/2]

MatrixXd lwtDev::Graph::scan	(	const ISource &	source,
		size_t	node_number ) const

Definition at line 332 of file Graph.cxx.

                                                                      {
    if (!m_seq_nodes.count(node_number)) {
      auto num = std::to_string(node_number);
      if (m_nodes.count(node_number)) {
        throw OutputRankException(
          "Graph: output at " + num + " not a sequence");
      }
      throw NNEvaluationException("Graph: no output at " + num);
    }
    return m_seq_nodes.at(node_number)->scan(source);
  }

Member Data Documentation

m_last_node

size_t lwtDev::Graph::m_last_node

private

Definition at line 139 of file Graph.h.

m_nodes

std::unordered_map<size_t, INode*> lwtDev::Graph::m_nodes

private

Definition at line 138 of file Graph.h.

m_seq_nodes

std::unordered_map<size_t, ISequenceNode*> lwtDev::Graph::m_seq_nodes

private

Definition at line 141 of file Graph.h.

m_seq_stacks

std::unordered_map<size_t, RecurrentStack*> lwtDev::Graph::m_seq_stacks

private

Definition at line 142 of file Graph.h.

m_stacks

std::unordered_map<size_t, Stack*> lwtDev::Graph::m_stacks

private

Definition at line 140 of file Graph.h.

---

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

• Graph.h
• Graph.cxx