Nnet Class Reference

#include <nnet-nnet.h>

Collaboration diagram for Nnet:

Public Member Functions
void	ReadConfig (std::istream &config_file)
int32	NumComponents () const
int32	NumNodes () const
Component *	GetComponent (int32 c)
	Return component indexed c. Not a copy; not owned by caller. More...
const Component *	GetComponent (int32 c) const
	Return component indexed c (const version). More...
void	SetComponent (int32 c, Component *component)
	Replace the component indexed by c with a new component. More...
int32	AddComponent (const std::string &name, Component *component)
	Adds a new component with the given name, which should not be the same as any existing component name. More...
const NetworkNode &	GetNode (int32 node) const
	returns const reference to a particular numbered network node. More...
NetworkNode &	GetNode (int32 node)
	Non-const accessor for the node... use with extreme caution. More...
bool	IsComponentNode (int32 node) const
	Returns true if this is a component node, meaning that it is of type kComponent. More...
bool	IsDimRangeNode (int32 node) const
	Returns true if this is a dim-range node, meaning that it is of type kDimRange. More...
bool	IsInputNode (int32 node) const
	Returns true if this is an output node, meaning that it is of type kInput. More...
bool	IsDescriptorNode (int32 node) const
	Returns true if this is a descriptor node, meaning that it is of type kDescriptor. More...
bool	IsOutputNode (int32 node) const
	Returns true if this is an output node, meaning that it is of type kDescriptor and is not directly followed by a node of type kComponent. More...
bool	IsComponentInputNode (int32 node) const
	Returns true if this is component-input node, i.e. More...
const std::vector< std::string > &	GetNodeNames () const
	returns vector of node names (needed by some parsing code, for instance). More...
const std::string &	GetNodeName (int32 node_index) const
	returns individual node name. More...
void	SetNodeName (int32 node_index, const std::string &new_name)
	This can be used to modify invidual node names. More...
const std::vector< std::string > &	GetComponentNames () const
	returns vector of component names (needed by some parsing code, for instance). More...
const std::string &	GetComponentName (int32 component_index) const
	returns individual component name. More...
int32	GetNodeIndex (const std::string &node_name) const
	returns index associated with this node name, or -1 if no such index. More...
int32	GetComponentIndex (const std::string &node_name) const
	returns index associated with this component name, or -1 if no such index. More...
int32	InputDim (const std::string &input_name) const
int32	OutputDim (const std::string &output_name) const
void	Read (std::istream &istream, bool binary)
void	Write (std::ostream &ostream, bool binary) const
void	Check (bool warn_for_orphans=true) const
	Checks the neural network for validity (dimension matches and various other requirements). More...
std::string	Info () const
	returns some human-readable information about the network, mostly for debugging purposes. More...
int32	Modulus () const
	[Relevant for clockwork RNNs and similar]. More...
	~Nnet ()
	Nnet ()
	Nnet (const Nnet &nnet)
Nnet *	Copy () const
void	Swap (Nnet *other)
Nnet &	operator= (const Nnet &nnet)
void	RemoveOrphanNodes (bool remove_orphan_inputs=false)
void	RemoveOrphanComponents ()
void	RemoveSomeNodes (const std::vector< int32 > &nodes_to_remove)
void	ResetGenerators ()
void	GetConfigLines (bool include_dim, std::vector< std::string > *config_lines) const

Private Member Functions
void	Destroy ()
std::string	GetAsConfigLine (int32 node_index, bool include_dim) const
void	ProcessComponentConfigLine (int32 initial_num_components, ConfigLine *config)
void	ProcessComponentNodeConfigLine (int32 pass, ConfigLine *config)
void	ProcessInputNodeConfigLine (ConfigLine *config)
void	ProcessOutputNodeConfigLine (int32 pass, ConfigLine *config)
void	ProcessDimRangeNodeConfigLine (int32 pass, ConfigLine *config)
void	GetSomeNodeNames (std::vector< std::string > *modified_node_names) const

Static Private Member Functions
static void	RemoveRedundantConfigLines (int32 num_lines_initial, std::vector< ConfigLine > *config_lines)

Private Attributes
std::vector< std::string >	component_names_
std::vector< Component * >	components_
std::vector< std::string >	node_names_
std::vector< NetworkNode >	nodes_

Detailed Description

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

Constructor & Destructor Documentation

~Nnet()

~Nnet ( )

inline

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

{ Destroy(); }

Nnet() [1/2]

Nnet ( )

inline

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

{ }

Nnet() [2/2]

Nnet

(

const Nnet &

nnet

)

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

References Nnet::Check(), Nnet::components_, and rnnlm::i.

                          :
    component_names_(nnet.component_names_),
    components_(nnet.components_.size()),
    node_names_(nnet.node_names_),
    nodes_(nnet.nodes_) {
  for (size_t i = 0; i < components_.size(); i++)
    components_[i] = nnet.components_[i]->Copy();
  Check();
}

Member Function Documentation

AddComponent()

int32 AddComponent	(	const std::string &	name,
		Component *	component
	)

Adds a new component with the given name, which should not be the same as any existing component name.

Returns the new component index. Takes ownership of the pointer 'component'.

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

References kaldi::IsValidName(), and KALDI_ASSERT.

Referenced by ModelCollapser::CollapseComponentsAffine(), ModelCollapser::CollapseComponentsScale(), SvdApplier::DecomposeComponents(), ModelCollapser::GetDiagonallyPreModifiedComponentIndex(), and ModelCollapser::GetScaledComponentIndex().

                                               {
  int32 ans = components_.size();
  KALDI_ASSERT(IsValidName(name) && component != NULL);
  components_.push_back(component);
  component_names_.push_back(name);
  return ans;
}

Check()

void Check

(

bool

warn_for_orphans = true

)

const

Checks the neural network for validity (dimension matches and various other requirements).

You can call this with warn_for_orphans = false to disable the warnings that are printed if orphan nodes or components exist.

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

References NetworkNode::component_index, NetworkNode::descriptor, NetworkNode::dim, NetworkNode::Dim(), NetworkNode::dim_offset, kaldi::nnet3::FindOrphanComponents(), kaldi::nnet3::FindOrphanNodes(), Descriptor::GetNodeDependencies(), rnnlm::i, Component::InputDim(), KALDI_ASSERT, KALDI_ERR, KALDI_WARN, kaldi::nnet3::kComponent, kaldi::nnet3::kDescriptor, kaldi::nnet3::kDimRange, kaldi::nnet3::kInput, rnnlm::n, NetworkNode::node_index, NetworkNode::node_type, kaldi::SortAndUniq(), and NetworkNode::u.

