MultiTaskLoss Class Reference

#include <nnet-loss.h>

Inheritance diagram for MultiTaskLoss:

Collaboration diagram for MultiTaskLoss:

Public Member Functions
	MultiTaskLoss (LossOptions &opts)
	~MultiTaskLoss ()
void	InitFromString (const std::string &s)
	Initialize from string, the format for string 's' is : 'multitask,<type1>,<dim1>,<weight1>,...,<typeN>,<dimN>,<weightN>'. More...
void	Eval (const VectorBase< BaseFloat > &frame_weights, const CuMatrixBase< BaseFloat > &net_out, const CuMatrixBase< BaseFloat > &target, CuMatrix< BaseFloat > *diff)
	Evaluate mean square error using target-matrix,. More...
void	Eval (const VectorBase< BaseFloat > &frame_weights, const CuMatrixBase< BaseFloat > &net_out, const Posterior &target, CuMatrix< BaseFloat > *diff)
	Evaluate mean square error using target-posteior,. More...
std::string	Report ()
	Generate string with error report. More...
BaseFloat	AvgLoss ()
	Get loss value (frame average),. More...
Public Member Functions inherited from LossItf
	LossItf (LossOptions &opts)
virtual	~LossItf ()

Private Attributes
std::vector< LossItf * >	loss_vec_
std::vector< int32 >	loss_dim_
std::vector< BaseFloat >	loss_weights_
std::vector< int32 >	loss_dim_offset_
CuMatrix< BaseFloat >	tgt_mat_

Additional Inherited Members
Protected Attributes inherited from LossItf
LossOptions	opts_
Timer	timer_

Detailed Description

Definition at line 197 of file nnet-loss.h.

Constructor & Destructor Documentation

MultiTaskLoss()

MultiTaskLoss ( LossOptions &  opts )

inline

Definition at line 199 of file nnet-loss.h.

                                  :
    LossItf(opts)
  { }

~MultiTaskLoss()

~MultiTaskLoss ( )

inline

Definition at line 203 of file nnet-loss.h.

                   {
    while (loss_vec_.size() > 0) {
      delete loss_vec_.back();
      loss_vec_.pop_back();
    }
  }

Member Function Documentation

AvgLoss()

BaseFloat AvgLoss ( )

virtual

Get loss value (frame average),.

Implements LossItf.

Definition at line 445 of file nnet-loss.cc.

References rnnlm::i, KALDI_ISFINITE, KALDI_WARN, and Xent::loss_vec_.

                                 {
  BaseFloat ans(0.0);
  for (int32 i = 0; i < loss_vec_.size(); i++) {
    BaseFloat val = loss_weights_[i] * loss_vec_[i]->AvgLoss();
    if (!KALDI_ISFINITE(val)) {
      KALDI_WARN << "Loss " << i+1 << ", has bad objective function value '"
                 << val << "', using 0.0 instead.";
      val = 0.0;
    }
    ans += val;
  }
  return ans;
}

Eval() [1/2]

void Eval ( const VectorBase< BaseFloat > &  frame_weights, const CuMatrixBase< BaseFloat > &  net_out, const CuMatrixBase< BaseFloat > &  target, CuMatrix< BaseFloat > *  diff  )

inlinevirtual

Evaluate mean square error using target-matrix,.

Implements LossItf.

Definition at line 218 of file nnet-loss.h.

References KALDI_ERR.

Referenced by main().

                                       {
    KALDI_ERR << "This is not supposed to be called!";
  }

Eval() [2/2]

void Eval ( const VectorBase< BaseFloat > &  frame_weights, const CuMatrixBase< BaseFloat > &  net_out, const Posterior &  target, CuMatrix< BaseFloat > *  diff  )

virtual

Evaluate mean square error using target-posteior,.

