GeneralDescriptor Struct Reference

This class is only used when parsing Descriptors. More...

#include <nnet-descriptor.h>

Collaboration diagram for GeneralDescriptor:

Public Types
enum	DescriptorType {   kAppend, kSum, kFailover, kIfDefined,   kOffset, kSwitch, kRound, kReplaceIndex,   kScale, kConst, kNodeName }

Public Member Functions
	GeneralDescriptor (DescriptorType t, int32 value1=-1, int32 value2=-1, BaseFloat alpha=0.0)
	~GeneralDescriptor ()
GeneralDescriptor *	GetNormalizedDescriptor () const
Descriptor *	ConvertToDescriptor ()
void	Print (const std::vector< std::string > &node_names, std::ostream &os)

Static Public Member Functions
static GeneralDescriptor *	Parse (const std::vector< std::string > &node_names, const std::string **next_token)

Private Member Functions
	KALDI_DISALLOW_COPY_AND_ASSIGN (GeneralDescriptor)
void	ParseAppendOrSumOrSwitch (const std::vector< std::string > &node_names, const std::string **next_token)
void	ParseIfDefined (const std::vector< std::string > &node_names, const std::string **next_token)
void	ParseOffset (const std::vector< std::string > &node_names, const std::string **next_token)
void	ParseSwitch (const std::vector< std::string > &node_names, const std::string **next_token)
void	ParseFailover (const std::vector< std::string > &node_names, const std::string **next_token)
void	ParseRound (const std::vector< std::string > &node_names, const std::string **next_token)
void	ParseScale (const std::vector< std::string > &node_names, const std::string **next_token)
void	ParseConst (const std::vector< std::string > &node_names, const std::string **next_token)
void	ParseReplaceIndex (const std::vector< std::string > &node_names, const std::string **next_token)
int32	NumAppendTerms () const
GeneralDescriptor *	GetAppendTerm (int32 term) const
GeneralDescriptor *	NormalizeAppend () const
SumDescriptor *	ConvertToSumDescriptor () const
ForwardingDescriptor *	ConvertToForwardingDescriptor () const

Static Private Member Functions
static bool	Normalize (GeneralDescriptor *ptr)

Private Attributes
DescriptorType	descriptor_type_
int32	value1_
int32	value2_
BaseFloat	alpha_
std::vector< GeneralDescriptor * >	descriptors_

Detailed Description

This class is only used when parsing Descriptors.

It is useful for normalizing descriptors that are structured in an invalid or redundant way, into a form that can be turned into a real Descriptor.

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

Member Enumeration Documentation

DescriptorType

enum DescriptorType

Enumerator
kAppend
kSum
kFailover
kIfDefined
kOffset
kSwitch
kRound
kReplaceIndex
kScale
kConst
kNodeName

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

                      { kAppend, kSum, kFailover, kIfDefined, kOffset, kSwitch,
                        kRound, kReplaceIndex, kScale, kConst, kNodeName };

Constructor & Destructor Documentation

GeneralDescriptor()

GeneralDescriptor ( DescriptorType  t, int32  value1 = -1, int32  value2 = -1, BaseFloat  alpha = 0.0  )

inlineexplicit

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

                                                                      :
      descriptor_type_(t), value1_(value1), value2_(value2),
      alpha_(alpha) { }

~GeneralDescriptor()

~GeneralDescriptor ( )

inline

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

References kaldi::DeletePointers(), ForwardingDescriptor::KALDI_DISALLOW_COPY_AND_ASSIGN(), and fst::Print().

{ DeletePointers(&descriptors_); }

Member Function Documentation

ConvertToDescriptor()

Descriptor * ConvertToDescriptor

(

)

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

References GeneralDescriptor::ConvertToSumDescriptor(), GeneralDescriptor::descriptor_type_, GeneralDescriptor::descriptors_, and rnnlm::i.

Referenced by kaldi::nnet3::NormalizeTextDescriptor(), Descriptor::Parse(), and kaldi::nnet3::UnitTestGeneralDescriptor().

                                                   {
  GeneralDescriptor *normalized = GetNormalizedDescriptor();
  std::vector<SumDescriptor*> sum_descriptors;
  if (normalized->descriptor_type_ == kAppend) {
    for (size_t i = 0; i < normalized->descriptors_.size(); i++)
      sum_descriptors.push_back(
          normalized->descriptors_[i]->ConvertToSumDescriptor());
  } else {
    sum_descriptors.push_back(normalized->ConvertToSumDescriptor());
  }
  Descriptor *ans = new Descriptor(sum_descriptors);
  delete normalized;
  return ans;
}