Referenced by Nnet::Nnet(), Nnet::operator=(), Nnet::RemoveOrphanComponents(), and Nnet::RemoveSomeNodes().

                                            {
  int32 num_nodes = nodes_.size(),
    num_input_nodes = 0,
    num_output_nodes = 0;
  KALDI_ASSERT(num_nodes != 0);
  for (int32 n = 0; n < num_nodes; n++) {
    const NetworkNode &node = nodes_[n];
    std::string node_name = node_names_[n];
    KALDI_ASSERT(GetNodeIndex(node_name) == n);
    switch (node.node_type) {
      case kInput:
        KALDI_ASSERT(node.dim > 0);
        num_input_nodes++;
        break;
      case kDescriptor: {
        if (IsOutputNode(n))
          num_output_nodes++;
        std::vector<int32> node_deps;
        node.descriptor.GetNodeDependencies(&node_deps);
        SortAndUniq(&node_deps);
        for (size_t i = 0; i < node_deps.size(); i++) {
          int32 src_node = node_deps[i];
          KALDI_ASSERT(src_node >= 0 && src_node < num_nodes);
          NodeType src_type = nodes_[src_node].node_type;
          if (src_type != kInput && src_type != kDimRange &&
              src_type != kComponent)
            KALDI_ERR << "Invalid source node type in Descriptor: source node "
                      << node_names_[src_node];
        }
        break;
      }
      case kComponent: {
        KALDI_ASSERT(n > 0 && nodes_[n-1].node_type == kDescriptor);
        const NetworkNode &src_node = nodes_[n-1];
        const Component *c = GetComponent(node.u.component_index);
        int32 src_dim, input_dim = c->InputDim();
        try {
          src_dim = src_node.Dim(*this);
        } catch (...) {
          KALDI_ERR << "Error in Descriptor for network-node "
                    << node_name << " (see error above)";
        }
        if (src_dim != input_dim) {
          KALDI_ERR << "Dimension mismatch for network-node "
                    << node_name << ": input-dim "
                    << src_dim << " versus component-input-dim "
                    << input_dim;
        }
        break;
      }
      case kDimRange: {
        int32 input_node = node.u.node_index;
        KALDI_ASSERT(input_node >= 0 && input_node < num_nodes);
        NodeType input_type = nodes_[input_node].node_type;
        if (input_type != kInput && input_type != kComponent)
          KALDI_ERR << "Invalid source node type in DimRange node: source node "
                    << node_names_[input_node];
        int32 input_dim = nodes_[input_node].Dim(*this);
        if (!(node.dim > 0 && node.dim_offset >= 0 &&
              node.dim + node.dim_offset <= input_dim)) {
          KALDI_ERR << "Invalid node dimensions for DimRange node: " << node_name
                    << ": input-dim=" << input_dim << ", dim=" << node.dim
                    << ", dim-offset=" << node.dim_offset;
        }
        break;
      }
      default:
        KALDI_ERR << "Invalid node type for node " << node_name;
    }
  }

  int32 num_components = components_.size();
  for (int32 c = 0; c < num_components; c++) {
    const std::string &component_name = component_names_[c];
    KALDI_ASSERT(GetComponentIndex(component_name) == c &&
                 "Duplicate component names?");
  }
  KALDI_ASSERT(num_input_nodes > 0);
  KALDI_ASSERT(num_output_nodes > 0);


  if (warn_for_orphans) {
    std::vector<int32> orphans;
    FindOrphanComponents(*this, &orphans);
    for (size_t i = 0; i < orphans.size(); i++) {
      KALDI_WARN << "Component " << GetComponentName(orphans[i])
                 << " is never used by any node.";
    }
    FindOrphanNodes(*this, &orphans);
    for (size_t i = 0; i < orphans.size(); i++) {
      if (!IsComponentInputNode(orphans[i])) {
        // There is no point warning about component-input nodes, since the
        // warning will be printed for the corresponding component nodes..  a
        // duplicate warning might be confusing to the user, as the
        // component-input nodes are implicit and usually hidden from users.
        KALDI_WARN << "Node " << GetNodeName(orphans[i])
                   << " is never used to compute any output.";
      }
    }
  }
}

Copy()

Nnet* Copy ( ) const

inline

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

References kaldi::nnet3::ResetGenerators().

Referenced by NnetChainTrainer::NnetChainTrainer(), NnetDiscriminativeTrainer::NnetDiscriminativeTrainer(), and NnetTrainer::NnetTrainer().

{ return new Nnet(*this); }

Destroy()

void Destroy ( )

private

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

References rnnlm::i.

Referenced by Nnet::operator=().

                   {
  for (size_t i = 0; i < components_.size(); i++)
    delete components_[i];
  component_names_.clear();
  components_.clear();
  node_names_.clear();
  nodes_.clear();
}

GetAsConfigLine()

std::string GetAsConfigLine ( int32  node_index, bool  include_dim  ) const

private

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

References KALDI_ASSERT, KALDI_ERR, kaldi::nnet3::kComponent, kaldi::nnet3::kDescriptor, kaldi::nnet3::kDimRange, kaldi::nnet3::kInput, kaldi::nnet3::kLinear, NetworkNode::node_index, and NetworkNode::node_type.

                                                                        {
  std::ostringstream ans;
  KALDI_ASSERT(node_index < nodes_.size() &&
               nodes_.size() == node_names_.size());
  const NetworkNode &node = nodes_[node_index];
  const std::string &name = node_names_[node_index];
  switch (node.node_type) {
    case kInput:
      ans << "input-node name=" << name << " dim=" << node.dim;
      break;
    case kDescriptor:
      // assert that it's an output-descriptor, not one describing the input to
      // a component-node.
      KALDI_ASSERT(IsOutputNode(node_index));
      ans << "output-node name=" << name << " input=";
      node.descriptor.WriteConfig(ans, node_names_);
      if (include_dim)
        ans << " dim=" << node.Dim(*this);
      ans << " objective=" << (node.u.objective_type == kLinear ? "linear" :
                               "quadratic");
      break;
    case kComponent:
      ans << "component-node name=" << name << " component="
          << component_names_[node.u.component_index] << " input=";
      KALDI_ASSERT(nodes_[node_index-1].node_type == kDescriptor);
      nodes_[node_index-1].descriptor.WriteConfig(ans, node_names_);
      if (include_dim)
        ans << " input-dim=" << nodes_[node_index-1].Dim(*this)
            << " output-dim=" << node.Dim(*this);
      break;
    case kDimRange:
      ans << "dim-range-node name=" << name << " input-node="
          << node_names_[node.u.node_index] << " dim-offset="
          << node.dim_offset << " dim=" << node.dim;
      break;
    default:
      KALDI_ERR << "Unknown node type.";
  }
  return ans.str();
}

GetComponent() [1/2]

Component * GetComponent

(

int32

c

)

Return component indexed c. Not a copy; not owned by caller.

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

References KALDI_ASSERT.

Referenced by Compiler::AddBackwardStepComponent(), ComputationGraphBuilder::AddDependencies(), Compiler::AddForwardStepComponent(), kaldi::nnet3::AddNnet(), kaldi::nnet3::AddNnetComponents(), kaldi::nnet3::ApplyL2Regularization(), ComputationChecker::CheckComputationCompression(), ComputationChecker::CheckComputationIndexes(), ModelCollapser::CollapseComponentsAffine(), ModelCollapser::CollapseComponentsBatchnorm(), ModelCollapser::CollapseComponentsDropout(), ModelCollapser::CollapseComponentsScale(), kaldi::nnet3::ComponentDotProducts(), kaldi::nnet3::ComputeCommandAttributes(), ComputationGraphBuilder::ComputeComputableInfo(), kaldi::nnet3::ComputeComputationGraph(), Compiler::ComputeDerivNeeded(), ComputationExpander::ComputePrecomputedIndexes(), kaldi::nnet3::ConsolidateMemory(), ModelUpdateConsolidator::ConsolidateModelUpdate(), kaldi::nnet3::ConstrainOrthonormal(), kaldi::nnet3::ConvertRepeatedToBlockAffine(), NnetComputer::DebugAfterExecute(), NnetComputer::DebugBeforeExecute(), SvdApplier::DecomposeComponents(), NetworkNode::Dim(), kaldi::nnet3::DotProduct(), NnetComputer::ExecuteCommand(), kaldi::nnet3::FreezeNaturalGradient(), ModelCollapser::GetDiagonallyPreModifiedComponentIndex(), ModelCollapser::GetScaledComponentIndex(), Compiler::GetStrideType(), kaldi::nnet3::HasBatchnorm(), VariableMergingOptimizer::MergeVariables(), DerivativeTimeLimiter::ModifyCommand(), kaldi::nnet3::NnetParametersAreIdentical(), kaldi::nnet3::NumParameters(), kaldi::nnet3::NumUpdatableComponents(), kaldi::nnet3::PerturbParams(), MaxChangeStats::Print(), kaldi::nnet3::PrintVectorPerUpdatableComponent(), ComputationStepsComputer::ProcessComponentStep(), MemoryCompressionOptimizer::ProcessMatrix(), kaldi::nnet3::ReadEditConfig(), kaldi::nnet3::ReduceRankOfComponents(), Nnet::ResetGenerators(), kaldi::nnet3::ResetGenerators(), kaldi::nnet3::ScaleBatchnormStats(), kaldi::nnet3::ScaleNnet(), kaldi::nnet3::SetBatchnormTestMode(), kaldi::nnet3::SetDropoutProportion(), kaldi::nnet3::SetDropoutTestMode(), kaldi::nnet3::SetLearningRate(), kaldi::nnet3::SetNnetAsGradient(), kaldi::nnet3::SetRequireDirectInput(), Compiler::SetUpPrecomputedIndexes(), kaldi::nnet3::UnitTestConvertRepeatedToBlockAffine(), kaldi::nnet3::UnitTestConvertRepeatedToBlockAffineComposite(), kaldi::nnet3::UnVectorizeNnet(), kaldi::nnet3::UpdateNnetWithMaxChange(), kaldi::nnet3::VectorizeNnet(), and kaldi::nnet3::ZeroComponentStats().

                                     {
  KALDI_ASSERT(static_cast<size_t>(c) < components_.size());
  return components_[c];
}

GetComponent() [2/2]

const Component * GetComponent