One vector of frame_weights per loss-function, The original frame weights are multiplied with a mask of `defined targets' according to the 'Posterior'.

Implements LossItf.

Definition at line 365 of file nnet-loss.cc.

References CuMatrixBase< Real >::ColRange(), KALDI_ASSERT, Xent::loss_vec_, CuMatrixBase< Real >::NumCols(), CuMatrixBase< Real >::NumRows(), kaldi::nnet1::PosteriorToMatrix(), CuMatrix< Real >::Resize(), and Xent::tgt_mat_.

                                       {
  int32 num_frames = net_out.NumRows(),
    num_output = net_out.NumCols();
  KALDI_ASSERT(num_frames == post.size());
  KALDI_ASSERT(num_output == loss_dim_offset_.back());  // sum of loss-dims,

  // convert posterior to matrix,
  PosteriorToMatrix(post, num_output, &tgt_mat_);

  // allocate diff matrix,
  diff->Resize(num_frames, num_output);

  std::vector<Vector<BaseFloat> > frmwei_have_tgt;
  for (int32 l = 0; l < loss_vec_.size(); l++) {
    // copy original weights,
    frmwei_have_tgt.push_back(Vector<BaseFloat>(frame_weights));
    // We need to mask-out the frames for which the 'posterior' is not defined (= is empty):
    int32 loss_beg = loss_dim_offset_[l];   // first column of loss target,
    int32 loss_end = loss_dim_offset_[l+1]; // (last+1) column of loss target,
    for (int32 f = 0; f < num_frames; f++) {
      bool tgt_defined = false;
      for (int32 p = 0; p < post[f].size(); p++) {
        if (post[f][p].first >= loss_beg && post[f][p].first < loss_end) {
          tgt_defined = true;
          break;
        }
      }
      if (!tgt_defined) {
        frmwei_have_tgt[l](f) = 0.0; // set zero_weight for the frame with no targets!
      }
    }
  }

  // call the vector of loss functions,
  CuMatrix<BaseFloat> diff_aux;
  for (int32 l = 0; l < loss_vec_.size(); l++) {
    loss_vec_[l]->Eval(frmwei_have_tgt[l],
      net_out.ColRange(loss_dim_offset_[l], loss_dim_[l]),
      tgt_mat_.ColRange(loss_dim_offset_[l], loss_dim_[l]),
      &diff_aux);
    // Scale the gradients,
    diff_aux.Scale(loss_weights_[l]);
    // Copy to diff,
    diff->ColRange(loss_dim_offset_[l], loss_dim_[l]).CopyFromMat(diff_aux);
  }
}

InitFromString()

void InitFromString

(

const std::string &

s

)

Initialize from string, the format for string 's' is : 'multitask,<type1>,<dim1>,<weight1>,...,<typeN>,<dimN>,<weightN>'.

Practically it can look like this : 'multitask,xent,2456,1.0,mse,440,0.001'

Definition at line 318 of file nnet-loss.cc.

References kaldi::ConvertStringToInteger(), kaldi::ConvertStringToReal(), rnnlm::i, KALDI_ASSERT, KALDI_ERR, Xent::loss_vec_, LossItf::opts_, kaldi::SplitStringToVector(), and Xent::Xent().

Referenced by main().

                                                     {
  std::vector<std::string> v;
  SplitStringToVector(s, ",:" /* delimiter */, false, &v);

  KALDI_ASSERT((v.size()-1) % 3 == 0);  // triplets,
  KALDI_ASSERT(v[0] == "multitask");  // header,

  // parse the definition of multitask loss,
  std::vector<std::string>::iterator it(v.begin()+1);  // skip header,
  for ( ; it != v.end(); ++it) {
    // type,
    if (*it == "xent") {
      loss_vec_.push_back(new Xent(opts_));
    } else if (*it == "mse") {
      loss_vec_.push_back(new Mse(opts_));
    } else {
      KALDI_ERR << "Unknown objective function code : " << *it;
    }
    ++it;
    // dim,
    int32 dim;
    if (!ConvertStringToInteger(*it, &dim)) {
      KALDI_ERR << "Cannot convert 'dim' " << *it << " to integer!";
    }
    loss_dim_.push_back(dim);
    ++it;
    // weight,
    BaseFloat weight;
    if (!ConvertStringToReal(*it, &weight)) {
      KALDI_ERR << "Cannot convert 'weight' " << *it << " to integer!";
    }
    KALDI_ASSERT(weight >= 0.0);
    loss_weights_.push_back(weight);
  }

  // build vector with starting-point offsets,
  loss_dim_offset_.resize(loss_dim_.size()+1, 0);  // 1st zero stays,
  for (int32 i = 1; i <= loss_dim_.size(); i++) {
    loss_dim_offset_[i] = loss_dim_offset_[i-1] + loss_dim_[i-1];
  }

  // sanity check,
  KALDI_ASSERT(loss_vec_.size() > 0);
  KALDI_ASSERT(loss_vec_.size() == loss_dim_.size());
  KALDI_ASSERT(loss_vec_.size() == loss_weights_.size());
}

Report()

std::string Report ( )

virtual

Generate string with error report.

Implements LossItf.

Definition at line 418 of file nnet-loss.cc.

References Xent::AvgLoss(), rnnlm::i, and Xent::loss_vec_.

Referenced by main().

                                {
  // calculate overall loss (weighted),
  BaseFloat overall_loss = AvgLoss();
  // copy the loss-values into a vector,
  std::vector<BaseFloat> loss_values;
  for (int32 i = 0; i < loss_vec_.size(); i++) {
    loss_values.push_back(loss_vec_[i]->AvgLoss());
  }

  // build the message,
  std::ostringstream oss;
  oss << "MultiTaskLoss, with " << loss_vec_.size()
      << " parallel loss functions." << std::endl;
  // individual loss reports first,
  for (int32 i = 0; i < loss_vec_.size(); i++) {
    oss << "Loss " << i+1 << ", " << loss_vec_[i]->Report() << std::endl;
  }

  // overall loss is last,
  oss << "Loss (OVERALL), "
      << "AvgLoss: " << overall_loss << " (MultiTaskLoss), "
      << "weights " << loss_weights_ << ", "
      << "values " << loss_values << std::endl;

  return oss.str();
}

Member Data Documentation

loss_dim_

std::vector<int32> loss_dim_

private

Definition at line 239 of file nnet-loss.h.

loss_dim_offset_

std::vector<int32> loss_dim_offset_

private

Definition at line 242 of file nnet-loss.h.

loss_vec_

std::vector<LossItf*> loss_vec_

private

Definition at line 238 of file nnet-loss.h.

loss_weights_

std::vector<BaseFloat> loss_weights_

private

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

tgt_mat_

CuMatrix<BaseFloat> tgt_mat_

private

Definition at line 244 of file nnet-loss.h.

---

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

• nnet/nnet-loss.h
• nnet/nnet-loss.cc