NetworkNode is used to represent, three types of thing: either an input of the network (which pretty much just states the dimension of the input vector); a Component (e.g. More...

#include <nnet-nnet.h>

Collaboration diagram for NetworkNode:

[legend]

Public Member Functions
int32	Dim (const Nnet &nnet) const

	NetworkNode (NodeType nt=kNone)

	NetworkNode (const NetworkNode &other)

Public Attributes
NodeType	node_type

Descriptor	descriptor

union {
int32 component_index

int32 node_index

ObjectiveType objective_type

}	u

int32	dim

int32	dim_offset

Detailed Description

NetworkNode is used to represent, three types of thing: either an input of the network (which pretty much just states the dimension of the input vector); a Component (e.g.

an affine component or a sigmoid component); or a Descriptor. A Descriptor is basically an expression that can do things like append the outputs of other components (or inputs) together, add them together, and do various other things like shifting the time index.

Each Component must have an input of type kDescriptor that is numbered Preceding to the Component, and that is not used elsewhere. This may seem unintuitive but it makes the implementation a lot easier; any apparent waste can be optimized out after compilation. And outputs must also be of type kDescriptor.

Note: in the actual computation you can provide input not only to nodes of type kInput but also to nodes of type kComponent; this is useful in things like recurrent nets where you may want to split the computation up into pieces.

Note that in the config-file format, there are three types of node: input, component and output. output maps to kDescriptor, but the nodes of type kDescriptor that represent the input to a component, are described in the same config-file line as the Component itself.

Definition at line 81 of file nnet-nnet.h.

Constructor & Destructor Documentation

◆ NetworkNode() [1/2]

NetworkNode ( NodeType nt = kNone )

inline

Definition at line 107 of file nnet-nnet.h.

References NetworkNode::u.

Referenced by Nnet::ProcessComponentNodeConfigLine(), Nnet::ProcessDimRangeNodeConfigLine(), Nnet::ProcessInputNodeConfigLine(), and Nnet::ProcessOutputNodeConfigLine().

107 :

108 node_type(nt), dim(-1), dim_offset(-1) { u.component_index = -1; }

kaldi::nnet3::NetworkNode::dim_offset

int32 dim_offset

Definition: nnet-nnet.h:103

kaldi::nnet3::NetworkNode::node_type

NodeType node_type

Definition: nnet-nnet.h:82

kaldi::nnet3::NetworkNode::dim

int32 dim

Definition: nnet-nnet.h:101

kaldi::nnet3::NetworkNode::u

union kaldi::nnet3::NetworkNode::@15 u

◆ NetworkNode() [2/2]

NetworkNode ( const NetworkNode & other )

Definition at line 545 of file nnet-nnet.cc.

References NetworkNode::component_index, and NetworkNode::u.

                                                 :
     node_type(other.node_type),
     descriptor(other.descriptor),
     dim(other.dim),
     dim_offset(other.dim_offset) {
   u.component_index = other.u.component_index;
 }

Member Function Documentation

◆ Dim()

int32 Dim ( const Nnet & nnet ) const

Definition at line 33 of file nnet-nnet.cc.

References NetworkNode::descriptor, NetworkNode::dim, Descriptor::Dim(), Nnet::GetComponent(), KALDI_ASSERT, KALDI_ERR, kaldi::nnet3::kComponent, kaldi::nnet3::kDescriptor, kaldi::nnet3::kDimRange, kaldi::nnet3::kInput, NetworkNode::node_type, Component::OutputDim(), and NetworkNode::u.

Referenced by Nnet::Check(), Compiler::CreateStepInfo(), SimpleForwardingDescriptor::Dim(), and Nnet::OutputDim().

                                              {
   int32 ans;
   switch (node_type) {
     case kInput: case kDimRange:
       ans = dim;
       break;
     case kDescriptor:
       ans = descriptor.Dim(nnet);
       break;
     case kComponent:
       ans = nnet.GetComponent(u.component_index)->OutputDim();
       break;
     default:
       ans = 0;  // suppress compiler warning
       KALDI_ERR << "Invalid node type.";
   }
   KALDI_ASSERT(ans > 0);
   return ans;
 }