(

int32

c

)

const

Return component indexed c (const version).

Not a copy; not owned by caller.

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

References KALDI_ASSERT.

                                                 {
  KALDI_ASSERT(static_cast<size_t>(c) < components_.size());
  return components_[c];
}

GetComponentIndex()

int32 GetComponentIndex

(

const std::string &

node_name

)

const

returns index associated with this component name, or -1 if no such index.

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

References rnnlm::i.

Referenced by ModelCollapser::CollapseComponentsAffine(), ModelCollapser::CollapseComponentsScale(), SvdApplier::DecomposeComponents(), ModelCollapser::GetDiagonallyPreModifiedComponentIndex(), and ModelCollapser::GetScaledComponentIndex().

                                                                   {
  size_t size = component_names_.size();
  for (size_t i = 0; i < size; i++)
    if (component_names_[i] == component_name)
      return static_cast<int32>(i);
  return -1;
}

GetComponentName()

const std::string & GetComponentName

(

int32

component_index

)

const

returns individual component name.

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

References NetworkNode::component_index, and KALDI_ASSERT.

Referenced by ModelCollapser::CollapseComponentsAffine(), ModelCollapser::CollapseComponentsBatchnorm(), ModelCollapser::CollapseComponentsScale(), NnetComputer::DebugAfterExecute(), SvdApplier::DecomposeComponents(), NnetComputer::ExecuteCommand(), ModelCollapser::GetDiagonallyPreModifiedComponentIndex(), ModelCollapser::GetScaledComponentIndex(), SvdApplier::ModifyTopology(), kaldi::nnet3::NnetParametersAreIdentical(), MaxChangeStats::Print(), kaldi::nnet3::PrintCommand(), kaldi::nnet3::PrintVectorPerUpdatableComponent(), kaldi::nnet3::ReadEditConfig(), kaldi::nnet3::ReduceRankOfComponents(), and kaldi::nnet3::UpdateNnetWithMaxChange().

                                                                   {
  KALDI_ASSERT(static_cast<size_t>(component_index) < component_names_.size());
  return component_names_[component_index];
}

GetComponentNames()

const std::vector< std::string > & GetComponentNames

(

)

const

returns vector of component names (needed by some parsing code, for instance).

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

                                                          {
  return component_names_;
}

GetConfigLines()

void GetConfigLines	(	bool	include_dim,
		std::vector< std::string > *	config_lines
	)		const

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

References rnnlm::n.

Referenced by Nnet::Info(), and kaldi::nnet3::ModifyNnetIvectorPeriod().

                                                                    {
  config_lines->clear();
  for (int32 n = 0; n < NumNodes(); n++)
    if (!IsComponentInputNode(n))
      config_lines->push_back(GetAsConfigLine(n, include_dim));

}

GetNode() [1/2]

const NetworkNode& GetNode ( int32  node ) const

inline

returns const reference to a particular numbered network node.

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

References KALDI_ASSERT.

Referenced by Compiler::AddBackwardStepComponent(), Compiler::AddBackwardStepInput(), ComputationGraphBuilder::AddDependencies(), Compiler::AddForwardStepComponent(), Compiler::AddForwardStepInput(), kaldi::nnet3::computation_graph::AddInputToGraph(), Compiler::CompileBackward(), Compiler::CompileBackwardSumDescriptor(), Compiler::CompileForward(), Compiler::CompileForwardSumDescriptor(), ComputationGraphBuilder::ComputeComputableInfo(), kaldi::nnet3::ComputeComputationGraph(), Compiler::ComputeDerivNeeded(), Compiler::ComputeInputLocationsList(), Compiler::CreateStepInfo(), SimpleForwardingDescriptor::Dim(), kaldi::nnet3::FindOrphanComponents(), Compiler::GetStrideType(), Compiler::IsInputStep(), SvdApplier::ModifyTopology(), kaldi::nnet3::NnetToDirectedGraph(), ModelCollapser::OptimizeNode(), NnetComputeProb::PrintTotalStats(), ComputationStepsComputer::ProcessComponentStep(), ComputationStepsComputer::ProcessDimRangeSubPhase(), NnetComputeProb::ProcessOutputs(), NnetTrainer::ProcessOutputs(), and Compiler::SetUpPrecomputedIndexes().

                                               {
    KALDI_ASSERT(node >= 0 && node < nodes_.size());
    return nodes_[node];
  }

GetNode() [2/2]

NetworkNode& GetNode ( int32  node )

inline

Non-const accessor for the node... use with extreme caution.

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

References NetworkNode::component_index, KALDI_ASSERT, and NetworkNode::node_index.

                                   {
    KALDI_ASSERT(node >= 0 && node < nodes_.size());
    return nodes_[node];
  }

GetNodeIndex()

int32 GetNodeIndex

(

const std::string &

node_name

)

const

returns index associated with this node name, or -1 if no such index.

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

References rnnlm::i.

Referenced by NnetComputer::AcceptInputs(), kaldi::nnet3::computation_graph::AddInputToGraph(), kaldi::nnet3::computation_graph::AddOutputToGraph(), kaldi::nnet3::ComputeSimpleNnetContextForShift(), kaldi::nnet3::GetChainComputationRequest(), ComputationGraphBuilder::GetComputableInfo(), kaldi::nnet3::GetComputationRequest(), kaldi::nnet3::GetDiscriminativeComputationRequest(), NnetComputer::GetIoMatrixIndex(), kaldi::nnet3::HasXentOutputs(), kaldi::nnet3::IsSimpleNnet(), NnetDiscriminativeComputeObjf::PrintTotalStats(), NnetChainComputeProb::PrintTotalStats(), NnetComputeProb::PrintTotalStats(), NnetDiscriminativeComputeObjf::ProcessOutputs(), NnetChainTrainer::ProcessOutputs(), NnetChainComputeProb::ProcessOutputs(), NnetDiscriminativeTrainer::ProcessOutputs(), NnetComputeProb::ProcessOutputs(), NnetTrainer::ProcessOutputs(), and kaldi::nnet3::ReadEditConfig().

                                                         {
  size_t size = node_names_.size();
  for (size_t i = 0; i < size; i++)
    if (node_names_[i] == node_name)
      return static_cast<int32>(i);
  return -1;
}

GetNodeName()

const std::string & GetNodeName

(

int32

node_index

)

const

returns individual node name.

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

References KALDI_ASSERT, and NetworkNode::node_index.

Referenced by NnetComputer::CheckNoPendingIo(), kaldi::nnet3::PrintCommand(), ComputationStepsComputer::ProcessInputOrOutputStep(), and kaldi::nnet3::ReadEditConfig().

                                                         {
  KALDI_ASSERT(static_cast<size_t>(node_index) < node_names_.size());
  return node_names_[node_index];
}

GetNodeNames()

const std::vector< std::string > & GetNodeNames

(

)

const

returns vector of node names (needed by some parsing code, for instance).

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

Referenced by Compiler::ComputeDerivNeeded(), Compiler::DeallocateMatrices(), kaldi::nnet3::EvaluateComputationRequest(), kaldi::nnet3::HasXentOutputs(), SvdApplier::ModifyTopology(), kaldi::nnet3::PrintComputationPreamble(), and ModelCollapser::ReplaceNodeInDescriptor().

                                                     {
  return node_names_;
}

GetSomeNodeNames()

void GetSomeNodeNames ( std::vector< std::string > *  modified_node_names ) const

private

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

References rnnlm::i, kaldi::nnet3::kComponent, kaldi::nnet3::kDimRange, kaldi::nnet3::kInput, and NetworkNode::node_type.

                                                     {
  modified_node_names->resize(node_names_.size());
  const std::string invalid_name = "**";
  size_t size = node_names_.size();
  for (size_t i = 0; i < size; i++) {
    if (nodes_[i].node_type == kComponent ||
        nodes_[i].node_type == kInput ||
        nodes_[i].node_type == kDimRange) {
      (*modified_node_names)[i] = node_names_[i];
    } else {
      (*modified_node_names)[i] = invalid_name;
    }
  }
}

Info()

std::string Info

(

)

const

returns some human-readable information about the network, mostly for debugging purposes.

Also see function NnetInfo() in nnet-utils.h, which prints out more extensive infoformation.

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

References Nnet::component_names_, Nnet::components_, kaldi::nnet3::ComputeSimpleNnetContext(), Nnet::GetConfigLines(), rnnlm::i, kaldi::nnet3::IsSimpleNnet(), Nnet::Modulus(), and kaldi::nnet3::NumParameters().

