Descriptor Class Reference

#include <nnet-descriptor.h>

Collaboration diagram for Descriptor:

Public Member Functions
int32	Dim (const Nnet &nnet) const
bool	Parse (const std::vector< std::string > &node_names, const std::string **next_token)
void	WriteConfig (std::ostream &os, const std::vector< std::string > &node_names) const
void	GetDependencies (const Index &index, std::vector< Cindex > *used_inputs) const
	This function exists to enable us to manage optional dependencies, i.e. More...
bool	IsComputable (const Index &ind, const CindexSet &cindex_set, std::vector< Cindex > *used_inputs) const
	Has the same purpose and interface as the IsComputable function of the SumDescriptor function. More...
void	GetNodeDependencies (std::vector< int32 > *node_indexes) const
int32	Modulus () const
int32	NumParts () const
	Returns the number of parts that are concatenated over. More...
const SumDescriptor &	Part (int32 n) const
	returns the n'th part. More...
	Descriptor ()
	Descriptor (const Descriptor &other)
	Copy constructor. More...
Descriptor &	operator= (const Descriptor &other)
	Assignment operator. More...
	Descriptor (const std::vector< SumDescriptor *> &parts)
	Takes ownership of pointers in "parts". More...
	~Descriptor ()
	Destructor. More...

Private Member Functions
void	Destroy ()

Private Attributes
std::vector< SumDescriptor * >	parts_

Detailed Description

Definition at line 525 of file nnet-descriptor.h.

Constructor & Destructor Documentation

Descriptor() [1/3]

Descriptor ( )

inline

Definition at line 587 of file nnet-descriptor.h.

{ }

Descriptor() [2/3]

Descriptor ( const Descriptor &  other )

inline

Copy constructor.

Definition at line 589 of file nnet-descriptor.h.

{ *this = other; }

Descriptor() [3/3]

Descriptor ( const std::vector< SumDescriptor *> &  parts )

inline

Takes ownership of pointers in "parts".

Definition at line 593 of file nnet-descriptor.h.

                                                    :
      parts_(parts) { }

~Descriptor()

~Descriptor ( )

inline

Destructor.

Definition at line 596 of file nnet-descriptor.h.

{ Destroy(); }

Member Function Documentation

Destroy()

void Destroy ( )

private

Definition at line 525 of file nnet-descriptor.cc.

References rnnlm::i.

                         {
  for (size_t i = 0; i < parts_.size(); i++)
    delete parts_[i];
  parts_.clear();
}

Dim()

int32 Dim

(

const Nnet &

nnet

)

const

Definition at line 531 of file nnet-descriptor.cc.

References ConstantSumDescriptor::Dim(), and KALDI_ASSERT.

Referenced by Compiler::CreateStepInfo(), and NetworkNode::Dim().

                                            {
  int32 num_parts = parts_.size();
  int32 dim = 0;
  for (int32 part = 0; part < num_parts; part++)
    dim += parts_[part]->Dim(nnet);
  KALDI_ASSERT(dim > 0);
  return dim;
}

GetDependencies()

void GetDependencies	(	const Index &	index,
		std::vector< Cindex > *	used_inputs
	)		const

This function exists to enable us to manage optional dependencies, i.e.

for making sense of expressions like (A + (B is present)) and (A if present; if not, B). Suppose we are trying to compute the index "ind", and the user represents that "cindex_set" is the set of Cindexes are available to the computation; then this function will return true if we can compute the expression given these inputs; and if so, will output to "used_inputs" the list of Cindexes (not necessarily unique) that this expression will include. Otherwise it will return false and set used_inputs to the empty vector.

Parameters

[in]	ind	The index that we want to compute at the output of the Descriptor.
[in]	cindex_set	The set of Cindexes that are available at the input of the Descriptor.
[out]	used_inputs	If non-NULL, if this function returns true then to this vector will be *appended* the inputs that will actually participate in the computation. Else (if non-NULL) it will be left unchanged.

Returns

Returns true if this output is computable given the provided inputs.

Definition at line 68 of file nnet-descriptor.cc.

References Descriptor::parts_.

Referenced by ComputationGraphBuilder::AddDependencies(), and kaldi::nnet3::ComputeComputationGraph().

                                           {
  dependencies->clear();
  std::vector<SumDescriptor*>::const_iterator sum_iter = parts_.begin(),
      sum_end = parts_.end();
  std::vector<Cindex> this_part;
  for (; sum_iter != sum_end; ++sum_iter)
    (*sum_iter)->GetDependencies(index, dependencies);
}

GetNodeDependencies()

void GetNodeDependencies

(

std::vector< int32 > *

node_indexes

)

const

Definition at line 577 of file nnet-descriptor.cc.

References ConstantSumDescriptor::GetNodeDependencies(), and rnnlm::i.

Referenced by Nnet::Check(), SwitchingForwardingDescriptor::GetNodeDependencies(), and kaldi::nnet3::NnetToDirectedGraph().

                                                                         {
  node_indexes->clear();
  for (size_t i = 0; i < parts_.size(); i++)
    parts_[i]->GetNodeDependencies(node_indexes);
}

