lwtDev Namespace Reference

Classes
struct	ActivationConfig
class	BiasLayer
class	BidirectionalLayer
	bidirectional unit /// More...
class	ConcatenateNode
struct	DenseComponents
class	DummyLayer
class	DummySource
class	ELU
struct	EmbeddingConfig
class	EmbeddingLayer
class	FeedForwardNode
class	Graph
struct	GraphConfig
class	GRULayer
struct	GRUState
class	HighwayLayer
class	ILayer
class	INode
struct	Input
class	InputNode
struct	InputNodeConfig
class	InputPreprocessor
class	InputSequenceNode
class	InputVectorPreprocessor
class	IRecurrentLayer
class	ISequenceNode
class	ISource
struct	JSONConfig
struct	LayerConfig
class	LeakyReLU
class	LightweightGraph
class	LightweightNNException
class	LSTMLayer
struct	LSTMState
class	MatrixLayer
class	MaxoutLayer
class	NNConfigurationException
class	NNEvaluationException
struct	NodeConfig
class	NormalizationLayer
	Normalization layer /// https://arxiv.org/abs/1502.03167 ///. More...
struct	OutputNodeConfig
class	OutputRankException
class	RecurrentStack
class	ReductionStack
class	SequenceNode
class	SoftmaxLayer
class	Stack
class	SumNode
class	Swish
class	TimeDistributedNode
class	UnaryActivationLayer
class	VectorSource

Typedefs
typedef LightweightGraph::NodeMap	NodeMap
typedef std::map< std::string, double >	ValueMap
typedef std::vector< std::pair< std::string, double > >	ValueVector
typedef std::map< std::string, std::vector< double > >	VectorMap

Enumerations
enum class	Activation {   NONE , LINEAR , SIGMOID , RECTIFIED ,   SOFTMAX , TANH , HARD_SIGMOID , ELU ,   LEAKY_RELU , SWISH , ABS }
enum class	Architecture {   NONE , DENSE , NORMALIZATION , MAXOUT ,   HIGHWAY , LSTM , GRU , BIDIRECTIONAL ,   EMBEDDING }
enum class	Component {   I , O , C , F ,   Z , R , H , T ,   CARRY }

Functions
JSONConfig	parse_json (std::istream &json)
GraphConfig	parse_json_graph (std::istream &json)
ILayer *	get_raw_activation_layer (ActivationConfig activation)
std::function< double(double)>	get_activation (lwtDev::ActivationConfig act)
double	nn_sigmoid (double x)
double	nn_hard_sigmoid (double x)
double	nn_tanh (double x)
double	nn_relu (double x)
MatrixXd	build_matrix (const std::vector< double > &weights, size_t n_inputs)
VectorXd	build_vector (const std::vector< double > &bias)
void	throw_if_not_maxout (const LayerConfig &layer)
void	throw_if_not_dense (const LayerConfig &layer)
void	throw_if_not_normalization (const LayerConfig &layer)
DenseComponents	get_component (const lwtDev::LayerConfig &layer, size_t n_in)

Typedef Documentation

NodeMap

typedef LightweightGraph::NodeMap lwtDev::NodeMap

Definition at line 67 of file LightweightGraph.cxx.

ValueMap

typedef std::map< std::string, double > lwtDev::ValueMap

Definition at line 22 of file InputPreprocessor.h.

ValueVector

typedef std::vector<std::pair<std::string, double> > lwtDev::ValueVector

Definition at line 23 of file InputPreprocessor.h.

VectorMap

typedef std::map< std::string, std::vector< double > > lwtDev::VectorMap

Definition at line 24 of file InputPreprocessor.h.

Enumeration Type Documentation

Activation

enum class lwtDev::Activation

strong

Enumerator
NONE
LINEAR
SIGMOID
RECTIFIED
SOFTMAX
TANH
HARD_SIGMOID
ELU
LEAKY_RELU
SWISH
ABS

Definition at line 20 of file NNLayerConfig.h.

                        {NONE, LINEAR, SIGMOID, RECTIFIED, SOFTMAX, TANH,
      HARD_SIGMOID, ELU, LEAKY_RELU, SWISH, ABS};

Architecture

enum class lwtDev::Architecture

strong