Referenced by AmNnetSimple::Info(), main(), kaldi::nnet3::NnetInfo(), kaldi::nnet3::TestNnetDecodable(), and kaldi::nnet3::UnitTestNnetCompileLooped().

                           {
  std::ostringstream os;

  if(IsSimpleNnet(*this))  {
    int32 left_context, right_context;
    ComputeSimpleNnetContext(*this, &left_context, &right_context);
    os << "left-context: " << left_context << "\n";
    os << "right-context: " << right_context << "\n";
  }
  os << "num-parameters: " << NumParameters(*this) << "\n";
  os << "modulus: " << this->Modulus() << "\n";
  std::vector<std::string> config_lines;
  bool include_dim = true;
  GetConfigLines(include_dim, &config_lines);
  for (size_t i = 0; i < config_lines.size(); i++)
    os << config_lines[i] << "\n";
  // Get component info.
  for (size_t i = 0; i < components_.size(); i++)
    os << "component name=" << component_names_[i]
       << " type=" << components_[i]->Info() << "\n";
  return os.str();
}

InputDim()

int32 InputDim

(

const std::string &

input_name

)

const

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

References NetworkNode::dim, kaldi::nnet3::kInput, rnnlm::n, and NetworkNode::node_type.

Referenced by BatchedXvectorComputer::BatchedXvectorComputer(), kaldi::nnet3::ComputeExampleComputationRequestSimple(), kaldi::nnet3::CreateLoopedComputationRequest(), DecodableNnetLoopedOnlineBase::DecodableNnetLoopedOnlineBase(), AmNnetSimple::Info(), DecodableNnetSimpleLoopedInfo::Init(), AmNnetSimple::InputDim(), AmNnetSimple::IvectorDim(), NnetBatchComputer::NnetBatchComputer(), kaldi::nnet3::NnetInfo(), and kaldi::nnet3::TestNnetDecodable().

                                                      {
  int32 n = GetNodeIndex(input_name);
  if (n == -1) return -1;
  const NetworkNode &node = nodes_[n];
  if (node.node_type != kInput) return -1;
  return node.dim;
}

IsComponentInputNode()

bool IsComponentInputNode

(

int32

node

)

const

Returns true if this is component-input node, i.e.

a node of type kDescriptor that immediately precedes a node of type kComponent.

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

References KALDI_ASSERT, kaldi::nnet3::kComponent, kaldi::nnet3::kDescriptor, and NetworkNode::node_type.

Referenced by Compiler::GetStrideType(), SvdApplier::ModifyTopology(), ComputationStepsComputer::ProcessSubPhase(), and Nnet::RemoveOrphanNodes().

                                                {
  int32 size = nodes_.size();
  KALDI_ASSERT(node >= 0 && node < size);
  return (node + 1 < size &&
          nodes_[node].node_type == kDescriptor &&
          nodes_[node+1].node_type == kComponent);
}

IsComponentNode()

bool IsComponentNode

(

int32

node

)

const

Returns true if this is a component node, meaning that it is of type kComponent.

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

References KALDI_ASSERT, kaldi::nnet3::kComponent, and NetworkNode::node_type.

Referenced by Compiler::ComputeDerivNeeded(), Compiler::ComputeStepDependencies(), kaldi::nnet3::FindOrphanComponents(), Compiler::GetStrideType(), SvdApplier::ModifyTopology(), ComputationStepsComputer::ProcessComponentStep(), ComputationStepsComputer::ProcessSubPhase(), and Nnet::RemoveOrphanComponents().

                                           {
  int32 size = nodes_.size();
  KALDI_ASSERT(node >= 0 && node < size);
  return (nodes_[node].node_type == kComponent);
}

IsDescriptorNode()

bool IsDescriptorNode

(

int32

node

)

const

Returns true if this is a descriptor node, meaning that it is of type kDescriptor.

Exactly one of IsOutput or IsComponentInput will also apply.

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

References KALDI_ASSERT, kaldi::nnet3::kDescriptor, and NetworkNode::node_type.

                                            {
  int32 size = nodes_.size();
  KALDI_ASSERT(node >= 0 && node < size);
  return (nodes_[node].node_type == kDescriptor);
}

IsDimRangeNode()

bool IsDimRangeNode

(

int32

node

)

const

Returns true if this is a dim-range node, meaning that it is of type kDimRange.

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

References KALDI_ASSERT, kaldi::nnet3::kDimRange, and NetworkNode::node_type.

Referenced by ComputationStepsComputer::ProcessDimRangeSubPhase(), and ComputationStepsComputer::ProcessSubPhase().

                                          {
  int32 size = nodes_.size();
  KALDI_ASSERT(node >= 0 && node < size);
  return (nodes_[node].node_type == kDimRange);
}

IsInputNode()

bool IsInputNode

(

int32

node

)

const

Returns true if this is an output node, meaning that it is of type kInput.

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

References KALDI_ASSERT, kaldi::nnet3::kInput, and NetworkNode::node_type.

Referenced by NnetComputer::AcceptInputs(), ComputationChecker::CheckComputationIndexes(), Compiler::DeallocateMatrices(), kaldi::nnet3::GetChainComputationRequest(), kaldi::nnet3::GetComputationRequest(), kaldi::nnet3::GetDiscriminativeComputationRequest(), kaldi::nnet3::IsSimpleNnet(), SvdApplier::ModifyTopology(), kaldi::nnet3::NumInputNodes(), ComputationStepsComputer::ProcessInputOrOutputStep(), ComputationStepsComputer::ProcessSubPhase(), and Nnet::RemoveOrphanNodes().

                                       {
  int32 size = nodes_.size();
  KALDI_ASSERT(node >= 0 && node < size);
  return (nodes_[node].node_type == kInput);
}

IsOutputNode()

bool IsOutputNode

(

int32

node

)

const

Returns true if this is an output node, meaning that it is of type kDescriptor and is not directly followed by a node of type kComponent.

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

References KALDI_ASSERT, kaldi::nnet3::kComponent, kaldi::nnet3::kDescriptor, and NetworkNode::node_type.

Referenced by Compiler::AllocateMatrices(), ComputationGraphBuilder::Check(), ComputationChecker::CheckComputationIndexes(), Compiler::CompileBackwardDescriptor(), Compiler::CompileForwardDescriptor(), Compiler::ComputeDerivNeeded(), ComputationGraphBuilder::ComputeRequiredArray(), Compiler::DeallocateMatrices(), kaldi::nnet3::FindOrphanNodes(), kaldi::nnet3::GetChainComputationRequest(), kaldi::nnet3::GetComputationRequest(), kaldi::nnet3::GetDiscriminativeComputationRequest(), kaldi::nnet3::HasXentOutputs(), kaldi::nnet3::IsSimpleNnet(), SvdApplier::ModifyTopology(), kaldi::nnet3::NumOutputNodes(), ComputationStepsComputer::ProcessInputOrOutputStep(), NnetDiscriminativeComputeObjf::ProcessOutputs(), NnetChainTrainer::ProcessOutputs(), NnetChainComputeProb::ProcessOutputs(), NnetDiscriminativeTrainer::ProcessOutputs(), NnetComputeProb::ProcessOutputs(), NnetTrainer::ProcessOutputs(), ComputationStepsComputer::ProcessSubPhase(), and kaldi::nnet3::ReadEditConfig().

                                        {
  int32 size = nodes_.size();
  KALDI_ASSERT(node >= 0 && node < size);
  return (nodes_[node].node_type == kDescriptor &&
          (node + 1 == size ||
           nodes_[node + 1].node_type != kComponent));
}

Modulus()

int32 Modulus

(

)

const

[Relevant for clockwork RNNs and similar].

Computes the smallest integer n >=1 such that the neural net's behavior will be the same if we shift the input and output's time indexes (t) by integer multiples of n. Does this by computing the lcm of all the moduli of the Descriptors in the network.

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

References NetworkNode::descriptor, kaldi::nnet3::kDescriptor, kaldi::Lcm(), Descriptor::Modulus(), rnnlm::n, and NetworkNode::node_type.

Referenced by kaldi::nnet3::ComputeSimpleNnetContext(), kaldi::nnet3::ComputeSimpleNnetContextForShift(), kaldi::nnet3::CreateLoopedComputationRequest(), kaldi::nnet3::GetChunkSize(), Nnet::Info(), and NnetBatchComputer::NnetBatchComputer().

                          {
  int32 ans = 1;
  for (int32 n = 0; n < NumNodes(); n++) {
    const NetworkNode &node = nodes_[n];
    if (node.node_type == kDescriptor)
      ans = Lcm(ans, node.descriptor.Modulus());
  }
  return ans;
}