ConvertToForwardingDescriptor()

ForwardingDescriptor * ConvertToForwardingDescriptor ( ) const

private

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

References rnnlm::i, KALDI_ASSERT, KALDI_ERR, ReplaceIndexForwardingDescriptor::kT, and ReplaceIndexForwardingDescriptor::kX.

                                                                             {
  switch (this->descriptor_type_) {
    case kNodeName: return new SimpleForwardingDescriptor(value1_);
    case kOffset: {
      KALDI_ASSERT(descriptors_.size() == 1 && "bad descriptor");
      return new OffsetForwardingDescriptor(
          descriptors_[0]->ConvertToForwardingDescriptor(),
          Index(0, value1_, value2_));
    }
    case kSwitch: {
      std::vector<ForwardingDescriptor*> descriptors;
      for (size_t i = 0; i < descriptors_.size(); i++)
        descriptors.push_back(descriptors_[i]->ConvertToForwardingDescriptor());
      return new SwitchingForwardingDescriptor(descriptors);
    }
    case kRound: {
      KALDI_ASSERT(descriptors_.size() == 1 && "bad descriptor");
      return new RoundingForwardingDescriptor(
          descriptors_[0]->ConvertToForwardingDescriptor(),
          value1_);
    }
    case kReplaceIndex: {
      KALDI_ASSERT(descriptors_.size() == 1 && "bad descriptor");
      KALDI_ASSERT(value1_ == int32(ReplaceIndexForwardingDescriptor::kT) ||
                   value1_ == int32(ReplaceIndexForwardingDescriptor::kX));
      return new ReplaceIndexForwardingDescriptor(
          descriptors_[0]->ConvertToForwardingDescriptor(),
          value1_ == int32(ReplaceIndexForwardingDescriptor::kT) ?
          ReplaceIndexForwardingDescriptor::kT :
          ReplaceIndexForwardingDescriptor::kX,
          value2_);
    }
    case kScale: {
      if (!(descriptors_.size() == 1 &&
            descriptors_[0]->descriptor_type_ == kNodeName)) {
        KALDI_ERR << "Invalid combination of Scale() expression and other "
            "expressions encountered in descriptor.";
      }
      return new SimpleForwardingDescriptor(descriptors_[0]->value1_,
                                            alpha_);
    }
    case kConst: {
      KALDI_ERR << "Error in Descriptor: Const() "
          "appeared too deep in the expression.";
    }
    default:
      KALDI_ERR << "Invalid descriptor type (failure in normalization?)";
      return NULL;
  }
}

ConvertToSumDescriptor()

SumDescriptor * ConvertToSumDescriptor ( ) const

private

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

References ConstantSumDescriptor::ConstantSumDescriptor(), KALDI_ASSERT, KALDI_ERR, BinarySumDescriptor::kFailoverOperation, and BinarySumDescriptor::kSumOperation.

Referenced by GeneralDescriptor::ConvertToDescriptor().

                                                               {
  KALDI_ASSERT(descriptor_type_ != kAppend &&
               "Badly normalized descriptor");
  switch (descriptor_type_) {
    case kAppend:
      KALDI_ERR << "Badly normalized descriptor";
    case kSum: case kFailover: {
      KALDI_ASSERT(descriptors_.size() == 2 && "Bad descriptor");
      return new BinarySumDescriptor(
          descriptor_type_ == kSum ?
          BinarySumDescriptor::kSumOperation :
          BinarySumDescriptor::kFailoverOperation,
          descriptors_[0]->ConvertToSumDescriptor(),
          descriptors_[1]->ConvertToSumDescriptor());
    }
    case kIfDefined: {
      KALDI_ASSERT(descriptors_.size() == 1 && "Bad descriptor");
      return new OptionalSumDescriptor(
          descriptors_[0]->ConvertToSumDescriptor());
    }
    case kConst: {
      KALDI_ASSERT(descriptors_.empty() && value1_ > 0);
      return new ConstantSumDescriptor(alpha_, value1_);
    }
    default: {
      return new SimpleSumDescriptor(this->ConvertToForwardingDescriptor());
    }
  }
}