IsComputable()

bool IsComputable	(	const Index &	ind,
		const CindexSet &	cindex_set,
		std::vector< Cindex > *	used_inputs
	)		const

Has the same purpose and interface as the IsComputable function of the SumDescriptor function.

Outputs to used_inputs rather than appending to it, though. used_inputs will not be sorted or have repeats removed.

Definition at line 556 of file nnet-descriptor.cc.

References rnnlm::i, and ConstantSumDescriptor::IsComputable().

Referenced by ComputationGraphBuilder::ComputeComputableInfo(), and ComputationGraphBuilder::PruneDependencies().

                                                                    {
  if (input_terms)
    input_terms->clear();
  for (size_t i = 0; i < parts_.size(); i++) {
    // if any of the parts is not computable, the whole is not computable.
    if (!parts_[i]->IsComputable(ind, cindex_set, input_terms)) {
      if (input_terms)
        input_terms->clear();
      return false;
    }
  }
  return true;
}

Modulus()

int32 Modulus

(

)

const

Definition at line 548 of file nnet-descriptor.cc.

References rnnlm::i, kaldi::Lcm(), and ConstantSumDescriptor::Modulus().

Referenced by Nnet::Modulus().

                                {
  int32 ans = 1;
  for (size_t i = 0; i < parts_.size(); i++)
    ans = Lcm(ans, parts_[i]->Modulus());
  return ans;
}

NumParts()

int32 NumParts ( ) const

inline

Returns the number of parts that are concatenated over.

Definition at line 583 of file nnet-descriptor.h.

References rnnlm::n.

Referenced by Compiler::CreateStepInfo(), and ModelCollapser::DescriptorIsCollapsible().

{ return parts_.size(); }

operator=()

Descriptor & operator=

(

const Descriptor &

other

)

Assignment operator.

Definition at line 541 of file nnet-descriptor.cc.

References rnnlm::i, and Descriptor::parts_.

                                                         {
  Destroy();
  for (size_t i = 0; i < other.parts_.size(); i++)
    parts_.push_back(other.parts_[i]->Copy());
  return *this;
}

Parse()

bool Parse	(	const std::vector< std::string > &	node_names,
		const std::string **	next_token
	)

Definition at line 491 of file nnet-descriptor.cc.

References GeneralDescriptor::ConvertToDescriptor(), KALDI_ERR, and GeneralDescriptor::Parse().

Referenced by Nnet::ProcessComponentNodeConfigLine(), Nnet::ProcessOutputNodeConfigLine(), ModelCollapser::ReplaceNodeInDescriptor(), and kaldi::nnet3::UnitTestDescriptorIo().

                                                     {
  GeneralDescriptor *gen_desc;
  try {
    gen_desc = GeneralDescriptor::Parse(node_names,
                                        next_token);
  } catch (...) {
    return false;
  }
  if (**next_token != "end of input")
    KALDI_ERR << "Parsing Descriptor, expected end of input but got "
              << "'" <<  **next_token << "'";
  Descriptor *desc = gen_desc->ConvertToDescriptor();
  *this = *desc;
  delete desc;
  delete gen_desc;
  return true;
}

Part()

const SumDescriptor & Part

(

int32

n

)

const

returns the n'th part.

Definition at line 572 of file nnet-descriptor.cc.

References KALDI_ASSERT, and rnnlm::n.

Referenced by Compiler::CompileBackwardSumDescriptor(), Compiler::CompileForwardSumDescriptor(), Compiler::ComputeInputLocationsList(), Compiler::CreateStepInfo(), and ModelCollapser::DescriptorIsCollapsible().

                                                   {
  KALDI_ASSERT(static_cast<size_t>(n) < parts_.size());
  return *(parts_[n]);
}

WriteConfig()

void WriteConfig	(	std::ostream &	os,
		const std::vector< std::string > &	node_names
	)		const

Definition at line 510 of file nnet-descriptor.cc.

References rnnlm::i, KALDI_ASSERT, and ConstantSumDescriptor::WriteConfig().

Referenced by SvdApplier::ModifyTopology(), kaldi::nnet3::NormalizeTextDescriptor(), ModelCollapser::ReplaceNodeInDescriptor(), kaldi::nnet3::UnitTestDescriptorIo(), and kaldi::nnet3::UnitTestGeneralDescriptor().

                                                                           {
  KALDI_ASSERT(parts_.size() > 0);
  if (parts_.size() == 1)
    parts_[0]->WriteConfig(os, node_names);
  else {
    os << "Append(";
    for (size_t i = 0; i < parts_.size(); i++) {
      parts_[i]->WriteConfig(os, node_names);
      if (i + 1 < parts_.size())
        os << ", ";
    }
    os << ")";
  }
}

Member Data Documentation

parts_

std::vector<SumDescriptor*> parts_

private

Definition at line 600 of file nnet-descriptor.h.

Referenced by Descriptor::GetDependencies(), and Descriptor::operator=().

---

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

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