Enumerator
NONE
DENSE
NORMALIZATION
MAXOUT
HIGHWAY
LSTM
GRU
BIDIRECTIONAL
EMBEDDING

Definition at line 22 of file NNLayerConfig.h.

                          {NONE, DENSE, NORMALIZATION, MAXOUT, HIGHWAY,
      LSTM, GRU, BIDIRECTIONAL, EMBEDDING};

Component

enum class lwtDev::Component

strong

Enumerator
I
O
C
F
Z
R
H
T
CARRY

Definition at line 25 of file NNLayerConfig.h.

                       {
    I, O, C, F,                 // LSTM
      Z, R, H,                  // GRU
      T, CARRY};                // Highway

Function Documentation

build_matrix()

MatrixXd lwtDev::build_matrix	(	const std::vector< double > &	weights,
		size_t	n_inputs )

Definition at line 741 of file Stack.cxx.

  {
    size_t n_elements = weights.size();
    if ((n_elements % n_inputs) != 0) {
      std::string problem = "matrix elements not divisible by number"
        " of columns. Elements: " + std::to_string(n_elements) +
        ", Inputs: " + std::to_string(n_inputs);
      throw lwtDev::NNConfigurationException(problem);
    }
    size_t n_outputs = n_elements / n_inputs;
    MatrixXd matrix(n_outputs, n_inputs);
    for (size_t row = 0; row < n_outputs; row++) {
      for (size_t col = 0; col < n_inputs; col++) {
        double element = weights.at(col + row * n_inputs);
        matrix(row, col) = element;
      }
    }
    return matrix;
  }

build_vector()

VectorXd lwtDev::build_vector

(

const std::vector< double > &

bias

)

Definition at line 760 of file Stack.cxx.

                                                       {
    VectorXd out(bias.size());
    size_t idx = 0;
    for (const auto& val: bias) {
      out(idx) = val;
      idx++;
    }
    return out;
  }

get_activation()

std::function< double(double)> lwtDev::get_activation

(

lwtDev::ActivationConfig

act

)

Definition at line 671 of file Stack.cxx.

                                                                         {
    using namespace lwtDev;
    switch (act.function) {
    case Activation::SIGMOID: return nn_sigmoid;
    case Activation::HARD_SIGMOID: return nn_hard_sigmoid;
    case Activation::SWISH: return Swish(act.alpha);
    case Activation::TANH: return nn_tanh;
    case Activation::RECTIFIED: return nn_relu;
    case Activation::ELU: return ELU(act.alpha);
    case Activation::LEAKY_RELU: return LeakyReLU(act.alpha);
    case Activation::LINEAR: return [](double x){return x;};
    case Activation::ABS: return [](double x){return std::abs(x);};
    default: {
      throw NNConfigurationException("Got undefined activation function");
    }
    }
  }

get_component()

DenseComponents lwtDev::get_component	(	const lwtDev::LayerConfig &	layer,
		size_t	n_in )

Definition at line 792 of file Stack.cxx.

                                                                             {
    using namespace Eigen;
    using namespace lwtDev;
    MatrixXd weights = build_matrix(layer.weights, n_in);
    size_t n_out = weights.rows();
    VectorXd bias = build_vector(layer.bias);
 
    // the u element is optional
    size_t u_el = layer.U.size();
    MatrixXd U = u_el ? build_matrix(layer.U, n_out) : MatrixXd::Zero(0,0);
 
    size_t u_out = U.rows();
    size_t b_out = bias.rows();
    bool u_mismatch = (u_out != n_out) && (u_out > 0);
    if ( u_mismatch || b_out != n_out) {
      throw NNConfigurationException(
        "Output dims mismatch, W: " + std::to_string(n_out) +
        ", U: " + std::to_string(u_out) + ", b: " + std::to_string(b_out));
    }
    return {std::move(weights), std::move(U), std::move(bias)};
  }

get_raw_activation_layer()

ILayer * lwtDev::get_raw_activation_layer

(

ActivationConfig

activation

)

Definition at line 661 of file Stack.cxx.

                                                                {
    // Check for special cases. If it's not one, use
    // UnaryActivationLayer
    switch (activation.function) {
    case Activation::SOFTMAX: return new SoftmaxLayer;
    default: return new UnaryActivationLayer(activation);
    }
  }