GetAppendTerm()

GeneralDescriptor * GetAppendTerm ( int32  term ) const

private

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

References GeneralDescriptor::descriptors_, rnnlm::i, KALDI_ASSERT, and KALDI_ERR.

                                                                    {
  switch (descriptor_type_) {
    case kNodeName:
      KALDI_ASSERT(term == 0);
      return new GeneralDescriptor(kNodeName, value1_);
    case kAppend: {
      int32 cur_term = term;
      for (size_t i = 0; i < descriptors_.size(); i++) {
        int32 this_num_terms = descriptors_[i]->NumAppendTerms();
        if (cur_term < this_num_terms)
          return descriptors_[i]->GetAppendTerm(cur_term);
        else
          cur_term -= this_num_terms;
      }
      KALDI_ERR << "Code error, getting append term.";
      return NULL; // avoid compiler warning
    }
    default: {
      GeneralDescriptor *ans = new GeneralDescriptor(descriptor_type_,
                                                     value1_, value2_,
                                                     alpha_);
      ans->descriptors_.resize(descriptors_.size());
      for (size_t i = 0; i < descriptors_.size(); i++)
        ans->descriptors_[i] = descriptors_[i]->GetAppendTerm(term);
      return ans;
    }
  }
}

GetNormalizedDescriptor()

GeneralDescriptor * GetNormalizedDescriptor

(

)

const

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

                                                                    {
  GeneralDescriptor *ans = NormalizeAppend();
  while (Normalize(ans));  // keep normalizing as long as it changes.
  return ans;
}

KALDI_DISALLOW_COPY_AND_ASSIGN()

KALDI_DISALLOW_COPY_AND_ASSIGN ( GeneralDescriptor  )

private

Normalize()

bool Normalize ( GeneralDescriptor *  ptr )

staticprivate

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

