kaldi::nnet1 Namespace Reference

Classes
class	AddShift
	Adds shift to all the lines of the matrix (can be used for global mean normalization) More...
class	AffineTransform
class	AveragePoolingComponent
	AveragePoolingComponent : The input/output matrices are split to submatrices with width 'pool_stride_'. More...
class	BlockSoftmax
class	BlstmProjected
class	Component
	Abstract class, building block of the network. More...
class	ConvolutionalComponent
	ConvolutionalComponent implements convolution over single axis (i.e. More...
class	CopyComponent
	Rearrange the matrix columns according to the indices in copy_from_indices_. More...
class	Dropout
class	FramePoolingComponent
	FramePoolingComponent : The input/output matrices are split to frames of width 'feature_dim_'. More...
class	HiddenSoftmax
class	KlHmm
class	LengthNormComponent
	Rescale the matrix-rows to have unit length (L2-norm). More...
class	LinearTransform
class	LossItf
struct	LossOptions
class	LstmProjected
class	MatrixBuffer
	A buffer for caching (utterance-key, feature-matrix) pairs. More...
struct	MatrixBufferOptions
class	MatrixRandomizer
	Shuffles rows of a matrix according to the indices in the mask,. More...
class	MaxPoolingComponent
	MaxPoolingComponent : The input/output matrices are split to submatrices with width 'pool_stride_'. More...
class	Mse
class	MultiBasisComponent
class	MultistreamComponent
	Class MultistreamComponent is an extension of UpdatableComponent for recurrent networks, which are trained with parallel sequences. More...
class	MultiTaskLoss
class	Nnet
struct	NnetDataRandomizerOptions
	Configuration variables that affect how frame-level shuffling is done. More...
struct	NnetTrainOptions
class	ParallelComponent
class	ParametricRelu
class	PdfPrior
struct	PdfPriorOptions
class	RandomizerMask
	Generates randomly ordered vector of indices,. More...
class	Rbm
class	RbmBase
struct	RbmTrainOptions
class	RecurrentComponent
	Component with recurrent connections, 'tanh' non-linearity. More...
class	Rescale
	Rescale the data column-wise by a vector (can be used for global variance normalization) More...
class	SentenceAveragingComponent
	Deprecated!!!, keeping it as Katka Zmolikova used it in JSALT 2015. More...
class	Sigmoid
class	SimpleSentenceAveragingComponent
	SimpleSentenceAveragingComponent does not have nested network, it is intended to be used inside of a <ParallelComponent>. More...
class	Softmax
class	Splice
	Splices the time context of the input features in N, out k*N, FrameOffset o_1,o_2,...,o_k FrameOffset example 11frames: -5 -4 -3 -2 -1 0 1 2 3 4 5. More...
class	StdVectorRandomizer
	Randomizes elements of a vector according to a mask. More...
class	Tanh
class	UpdatableComponent
	Class UpdatableComponent is a Component which has trainable parameters, it contains SGD training hyper-parameters in NnetTrainOptions. More...
class	VectorRandomizer
	Randomizes elements of a vector according to a mask. More...
class	Xent

Typedefs
typedef StdVectorRandomizer< int32 >	Int32VectorRandomizer
typedef StdVectorRandomizer< std::vector< std::pair< int32, BaseFloat > > >	PosteriorRandomizer

Functions
template<typename Real >
void	ReadCuMatrixFromString (const std::string &s, CuMatrix< Real > *m)
Component *	ReadComponentFromString (const std::string &s)
void	UnitTestLengthNorm ()
void	UnitTestSimpleSentenceAveragingComponent ()
void	UnitTestConvolutionalComponentUnity ()
void	UnitTestConvolutionalComponent3x3 ()
void	UnitTestMaxPoolingComponent ()
void	UnitTestDropoutComponent ()
template<typename T >
void	CountCorrectFramesWeighted (const CuArray< T > &hyp, const CuArray< T > &ref, const CuVectorBase< BaseFloat > &weights, Vector< double > *correct)
	Helper function of Xent::Eval, calculates number of matching elemente in 'hyp', 'ref' weighted by 'weights'. More...
template<typename T >
std::ostream &	operator<< (std::ostream &os, const std::vector< T > &v)
	Define stream insertion opeartor for 'std::vector', useful for log-prints,. More...
template<typename T >
std::string	ToString (const T &t)
	Convert basic type to a string (please don't overuse),. More...
template<typename Real >
std::string	MomentStatistics (const VectorBase< Real > &vec)
	Get a string with statistics of the data in a vector, so we can print them easily. More...
template<typename Real >
std::string	MomentStatistics (const MatrixBase< Real > &mat)
	Overload MomentStatistics to MatrixBase<Real> More...
template<typename Real >
std::string	MomentStatistics (const CuVectorBase< Real > &vec)
	Overload MomentStatistics to CuVectorBase<Real> More...
template<typename Real >
std::string	MomentStatistics (const CuMatrixBase< Real > &mat)
	Overload MomentStatistics to CuMatrix<Real> More...
template<typename Real >
void	CheckNanInf (const CuMatrixBase< Real > &mat, const char *msg="")
	Check that matrix contains no nan or inf. More...
template<typename Real >
Real	ComputeStdDev (const CuMatrixBase< Real > &mat)
	Get the standard deviation of values in the matrix. More...
template<typename Real >
void	RandGauss (BaseFloat mu, BaseFloat sigma, CuMatrixBase< Real > *mat, struct RandomState *state=NULL)
	Fill CuMatrix with random numbers (Gaussian distribution): mu = the mean value, sigma = standard deviation,. More...
template<typename Real >
void	RandUniform (BaseFloat mu, BaseFloat range, CuMatrixBase< Real > *mat, struct RandomState *state=NULL)
	Fill CuMatrix with random numbers (Uniform distribution): mu = the mean value, range = the 'width' of the uniform PDF (spanning mu-range/2 . More...
template<typename Real >
void	RandUniform (BaseFloat mu, BaseFloat range, CuVectorBase< Real > *vec, struct RandomState *state=NULL)
	Fill CuVector with random numbers (Uniform distribution): mu = the mean value, range = the 'width' of the uniform PDF (spanning mu-range/2 . More...
void	BuildIntegerVector (const std::vector< std::vector< int32 > > &in, std::vector< int32 > *out)
	Build 'integer vector' out of vector of 'matlab-like' representation: 'b, b:e, b:s:e'. More...
void	BuildIntegerVector (const std::vector< std::vector< int32 > > &in, CuArray< int32 > *out)
	Wrapper with 'CuArray<int32>' output. More...
template<typename Real >
void	PosteriorToMatrix (const Posterior &post, const int32 post_dim, CuMatrix< Real > *mat)
	Wrapper of PosteriorToMatrix with CuMatrix argument. More...
template<typename Real >
void	PosteriorToPdfMatrix (const Posterior &post, const TransitionModel &model, CuMatrix< Real > *mat)
	Wrapper of PosteriorToMatrixMapped with CuMatrix argument. More...
void	LatticeAcousticRescore (const Matrix< BaseFloat > &log_like, const TransitionModel &trans_model, const std::vector< int32 > &state_times, Lattice *lat)

Typedef Documentation

Int32VectorRandomizer

typedef StdVectorRandomizer<int32> Int32VectorRandomizer

Definition at line 267 of file nnet-randomizer.h.

PosteriorRandomizer

typedef StdVectorRandomizer<std::vector<std::pair<int32, BaseFloat> > > PosteriorRandomizer

Definition at line 268 of file nnet-randomizer.h.

Function Documentation

BuildIntegerVector() [1/2]

void kaldi::nnet1::BuildIntegerVector ( const std::vector< std::vector< int32 > > &  in, std::vector< int32 > *  out  )

inline

Build 'integer vector' out of vector of 'matlab-like' representation: 'b, b:e, b:s:e'.

b,e,s are integers, where: b = beginning e = end s = step

The sequence includes 'end', 1:3 => [ 1 2 3 ]. The 'step' has to be positive.

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

References rnnlm::i, rnnlm::j, KALDI_ASSERT, and KALDI_ERR.

Referenced by BuildIntegerVector(), Splice::InitData(), and CopyComponent::InitData().

                                                      {
  // start with empty vector,
  out->clear();
  // loop over records,
  for (int32 i = 0; i < in.size(); i++) {
    // process i'th record,
    int32 beg = 0, end = 0, step = 1;
    switch (in[i].size()) {
      case 1:
        beg  = in[i][0];
        end  = in[i][0];
        step = 1;
        break;
      case 2:
        beg  = in[i][0];
        end  = in[i][1];
        step = 1;
        break;
      case 3:
        beg  = in[i][0];
        end  = in[i][2];
        step = in[i][1];
        break;
      default:
        KALDI_ERR << "Something is wrong! (should be 1-3) : "
                  << in[i].size();
    }
    // check the inputs,
    KALDI_ASSERT(beg <= end);
    KALDI_ASSERT(step > 0);  // positive,
    // append values to vector,
    for (int32 j = beg; j <= end; j += step) {
      out->push_back(j);
    }
  }
}

BuildIntegerVector() [2/2]

void kaldi::nnet1::BuildIntegerVector ( const std::vector< std::vector< int32 > > &  in, CuArray< int32 > *  out  )

inline

Wrapper with 'CuArray<int32>' output.

Definition at line 280 of file nnet-utils.h.

References BuildIntegerVector().

                                                    {
  std::vector<int32> v;
  BuildIntegerVector(in, &v);
  (*out) = v;
}

CheckNanInf()

void kaldi::nnet1::CheckNanInf	(	const CuMatrixBase< Real > &	mat,
		const char *	msg = ""
	)

Check that matrix contains no nan or inf.

Definition at line 132 of file nnet-utils.h.

References KALDI_ERR, KALDI_ISINF, KALDI_ISNAN, and CuMatrixBase< Real >::Sum().

Referenced by Rbm::RbmUpdate().

                                                                      {
  Real sum = mat.Sum();
  if (KALDI_ISINF(sum)) { KALDI_ERR << "'inf' in " << msg; }
  if (KALDI_ISNAN(sum)) { KALDI_ERR << "'nan' in " << msg; }
}

ComputeStdDev()

Real kaldi::nnet1::ComputeStdDev

(

const CuMatrixBase< Real > &

mat

)

Get the standard deviation of values in the matrix.

Definition at line 142 of file nnet-utils.h.

References KALDI_WARN, CuMatrixBase< Real >::MulElements(), CuMatrixBase< Real >::NumCols(), CuMatrixBase< Real >::NumRows(), and CuMatrixBase< Real >::Sum().

Referenced by Rbm::RbmUpdate().

                                                  {
  int32 N = mat.NumRows() * mat.NumCols();
  Real mean = mat.Sum() / N;
  CuMatrix<Real> pow_2(mat);
  pow_2.MulElements(mat);
  Real var = pow_2.Sum() / N - mean * mean;
  if (var < 0.0) {
    KALDI_WARN << "Forcing the variance to be non-negative! " << var << "->0.0";
    var = 0.0;
  }
  return sqrt(var);
}

CountCorrectFramesWeighted()

void kaldi::nnet1::CountCorrectFramesWeighted ( const CuArray< T > &  hyp, const CuArray< T > &  ref, const CuVectorBase< BaseFloat > &  weights, Vector< double > *  correct  )

inline

Helper function of Xent::Eval, calculates number of matching elemente in 'hyp', 'ref' weighted by 'weights'.

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

References CuArrayBase< T >::CopyToVec(), CuVectorBase< Real >::CopyToVec(), CuArrayBase< T >::Dim(), VectorBase< Real >::Dim(), CuVectorBase< Real >::Dim(), rnnlm::i, and KALDI_ASSERT.

Referenced by Xent::Eval().

                                                                {
  KALDI_ASSERT(hyp.Dim() == ref.Dim());
  KALDI_ASSERT(hyp.Dim() == weights.Dim());
  int32 dim = hyp.Dim();
  // Get GPU data to host,
  std::vector<T> hyp_h(dim), ref_h(dim);
  hyp.CopyToVec(&hyp_h);
  ref.CopyToVec(&ref_h);
  Vector<BaseFloat> w(dim);
  weights.CopyToVec(&w);
  // Accumulate weighted counts of correct frames,
  for (int32 i = 0; i < dim; i++) {
    KALDI_ASSERT(ref_h[i] < correct->Dim());
    (*correct)(ref_h[i]) += w(i) * (hyp_h[i] == ref_h[i] ? 1.0 : 0.0);
  }
}

LatticeAcousticRescore()

void LatticeAcousticRescore	(	const Matrix< BaseFloat > &	log_like,
		const TransitionModel &	trans_model,
		const std::vector< int32 > &	state_times,
		Lattice *	lat
	)

Definition at line 45 of file nnet-train-mmi-sequential.cc.

References rnnlm::i, KALDI_ASSERT, KALDI_ERR, MatrixBase< Real >::NumRows(), and TransitionModel::TransitionIdToPdf().

Referenced by main().

                                          {
  kaldi::uint64 props = lat->Properties(fst::kFstProperties, false);
  if (!(props & fst::kTopSorted))
    KALDI_ERR << "Input lattice must be topologically sorted.";

  KALDI_ASSERT(!state_times.empty());
  std::vector<std::vector<int32> > time_to_state(log_like.NumRows());
  for (size_t i = 0; i < state_times.size(); i++) {
    KALDI_ASSERT(state_times[i] >= 0);
    if (state_times[i] < log_like.NumRows())  // end state may be past this..
      time_to_state[state_times[i]].push_back(i);
    else
      KALDI_ASSERT(state_times[i] == log_like.NumRows()
                   && "There appears to be lattice/feature mismatch.");
  }

  for (int32 t = 0; t < log_like.NumRows(); t++) {
    for (size_t i = 0; i < time_to_state[t].size(); i++) {
      int32 state = time_to_state[t][i];
      for (fst::MutableArcIterator<Lattice> aiter(lat, state); !aiter.Done();
           aiter.Next()) {
        LatticeArc arc = aiter.Value();
        int32 trans_id = arc.ilabel;
        if (trans_id != 0) {  // Non-epsilon input label on arc
          int32 pdf_id = trans_model.TransitionIdToPdf(trans_id);
          arc.weight.SetValue2(-log_like(t, pdf_id) + arc.weight.Value2());
          aiter.SetValue(arc);
        }
      }
    }
  }
}

MomentStatistics() [1/4]

std::string kaldi::nnet1::MomentStatistics

(

const VectorBase< Real > &

vec

)

Get a string with statistics of the data in a vector, so we can print them easily.

Definition at line 63 of file nnet-utils.h.

References VectorBase< Real >::Add(), VectorBase< Real >::Dim(), VectorBase< Real >::Max(), VectorBase< Real >::Min(), VectorBase< Real >::MulElements(), and VectorBase< Real >::Sum().

Referenced by ParametricRelu::Info(), LinearTransform::Info(), AffineTransform::Info(), RecurrentComponent::Info(), ConvolutionalComponent::Info(), LstmProjected::Info(), AddShift::Info(), BlstmProjected::Info(), Rescale::Info(), Nnet::InfoBackPropagate(), ParametricRelu::InfoGradient(), LinearTransform::InfoGradient(), AffineTransform::InfoGradient(), RecurrentComponent::InfoGradient(), ConvolutionalComponent::InfoGradient(), LstmProjected::InfoGradient(), AddShift::InfoGradient(), BlstmProjected::InfoGradient(), Rescale::InfoGradient(), Nnet::InfoPropagate(), and MomentStatistics().

                                                        {
  // we use an auxiliary vector for the higher order powers
  Vector<Real> vec_aux(vec);
  Vector<Real> vec_no_mean(vec);  // vec with mean subtracted
  // mean
  Real mean = vec.Sum() / vec.Dim();
  // variance
  vec_aux.Add(-mean);
  vec_no_mean = vec_aux;
  vec_aux.MulElements(vec_no_mean);  // (vec-mean)^2
  Real variance = vec_aux.Sum() / vec.Dim();
  // skewness
  // - negative : left tail is longer,
  // - positive : right tail is longer,
  // - zero : symmetric
  vec_aux.MulElements(vec_no_mean);  // (vec-mean)^3
  Real skewness = vec_aux.Sum() / pow(variance, 3.0/2.0) / vec.Dim();
  // kurtosis (peakedness)
  // - makes sense for symmetric distributions (skewness is zero)
  // - positive : 'sharper peak' than Normal distribution
  // - negative : 'heavier tails' than Normal distribution
  // - zero : same peakedness as the Normal distribution
  vec_aux.MulElements(vec_no_mean);  // (vec-mean)^4
  Real kurtosis = vec_aux.Sum() / (variance * variance) / vec.Dim() - 3.0;
  // send the statistics to stream,
  std::ostringstream ostr;
  ostr << " ( min " << vec.Min() << ", max " << vec.Max()
       << ", mean " << mean
       << ", stddev " << sqrt(variance)
       << ", skewness " << skewness
       << ", kurtosis " << kurtosis
       << " ) ";
  return ostr.str();
}

MomentStatistics() [2/4]

std::string kaldi::nnet1::MomentStatistics

(

const MatrixBase< Real > &

mat

)

Overload MomentStatistics to MatrixBase<Real>

Definition at line 102 of file nnet-utils.h.

References VectorBase< Real >::CopyRowsFromMat(), MomentStatistics(), MatrixBase< Real >::NumCols(), and MatrixBase< Real >::NumRows().

                                                        {
  Vector<Real> vec(mat.NumRows()*mat.NumCols());
  vec.CopyRowsFromMat(mat);
  return MomentStatistics(vec);
}

MomentStatistics() [3/4]

std::string kaldi::nnet1::MomentStatistics

(

const CuVectorBase< Real > &

vec

)

Overload MomentStatistics to CuVectorBase<Real>

Definition at line 112 of file nnet-utils.h.

References CuVectorBase< Real >::CopyToVec(), CuVectorBase< Real >::Dim(), and MomentStatistics().

                                                          {
  Vector<Real> vec_host(vec.Dim());
  vec.CopyToVec(&vec_host);
  return MomentStatistics(vec_host);
}

MomentStatistics() [4/4]

std::string kaldi::nnet1::MomentStatistics

(

const CuMatrixBase< Real > &

mat

)

Overload MomentStatistics to CuMatrix<Real>

Definition at line 122 of file nnet-utils.h.

References CuMatrixBase< Real >::CopyToMat(), MomentStatistics(), CuMatrixBase< Real >::NumCols(), and CuMatrixBase< Real >::NumRows().

                                                          {
  Matrix<Real> mat_host(mat.NumRows(), mat.NumCols());
  mat.CopyToMat(&mat_host);
  return MomentStatistics(mat_host);
}

operator<<()

std::ostream& kaldi::nnet1::operator<<	(	std::ostream &	os,
		const std::vector< T > &	v
	)

Define stream insertion opeartor for 'std::vector', useful for log-prints,.

Definition at line 43 of file nnet-utils.h.

                                                              {
  std::copy(v.begin(), v.end(), std::ostream_iterator<T>(os, " "));
  return os;
}

PosteriorToMatrix()

void kaldi::nnet1::PosteriorToMatrix	(	const Posterior &	post,
		const int32	post_dim,
		CuMatrix< Real > *	mat
	)

Wrapper of PosteriorToMatrix with CuMatrix argument.

Definition at line 292 of file nnet-utils.h.

Referenced by Xent::Eval(), Mse::Eval(), and MultiTaskLoss::Eval().

                                                                  {
  Matrix<Real> m;
  PosteriorToMatrix(post, post_dim, &m);
  (*mat) = m;
}

PosteriorToPdfMatrix()

void kaldi::nnet1::PosteriorToPdfMatrix	(	const Posterior &	post,
		const TransitionModel &	model,
		CuMatrix< Real > *	mat
	)

Wrapper of PosteriorToMatrixMapped with CuMatrix argument.

Definition at line 304 of file nnet-utils.h.

Referenced by main().

                                               {
  Matrix<BaseFloat> m;
  PosteriorToPdfMatrix(post, model, &m);
  // Copy to output GPU matrix,
  (*mat) = m;
}

RandGauss()

void kaldi::nnet1::RandGauss	(	BaseFloat	mu,
		BaseFloat	sigma,
		CuMatrixBase< Real > *	mat,
		struct RandomState *	state = NULL
	)

Fill CuMatrix with random numbers (Gaussian distribution): mu = the mean value, sigma = standard deviation,.

Using the CPU random generator.

Definition at line 164 of file nnet-utils.h.

References CuMatrixBase< Real >::CopyFromMat(), kaldi::kUndefined, CuMatrixBase< Real >::NumCols(), and CuMatrixBase< Real >::NumRows().

Referenced by AffineTransform::InitData(), LinearTransform::InitData(), ConvolutionalComponent::InitData(), Rbm::InitData(), and InitRand().

                                                 {
  // fill temporary matrix with 'Normal' samples,
  Matrix<Real> m(mat->NumRows(), mat->NumCols(), kUndefined);
  for (int32 r = 0; r < m.NumRows(); r++) {
    for (int32 c = 0; c < m.NumCols(); c++) {
      m(r, c) = RandGauss(state);
    }
  }
  // re-shape the distrbution,
  m.Scale(sigma);
  m.Add(mu);
  // export,
  mat->CopyFromMat(m);
}

RandUniform() [1/2]

void kaldi::nnet1::RandUniform	(	BaseFloat	mu,
		BaseFloat	range,
		CuMatrixBase< Real > *	mat,
		struct RandomState *	state = NULL
	)

Fill CuMatrix with random numbers (Uniform distribution): mu = the mean value, range = the 'width' of the uniform PDF (spanning mu-range/2 .

. mu+range/2)

Using the CPU random generator.

Definition at line 188 of file nnet-utils.h.

References CuMatrixBase< Real >::CopyFromMat(), kaldi::kUndefined, CuMatrixBase< Real >::NumCols(), CuMatrixBase< Real >::NumRows(), and kaldi::Rand().

Referenced by AffineTransform::InitData(), RecurrentComponent::InitData(), LstmProjected::InitData(), BlstmProjected::InitData(), ConvolutionalComponent::InitData(), and Rbm::InitData().

                                                   {
  // fill temporary matrix with '0..1' samples,
  Matrix<Real> m(mat->NumRows(), mat->NumCols(), kUndefined);
  for (int32 r = 0; r < m.NumRows(); r++) {
    for (int32 c = 0; c < m.NumCols(); c++) {
      m(r, c) = Rand(state) / static_cast<Real>(RAND_MAX);
    }
  }
  // re-shape the distrbution,
  m.Scale(range);  // 0..range,
  m.Add(mu - (range / 2.0));  // mu-range/2 .. mu+range/2,
  // export,
  mat->CopyFromMat(m);
}

RandUniform() [2/2]

void kaldi::nnet1::RandUniform	(	BaseFloat	mu,
		BaseFloat	range,
		CuVectorBase< Real > *	vec,
		struct RandomState *	state = NULL
	)

Fill CuVector with random numbers (Uniform distribution): mu = the mean value, range = the 'width' of the uniform PDF (spanning mu-range/2 .

. mu+range/2)

Using the CPU random generator.

Definition at line 212 of file nnet-utils.h.

References CuVectorBase< Real >::CopyFromVec(), CuVectorBase< Real >::Dim(), rnnlm::i, kaldi::kUndefined, and kaldi::Rand().

                                                   {
  // fill temporary vector with '0..1' samples,
  Vector<Real> v(vec->Dim(), kUndefined);
  for (int32 i = 0; i < v.Dim(); i++) {
    v(i) = Rand(state) / static_cast<Real>(RAND_MAX);
  }
  // re-shape the distrbution,
  v.Scale(range);  // 0..range,
  v.Add(mu - (range / 2.0));  // mu-range/2 .. mu+range/2,
  // export,
  vec->CopyFromVec(v);
}

ReadComponentFromString()

Component* kaldi::nnet1::ReadComponentFromString

(

const std::string &

s

)

Definition at line 42 of file nnet-component-test.cc.

References Component::Read().

Referenced by UnitTestConvolutionalComponent3x3(), UnitTestConvolutionalComponentUnity(), UnitTestDropoutComponent(), UnitTestLengthNorm(), and UnitTestSimpleSentenceAveragingComponent().

                                                         {
    std::istringstream is(s + "\n");
    return Component::Read(is, false);  // false for ascii
  }

ReadCuMatrixFromString()

void kaldi::nnet1::ReadCuMatrixFromString	(	const std::string &	s,
		CuMatrix< Real > *	m
	)

Definition at line 37 of file nnet-component-test.cc.

References CuMatrix< Real >::Read().

Referenced by UnitTestConvolutionalComponent3x3(), UnitTestConvolutionalComponentUnity(), UnitTestLengthNorm(), UnitTestMaxPoolingComponent(), and UnitTestSimpleSentenceAveragingComponent().

                                                                     {
    std::istringstream is(s + "\n");
    m->Read(is, false);  // false for ascii
  }

ToString()

std::string kaldi::nnet1::ToString

(

const T &

t

)

Convert basic type to a string (please don't overuse),.

Definition at line 52 of file nnet-utils.h.

Referenced by SimpleSentenceAveragingComponent::Info(), ParametricRelu::Info(), LinearTransform::Info(), AffineTransform::Info(), BlockSoftmax::Info(), CopyComponent::Info(), ConvolutionalComponent::Info(), LstmProjected::Info(), Dropout::Info(), AddShift::Info(), BlstmProjected::Info(), Rescale::Info(), ParametricRelu::InfoGradient(), LinearTransform::InfoGradient(), AffineTransform::InfoGradient(), RecurrentComponent::InfoGradient(), FramePoolingComponent::InfoGradient(), ConvolutionalComponent::InfoGradient(), LstmProjected::InfoGradient(), AddShift::InfoGradient(), BlstmProjected::InfoGradient(), Rescale::InfoGradient(), and main().

                               {
  std::ostringstream os;
  os << t;
  return os.str();
}

UnitTestConvolutionalComponent3x3()

void kaldi::nnet1::UnitTestConvolutionalComponent3x3

(

)

Definition at line 131 of file nnet-component-test.cc.

References kaldi::AssertEqual(), Component::Backpropagate(), KALDI_LOG, Component::Propagate(), ReadComponentFromString(), and ReadCuMatrixFromString().

Referenced by main().

                                           {
    // make 3x3 convolutional component,
    // design such weights and input so output is zero,
    Component* c = ReadComponentFromString("<ConvolutionalComponent> 9 15 \
      <PatchDim> 3 <PatchStep> 1 <PatchStride> 5 \
      <LearnRateCoef> 1.0 <BiasLearnRateCoef> 1.0 \
      <MaxNorm> 0 \
      <Filters> [ -1 -2 -7   0 0 0   1 2 7 ; \
                  -1  0  1  -3 0 3  -2 2 0 ; \
                  -4  0  0  -3 0 3   4 0 0 ] \
      <Bias> [ -20 -20 -20 ]"
    );

    // prepare input, reference output,
    CuMatrix<BaseFloat> mat_in;
    ReadCuMatrixFromString("[ 1 3 5 7 9  2 4 6 8 10  3 5 7 9 11 ]", &mat_in);
    CuMatrix<BaseFloat> mat_out_ref;
    ReadCuMatrixFromString("[ 0 0 0  0 0 0  0 0 0 ]", &mat_out_ref);

    // propagate,
    CuMatrix<BaseFloat> mat_out;
    c->Propagate(mat_in, &mat_out);
    KALDI_LOG << "mat_in" << mat_in << "mat_out" << mat_out;
    AssertEqual(mat_out, mat_out_ref);

    // prepare mat_out_diff, mat_in_diff_ref,
    CuMatrix<BaseFloat> mat_out_diff;
    ReadCuMatrixFromString("[ 1 0 0  1 1 0  1 1 1 ]", &mat_out_diff);
    // hand-computed back-propagated values,
    CuMatrix<BaseFloat> mat_in_diff_ref;
    ReadCuMatrixFromString("[ -1 -4 -15 -8 -6   0 -3 -6 3 6   1 1 14 11 7 ]",
                           &mat_in_diff_ref);

    // backpropagate,
    CuMatrix<BaseFloat> mat_in_diff;
    c->Backpropagate(mat_in, mat_out, mat_out_diff, &mat_in_diff);
    KALDI_LOG << "mat_in_diff " << mat_in_diff
              << " mat_in_diff_ref " << mat_in_diff_ref;
    AssertEqual(mat_in_diff, mat_in_diff_ref);

    // clean,
    delete c;
  }

UnitTestConvolutionalComponentUnity()

void kaldi::nnet1::UnitTestConvolutionalComponentUnity

(

)

Definition at line 100 of file nnet-component-test.cc.

References kaldi::AssertEqual(), Component::Backpropagate(), KALDI_LOG, Component::Propagate(), ReadComponentFromString(), and ReadCuMatrixFromString().

Referenced by main().

                                             {
    // make 'identity' convolutional component,
    Component* c = ReadComponentFromString("<ConvolutionalComponent> 5 5 \
      <PatchDim> 1 <PatchStep> 1 <PatchStride> 5 \
      <LearnRateCoef> 1.0 <BiasLearnRateCoef> 1.0 \
      <MaxNorm> 0 \
      <Filters> [ 1 \
      ] <Bias> [ 0 ]"
    );

    // prepare input,
    CuMatrix<BaseFloat> mat_in;
    ReadCuMatrixFromString("[ 1 2 3 4 5 ] ", &mat_in);

    // propagate,
    CuMatrix<BaseFloat> mat_out;
    c->Propagate(mat_in, &mat_out);
    KALDI_LOG << "mat_in" << mat_in << "mat_out" << mat_out;
    AssertEqual(mat_in, mat_out);

    // backpropagate,
    CuMatrix<BaseFloat> mat_out_diff(mat_in), mat_in_diff;
    c->Backpropagate(mat_in, mat_out, mat_out_diff, &mat_in_diff);
    KALDI_LOG << "mat_out_diff " << mat_out_diff
              << " mat_in_diff " << mat_in_diff;
    AssertEqual(mat_out_diff, mat_in_diff);

    // clean,
    delete c;
  }

UnitTestDropoutComponent()

void kaldi::nnet1::UnitTestDropoutComponent

(

)

Definition at line 245 of file nnet-component-test.cc.

References kaldi::AssertEqual(), Component::Backpropagate(), Component::Propagate(), ReadComponentFromString(), CuMatrixBase< Real >::Set(), and CuMatrixBase< Real >::Sum().

Referenced by main().

                                  {
    Component* c = ReadComponentFromString("<Dropout> 100 100 <DropoutRetention> 0.7");
    // buffers,
    CuMatrix<BaseFloat> in(777, 100),
                        out,
                        out_diff,
                        in_diff;
    // init,
    in.Set(2.0);

    // propagate,
    c->Propagate(in, &out);
    AssertEqual(in.Sum(), out.Sum(), 0.01);

    // backprop,
    out_diff = in;
    c->Backpropagate(in, out, out_diff, &in_diff);
    AssertEqual(in_diff, out);

    delete c;
  }

UnitTestLengthNorm()

void kaldi::nnet1::UnitTestLengthNorm

(

)

Definition at line 51 of file nnet-component-test.cc.

References CuVectorBase< Real >::AddColSumMat(), CuVectorBase< Real >::ApplyPow(), kaldi::AssertEqual(), CuMatrixBase< Real >::MulElements(), Component::Propagate(), ReadComponentFromString(), ReadCuMatrixFromString(), and CuVectorBase< Real >::Set().

Referenced by main().

                            {
    // make L2-length normalization component,
    Component* c = ReadComponentFromString("<LengthNormComponent> 5 5");
    // prepare input,
    CuMatrix<BaseFloat> mat_in;
    ReadCuMatrixFromString("[ 1 2 3 4 5 \n 2 3 5 6 8 ] ", &mat_in);
    // propagate,
    CuMatrix<BaseFloat> mat_out;
    c->Propagate(mat_in, &mat_out);
    // check the length,
    mat_out.MulElements(mat_out);  // ^2,
    CuVector<BaseFloat> check_length_is_one(2);
    check_length_is_one.AddColSumMat(1.0, mat_out, 0.0);  // sum_of_cols(x^2),
    check_length_is_one.ApplyPow(0.5);  // L2norm = sqrt(sum_of_cols(x^2)),
    CuVector<BaseFloat> ones(2);
    ones.Set(1.0);
    AssertEqual(check_length_is_one, ones);
  }

UnitTestMaxPoolingComponent()

void kaldi::nnet1::UnitTestMaxPoolingComponent

(

)

Definition at line 176 of file nnet-component-test.cc.

References kaldi::AssertEqual(), Component::Backpropagate(), Component::Init(), KALDI_LOG, Component::Propagate(), ReadCuMatrixFromString(), and CuMatrixBase< Real >::Set().

Referenced by main().

                                     {
    // make max-pooling component, assuming 4 conv. neurons,
    // non-overlapping pool of size 3,
    Component* c = Component::Init(
        "<MaxPoolingComponent> <InputDim> 24 <OutputDim> 8 \
         <PoolSize> 3 <PoolStep> 3 <PoolStride> 4"
    );

    // input matrix,
    CuMatrix<BaseFloat> mat_in;
    ReadCuMatrixFromString("[ 3 8 2 9 \
                              8 3 9 3 \
                              2 4 9 6 \
                              \
                              2 4 2 0 \
                              6 4 9 4 \
                              7 3 0 3;\
                              \
                              5 4 7 8 \
                              3 9 5 6 \
                              3 4 8 9 \
                              \
                              5 4 5 6 \
                              3 1 4 5 \
                              8 2 1 7 ]", &mat_in);

    // expected output (max values in columns),
    CuMatrix<BaseFloat> mat_out_ref;
    ReadCuMatrixFromString("[ 8 8 9 9 \
                              7 4 9 4;\
                              5 9 8 9 \
                              8 4 5 7 ]", &mat_out_ref);

    // propagate,
    CuMatrix<BaseFloat> mat_out;
    c->Propagate(mat_in, &mat_out);
    KALDI_LOG << "mat_out" << mat_out << "mat_out_ref" << mat_out_ref;
    AssertEqual(mat_out, mat_out_ref);

    // locations of max values will be shown,
    CuMatrix<BaseFloat> mat_out_diff(mat_out);
    mat_out_diff.Set(1);
    // expected backpropagated values (hand-computed),
    CuMatrix<BaseFloat> mat_in_diff_ref;
    ReadCuMatrixFromString("[ 0 1 0 1 \
                              1 0 1 0 \
                              0 0 1 0 \
                              \
                              0 1 0 0 \
                              0 1 1 1 \
                              1 0 0 0;\
                              \
                              1 0 0 0 \
                              0 1 0 0 \
                              0 0 1 1 \
                              \
                              0 1 1 0 \
                              0 0 0 0 \
                              1 0 0 1 ]", &mat_in_diff_ref);
    // backpropagate,
    CuMatrix<BaseFloat> mat_in_diff;
    c->Backpropagate(mat_in, mat_out, mat_out_diff, &mat_in_diff);
    KALDI_LOG << "mat_in_diff " << mat_in_diff
              << " mat_in_diff_ref " << mat_in_diff_ref;
    AssertEqual(mat_in_diff, mat_in_diff_ref);

    delete c;
  }

UnitTestSimpleSentenceAveragingComponent()

void kaldi::nnet1::UnitTestSimpleSentenceAveragingComponent

(

)

Definition at line 70 of file nnet-component-test.cc.

References kaldi::AssertEqual(), Component::Backpropagate(), rnnlm::i, CuMatrixBase< Real >::NumRows(), Component::Propagate(), ReadComponentFromString(), ReadCuMatrixFromString(), CuMatrixBase< Real >::Row(), and CuVectorBase< Real >::Set().

Referenced by main().

                                                  {
    // make SimpleSentenceAveraging component,
    Component* c = ReadComponentFromString(
      "<SimpleSentenceAveragingComponent> 2 2 <GradientBoost> 10.0"
    );
    // prepare input,
    CuMatrix<BaseFloat> mat_in;
    ReadCuMatrixFromString("[ 0 0.5 \n 1 1 \n 2 1.5 ] ", &mat_in);

    // propagate,
    CuMatrix<BaseFloat> mat_out;
    c->Propagate(mat_in, &mat_out);
    // check the output,
    CuVector<BaseFloat> ones(2);
    ones.Set(1.0);
    for (int32 i = 0; i < mat_out.NumRows(); i++) {
      AssertEqual(mat_out.Row(i), ones);
    }

    // backpropagate,
    CuMatrix<BaseFloat> dummy1(3, 2), dummy2(3, 2), diff_out(mat_in), diff_in;
    // the average 1.0 in 'diff_in' will be boosted by 10.0,
    c->Backpropagate(dummy1, dummy2, diff_out, &diff_in);
    // check the output,
    CuVector<BaseFloat> tens(2); tens.Set(10);
    for (int32 i = 0; i < diff_in.NumRows(); i++) {
      AssertEqual(diff_in.Row(i), tens);
    }
  }