nn_hard_sigmoid()

double lwtDev::nn_hard_sigmoid

(

double

x

)

Definition at line 697 of file Stack.cxx.

                                    {
    //github.com/Theano/Theano/blob/master/theano/tensor/nnet/sigm.py#L279
    double out = 0.2*x + 0.5;
    if (out < 0) return 0.0;
    if (out > 1) return 1.0;
    return out;
  }

nn_relu()

double lwtDev::nn_relu

(

double

x

)

Definition at line 716 of file Stack.cxx.

                            {
    if (std::isnan(x)) return x;
    else return x > 0 ? x : 0;
  }

nn_sigmoid()

double lwtDev::nn_sigmoid

(

double

x

)

Definition at line 690 of file Stack.cxx.

                               {
    //github.com/Theano/Theano/blob/master/theano/tensor/nnet/sigm.py#L35
    if (x < -30.0) return 0.0;
    if (x >  30.0) return 1.0;
    return 1.0 / (1.0 + std::exp(-1.0*x));
  }

nn_tanh()

double lwtDev::nn_tanh

(

double

x

)

Definition at line 712 of file Stack.cxx.

                            {
    return std::tanh(x);
  }

parse_json()

JSONConfig lwtDev::parse_json

(

std::istream &

json

)

Definition at line 42 of file parse_json.cxx.

  {
    boost::property_tree::ptree pt;
    boost::property_tree::read_json(json, pt);
 
    JSONConfig cfg;
    for (const auto& v: pt.get_child("inputs")) {
      cfg.inputs.push_back(get_input(v));
    }
    for (const auto& v: pt.get_child("layers")) {
      cfg.layers.push_back(get_layer(v));
    }
    for (const auto& v: pt.get_child("outputs"))
    {
      assert(v.first.empty()); // array elements have no names
      cfg.outputs.push_back(v.second.data());
    }
    cfg.defaults = get_defaults(pt);
    const std::string mname = "miscellaneous";
    if (pt.count(mname)) {
      for (const auto& misc: pt.get_child(mname)) {
        cfg.miscellaneous.emplace(
          misc.first, misc.second.get_value<std::string>());
      }
    }
    return cfg;
  }

parse_json_graph()

GraphConfig lwtDev::parse_json_graph

(

std::istream &

json

)

Definition at line 71 of file parse_json.cxx.

                                                 {
    boost::property_tree::ptree pt;
    boost::property_tree::read_json(json, pt);
 
    GraphConfig cfg;
    for (const auto& v: pt.get_child("inputs")) {
      cfg.inputs.push_back(get_input_node(v));
    }
    for (const auto& v: pt.get_child("input_sequences")) {
      cfg.input_sequences.push_back(get_input_node(v));
    }
    for (const auto& v: pt.get_child("nodes")) {
      cfg.nodes.push_back(get_node(v));
    }
    for (const auto& v: pt.get_child("layers")) {
      cfg.layers.push_back(get_layer(v));
    }
    for (const auto& v: pt.get_child("outputs")) {
      cfg.outputs.emplace(v.first, get_output_node(v));
    }
    return cfg;
  }

throw_if_not_dense()

void lwtDev::throw_if_not_dense

(

const LayerConfig &

layer

)

Definition at line 779 of file Stack.cxx.

                                                    {
    if (layer.sublayers.size() > 0) {
      throw NNConfigurationException("sublayers in dense layer");
    }
  }

throw_if_not_maxout()

void lwtDev::throw_if_not_maxout

(

const LayerConfig &

layer

)

Definition at line 771 of file Stack.cxx.

                                                     {
    bool wt_ok = layer.weights.size() == 0;
    bool bias_ok = layer.bias.size() == 0;
    bool maxout_ok = layer.sublayers.size() > 0;
    bool act_ok = layer.activation.function == Activation::NONE;
    if (wt_ok && bias_ok && maxout_ok && act_ok) return;
    throw NNConfigurationException("layer has wrong info for maxout");
  }

throw_if_not_normalization()

void lwtDev::throw_if_not_normalization

(

const LayerConfig &

layer

)

Definition at line 785 of file Stack.cxx.

                                                            {
    if (layer.sublayers.size() > 0) {
      throw NNConfigurationException("sublayers in normalization layer");
    }
  }