References GeneralDescriptor::alpha_, GeneralDescriptor::descriptor_type_, GeneralDescriptor::descriptors_, rnnlm::i, KALDI_ASSERT, KALDI_ERR, kaldi::swap(), GeneralDescriptor::value1_, and GeneralDescriptor::value2_.

                                                         {
  bool changed = false;
  switch (desc->descriptor_type_) {
    case kOffset: {  // this block combines Offset(Offset(x, ..), ..).
      KALDI_ASSERT(desc->descriptors_.size() == 1);
      GeneralDescriptor *child = desc->descriptors_[0];
      if (child->descriptor_type_ == kOffset) {
        KALDI_ASSERT(child->descriptors_.size() == 1);
        GeneralDescriptor *grandchild = child->descriptors_[0];
        desc->value1_ += child->value1_;
        desc->value2_ += child->value2_;
        child->descriptors_.clear();  // avoid delete in destructor.
        delete child;
        desc->descriptors_[0] = grandchild;
        changed = true;
      } else if (desc->value1_ == 0 && desc->value2_ == 0) {
        // remove redundant Offset expression like Offset(x, 0).
        desc->descriptors_.swap(child->descriptors_);
        desc->descriptor_type_ = child->descriptor_type_;
        desc->value1_ = child->value1_;
        desc->value2_ = child->value2_;
        desc->alpha_ = child->alpha_;
        child->descriptors_.clear();  // avoid delete in destructor.
        delete child;
        changed = true;
        break;  // break from the switch ('desc' is no longer of type
        // kOffset)', so we don't want to carry through.
      }
    }
    // ... and continue through to the next case statement.
    case kSwitch: case kRound: case kReplaceIndex: { // ..and kOffset:
      KALDI_ASSERT(desc->descriptors_.size() >= 1);
      GeneralDescriptor *child = desc->descriptors_[0];
      // If child->descriptor_type_ == kAppend, it would be code error since we
      // already did NormalizeAppend().
      KALDI_ASSERT(child->descriptor_type_ != kAppend);
      if (child->descriptor_type_ == kSum ||
          child->descriptor_type_ == kFailover ||
          child->descriptor_type_ == kIfDefined) {
        if (desc->descriptors_.size() > 1) {
          KALDI_ASSERT(desc->descriptor_type_ == kSwitch);
          KALDI_ERR << "Sum(), Failover() or IfDefined() expression inside Switch(), "
                    << "we can't currently normalize this.";
        }
        // this is a forbidden case of a sum descriptor inside a forwarding
        // descriptor.  we need to rearrange.  E.g. Offset(Sum(x, y), 1) becomes
        // Sum(Offset(x, 1), Offset(y, 1)).
        for (size_t i = 0; i < child->descriptors_.size(); i++) {
          GeneralDescriptor *grandchild = child->descriptors_[i];
          GeneralDescriptor *modified_grandchild =
              new GeneralDescriptor(desc->descriptor_type_,
                                    desc->value1_,
                                    desc->value2_,
                                    desc->alpha_);
          // modified_grandchild takes ownership of grandchild.
          modified_grandchild->descriptors_.push_back(grandchild);
          child->descriptors_[i] = modified_grandchild;
        }
        // copy all members from child to desc.
        desc->descriptor_type_ = child->descriptor_type_;
        desc->value1_ = child->value1_;
        desc->value2_ = child->value2_;
        desc->descriptors_.swap(child->descriptors_);
        child->descriptors_.clear();  // avoid delete in destructor of 'child'
        delete child;
        changed = true;
      }
      break;
    }
    case kSum: {
      KALDI_ASSERT(!desc->descriptors_.empty());
      if (desc->descriptors_.size() == 1) {
        // convert Sum(x) to just x.
        GeneralDescriptor *child = desc->descriptors_[0];
        desc->descriptor_type_ = child->descriptor_type_;
        desc->descriptors_.swap(child->descriptors_);
        desc->value1_ = child->value1_;
        desc->value2_ = child->value2_;
        desc->alpha_ = child->alpha_;
        child->descriptors_.clear();  // avoid delete in destructor.
        delete child;
        changed = true;
      } else if (desc->descriptors_.size() > 2) {
        // convert Sum(a, b, c, ...) to Sum(a, Sum(b, c, ...)).
        GeneralDescriptor *new_child = new GeneralDescriptor(kSum);
        // assign b, c, .. to the descriptors of new_child.
        new_child->descriptors_.insert(new_child->descriptors_.begin(),
                                       desc->descriptors_.begin() + 1,
                                       desc->descriptors_.end());
        desc->descriptors_.erase(desc->descriptors_.begin() + 1,
                                   desc->descriptors_.end());
        desc->descriptors_.push_back(new_child);
        changed = true;
      }
      break;
    }
    case kScale: {
      KALDI_ASSERT(desc->descriptors_.size() == 1);
      GeneralDescriptor *child = desc->descriptors_[0];
      if (child->descriptor_type_ == kOffset ||
          child->descriptor_type_ == kReplaceIndex ||
          child->descriptor_type_ == kRound) {
        // push the Scale() inside those expressions.
        std::swap(desc->descriptor_type_, child->descriptor_type_);
        std::swap(desc->alpha_, child->alpha_);
        std::swap(desc->value1_, child->value1_);
        std::swap(desc->value2_, child->value2_);
        changed = true;
      } else if (child->descriptor_type_ == kSum) {
        // Push the Scale() inside the sum expression.
        desc->descriptors_.clear();
        for (size_t i = 0; i < child->descriptors_.size(); i++) {
          GeneralDescriptor *new_child =
              new GeneralDescriptor(kScale, -1, -1, desc->alpha_);
          new_child->descriptors_.push_back(child->descriptors_[i]);
          desc->descriptors_.push_back(new_child);
        }
        desc->descriptor_type_ = kSum;
        desc->alpha_ = 0.0;
        child->descriptors_.clear();  // prevent them being freed.
        delete child;
        changed = true;
      } else if (child->descriptor_type_ == kScale) {
        // Combine the 'scale' expressions.
        KALDI_ASSERT(child->descriptors_.size() == 1);
        GeneralDescriptor *grandchild = child->descriptors_[0];
        desc->alpha_ *= child->alpha_;
        desc->descriptors_[0] = grandchild;
        child->descriptors_.clear();  // prevent them being freed.
        delete child;
        changed = true;
      } else if (child->descriptor_type_ != kNodeName) {
        KALDI_ERR << "Unhandled case encountered when normalizing Descriptor; "
            "you can work around this by pushing Scale() inside "
            "other expressions.";
      }
      break;
    }
    default: { } // empty statement
  }
  // ... and recurse.
  for (size_t i = 0; i < desc->descriptors_.size(); i++)
    changed = changed || Normalize(desc->descriptors_[i]);
  return changed;
}