NumComponents()

int32 NumComponents ( ) const

inline

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

Referenced by kaldi::nnet3::AddNnet(), kaldi::nnet3::AddNnetComponents(), kaldi::nnet3::ApplyL2Regularization(), ComputationChecker::CheckComputationIndexes(), ModelCollapser::Collapse(), kaldi::nnet3::ComponentDotProducts(), kaldi::nnet3::ConsolidateMemory(), ModelUpdateConsolidator::ConsolidateModelUpdate(), kaldi::nnet3::ConstrainOrthonormal(), kaldi::nnet3::ConvertRepeatedToBlockAffine(), SvdApplier::DecomposeComponents(), kaldi::nnet3::DotProduct(), kaldi::nnet3::FindOrphanComponents(), kaldi::nnet3::FreezeNaturalGradient(), kaldi::nnet3::HasBatchnorm(), kaldi::nnet3::NnetParametersAreIdentical(), kaldi::nnet3::NumParameters(), kaldi::nnet3::NumUpdatableComponents(), kaldi::nnet3::PerturbParams(), MaxChangeStats::Print(), kaldi::nnet3::PrintVectorPerUpdatableComponent(), kaldi::nnet3::ReadEditConfig(), kaldi::nnet3::ReduceRankOfComponents(), Nnet::ResetGenerators(), kaldi::nnet3::ResetGenerators(), kaldi::nnet3::ScaleBatchnormStats(), kaldi::nnet3::ScaleNnet(), kaldi::nnet3::SetBatchnormTestMode(), kaldi::nnet3::SetDropoutProportion(), kaldi::nnet3::SetDropoutTestMode(), kaldi::nnet3::SetLearningRate(), kaldi::nnet3::SetNnetAsGradient(), kaldi::nnet3::SetRequireDirectInput(), kaldi::nnet3::UnitTestConvertRepeatedToBlockAffine(), kaldi::nnet3::UnitTestConvertRepeatedToBlockAffineComposite(), kaldi::nnet3::UnVectorizeNnet(), kaldi::nnet3::UpdateNnetWithMaxChange(), kaldi::nnet3::VectorizeNnet(), and kaldi::nnet3::ZeroComponentStats().

{ return components_.size(); }

NumNodes()

int32 NumNodes ( ) const

inline

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

Referenced by ModelCollapser::Collapse(), kaldi::nnet3::computation_graph::ComputeEpochInfo(), ComputationGraphBuilder::ComputeRequiredArray(), kaldi::nnet3::FindOrphanComponents(), kaldi::nnet3::FindOrphanNodes(), SvdApplier::ModifyTopology(), kaldi::nnet3::NnetToDirectedGraph(), kaldi::nnet3::NumInputNodes(), kaldi::nnet3::NumOutputNodes(), ModelCollapser::OptimizeNode(), kaldi::nnet3::ReadEditConfig(), and Nnet::RemoveOrphanComponents().

{ return nodes_.size(); }

operator=()

Nnet & operator=

(

const Nnet &

nnet

)

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

References Nnet::Check(), Nnet::component_names_, Nnet::components_, Nnet::Destroy(), rnnlm::i, Nnet::node_names_, and Nnet::nodes_.

                                       {
  if (this == &nnet)
    return *this;
  Destroy();
  component_names_ = nnet.component_names_;
  components_.resize(nnet.components_.size());
  node_names_ = nnet.node_names_;
  nodes_ = nnet.nodes_;
  for (size_t i = 0; i < components_.size(); i++)
    components_[i] = nnet.components_[i]->Copy();
  Check();
  return *this;
}

OutputDim()

int32 OutputDim

(

const std::string &

output_name

)

const

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

References NetworkNode::Dim(), and rnnlm::n.

Referenced by BatchedXvectorComputer::BatchedXvectorComputer(), AmNnetSimple::Info(), DecodableNnetSimpleLoopedInfo::Init(), main(), NnetBatchComputer::NnetBatchComputer(), kaldi::nnet3::NnetInfo(), AmNnetSimple::NumPdfs(), AmNnetSimple::SetNnet(), AmNnetSimple::SetPriors(), kaldi::nnet3::TestNnetDecodable(), kaldi::nnet3::UnitTestNnetInputDerivatives(), and kaldi::nnet3::UnitTestNnetModelDerivatives().

                                                       {
  int32 n = GetNodeIndex(input_name);
  if (n == -1 || !IsOutputNode(n)) return -1;
  const NetworkNode &node = nodes_[n];
  return node.Dim(*this);
}

ProcessComponentConfigLine()

void ProcessComponentConfigLine ( int32  initial_num_components, ConfigLine *  config  )

private

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

References ConfigLine::GetValue(), ConfigLine::HasUnusedValues(), Component::InitFromConfig(), kaldi::IsToken(), KALDI_ERR, Component::NewComponentOfType(), ConfigLine::UnusedValues(), and ConfigLine::WholeLine().

                        {
  std::string name, type;
  if (!config->GetValue("name", &name))
    KALDI_ERR << "Expected field name=<component-name> in config line: "
              << config->WholeLine();
  if (!IsToken(name)) // e.g. contains a space.
    KALDI_ERR << "Component name '" << name << "' is not allowed, in line: "
              << config->WholeLine();
  if (!config->GetValue("type", &type))
    KALDI_ERR << "Expected field type=<component-type> in config line: "
              << config->WholeLine();
  Component *new_component = Component::NewComponentOfType(type);
  if (new_component == NULL)
    KALDI_ERR << "Unknown component-type '" << type
              << "' in config file.  Check your code version and config.";
  // the next call will call KALDI_ERR or KALDI_ASSERT and die if something
  // went wrong.
  new_component->InitFromConfig(config);
  int32 index = GetComponentIndex(name);
  if (index != -1) {  // Replacing existing component.
    if (index >= initial_num_components) {
      // that index was something we added from this config.
      KALDI_ERR << "You are adding two components with the same name: '"
                << name << "'";
    }
    delete components_[index];
    components_[index] = new_component;
  } else {
    components_.push_back(new_component);
    component_names_.push_back(name);
  }
  if (config->HasUnusedValues())
    KALDI_ERR << "Unused values '" << config->UnusedValues()
              << "' in config line: " << config->WholeLine();
}

ProcessComponentNodeConfigLine()

void ProcessComponentNodeConfigLine ( int32  pass, ConfigLine *  config  )

private

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

References NetworkNode::component_index, NetworkNode::descriptor, kaldi::nnet3::DescriptorTokenize(), ConfigLine::GetValue(), ConfigLine::HasUnusedValues(), KALDI_ASSERT, KALDI_ERR, kaldi::nnet3::kComponent, kaldi::nnet3::kDescriptor, NetworkNode::NetworkNode(), NetworkNode::node_index, Descriptor::Parse(), ConfigLine::UnusedValues(), and ConfigLine::WholeLine().

                        {

  std::string name;
  if (!config->GetValue("name", &name))
    KALDI_ERR << "Expected field name=<component-name> in config line: "
              << config->WholeLine();

  std::string input_name = name + std::string("_input");
  int32 input_node_index = GetNodeIndex(input_name),
      node_index = GetNodeIndex(name);

  if (pass == 0) {
    KALDI_ASSERT(input_node_index == -1 && node_index == -1);
    // just set up the node types and names for now, we'll properly set them up
    // on pass 1.
    nodes_.push_back(NetworkNode(kDescriptor));
    nodes_.push_back(NetworkNode(kComponent));
    node_names_.push_back(input_name);
    node_names_.push_back(name);
    return;
  } else {
    KALDI_ASSERT(input_node_index != -1 && node_index == input_node_index + 1);
    std::string component_name, input_descriptor;
    if (!config->GetValue("component", &component_name))
      KALDI_ERR << "Expected component=<component-name>, in config line: "
                << config->WholeLine();
    int32 component_index = GetComponentIndex(component_name);
    if (component_index == -1)
      KALDI_ERR << "No component named '" << component_name
                << "', in config line: " << config->WholeLine();
    nodes_[node_index].u.component_index = component_index;

    if (!config->GetValue("input", &input_descriptor))
      KALDI_ERR << "Expected input=<input-descriptor>, in config line: "
                << config->WholeLine();
    std::vector<std::string> tokens;
    if (!DescriptorTokenize(input_descriptor, &tokens))
      KALDI_ERR << "Error tokenizing descriptor in config line "
                << config->WholeLine();
    std::vector<std::string> node_names_temp;
    GetSomeNodeNames(&node_names_temp);
    tokens.push_back("end of input");
    const std::string *next_token = &(tokens[0]);
    if (!nodes_[input_node_index].descriptor.Parse(node_names_temp,
                                                   &next_token))
      KALDI_ERR << "Error parsing Descriptor in config line: "
                << config->WholeLine();
    if (config->HasUnusedValues())
      KALDI_ERR << "Unused values '" << config->UnusedValues()
                << " in config line: " << config->WholeLine();
  }
}

