lwtDev::RecurrentStack Class Reference

#include <Stack.h>

Collaboration diagram for lwtDev::RecurrentStack:

Public Member Functions
	RecurrentStack (size_t n_inputs, const std::vector< LayerConfig > &layers)
	~RecurrentStack ()
	RecurrentStack (RecurrentStack &)=delete
RecurrentStack &	operator= (RecurrentStack &)=delete
MatrixXd	scan (MatrixXd inputs) const
size_t	n_outputs () const

Private Member Functions
size_t	add_lstm_layers (size_t n_inputs, const LayerConfig &)
size_t	add_gru_layers (size_t n_inputs, const LayerConfig &)
size_t	add_bidirectional_layers (size_t n_inputs, const LayerConfig &)
size_t	add_embedding_layers (size_t n_inputs, const LayerConfig &)

Private Attributes
std::vector< IRecurrentLayer * >	m_layers
size_t	m_n_outputs

Detailed Description

Definition at line 173 of file Stack.h.

Constructor & Destructor Documentation

RecurrentStack() [1/2]

lwtDev::RecurrentStack::RecurrentStack	(	size_t	n_inputs,
		const std::vector< LayerConfig > &	layers )

Definition at line 271 of file Stack.cxx.

  {
    using namespace lwtDev;
    const size_t n_layers = layers.size();
    for (size_t layer_n = 0; layer_n < n_layers; layer_n++) {
      auto& layer = layers.at(layer_n);
 
      // add recurrent layers (now LSTM and GRU!)
      if (layer.architecture == Architecture::LSTM) {
        n_inputs = add_lstm_layers(n_inputs, layer);
      } else if (layer.architecture == Architecture::GRU) {
        n_inputs = add_gru_layers(n_inputs, layer);
      } else if (layer.architecture == Architecture::BIDIRECTIONAL) {
        n_inputs = add_bidirectional_layers(n_inputs, layer);
      } else if (layer.architecture == Architecture::EMBEDDING) {
        n_inputs = add_embedding_layers(n_inputs, layer);
      } else {
        throw NNConfigurationException("found non-recurrent layer");
      }
    }
    m_n_outputs = n_inputs;
  }

~RecurrentStack()

lwtDev::RecurrentStack::~RecurrentStack

(

)

Definition at line 294 of file Stack.cxx.

                                  {
    for (auto& layer: m_layers) {
      delete layer;
      layer = 0;
    }
  }

RecurrentStack() [2/2]

lwtDev::RecurrentStack::RecurrentStack ( RecurrentStack & )

delete

Member Function Documentation

add_bidirectional_layers()

size_t lwtDev::RecurrentStack::add_bidirectional_layers ( size_t n_inputs, const LayerConfig & layer )

private

Definition at line 344 of file Stack.cxx.

                                                                   {
    // nasty hack to get the hands on RNNs: create RNN, fetch it from m_layers and finally pop it
    if(layer.sublayers.size() != 2)
        throw NNConfigurationException("Number of sublayers not matching expected number of 2 for bidirectional layers");
    const LayerConfig forward_layer_conf = layer.sublayers[0];
    const LayerConfig backward_layer_conf = layer.sublayers[1];
    size_t n_forward = 0;
    // fixing nasty -Wunused-but-set-variable warning
    (void) n_forward;
    size_t n_backward = 0;
    if(forward_layer_conf.architecture == Architecture::LSTM)
      n_forward = add_lstm_layers(n_inputs, forward_layer_conf);
    else if(forward_layer_conf.architecture == Architecture::GRU)
      n_forward = add_gru_layers(n_inputs, forward_layer_conf);
    else
      throw NNConfigurationException("Bidirectional forward layer type not supported");
 
    std::unique_ptr<IRecurrentLayer> forward_layer(m_layers.back());
    m_layers.pop_back();
 
    if(backward_layer_conf.architecture == Architecture::LSTM)
      n_backward = add_lstm_layers(n_inputs, backward_layer_conf);
    else if(backward_layer_conf.architecture == Architecture::GRU)
      n_backward = add_gru_layers(n_inputs, backward_layer_conf);
    else
        throw NNConfigurationException("Bidirectional backward layer type not supported");
 
    std::unique_ptr<IRecurrentLayer> backward_layer(m_layers.back());
    backward_layer->m_go_backwards = (!forward_layer->m_go_backwards);
    m_layers.pop_back();
 
    m_layers.push_back(new BidirectionalLayer(std::move(forward_layer), 
                                              std::move(backward_layer), 
                                              layer.merge_mode, 
                                              layer.return_sequence));
    return n_backward;
 
  }