NormalizeAppend()

GeneralDescriptor * NormalizeAppend ( ) const

private

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

References GeneralDescriptor::descriptors_, rnnlm::i, and KALDI_ASSERT.

                                                            {
  int32 num_terms = NumAppendTerms();
  KALDI_ASSERT(num_terms > 0);
  if (num_terms == 1) {
    return GetAppendTerm(0);
  } else {
    GeneralDescriptor *ans = new GeneralDescriptor(kAppend);
    ans->descriptors_.resize(num_terms);
    for (size_t i = 0; i < num_terms; i++) {
      ans->descriptors_[i] = GetAppendTerm(i);
    }
    return ans;
  }
}

NumAppendTerms()

int32 NumAppendTerms ( ) const

private

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

References rnnlm::i, and KALDI_ASSERT.

                                              {
  int32 ans = 0;
  switch (descriptor_type_) {
    case kNodeName: ans = 1; break;
    case kConst: ans = 1; break;
    case kAppend: {
      for (size_t i = 0; i < descriptors_.size(); i++)
        ans += descriptors_[i]->NumAppendTerms();
      break;
    }
    default:
      KALDI_ASSERT(descriptors_.size() > 0);
      ans = descriptors_[0]->NumAppendTerms();
      for (size_t i = 1; i < descriptors_.size(); i++)
        KALDI_ASSERT(descriptors_[i]->NumAppendTerms() == ans);
  }
  return ans;
}

Parse()

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

static

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

References kaldi::nnet3::ExpectToken(), rnnlm::i, KALDI_ERR, GeneralDescriptor::ParseAppendOrSumOrSwitch(), GeneralDescriptor::ParseConst(), GeneralDescriptor::ParseFailover(), GeneralDescriptor::ParseIfDefined(), GeneralDescriptor::ParseOffset(), GeneralDescriptor::ParseReplaceIndex(), GeneralDescriptor::ParseRound(), and GeneralDescriptor::ParseScale().

Referenced by kaldi::nnet3::NormalizeTextDescriptor(), Descriptor::Parse(), and kaldi::nnet3::UnitTestGeneralDescriptor().

                                  {

  DescriptorType t;
  if (**next_token == "Append") {
    t = kAppend;
  } else if (**next_token == "Sum") {
    t = kSum;
  } else if (**next_token == "Failover") {
    t = kFailover;
  } else if (**next_token == "IfDefined") {
    t = kIfDefined;
  } else if (**next_token == "Offset") {
    t = kOffset;
  } else if (**next_token == "Switch") {
    t = kSwitch;
  } else if (**next_token == "Scale") {
    t = kScale;
  } else if (**next_token == "Const") {
    t = kConst;
  } else if (**next_token == "Round") {
    t = kRound;
  } else if (**next_token == "ReplaceIndex") {
    t = kReplaceIndex;
  } else {
    // what we read wasn't a reserved name like Offset, etc.
    // We expect a node name in that case.
    for (size_t i = 0; i < node_names.size(); i++) {
      if (**next_token == node_names[i]) {
        GeneralDescriptor *ans = new GeneralDescriptor(kNodeName, i);
        (*next_token)++;
        return ans;
      }
    }
    KALDI_ERR << "Expected a Descriptor, got instead "
              << **next_token;
    t = kNodeName;  // suppress compiler warning.
  }
  (*next_token)++;
  ExpectToken("(", "Descriptor", next_token);
  GeneralDescriptor *ans = new GeneralDescriptor(t);
  switch (t) {
    case kAppend: case kSum: case kSwitch:
      ans->ParseAppendOrSumOrSwitch(node_names, next_token); break;
    case kFailover: ans->ParseFailover(node_names, next_token); break;
    case kIfDefined: ans->ParseIfDefined(node_names, next_token); break;
    case kOffset: ans->ParseOffset(node_names, next_token); break;
    case kRound: ans->ParseRound(node_names, next_token); break;
    case kReplaceIndex: ans->ParseReplaceIndex(node_names, next_token); break;
    case kScale: ans->ParseScale(node_names, next_token); break;
    case kConst: ans->ParseConst(node_names, next_token); break;
    default:
      KALDI_ERR << "Code error";
  }
  return ans;
}