ProcessDimRangeNodeConfigLine()

void ProcessDimRangeNodeConfigLine ( int32  pass, ConfigLine *  config  )

private

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

References NetworkNode::dim, NetworkNode::dim_offset, ConfigLine::GetValue(), ConfigLine::HasUnusedValues(), KALDI_ASSERT, KALDI_ERR, kaldi::nnet3::kComponent, kaldi::nnet3::kDimRange, kaldi::nnet3::kInput, NetworkNode::NetworkNode(), NetworkNode::node_index, NetworkNode::node_type, NetworkNode::u, ConfigLine::UnusedValues(), and ConfigLine::WholeLine().

                        {
  std::string name;
  if (!config->GetValue("name", &name))
    KALDI_ERR << "Expected field name=<input-name> in config line: "
              << config->WholeLine();
  int32 node_index = GetNodeIndex(name);
  if (pass == 0) {
    KALDI_ASSERT(node_index == -1);
    nodes_.push_back(NetworkNode(kDimRange));
    node_names_.push_back(name);
  } else {
    KALDI_ASSERT(node_index != -1);
    std::string input_node_name;
    if (!config->GetValue("input-node", &input_node_name))
      KALDI_ERR << "Expected input-node=<input-node-name>, in config line: "
                << config->WholeLine();
    int32 dim, dim_offset;
    if (!config->GetValue("dim", &dim))
      KALDI_ERR << "Expected dim=<feature-dim>, in config line: "
                << config->WholeLine();
    if (!config->GetValue("dim-offset", &dim_offset))
      KALDI_ERR << "Expected dim-offset=<dimension-offset>, in config line: "
                << config->WholeLine();

    int32 input_node_index = GetNodeIndex(input_node_name);
    if (input_node_index == -1 ||
        !(nodes_[input_node_index].node_type == kComponent ||
          nodes_[input_node_index].node_type == kInput))
      KALDI_ERR << "invalid input-node " << input_node_name
                << ": " << config->WholeLine();

    if (config->HasUnusedValues())
      KALDI_ERR << "Unused values '" << config->UnusedValues()
                << " in config line: " << config->WholeLine();

    NetworkNode &node = nodes_[node_index];
    KALDI_ASSERT(node.node_type == kDimRange);
    node.u.node_index = input_node_index;
    node.dim = dim;
    node.dim_offset = dim_offset;
  }
}

ProcessInputNodeConfigLine()

void ProcessInputNodeConfigLine ( ConfigLine *  config )

private

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

References NetworkNode::dim, ConfigLine::GetValue(), ConfigLine::HasUnusedValues(), KALDI_ASSERT, KALDI_ERR, kaldi::nnet3::kInput, NetworkNode::NetworkNode(), NetworkNode::node_index, ConfigLine::UnusedValues(), and ConfigLine::WholeLine().

                        {
  std::string name;
  if (!config->GetValue("name", &name))
    KALDI_ERR << "Expected field name=<input-name> in config line: "
              << config->WholeLine();
  int32 dim;
  if (!config->GetValue("dim", &dim))
    KALDI_ERR << "Expected field dim=<input-dim> in config line: "
              << config->WholeLine();

  if (config->HasUnusedValues())
    KALDI_ERR << "Unused values '" << config->UnusedValues()
              << " in config line: " << config->WholeLine();

  KALDI_ASSERT(GetNodeIndex(name) == -1);
  if (dim <= 0)
    KALDI_ERR << "Invalid dimension in config line: " << config->WholeLine();

  int32 node_index = nodes_.size();
  nodes_.push_back(NetworkNode(kInput));
  nodes_[node_index].dim = dim;
  node_names_.push_back(name);
}

ProcessOutputNodeConfigLine()

void ProcessOutputNodeConfigLine ( int32  pass, ConfigLine *  config  )

private

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

References NetworkNode::descriptor, kaldi::nnet3::DescriptorTokenize(), ConfigLine::GetValue(), ConfigLine::HasUnusedValues(), KALDI_ASSERT, KALDI_ERR, kaldi::nnet3::kDescriptor, kaldi::nnet3::kLinear, kaldi::nnet3::kQuadratic, NetworkNode::NetworkNode(), NetworkNode::node_index, NetworkNode::objective_type, Descriptor::Parse(), ConfigLine::UnusedValues(), and ConfigLine::WholeLine().

                        {
  std::string name;
  if (!config->GetValue("name", &name))
    KALDI_ERR << "Expected field name=<input-name> in config line: "
              << config->WholeLine();
  int32 node_index = GetNodeIndex(name);
  if (pass == 0) {
    KALDI_ASSERT(node_index == -1);
    nodes_.push_back(NetworkNode(kDescriptor));
    node_names_.push_back(name);
  } else {
    KALDI_ASSERT(node_index != -1);
    std::string input_descriptor;
    if (!config->GetValue("input", &input_descriptor))
      KALDI_ERR << "Expected input=<input-descriptor>, in config line: "
                << config->WholeLine();
    std::vector<std::string> tokens;
    if (!DescriptorTokenize(input_descriptor, &tokens))
      KALDI_ERR << "Error tokenizing descriptor in config line "
                << config->WholeLine();
    tokens.push_back("end of input");
    // if the following fails it will die.
    std::vector<std::string> node_names_temp;
    GetSomeNodeNames(&node_names_temp);
    const std::string *next_token = &(tokens[0]);
    if (!nodes_[node_index].descriptor.Parse(node_names_temp, &next_token))
      KALDI_ERR << "Error parsing descriptor (input=...) in config line "
                << config->WholeLine();
    std::string objective_type;
    if (config->GetValue("objective", &objective_type)) {
      if (objective_type == "linear") {
        nodes_[node_index].u.objective_type = kLinear;
      } else if (objective_type == "quadratic") {
        nodes_[node_index].u.objective_type = kQuadratic;
      } else {
        KALDI_ERR << "Invalid objective type: " << objective_type;
      }
    } else {
      // the default objective type is linear.  This is what we use
      // for softmax objectives; the LogSoftmaxLayer is included as the
      // last layer, in this case.
      nodes_[node_index].u.objective_type = kLinear;
    }
    if (config->HasUnusedValues())
      KALDI_ERR << "Unused values '" << config->UnusedValues()
                << " in config line: " << config->WholeLine();
  }
}

Read()

void Read	(	std::istream &	istream,
		bool	binary
	)

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

References kaldi::nnet3::ExpectToken(), AmNnetSimple::GetNnet(), KALDI_ASSERT, KALDI_ERR, kaldi::PeekToken(), AmNnetSimple::Read(), TransitionModel::Read(), kaldi::ReadBasicType(), Component::ReadNew(), kaldi::ReadToken(), and Nnet::Swap().

Referenced by AmNnetSimple::Read(), and kaldi::nnet3::UnitTestNnetIo().

                                           {
  Destroy();
  int first_char = PeekToken(is, binary);
  if (first_char == 'T') {
    // This branch is to allow '.mdl' files (containing a TransitionModel
    // and then an AmNnetSimple) to be read where .raw files (containing
    // just an Nnet) would be expected.  This is often convenient.
    TransitionModel temp_trans_model;
    temp_trans_model.Read(is, binary);
    AmNnetSimple temp_am_nnet;
    temp_am_nnet.Read(is, binary);
    temp_am_nnet.GetNnet().Swap(this);
    return;
  }

  ExpectToken(is, binary, "<Nnet3>");
  std::ostringstream config_file_out;
  std::string cur_line;
  getline(is, cur_line);  // Eat up a single newline.
  if (!(cur_line == "" || cur_line == "\r"))
    KALDI_ERR << "Expected newline in config file, got " << cur_line;
  while (getline(is, cur_line)) {
    // config-file part of file is terminated by an empty line.
    if (cur_line == "" || cur_line == "\r")
      break;
    config_file_out << cur_line << std::endl;
  }
  // Now we read the Components; later we try to parse the config_lines.
  ExpectToken(is, binary, "<NumComponents>");
  int32 num_components;
  ReadBasicType(is, binary, &num_components);
  KALDI_ASSERT(num_components >= 0 && num_components < 100000);
  components_.resize(num_components, NULL);
  component_names_.resize(num_components);
  for (int32 c = 0; c < num_components; c++) {
    ExpectToken(is, binary, "<ComponentName>");
    ReadToken(is, binary, &(component_names_[c]));
    components_[c] = Component::ReadNew(is, binary);
  }
  ExpectToken(is, binary, "</Nnet3>");
  std::istringstream config_file_in(config_file_out.str());
  this->ReadConfig(config_file_in);
}