add_embedding_layers()

size_t lwtDev::RecurrentStack::add_embedding_layers ( size_t n_inputs, const LayerConfig & layer )

private

Definition at line 384 of file Stack.cxx.

                                                                        {
    for (const auto& emb: layer.embedding) {
      size_t n_wt = emb.weights.size();
      size_t n_cats = n_wt / emb.n_out;
      MatrixXd mat = build_matrix(emb.weights, n_cats);
      m_layers.push_back(new EmbeddingLayer(emb.index, mat));
      n_inputs += emb.n_out - 1;
    }
    return n_inputs;
  }

add_gru_layers()

size_t lwtDev::RecurrentStack::add_gru_layers ( size_t n_inputs, const LayerConfig & layer )

private

Definition at line 330 of file Stack.cxx.

                                                                   {
    auto& comps = layer.components;
    const auto& z = get_component(comps.at(Component::Z), n_inputs);
    const auto& r = get_component(comps.at(Component::R), n_inputs);
    const auto& h = get_component(comps.at(Component::H), n_inputs);
    m_layers.push_back(
      new GRULayer(layer.activation, layer.inner_activation,
                    z.W, z.U, z.b,
                    r.W, r.U, r.b,
                    h.W, h.U, h.b));
    return h.b.rows();
  }

add_lstm_layers()

size_t lwtDev::RecurrentStack::add_lstm_layers ( size_t n_inputs, const LayerConfig & layer )

private

Definition at line 310 of file Stack.cxx.

                                                                   {
    auto& comps = layer.components;
    const auto& i = get_component(comps.at(Component::I), n_inputs);
    const auto& o = get_component(comps.at(Component::O), n_inputs);
    const auto& f = get_component(comps.at(Component::F), n_inputs);
    const auto& c = get_component(comps.at(Component::C), n_inputs);
    const bool& go_backwards = layer.go_backwards;
    const bool& return_sequence = layer.return_sequence;
    m_layers.push_back(
      new LSTMLayer(layer.activation, layer.inner_activation,
                    i.W, i.U, i.b,
                    f.W, f.U, f.b,
                    o.W, o.U, o.b,
                    c.W, c.U, c.b,
                    go_backwards,
                    return_sequence));
    return o.b.rows();
  }

n_outputs()

size_t lwtDev::RecurrentStack::n_outputs

(

)

const

Definition at line 306 of file Stack.cxx.

                                         {
    return m_n_outputs;
  }

operator=()

RecurrentStack & lwtDev::RecurrentStack::operator= ( RecurrentStack & )

delete

scan()

MatrixXd lwtDev::RecurrentStack::scan

(

MatrixXd

inputs

)

const

Definition at line 300 of file Stack.cxx.

                                                 {
    for (auto* layer: m_layers) {
      in = layer->scan(in);
    }
    return in;
  }

Member Data Documentation

m_layers

std::vector<IRecurrentLayer*> lwtDev::RecurrentStack::m_layers

private

Definition at line 183 of file Stack.h.

m_n_outputs

size_t lwtDev::RecurrentStack::m_n_outputs

private

Definition at line 188 of file Stack.h.

---

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

• Stack.h
• Stack.cxx