ParseAppendOrSumOrSwitch()

void ParseAppendOrSumOrSwitch ( const std::vector< std::string > &  node_names, const std::string **  next_token  )

private

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

References KALDI_ERR.

Referenced by GeneralDescriptor::Parse().

                                  {
  descriptors_.push_back(Parse(node_names, next_token));
  while (true) {
    if (**next_token == ")") {
      (*next_token)++;
      return;
    } else if (**next_token == ",") {
      (*next_token)++;
      descriptors_.push_back(Parse(node_names, next_token));
    } else {
      KALDI_ERR << "Expected ',' or ')', got "
                << **next_token;
    }
  }
}

ParseConst()

void ParseConst ( const std::vector< std::string > &  node_names, const std::string **  next_token  )

private

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

References kaldi::ConvertStringToInteger(), kaldi::ConvertStringToReal(), kaldi::nnet3::ExpectToken(), and KALDI_ERR.

Referenced by GeneralDescriptor::Parse().

                                  {
  if (!ConvertStringToReal(**next_token, &alpha_)) {
    KALDI_ERR << "Parsing Const() in descriptor: expected floating-point value"
        ", got: " << **next_token;
  }
  (*next_token)++;  // Consume the float.
  ExpectToken(",", "Const", next_token);
  if (!ConvertStringToInteger(**next_token, &value1_) ||
      value1_ <= 0) {
    KALDI_ERR << "Parsing Const() in descriptor: expected nonnegative integer, "
        "got: " << **next_token;
  }
  (*next_token)++;  // Consume the int.
  ExpectToken(")", "Const", next_token);
}

ParseFailover()

void ParseFailover ( const std::vector< std::string > &  node_names, const std::string **  next_token  )

private

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

References kaldi::nnet3::ExpectToken().

Referenced by GeneralDescriptor::Parse().

                                  {
  descriptors_.push_back(Parse(node_names, next_token));
  ExpectToken(",", "Failover", next_token);
  descriptors_.push_back(Parse(node_names, next_token));
  ExpectToken(")", "Failover", next_token);
}

ParseIfDefined()

void ParseIfDefined ( const std::vector< std::string > &  node_names, const std::string **  next_token  )

private

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

References kaldi::nnet3::ExpectToken().

Referenced by GeneralDescriptor::Parse().

                                  {
  descriptors_.push_back(Parse(node_names, next_token));
  ExpectToken(")", "IfDefined", next_token);
}

ParseOffset()

void ParseOffset ( const std::vector< std::string > &  node_names, const std::string **  next_token  )

private

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

References kaldi::nnet3::ExpectToken(), and kaldi::nnet3::ReadIntegerToken().

Referenced by GeneralDescriptor::Parse().

                                  {
  descriptors_.push_back(Parse(node_names, next_token));
  ExpectToken(",", "Offset", next_token);
  value1_ = ReadIntegerToken("Offset", next_token);
  if (**next_token == ",") {
    (*next_token)++;
    value2_ = ReadIntegerToken("Offset", next_token);
  } else {
    value2_ = 0;
  }
  ExpectToken(")", "Offset", next_token);
}

ParseReplaceIndex()

void ParseReplaceIndex ( const std::vector< std::string > &  node_names, const std::string **  next_token  )

private

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

References kaldi::nnet3::ExpectToken(), KALDI_ERR, ReplaceIndexForwardingDescriptor::kT, ReplaceIndexForwardingDescriptor::kX, and kaldi::nnet3::ReadIntegerToken().

Referenced by GeneralDescriptor::Parse().

                                  {
  descriptors_.push_back(Parse(node_names, next_token));
  ExpectToken(",", "ReplaceIndex", next_token);
  if (**next_token == "t") {
    value1_ = int32(ReplaceIndexForwardingDescriptor::kT);
    (*next_token)++;
  } else if (**next_token == "x") {
    value1_ = int32(ReplaceIndexForwardingDescriptor::kX);
    (*next_token)++;
  } else {
    KALDI_ERR << "Expected 't' or 'x', got " << **next_token;
  }
  ExpectToken(",", "ReplaceIndex", next_token);
  value2_ = ReadIntegerToken("Replace", next_token);
  ExpectToken(")", "ReplaceIndex", next_token);
}