ReadConfig()

void ReadConfig

(

std::istream &

config_file

)

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

References rnnlm::i, KALDI_ERR, kaldi::nnet3::ParseConfigLines(), and kaldi::ReadConfigLines().

Referenced by main(), kaldi::nnet3::ModifyNnetIvectorPeriod(), SvdApplier::ModifyTopology(), kaldi::nnet3::UnitTestConvertRepeatedToBlockAffine(), kaldi::nnet3::UnitTestConvertRepeatedToBlockAffineComposite(), kaldi::nnet3::UnitTestNnetAnalyze(), kaldi::nnet3::UnitTestNnetCompile(), kaldi::nnet3::UnitTestNnetCompileLooped(), kaldi::nnet3::UnitTestNnetCompileMulti(), kaldi::nnet3::UnitTestNnetCompute(), kaldi::nnet3::UnitTestNnetContext(), kaldi::nnet3::UnitTestNnetInputDerivatives(), kaldi::nnet3::UnitTestNnetIo(), kaldi::nnet3::UnitTestNnetModelDerivatives(), and kaldi::nnet3::UnitTestNnetOptimizeWithOptions().

                                           {

  std::vector<std::string> lines;
  // Write into "lines" a config file corresponding to whatever
  // nodes we currently have.  Because the numbering of nodes may
  // change, it's most convenient to convert to the text representation
  // and combine the existing and new config lines in that representation.
  const bool include_dim = false;
  GetConfigLines(include_dim, &lines);

  // we'll later regenerate what we need from nodes_ and node_name_ from the
  // string representation.
  nodes_.clear();
  node_names_.clear();

  int32 num_lines_initial = lines.size();

  ReadConfigLines(config_is, &lines);
  // now "lines" will have comments removed and empty lines stripped out

  std::vector<ConfigLine> config_lines(lines.size());

  ParseConfigLines(lines, &config_lines);

  // the next line will possibly remove some elements from "config_lines" so no
  // node or component is doubly defined, always keeping the second repeat.
  // Things being doubly defined can happen when a previously existing node or
  // component is redefined in a new config file.
  RemoveRedundantConfigLines(num_lines_initial, &config_lines);

  int32 initial_num_components = components_.size();
  for (int32 pass = 0; pass <= 1; pass++) {
    for (size_t i = 0; i < config_lines.size(); i++) {
      const std::string &first_token = config_lines[i].FirstToken();
      if (first_token == "component") {
        if (pass == 0)
          ProcessComponentConfigLine(initial_num_components,
                                     &(config_lines[i]));
      } else if (first_token == "component-node") {
        ProcessComponentNodeConfigLine(pass,  &(config_lines[i]));
      } else if (first_token == "input-node") {
        if (pass == 0)
          ProcessInputNodeConfigLine(&(config_lines[i]));
      } else if (first_token == "output-node") {
        ProcessOutputNodeConfigLine(pass, &(config_lines[i]));
      } else if (first_token == "dim-range-node") {
        ProcessDimRangeNodeConfigLine(pass, &(config_lines[i]));
      } else {
        KALDI_ERR << "Invalid config-file line ('" << first_token
                  << "' not expected): " << config_lines[i].WholeLine();
      }
    }
  }
  Check();
}

RemoveOrphanComponents()

void RemoveOrphanComponents

(

)

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

References Nnet::Check(), Nnet::component_names_, Nnet::components_, kaldi::nnet3::FindOrphanComponents(), rnnlm::i, Nnet::IsComponentNode(), KALDI_ASSERT, KALDI_LOG, rnnlm::n, Nnet::nodes_, and Nnet::NumNodes().

Referenced by ModelCollapser::Collapse(), SvdApplier::ModifyTopology(), and kaldi::nnet3::ReadEditConfig().

                                  {
  std::vector<int32> orphan_components;
  FindOrphanComponents(*this, &orphan_components);
  KALDI_LOG << "Removing " << orphan_components.size()
            << " orphan components.";
  if (orphan_components.empty())
    return;
  int32 old_num_components = components_.size(),
      new_num_components = 0;
  std::vector<int32> old2new_map(old_num_components, 0);
  for (size_t i = 0; i < orphan_components.size(); i++)
    old2new_map[orphan_components[i]] = -1;
  std::vector<Component*> new_components;
  std::vector<std::string> new_component_names;
  for (int32 c = 0; c < old_num_components; c++) {
    if (old2new_map[c] != -1) {
      old2new_map[c] = new_num_components++;
      new_components.push_back(components_[c]);
      new_component_names.push_back(component_names_[c]);
    } else {
      delete components_[c];
      components_[c] = NULL;
    }
  }
  for (int32 n = 0; n < NumNodes(); n++) {
    if (IsComponentNode(n)) {
      int32 old_c = nodes_[n].u.component_index,
          new_c = old2new_map[old_c];
      KALDI_ASSERT(new_c >= 0);
      nodes_[n].u.component_index = new_c;
    }
  }
  components_ = new_components;
  component_names_ = new_component_names;
  Check();
}

RemoveOrphanNodes()

void RemoveOrphanNodes

(

bool

remove_orphan_inputs = false

)

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

References kaldi::nnet3::FindOrphanNodes(), rnnlm::i, Nnet::IsComponentInputNode(), Nnet::IsInputNode(), KALDI_LOG, and Nnet::RemoveSomeNodes().

Referenced by ModelCollapser::Collapse(), SvdApplier::ModifyTopology(), and kaldi::nnet3::ReadEditConfig().

                                                      {
  std::vector<int32> orphan_nodes;
  FindOrphanNodes(*this, &orphan_nodes);
  if (!remove_orphan_inputs)
    for (int32 i = 0; i < orphan_nodes.size(); i++)
      if (IsInputNode(orphan_nodes[i]))
        orphan_nodes.erase(orphan_nodes.begin() + i);
  // For each component-node, its component-input node (which is kind of a
  // "hidden" node) would be included in 'orphan_nodes', but for diagnostic
  // purposes we want to exclude these from 'num_nodes_removed' to avoid
  // confusing users.
  int32 num_nodes_removed = 0;
  for (int32 i = 0; i < orphan_nodes.size(); i++)
    if (!IsComponentInputNode(orphan_nodes[i]))
      num_nodes_removed++;
  RemoveSomeNodes(orphan_nodes);
  KALDI_LOG << "Removed " << num_nodes_removed << " orphan nodes.";
}

RemoveRedundantConfigLines()

void RemoveRedundantConfigLines ( int32  num_lines_initial, std::vector< ConfigLine > *  config_lines  )

staticprivate

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

