lwtDev::Stack Class Reference

#include <Stack.h>

Collaboration diagram for lwtDev::Stack:

Public Member Functions
	Stack ()
	Stack (size_t n_inputs, const std::vector< LayerConfig > &layers, size_t skip_layers=0)
	~Stack ()
	Stack (Stack &)=delete
Stack &	operator= (Stack &)=delete
VectorXd	compute (VectorXd) const
size_t	n_outputs () const

Private Member Functions
size_t	add_layers (size_t n_inputs, const LayerConfig &)
size_t	add_dense_layers (size_t n_inputs, const LayerConfig &)
size_t	add_normalization_layers (size_t n_inputs, const LayerConfig &)
size_t	add_highway_layers (size_t n_inputs, const LayerConfig &)
size_t	add_maxout_layers (size_t n_inputs, const LayerConfig &)

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

Detailed Description

Definition at line 47 of file Stack.h.

Constructor & Destructor Documentation

Stack() [1/3]

lwtDev::Stack::Stack

(

)

Definition at line 20 of file Stack.cxx.

               {
    m_layers.push_back(new DummyLayer);
    m_layers.push_back(new UnaryActivationLayer({ Activation::SIGMOID, 0.0 }));
 
    m_layers.push_back(new BiasLayer(std::vector<double>{1, 1, 1, 1}));
    MatrixXd mat(4, 4);
    mat <<
      0, 0, 0, 1,
      0, 0, 1, 0,
      0, 1, 0, 0,
      1, 0, 0, 0;
    m_layers.push_back(new MatrixLayer(mat));
    m_n_outputs = 4;
  }

Stack() [2/3]

lwtDev::Stack::Stack	(	size_t	n_inputs,
		const std::vector< LayerConfig > &	layers,
		size_t	skip_layers = 0 )

Definition at line 36 of file Stack.cxx.

                            {
    for (size_t nnn = skip; nnn < layers.size(); nnn++) {
      n_inputs = add_layers(n_inputs, layers.at(nnn));
    }
    // the final assigned n_inputs is the number of output nodes
    m_n_outputs = n_inputs;
  }

~Stack()

lwtDev::Stack::~Stack

(

)

Definition at line 45 of file Stack.cxx.

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

Stack() [3/3]

lwtDev::Stack::Stack ( Stack & )

delete

Member Function Documentation

add_dense_layers()

size_t lwtDev::Stack::add_dense_layers ( size_t n_inputs, const LayerConfig & layer )

private

Definition at line 79 of file Stack.cxx.

                                                                          {
    assert(layer.architecture == Architecture::DENSE);
    throw_if_not_dense(layer);
 
    size_t n_outputs = n_inputs;
 
    // add matrix layer
    if (layer.weights.size() > 0) {
      MatrixXd matrix = build_matrix(layer.weights, n_inputs);
      n_outputs = matrix.rows();
      m_layers.push_back(new MatrixLayer(matrix));
    };
 
    // add bias layer
    if (layer.bias.size() > 0) {
      if (n_outputs != layer.bias.size() ) {
        std::string problem = "tried to add a bias layer with " +
          std::to_string(layer.bias.size()) + " entries, previous layer"
          " had " + std::to_string(n_outputs) + " outputs";
        throw NNConfigurationException(problem);
      }
      m_layers.push_back(new BiasLayer(layer.bias));
    }
 
    // add activation layer
    if (layer.activation.function != Activation::LINEAR) {
      m_layers.push_back(get_raw_activation_layer(layer.activation));
    }
 
    return n_outputs;
  }

add_highway_layers()

size_t lwtDev::Stack::add_highway_layers ( size_t n_inputs, const LayerConfig & layer )

private

Definition at line 133 of file Stack.cxx.

                                                                            {
    auto& comps = layer.components;
    const auto& t = get_component(comps.at(Component::T), n_inputs);
    const auto& c = get_component(comps.at(Component::CARRY), n_inputs);
 
    m_layers.push_back(
      new HighwayLayer(t.W, t.b, c.W, c.b, layer.activation));
    return n_inputs;
  }

add_layers()

size_t lwtDev::Stack::add_layers ( size_t n_inputs, const LayerConfig & layer )

private

Definition at line 66 of file Stack.cxx.

                                                                    {
    if (layer.architecture == Architecture::DENSE) {
      return add_dense_layers(n_inputs, layer);
    } else if (layer.architecture == Architecture::NORMALIZATION){
      return add_normalization_layers(n_inputs, layer);
    } else if (layer.architecture == Architecture::HIGHWAY){
      return add_highway_layers(n_inputs, layer);
    } else if (layer.architecture == Architecture::MAXOUT) {
      return add_maxout_layers(n_inputs, layer);
    }
    throw NNConfigurationException("unknown architecture");
  }

add_maxout_layers()

size_t lwtDev::Stack::add_maxout_layers ( size_t n_inputs, const LayerConfig & layer )

private

Definition at line 144 of file Stack.cxx.

                                                                           {
    assert(layer.architecture == Architecture::MAXOUT);
    throw_if_not_maxout(layer);
    std::vector<MaxoutLayer::InitUnit> matrices;
    std::set<size_t> n_outputs;
    for (const auto& sublayer: layer.sublayers) {
      MatrixXd matrix = build_matrix(sublayer.weights, n_inputs);
      VectorXd bias = build_vector(sublayer.bias);
      n_outputs.insert(matrix.rows());
      matrices.push_back(std::make_pair(matrix, bias));
    }
    if (n_outputs.size() == 0) {
      throw NNConfigurationException("tried to build maxout withoutweights!");
    }
    else if (n_outputs.size() != 1) {
      throw NNConfigurationException("uneven matrices for maxout");
    }
    m_layers.push_back(new MaxoutLayer(matrices));
    return *n_outputs.begin();
  }

add_normalization_layers()

size_t lwtDev::Stack::add_normalization_layers ( size_t n_inputs, const LayerConfig & layer )

private

Definition at line 111 of file Stack.cxx.

                                                                                  {
    assert(layer.architecture == Architecture::NORMALIZATION);
    throw_if_not_normalization(layer);
 
    // Do some checks
    if ( layer.weights.size() < 1 || layer.bias.size() < 1 ) {
      std::string problem = "Either weights or bias layer size is < 1";
      throw NNConfigurationException(problem);
    };
    if ( layer.weights.size() != layer.bias.size() ) {
      std::string problem = "weights and bias layer are not equal in size!";
      throw NNConfigurationException(problem);
    };
    VectorXd v_weights = build_vector(layer.weights);
    VectorXd v_bias = build_vector(layer.bias);
 
    m_layers.push_back(
      new NormalizationLayer(v_weights, v_bias));
    return n_inputs;
  }

compute()

VectorXd lwtDev::Stack::compute

(

VectorXd

in

)

const

Definition at line 51 of file Stack.cxx.

                                           {
    for (const auto& layer: m_layers) {
      in = layer->compute(in);
    }
    return in;
  }

n_outputs()

size_t lwtDev::Stack::n_outputs

(

)

const

Definition at line 57 of file Stack.cxx.

                                {
    return m_n_outputs;
  }

operator=()

Stack & lwtDev::Stack::operator= ( Stack & )

delete

Member Data Documentation

m_layers

std::vector<ILayer*> lwtDev::Stack::m_layers

private

Definition at line 71 of file Stack.h.

m_n_outputs

size_t lwtDev::Stack::m_n_outputs

private

Definition at line 72 of file Stack.h.

---

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

• Stack.h
• Stack.cxx