ParseRound()

void ParseRound ( const std::vector< std::string > &  node_names, const std::string **  next_token  )

private

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

References kaldi::nnet3::ExpectToken(), and kaldi::nnet3::ReadIntegerToken().

Referenced by GeneralDescriptor::Parse().

                                  {
  descriptors_.push_back(Parse(node_names, next_token));
  ExpectToken(",", "Round", next_token);
  value1_ = ReadIntegerToken("Round", next_token);
  ExpectToken(")", "Round", next_token);
}

ParseScale()

void ParseScale ( const std::vector< std::string > &  node_names, const std::string **  next_token  )

private

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

References kaldi::ConvertStringToReal(), kaldi::nnet3::ExpectToken(), and KALDI_ERR.

Referenced by GeneralDescriptor::Parse().

                                  {
  if (!ConvertStringToReal(**next_token, &alpha_)) {
    KALDI_ERR << "Parsing Scale() in descriptor: expected floating-point scale"
        ", got: " << **next_token;
  }
  (*next_token)++;  // Consume the float.
  ExpectToken(",", "Scale", next_token);
  descriptors_.push_back(Parse(node_names, next_token));
  ExpectToken(")", "Scale", next_token);
}

ParseSwitch()

void ParseSwitch ( const std::vector< std::string > &  node_names, const std::string **  next_token  )

private

Print()

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

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

References rnnlm::i, KALDI_ASSERT, ReplaceIndexForwardingDescriptor::kT, and ReplaceIndexForwardingDescriptor::kX.

                                              {
  switch (descriptor_type_) {
    // first handle all the expressions of the form "Operator(<desc1>, ... <descN>)".
    case kAppend: os << "Append("; break;
    case kSum: os << "Sum("; break;
    case kFailover: os << "Failover("; break;
    case kIfDefined: os << "IfDefined("; break;
    case kSwitch: os << "Switch("; break;
    // Scale() ends in a descriptor, so we also break and let the generic code
    // handle that.
    case kScale: os << "Scale(" << alpha_ << ", "; break;
      // now handle the exceptions.
    case kOffset: case kRound: {
      os << "Offset(";
      KALDI_ASSERT(descriptors_.size() == 1);
      descriptors_[0]->Print(node_names, os);
      os << ", " << value1_;
      if (descriptor_type_ == kOffset && value2_ != 0) os << ", " << value2_;
      os << ")";
      return;
    }
    case kReplaceIndex: {
      os << "ReplaceIndex(";
      KALDI_ASSERT(descriptors_.size() == 1);
      descriptors_[0]->Print(node_names, os);
      KALDI_ASSERT(value1_ == int32(ReplaceIndexForwardingDescriptor::kT) ||
                   value1_ == int32(ReplaceIndexForwardingDescriptor::kX));
      if (value1_ == int32(ReplaceIndexForwardingDescriptor::kT)) {
        os << ", t, ";
      } else {
        os << ", x, ";
      }
      os << value2_ << ")";
      return;
    }
    case kNodeName: {
      KALDI_ASSERT(static_cast<size_t>(value1_) < node_names.size());
      os << node_names[value1_];
      return;
    }
    case kConst: {
      os << "Const(" << alpha_ << ", " << value1_ << ")";
      return;
    }
  }
  for (size_t i = 0; i < descriptors_.size(); i++) {
    if (i > 0) os << ", ";
    descriptors_[i]->Print(node_names, os);
  }
  os << ")";
}

Member Data Documentation

alpha_

BaseFloat alpha_

private

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

Referenced by GeneralDescriptor::Normalize().

descriptor_type_

DescriptorType descriptor_type_

private

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

Referenced by GeneralDescriptor::ConvertToDescriptor(), and GeneralDescriptor::Normalize().

descriptors_

std::vector<GeneralDescriptor*> descriptors_

private

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

Referenced by GeneralDescriptor::ConvertToDescriptor(), GeneralDescriptor::GetAppendTerm(), GeneralDescriptor::Normalize(), and GeneralDescriptor::NormalizeAppend().

value1_

int32 value1_

private

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

Referenced by GeneralDescriptor::Normalize().

value2_

int32 value2_

private

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

Referenced by GeneralDescriptor::Normalize().

---

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

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