References ConfigLine::FirstToken(), ConfigLine::GetValue(), rnnlm::i, kaldi::IsValidName(), KALDI_ASSERT, KALDI_ERR, and ConfigLine::WholeLine().

                                                                           {
  int32 num_lines = config_lines->size();
  KALDI_ASSERT(num_lines_initial <= num_lines);
  // node names and component names live in different namespaces.
  unordered_map<std::string, int32, StringHasher> node_name_to_most_recent_line;
  unordered_set<std::string, StringHasher> component_names;
  typedef unordered_map<std::string, int32, StringHasher>::iterator IterType;

  std::vector<bool> to_remove(num_lines, false);
  for (int32 line = 0; line < num_lines; line++) {
    ConfigLine &config_line = (*config_lines)[line];
    std::string name;
    if (!config_line.GetValue("name", &name))
      KALDI_ERR << "Config line has no field 'name=xxx': "
                << config_line.WholeLine();
    if (!IsValidName(name))
      KALDI_ERR << "Name '" << name << "' is not allowable, in line: "
                << config_line.WholeLine();
    if (config_line.FirstToken() == "component") {
      // a line starting with "component"... components live in their own
      // namespace.  No repeats are allowed because we never wrote them
      // to the config generated from the nnet.
      if (!component_names.insert(name).second) {
        // we could not insert it because it was already there.
        KALDI_ERR << "Component name " << name
                  << " appears twice in the same config file.";
      }
    } else {
      // the line defines some sort of network node, e.g. component-node.
      IterType iter = node_name_to_most_recent_line.find(name);
      if (iter != node_name_to_most_recent_line.end()) {
        // name is repeated.
        int32 prev_line = iter->second;
        if (prev_line >= num_lines_initial) {
          // user-provided config contained repeat of node with this name.
          KALDI_ERR << "Node name " << name
                    << " appears twice in the same config file.";
        }
        // following assert checks that the config-file generated
        // from an actual nnet does not contain repeats.. that
        // would be a bug so check it with assert.
        KALDI_ASSERT(line >= num_lines_initial);
        to_remove[prev_line] = true;
      }
      node_name_to_most_recent_line[name] = line;
    }
  }
  // Now remove any lines with to_remove[i] = true.
  std::vector<ConfigLine> config_lines_out;
  config_lines_out.reserve(num_lines);
  for (int32 i = 0; i < num_lines; i++) {
    if (!to_remove[i])
      config_lines_out.push_back((*config_lines)[i]);
  }
  config_lines->swap(config_lines_out);
}

RemoveSomeNodes()

void RemoveSomeNodes

(

const std::vector< int32 > &

nodes_to_remove

)

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

References Nnet::Check(), kaldi::nnet3::DescriptorTokenize(), rnnlm::i, KALDI_ASSERT, KALDI_ERR, kaldi::nnet3::kDescriptor, kaldi::nnet3::kDimRange, rnnlm::n, Nnet::node_names_, and Nnet::nodes_.

Referenced by kaldi::nnet3::ReadEditConfig(), and Nnet::RemoveOrphanNodes().

                                                                  {
  if (nodes_to_remove.empty())
    return;
  int32 old_num_nodes = nodes_.size(),
      new_num_nodes = 0;
  std::vector<int32> old2new_map(old_num_nodes, 0);
  for (size_t i = 0; i < nodes_to_remove.size(); i++)
    old2new_map[nodes_to_remove[i]] = -1;
  std::vector<NetworkNode> new_nodes;
  std::vector<std::string> new_node_names;
  for (int32 n = 0; n < old_num_nodes; n++) {
    if (old2new_map[n] != -1) {
      old2new_map[n] = new_num_nodes++;
      new_nodes.push_back(nodes_[n]);
      new_node_names.push_back(node_names_[n]);
    }
  }
  for (int32 n = 0; n < new_num_nodes; n++) {
    if (new_nodes[n].node_type == kDescriptor) {
      // we need to renumber the node indexes inside the descriptor.  It's
      // easiest to do this by converting back and forth to text format.  This
      // is inefficient, of course, but these graphs are typically quite small.
      std::ostringstream os;
      new_nodes[n].descriptor.WriteConfig(os, node_names_);
      std::vector<std::string> tokens;
      DescriptorTokenize(os.str(), &tokens);
      KALDI_ASSERT(!tokens.empty());
      tokens.push_back("end of input");
      const std::string *token = &(tokens[0]);
      Descriptor new_descriptor;
      // this should work; if it doesn't, there was a programming error.
      if (!new_nodes[n].descriptor.Parse(new_node_names, &token)) {
        KALDI_ERR << "Code error removing orphan nodes.";
      }
    } else if (new_nodes[n].node_type == kDimRange) {
      int32 old_node_index = new_nodes[n].u.node_index,
          new_node_index = old2new_map[old_node_index];
      KALDI_ASSERT(new_node_index >= 0 && new_node_index <= new_num_nodes);
      new_nodes[n].u.node_index = new_node_index;
    }
  }
  nodes_ = new_nodes;
  node_names_ = new_node_names;
  bool warn_for_orphans = false;
  // don't warn about orphans, because at this stage we may have
  // orphan components that will later be removed by calling
  // RemoveOrphanComponents().
  Check(warn_for_orphans);
}

ResetGenerators()

void ResetGenerators

(

)

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

References Nnet::GetComponent(), Nnet::NumComponents(), and RandomComponent::ResetGenerator().

                           {
  // resets random-number generators for all random
  // components.
  for (int32 c = 0; c < NumComponents(); c++) {
    RandomComponent *rc = dynamic_cast<RandomComponent*>(GetComponent(c));
    if (rc != NULL)
      rc->ResetGenerator();
  }
}

SetComponent()

void SetComponent	(	int32	c,
		Component *	component
	)

Replace the component indexed by c with a new component.

Frees previous component indexed by c. Takes ownership of the pointer 'component'.

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

References KALDI_ASSERT.

Referenced by kaldi::nnet3::ConvertRepeatedToBlockAffine(), and kaldi::nnet3::ReadEditConfig().

                                                     {
  KALDI_ASSERT(static_cast<size_t>(c) < components_.size());
  delete components_[c];
  components_[c] = component;
}

SetNodeName()

void SetNodeName	(	int32	node_index,
		const std::string &	new_name
	)

This can be used to modify invidual node names.

Note, this does not affect the neural net structure at all, it just assigns a new name to an existing node while leaving all connections identical.

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

References kaldi::IsValidName(), KALDI_ERR, and NetworkNode::node_index.

Referenced by kaldi::nnet3::ReadEditConfig().

                                                                  {
  if (!(static_cast<size_t>(node_index) < nodes_.size()))
    KALDI_ERR << "Invalid node index";
  if (GetNodeIndex(new_name) != -1)
    KALDI_ERR << "You cannot rename a node to create a duplicate node name";
  if (!IsValidName(new_name))
    KALDI_ERR << "Node name " << new_name << " is not allowed.";
  node_names_[node_index] = new_name;
}

Swap()

void Swap

(

Nnet *

other

)

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

References Nnet::component_names_, Nnet::components_, Nnet::node_names_, and Nnet::nodes_.

Referenced by Nnet::Read().

                           {
  component_names_.swap(other->component_names_);
  components_.swap(other->components_);
  node_names_.swap(other->node_names_);
  nodes_.swap(other->nodes_);
}

Write()

void Write	(	std::ostream &	ostream,
		bool	binary
	)		const

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

References rnnlm::i, KALDI_ASSERT, kaldi::WriteBasicType(), and kaldi::WriteToken().

Referenced by main(), kaldi::nnet3::UnitTestNnetIo(), and AmNnetSimple::Write().

                                                  {
  WriteToken(os, binary, "<Nnet3>");
  os << std::endl;
  std::vector<std::string> config_lines;
  const bool include_dim = false;
  GetConfigLines(include_dim, &config_lines);
  for (size_t i = 0; i < config_lines.size(); i++) {
    KALDI_ASSERT(!config_lines[i].empty());
    os << config_lines[i] << std::endl;
  }
  // A blank line terminates the config-like section of the file.
  os << std::endl;
  // Now write the Components
  int32 num_components = components_.size();
  WriteToken(os, binary, "<NumComponents>");
  WriteBasicType(os, binary, num_components);
  if (!binary)
    os << std::endl;
  for (int32 c = 0; c < num_components; c++) {
    WriteToken(os, binary, "<ComponentName>");
    WriteToken(os, binary, component_names_[c]);
    components_[c]->Write(os, binary);
    if (!binary)
      os << std::endl;
  }
  WriteToken(os, binary, "</Nnet3>");
}

Member Data Documentation

component_names_

std::vector<std::string> component_names_

private

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

Referenced by Nnet::Info(), Nnet::operator=(), Nnet::RemoveOrphanComponents(), and Nnet::Swap().

components_

std::vector<Component*> components_

private

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

Referenced by Nnet::Info(), Nnet::Nnet(), Nnet::operator=(), Nnet::RemoveOrphanComponents(), and Nnet::Swap().

node_names_

std::vector<std::string> node_names_

private

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

Referenced by Nnet::operator=(), Nnet::RemoveSomeNodes(), and Nnet::Swap().

nodes_

std::vector<NetworkNode> nodes_

private

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

Referenced by Nnet::operator=(), Nnet::RemoveOrphanComponents(), Nnet::RemoveSomeNodes(), and Nnet::Swap().

---

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

• nnet3/nnet-nnet.h
• nnet3/nnet-nnet.cc